refactor(base-driver): Enable strictNullChecks for TypeScript (#6201)

Author: ovr

packages/cubejs-backend-shared/src/promises.ts

@@ -3,7 +3,7 @@ import crypto from 'crypto';
 
 import { Optional } from './type-helpers';
 
-type CancelablePromiseCancel = (waitExecution?: boolean) => Promise<any>;
+export type CancelablePromiseCancel = (waitExecution?: boolean) => Promise<any>;
 
 export interface CancelablePromise<T> extends Promise<T> {
   cancel: CancelablePromiseCancel;

packages/cubejs-base-driver/src/BaseDriver.ts

@@ -179,10 +179,9 @@ export abstract class BaseDriver implements DriverInterface {
     ) {
       ssl = sslOptions.reduce(
         (agg, { name, envKey, canBeFile, validate }) => {
-          if (process.env[envKey]) {
-            const value = process.env[envKey];
-
-            if (validate(value)) {
+          const value = process.env[envKey];
+          if (value) {
+            if (validate && validate(value)) {
               return {
                 ...agg,
                 ...{ [name]: value }
@@ -282,16 +281,15 @@ export abstract class BaseDriver implements DriverInterface {
     return this.query(query).then(data => reduce(this.informationColumnsSchemaReducer, {}, data));
   }
 
-  public async createSchemaIfNotExists(schemaName: string): Promise<Array<unknown>> {
-    return this.query(
+  public async createSchemaIfNotExists(schemaName: string): Promise<void> {
+    const schemas = await this.query(
       `SELECT schema_name FROM information_schema.schemata WHERE schema_name = ${this.param(0)}`,
       [schemaName]
-    ).then((schemas) => {
-      if (schemas.length === 0) {
-        return this.query(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
-      }
-      return null;
-    });
+    );
+
+    if (schemas.length === 0) {
+      await this.query(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+    }
   }
 
   public getTablesQuery(schemaName: string) {
@@ -305,7 +303,7 @@ export abstract class BaseDriver implements DriverInterface {
     return this.query(loadSql, params, options);
   }
 
-  public dropTable(tableName: string, options?: unknown): Promise<unknown> {
+  public dropTable(tableName: string, options?: QueryOptions): Promise<unknown> {
     return this.query(`DROP TABLE ${tableName}`, [], options);
   }
 

packages/cubejs-base-driver/src/driver.interface.ts

@@ -165,7 +165,7 @@ export type DownloadQueryResultsResult = DownloadQueryResultsBase & (DownloadTab
 export type TableQueryResult = { table_name?: string, TABLE_NAME?: string };
 
 export interface DriverInterface {
-  createSchemaIfNotExists(schemaName: string): Promise<any>;
+  createSchemaIfNotExists(schemaName: string): Promise<void>;
   uploadTableWithIndexes(
     table: string, columns: TableStructure, tableData: DownloadTableData, indexesSql: IndexesSQL, uniqueKeyColumns: string[], queryTracingObj: any, externalOptions: ExternalCreateTableOptions
   ): Promise<void>;

packages/cubejs-base-driver/src/utils.ts

@@ -1,11 +1,11 @@
-import { MaybeCancelablePromise } from '@cubejs-backend/shared';
+import { CancelablePromiseCancel, MaybeCancelablePromise } from '@cubejs-backend/shared';
 
 export type SaveCancelFn = <T>(promise: MaybeCancelablePromise<T>) => Promise<T>;
 
 export function cancelCombinator(fn) {
-  const cancelFnArray = [];
+  const cancelFnArray: CancelablePromiseCancel[] = [];
 
-  const saveCancelFn = promise => {
+  const saveCancelFn: SaveCancelFn = (promise) => {
     if (promise.cancel) {
       cancelFnArray.push(promise.cancel);
     }

packages/cubejs-base-driver/tsconfig.json

@@ -9,10 +9,6 @@
     "rootDir": ".",
     "baseUrl": ".",
     "allowJs": true,
-    "noImplicitAny": false,
-    "strictNullChecks": false,
-    "strictFunctionTypes": false,
-    "strictBindCallApply": false,
-    "strictPropertyInitialization": false,
+    "noImplicitAny": false
   },
 }

packages/cubejs-bigquery-driver/src/BigQueryDriver.ts

@@ -223,8 +223,8 @@ export class BigQueryDriver extends BaseDriver implements DriverInterface {
     return bigQueryTable.schema.fields.map((c: any) => ({ name: c.name, type: this.toGenericType(c.type) }));
   }
 
-  public async createSchemaIfNotExists(schemaName: string) {
-    return this.bigquery.dataset(schemaName).get({ autoCreate: true });
+  public async createSchemaIfNotExists(schemaName: string): Promise<void> {
+    await this.bigquery.dataset(schemaName).get({ autoCreate: true });
   }
 
   public async isUnloadSupported() {

packages/cubejs-clickhouse-driver/src/ClickHouseDriver.ts

@@ -355,8 +355,8 @@ export class ClickHouseDriver extends BaseDriver implements DriverInterface {
     return super.toGenericType(columnType);
   }
 
-  public async createSchemaIfNotExists(schemaName: string): Promise<unknown[]> {
-    return this.query(`CREATE DATABASE IF NOT EXISTS ${schemaName}`, []);
+  public async createSchemaIfNotExists(schemaName: string): Promise<void> {
+    await this.query(`CREATE DATABASE IF NOT EXISTS ${schemaName}`, []);
   }
 
   public getTablesQuery(schemaName: string) {

packages/cubejs-databricks-jdbc-driver/src/DatabricksDriver.ts

@@ -19,7 +19,7 @@ import {
   SASProtocol,
   generateBlobSASQueryParameters,
 } from '@azure/storage-blob';
-import { DriverCapabilities, UnloadOptions, } from '@cubejs-backend/base-driver';
+import { DriverCapabilities, QueryOptions, UnloadOptions } from '@cubejs-backend/base-driver';
 import {
   JDBCDriver,
   JDBCDriverConfiguration,
@@ -337,7 +337,7 @@ export class DatabricksDriver extends JDBCDriver {
   /**
    * @override
    */
-  public dropTable(tableName: string, options?: unknown): Promise<unknown> {
+  public dropTable(tableName: string, options?: QueryOptions): Promise<unknown> {
     const tableFullName = `${
       this.config?.catalog ? `${this.config.catalog}.` : ''
     }${tableName}`;
@@ -380,7 +380,7 @@ export class DatabricksDriver extends JDBCDriver {
    * Execute create schema query.
    */
   public async createSchemaIfNotExists(schemaName: string) {
-    return this.query(
+    await this.query(
       `CREATE SCHEMA IF NOT EXISTS ${
         this.getSchemaFullName(schemaName)
       }`,

packages/cubejs-druid-driver/src/DruidDriver.ts

@@ -105,7 +105,7 @@ export class DruidDriver extends BaseDriver {
     `;
   }
 
-  public async createSchemaIfNotExists(schemaName: string): Promise<unknown[]> {
+  public async createSchemaIfNotExists(schemaName: string): Promise<void> {
     throw new Error('Unable to create schema, Druid does not support it');
   }
 

packages/cubejs-materialize-driver/src/MaterializeDriver.ts

@@ -66,14 +66,13 @@ export class MaterializeDriver extends PostgresDriver {
    * @param {string} schemaName
    * @return {Promise<Array<unknown>>}
    */
-  public async createSchemaIfNotExists(schemaName: string): Promise<unknown[]> {
+  public async createSchemaIfNotExists(schemaName: string): Promise<void> {
     const schemas = await this.query(
       `SHOW SCHEMAS WHERE name = '${schemaName}'`, []
     );
     if (schemas.length === 0) {
       await this.query(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`, []);
     }
-    return [];
   }
 
   public async uploadTableWithIndexes(