Merge pull request #63 from mtgto/base_type

Add return type definitions to datasources

Author: hokaccha

src/lib/DataSourceDefinition/Athena.ts

@@ -1,17 +1,17 @@
 import AthenaClient from "../AthenaClient";
-import Base from "./Base";
+import Base, { ConfigSchemaType } from "./Base";
 import Util from "../Util";
 
 export default class Athena extends Base {
   client: AthenaClient;
 
-  static get key() {
+  static get key(): string {
     return "athena";
   }
-  static get label() {
+  static get label(): string {
     return "Amazon Athena";
   }
-  static get configSchema() {
+  static get configSchema(): ConfigSchemaType {
     return [
       {
         name: "region",
@@ -57,21 +57,24 @@ export default class Athena extends Base {
     return { fields, rows };
   }
 
-  cancel() {
-    return this.client.cancel();
+  cancel(): void {
+    this.client.cancel();
   }
 
-  async connectionTest() {
+  async connectionTest(): Promise<void> {
     await this.client.execute("select 1");
-    return;
   }
 
-  async fetchTables() {
+  async fetchTables(): Promise<{ name: string; type: string; schema?: string }[]> {
     const rows = await this.client.execute("show tables");
-    return rows.map(row => ({ name: row[0], type: "table" }));
+    return rows.map(row => ({ name: row[0]!, type: "table" }));
   }
 
-  async fetchTableSummary({ name }) {
+  async fetchTableSummary({
+    name
+  }: {
+    name: string;
+  }): Promise<{ name: string; defs: { fields: string[]; rows: (string | null)[][] }; schema?: string }> {
     const rows = await this.client.execute(`describe ${name}`);
     const defs = {
       fields: ["name", "type"],
@@ -84,7 +87,7 @@ export default class Athena extends Base {
     return { name, defs };
   }
 
-  descriptionTable() {
+  descriptionTable(): string {
     return Util.stripHeredoc(`
       |region|${this.config.region}|
       |database|${this.config.database}|

src/lib/DataSourceDefinition/Base.ts

@@ -7,20 +7,37 @@ export default abstract class Base {
   static get label(): string {
     throw new Error("Not Implemented");
   }
+  static get configSchema(): ConfigSchemaType {
+    throw new Error("Not Implemented");
+  }
 
   constructor(config) {
     this.config = config;
   }
 
-  abstract execute(query);
+  abstract execute(query: string): Promise<any>;
 
-  abstract cancel();
+  // @todo Set return type as Promise<void> ?
+  abstract cancel(): void | Promise<void>;
 
-  abstract connectionTest();
+  // @todo Define type of the result (boolean or void ?)
+  abstract connectionTest(): Promise<any>;
 
-  abstract fetchTables();
+  abstract fetchTables(): Promise<{ name: string; type: string; schema?: string }[]>;
 
-  abstract descriptionTable();
+  abstract descriptionTable(): string;
 
-  abstract fetchTableSummary(args);
+  abstract fetchTableSummary(
+    args: any
+  ): Promise<{ name: string; defs: { fields: string[]; rows: (string | null)[][] }; schema?: string }>;
 }
+
+export type ConfigSchemaType = {
+  readonly name: string;
+  readonly label: string;
+  readonly type: string;
+  readonly placeholder?: string | number;
+  readonly required?: boolean;
+  readonly values?: string[];
+  readonly default?: string;
+}[];

src/lib/DataSourceDefinition/BigQuery.ts

@@ -1,17 +1,17 @@
 import bigquery from "@google-cloud/bigquery";
-import Base from "./Base";
+import Base, { ConfigSchemaType } from "./Base";
 import { flatten } from "lodash";
 
 export default class BigQuery extends Base {
   _cancel: any;
 
-  static get key() {
+  static get key(): string {
     return "bigquery";
   }
-  static get label() {
+  static get label(): string {
     return "BigQuery";
   }
-  static get configSchema() {
+  static get configSchema(): ConfigSchemaType {
     return [
       {
         name: "project",
@@ -28,7 +28,7 @@ export default class BigQuery extends Base {
     ];
   }
 
-  execute(query) {
+  execute(query: string) {
     this._cancel = null;
     return new Promise((resolve, reject) => {
       bigquery(this.config).startQuery(query, (err, job) => {
@@ -52,18 +52,17 @@ export default class BigQuery extends Base {
     });
   }
 
-  cancel() {
+  cancel(): void {
     return this._cancel && this._cancel();
   }
 
-  async connectionTest() {
+  async connectionTest(): Promise<void> {
     await bigquery(this.config).query("select 1");
-    return true;
   }
 
-  async fetchTables() {
-    const [datasets] = await bigquery(this.config).getDatasets();
-    const promises = datasets.map(async dataset => {
+  async fetchTables(): Promise<{ name: string; type: string; schema?: string }[]> {
+    const [datasets]: [any[]] = await bigquery(this.config).getDatasets();
+    const promises = datasets.map<Promise<{ name: string; type: string; schema?: string }>>(async dataset => {
       const [tables] = await dataset.getTables();
       return tables.map(table => ({
         schema: dataset.id,
@@ -75,7 +74,13 @@ export default class BigQuery extends Base {
     return flatten(results);
   }
 
-  async fetchTableSummary({ schema, name }) {
+  async fetchTableSummary({
+    schema,
+    name
+  }: {
+    schema: string;
+    name: string;
+  }): Promise<{ name: string; defs: { fields: string[]; rows: (string | null)[][] }; schema?: string }> {
     const [metadata] = await bigquery(this.config)
       .dataset(schema)
       .table(name)
@@ -88,7 +93,7 @@ export default class BigQuery extends Base {
     return { schema, name, defs };
   }
 
-  descriptionTable() {
+  descriptionTable(): string {
     return `|project|${this.config.project}|`;
   }
 }

src/lib/DataSourceDefinition/Mysql.ts

@@ -1,18 +1,18 @@
 import mysql from "mysql2";
-import Base from "./Base";
+import Base, { ConfigSchemaType } from "./Base";
 import Util from "../Util";
 import { zipObject } from "lodash";
 
 export default class Mysql extends Base {
   currentConnection: any;
 
-  static get key() {
+  static get key(): string {
     return "mysql";
   }
-  static get label() {
+  static get label(): string {
     return "MySQL";
   }
-  static get configSchema() {
+  static get configSchema(): ConfigSchemaType {
     return [
       { name: "host", label: "Host", type: "string", placeholder: "localhost" },
       { name: "port", label: "Port", type: "number", placeholder: 3306 },
@@ -31,7 +31,7 @@ export default class Mysql extends Base {
     return this._execute(query);
   }
 
-  cancel() {
+  cancel(): Promise<void> {
     const tid = this.currentConnection && this.currentConnection.threadId;
     if (!tid) return Promise.resolve();
 
@@ -43,7 +43,7 @@ export default class Mysql extends Base {
     return true;
   }
 
-  async fetchTables() {
+  async fetchTables(): Promise<{ name: string; type: string; schema?: string }[]> {
     const query = Util.stripHeredoc(`
       select table_name as name, table_type as type
       from information_schema.tables
@@ -55,14 +55,18 @@ export default class Mysql extends Base {
     return rows.map(row => zipObject(fields, row));
   }
 
-  async fetchTableSummary({ name }) {
+  async fetchTableSummary({
+    name
+  }: {
+    name: string;
+  }): Promise<{ name: string; defs: { fields: string[]; rows: (string | null)[][] }; schema?: string }> {
     const sql = "show columns from ??";
     const defs = await this._execute(sql, name);
 
     return { name, defs };
   }
 
-  _execute(query, ...args): Promise<any> {
+  _execute(query: string, ...args): Promise<any> {
     if (this.currentConnection) {
       return Promise.reject(new Error("A query is running"));
     }
@@ -96,7 +100,7 @@ export default class Mysql extends Base {
     });
   }
 
-  descriptionTable() {
+  descriptionTable(): string {
     return Util.stripHeredoc(`
       |host|${this.config.host}|
       |port|${this.config.port}|

src/lib/DataSourceDefinition/Postgres.ts

@@ -1,5 +1,5 @@
 import pg from "pg";
-import Base from "./Base";
+import Base, { ConfigSchemaType } from "./Base";
 import Util from "../Util";
 import { zipObject } from "lodash";
 
@@ -50,13 +50,13 @@ import { zipObject } from "lodash";
 export default class Postgres extends Base {
   currentClient: any;
 
-  static get key() {
+  static get key(): string {
     return "postgres";
   }
-  static get label() {
+  static get label(): string {
     return "PostgreSQL";
   }
-  static get configSchema() {
+  static get configSchema(): ConfigSchemaType {
     return [
       { name: "host", label: "Host", type: "string", placeholder: "localhost" },
       { name: "port", label: "Port", type: "number", placeholder: 5432 },
@@ -72,27 +72,27 @@ export default class Postgres extends Base {
     ];
   }
 
-  async execute(query, options: any = {}) {
+  async execute(query: string, options: any = {}): Promise<any> {
     try {
       return await this._execute(query);
     } catch (err) {
       throw this._errorWithLine(err, query, options.startLine || 1);
     }
   }
 
-  cancel() {
+  cancel(): Promise<void> {
     const pid = this.currentClient && this.currentClient.processID;
     if (!pid) return Promise.resolve();
 
     return new Postgres(this.config)._execute(`select pg_cancel_backend(${pid})`);
   }
 
-  async connectionTest() {
+  async connectionTest(): Promise<any> {
     await this._execute("select 1");
     return true;
   }
 
-  async fetchTables() {
+  async fetchTables(): Promise<{ name: string; type: string; schema?: string }[]> {
     const query = Util.stripHeredoc(`
       select table_schema as schema, table_name as name, table_type as type
       from information_schema.tables
@@ -104,7 +104,13 @@ export default class Postgres extends Base {
     return rows.map(row => zipObject(fields, row));
   }
 
-  async fetchTableSummary({ schema, name }) {
+  async fetchTableSummary({
+    schema,
+    name
+  }: {
+    schema: string;
+    name: string;
+  }): Promise<{ name: string; defs: { fields: string[]; rows: (string | null)[][] }; schema?: string }> {
     const query = Util.stripHeredoc(`
       select
           pg_attribute.attname as name,
@@ -130,7 +136,7 @@ export default class Postgres extends Base {
     return { schema, name, defs };
   }
 
-  descriptionTable() {
+  descriptionTable(): string {
     return Util.stripHeredoc(`
       |host|${this.config.host}|
       |port|${this.config.port}|