serverless-simple-middleware 0.0.63 → 0.0.65

package/src/middleware/build.ts

@@ -1,173 +1,173 @@
-import { getLogger } from '../utils/logger';
-
-import { stringifyError } from '../utils';
-import {
-  Handler,
-  HandlerAuxBase,
-  HandlerPluginBase,
-  HandlerRequest,
-  HandlerResponse,
-} from './base';
-
-const logger = getLogger(__filename);
-
-type Delegator = (okResponsible: boolean) => Promise<any>;
-
-class HandlerMiddleware<A extends HandlerAuxBase> {
-  public auxPromise: Promise<A>;
-  public plugins: Array<HandlerPluginBase<any>>;
-
-  constructor(plugins: Array<HandlerPluginBase<any>>) {
-    this.plugins = plugins;
-    this.auxPromise = this.createAuxPromise();
-  }
-
-  private createAuxPromise = (): Promise<A> => {
-    return !this.plugins || this.plugins.length === 0
-      ? Promise.resolve({} as A) // tslint:disable-line
-      : Promise.all(
-          this.plugins.map((plugin) => {
-            const maybePromise = plugin.create();
-            return maybePromise instanceof Promise
-              ? maybePromise
-              : Promise.resolve(maybePromise);
-          }),
-        ).then(
-          (auxes) =>
-            auxes.reduce((all, each) => ({ ...all, ...each }), {}) as A,
-        );
-  };
-}
-
-class HandlerProxy<A extends HandlerAuxBase> {
-  private request: HandlerRequest;
-  private response: HandlerResponse;
-  private aux: A;
-
-  public constructor(event: any, context: any, callback: any) {
-    logger.stupid(`event`, event);
-    this.request = new HandlerRequest(event, context);
-    this.response = new HandlerResponse(callback);
-    this.aux = {} as A; // tslint:disable-line
-  }
-
-  public call = async (
-    middleware: HandlerMiddleware<A>,
-    handler: Handler<A>,
-  ) => {
-    try {
-      this.aux = await middleware.auxPromise;
-    } catch (error) {
-      logger.error(
-        `Error while initializing plugins' aux: ${stringifyError(error)}`,
-      );
-      this.response.fail(
-        error instanceof Error ? { error: error.message } : error,
-      );
-      return [error];
-    }
-
-    const actualHandler = [this.generateDelegator(handler)];
-    const beginHandlers = middleware.plugins.map((plugin) =>
-      this.generateDelegator(plugin.begin),
-    );
-    const endHandlers = middleware.plugins.map((plugin) =>
-      this.generateDelegator(plugin.end),
-    );
-    const errorHandlers = middleware.plugins.map((plugin) =>
-      this.generateDelegator(plugin.error),
-    );
-
-    const iterate = async (
-      handlers: Delegator[],
-      okResponsible: boolean = false,
-    ) =>
-      Promise.all(
-        handlers.map((each) =>
-          this.safeCall(each, okResponsible, errorHandlers),
-        ),
-      );
-
-    const results = [
-      ...(await iterate(beginHandlers)),
-      ...(await iterate(actualHandler, true)),
-      ...(await iterate(endHandlers)),
-    ].filter((x) => x);
-    // In test phase, throws any exception if there was.
-    if (process.env.NODE_ENV === 'test') {
-      for (const each of results) {
-        if (each instanceof Error) {
-          logger.error(`Error occurred: ${stringifyError(each)}`);
-          throw each;
-        }
-      }
-    }
-    results.forEach((result) =>
-      logger.silly(`middleware result : ${JSON.stringify(result)}`),
-    );
-  };
-
-  private safeCall = async (
-    delegator: Delegator,
-    okResponsible: boolean,
-    errorHandlers: Delegator[],
-  ) => {
-    try {
-      const result = await delegator(okResponsible);
-      return result;
-    } catch (error) {
-      const handled = await this.handleError(error, errorHandlers);
-      return handled;
-    }
-  };
-
-  private generateDelegator =
-    (handler: Handler<A>): Delegator =>
-    async (okResponsible: boolean) => {
-      const maybePromise = handler({
-        request: this.request,
-        response: this.response,
-        aux: this.aux,
-      });
-      const result =
-        maybePromise instanceof Promise ? await maybePromise : maybePromise;
-      logger.stupid(`result`, result);
-      if (!this.response.completed && okResponsible) {
-        this.response.ok(result);
-      }
-      return result;
-    };
-
-  private handleError = async (error: Error, errorHandlers?: Delegator[]) => {
-    logger.error(error);
-    this.request.lastError = error;
-
-    if (errorHandlers) {
-      for (const handler of errorHandlers) {
-        try {
-          await handler(false);
-        } catch (ignorable) {
-          logger.error(ignorable);
-        }
-      }
-    }
-    if (!this.response.completed) {
-      this.response.fail(
-        error instanceof Error ? { error: error.message } : error,
-      );
-    }
-    return error;
-  };
-}
-
-// It will break type safety because there is no relation between Aux and Plugin.
-const build = <Aux extends HandlerAuxBase>(
-  plugins: Array<HandlerPluginBase<any>>,
-) => {
-  const middleware = new HandlerMiddleware<Aux>(plugins);
-  return (handler: Handler<Aux>) =>
-    (event: any, context: any, callback: any) => {
-      new HandlerProxy<Aux>(event, context, callback).call(middleware, handler);
-    };
-};
-export default build;
+import { getLogger } from '../utils/logger';
+
+import { stringifyError } from '../utils';
+import {
+  Handler,
+  HandlerAuxBase,
+  HandlerPluginBase,
+  HandlerRequest,
+  HandlerResponse,
+} from './base';
+
+const logger = getLogger(__filename);
+
+type Delegator = (okResponsible: boolean) => Promise<any>;
+
+class HandlerMiddleware<A extends HandlerAuxBase> {
+  public auxPromise: Promise<A>;
+  public plugins: Array<HandlerPluginBase<any>>;
+
+  constructor(plugins: Array<HandlerPluginBase<any>>) {
+    this.plugins = plugins;
+    this.auxPromise = this.createAuxPromise();
+  }
+
+  private createAuxPromise = (): Promise<A> => {
+    return !this.plugins || this.plugins.length === 0
+      ? Promise.resolve({} as A) // tslint:disable-line
+      : Promise.all(
+          this.plugins.map((plugin) => {
+            const maybePromise = plugin.create();
+            return maybePromise instanceof Promise
+              ? maybePromise
+              : Promise.resolve(maybePromise);
+          }),
+        ).then(
+          (auxes) =>
+            auxes.reduce((all, each) => ({ ...all, ...each }), {}) as A,
+        );
+  };
+}
+
+class HandlerProxy<A extends HandlerAuxBase> {
+  private request: HandlerRequest;
+  private response: HandlerResponse;
+  private aux: A;
+
+  public constructor(event: any, context: any, callback: any) {
+    logger.stupid(`event`, event);
+    this.request = new HandlerRequest(event, context);
+    this.response = new HandlerResponse(callback);
+    this.aux = {} as A; // tslint:disable-line
+  }
+
+  public call = async (
+    middleware: HandlerMiddleware<A>,
+    handler: Handler<A>,
+  ) => {
+    try {
+      this.aux = await middleware.auxPromise;
+    } catch (error) {
+      logger.error(
+        `Error while initializing plugins' aux: ${stringifyError(error)}`,
+      );
+      this.response.fail(
+        error instanceof Error ? { error: error.message } : error,
+      );
+      return [error];
+    }
+
+    const actualHandler = [this.generateDelegator(handler)];
+    const beginHandlers = middleware.plugins.map((plugin) =>
+      this.generateDelegator(plugin.begin),
+    );
+    const endHandlers = middleware.plugins.map((plugin) =>
+      this.generateDelegator(plugin.end),
+    );
+    const errorHandlers = middleware.plugins.map((plugin) =>
+      this.generateDelegator(plugin.error),
+    );
+
+    const iterate = async (
+      handlers: Delegator[],
+      okResponsible: boolean = false,
+    ) =>
+      Promise.all(
+        handlers.map((each) =>
+          this.safeCall(each, okResponsible, errorHandlers),
+        ),
+      );
+
+    const results = [
+      ...(await iterate(beginHandlers)),
+      ...(await iterate(actualHandler, true)),
+      ...(await iterate(endHandlers)),
+    ].filter((x) => x);
+    // In test phase, throws any exception if there was.
+    if (process.env.NODE_ENV === 'test') {
+      for (const each of results) {
+        if (each instanceof Error) {
+          logger.error(`Error occurred: ${stringifyError(each)}`);
+          throw each;
+        }
+      }
+    }
+    results.forEach((result) =>
+      logger.silly(`middleware result : ${JSON.stringify(result)}`),
+    );
+  };
+
+  private safeCall = async (
+    delegator: Delegator,
+    okResponsible: boolean,
+    errorHandlers: Delegator[],
+  ) => {
+    try {
+      const result = await delegator(okResponsible);
+      return result;
+    } catch (error) {
+      const handled = await this.handleError(error, errorHandlers);
+      return handled;
+    }
+  };
+
+  private generateDelegator =
+    (handler: Handler<A>): Delegator =>
+    async (okResponsible: boolean) => {
+      const maybePromise = handler({
+        request: this.request,
+        response: this.response,
+        aux: this.aux,
+      });
+      const result =
+        maybePromise instanceof Promise ? await maybePromise : maybePromise;
+      logger.stupid(`result`, result);
+      if (!this.response.completed && okResponsible) {
+        this.response.ok(result);
+      }
+      return result;
+    };
+
+  private handleError = async (error: Error, errorHandlers?: Delegator[]) => {
+    logger.error(error);
+    this.request.lastError = error;
+
+    if (errorHandlers) {
+      for (const handler of errorHandlers) {
+        try {
+          await handler(false);
+        } catch (ignorable) {
+          logger.error(ignorable);
+        }
+      }
+    }
+    if (!this.response.completed) {
+      this.response.fail(
+        error instanceof Error ? { error: error.message } : error,
+      );
+    }
+    return error;
+  };
+}
+
+// It will break type safety because there is no relation between Aux and Plugin.
+const build = <Aux extends HandlerAuxBase>(
+  plugins: Array<HandlerPluginBase<any>>,
+) => {
+  const middleware = new HandlerMiddleware<Aux>(plugins);
+  return (handler: Handler<Aux>) =>
+    (event: any, context: any, callback: any) => {
+      new HandlerProxy<Aux>(event, context, callback).call(middleware, handler);
+    };
+};
+export default build;

package/src/middleware/database/connectionProxy.ts

@@ -0,0 +1,174 @@
+import { createConnection, type Connection, type MysqlError } from 'mysql';
+import { getLogger } from '../../utils';
+import { MySQLPluginOptions } from '../mysql';
+
+const logger = getLogger(__filename);
+
+export class ConnectionProxy {
+  private pluginConfig: MySQLPluginOptions;
+  private connection?: Connection;
+
+  private initialized: boolean;
+  private dbName?: string;
+
+  public constructor(config: MySQLPluginOptions) {
+    this.pluginConfig = config;
+    if (config.schema && config.schema.database) {
+      this.dbName = config.config.database;
+      config.config.database = undefined;
+    }
+  }
+
+  public query = <T>(sql: string, params?: any[]) =>
+    new Promise<T | undefined>(async (resolve, reject) => {
+      const connection = this.prepareConnection();
+      await this.tryToInitializeSchema(false);
+
+      if (process.env.NODE_ENV !== 'test') {
+        logger.silly(`Execute query[${sql}] with params[${params}]`);
+      }
+      connection.query(sql, params, (err: MysqlError, result?: T) => {
+        if (err) {
+          logger.error(`error occurred in database query=${sql}, error=${err}`);
+          reject(err);
+        } else {
+          resolve(result);
+          if (process.env.NODE_ENV !== 'test') {
+            logger.silly(`DB result is ${JSON.stringify(result)}`);
+          }
+        }
+      });
+    });
+
+  public fetch = <T>(sql: string, params?: any[]) =>
+    this.query<T[]>(sql, params).then((res) => res || []);
+
+  public fetchOne = <T>(sql: string, params?: any[], defaultValue?: T) =>
+    this.fetch<T>(sql, params).then((res) => {
+      if (res === undefined || res[0] === undefined) {
+        // Makes it as non-null result.
+        return defaultValue || ({} as any as T);
+      }
+      return res[0];
+    });
+
+  public beginTransaction = () =>
+    new Promise<void>(async (resolve, reject) => {
+      const connection = this.prepareConnection();
+      await this.tryToInitializeSchema(false);
+
+      connection.beginTransaction((err: MysqlError) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+
+  public commit = () =>
+    new Promise<void>(async (resolve, reject) => {
+      const connection = this.prepareConnection();
+      await this.tryToInitializeSchema(false);
+
+      connection.commit((err: MysqlError) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+
+  public rollback = () =>
+    new Promise<void>(async (resolve, reject) => {
+      const connection = this.prepareConnection();
+      await this.tryToInitializeSchema(false);
+
+      connection.rollback((err: MysqlError) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+
+  public clearConnection = () => {
+    if (this.connection) {
+      this.connection.end();
+      this.connection = undefined;
+      logger.verbose('Connection is end');
+    }
+  };
+
+  public onPluginCreated = async () => this.tryToInitializeSchema(true);
+
+  private prepareConnection = () => {
+    if (this.connection) {
+      return this.connection;
+    }
+    this.connection = createConnection(this.pluginConfig.config);
+    this.connection.connect();
+    return this.connection;
+  };
+
+  private changeDatabase = (dbName: string) =>
+    new Promise<void>((resolve, reject) =>
+      this.prepareConnection().changeUser(
+        {
+          database: dbName,
+        },
+        (err) => (err ? reject(err) : resolve(undefined)),
+      ),
+    );
+
+  private tryToInitializeSchema = async (initial: boolean) => {
+    const {
+      eager = false,
+      ignoreError = false,
+      database = '',
+      tables = {},
+    } = this.pluginConfig.schema || {};
+    if (initial && !eager) {
+      return;
+    }
+
+    // This method can be called twice when eager option is on,
+    // so this flag should be set and checked at first.
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+
+    try {
+      if (database) {
+        logger.debug(`Prepare a database[${this.dbName}]`);
+        logger.stupid(this.dbName!, database);
+        const result = await this.query(database);
+        logger.debug(
+          `Database[${this.dbName}] is initialized: ${JSON.stringify(result)}`,
+        );
+      }
+      if (this.dbName) {
+        await this.changeDatabase(this.dbName);
+        logger.verbose(`Database[${this.dbName}] is connected.`);
+      }
+
+      for (const [name, query] of Object.entries(tables)) {
+        logger.debug(`Prepare a table[${name}]`);
+        logger.stupid(name, query);
+        const result = await this.query(query);
+        logger.debug(
+          `Table[${name}] is initialized: ${JSON.stringify(result)}`,
+        );
+      }
+      logger.verbose(`Database schema is initialized.`);
+    } catch (error) {
+      logger.warn(error);
+      if (!ignoreError) {
+        throw error;
+      }
+    }
+  };
+}

package/src/middleware/database/index.ts

@@ -0,0 +1,14 @@
+export { ConnectionProxy } from './connectionProxy';
+export {
+  sql,
+  type DeleteQueryBuilder,
+  type Expression,
+  type ExpressionBuilder,
+  type InsertQueryBuilder,
+  type NotNull,
+  type RawBuilder,
+  type SelectQueryBuilder,
+  type SqlBool,
+  type SQLClient,
+  type UpdateQueryBuilder,
+} from './sqlClient';

package/src/middleware/database/sqlClient.ts

@@ -0,0 +1,95 @@
+import {
+  HandleEmptyInListsPlugin,
+  Kysely,
+  MysqlDialect,
+  MysqlPool,
+  replaceWithNoncontingentExpression,
+} from 'kysely';
+import {
+  createConnection,
+  type Connection,
+  type ConnectionOptions,
+  type QueryError,
+} from 'mysql2';
+
+interface LazyMysqlPoolConnection extends Connection {
+  release: () => void;
+}
+
+class LazyConnectionPool implements MysqlPool {
+  private connection: LazyMysqlPoolConnection | null = null;
+
+  constructor(private config: ConnectionOptions) {}
+
+  public getConnection = (
+    callback: (error: unknown, connection: LazyMysqlPoolConnection) => void,
+  ): void => {
+    if (this.connection) {
+      callback(null, this.connection);
+      return;
+    }
+    const conn = createConnection(this.config);
+    conn.connect((err: QueryError) => {
+      if (err) {
+        callback(err, {} as LazyMysqlPoolConnection);
+        return;
+      }
+      this.connection = this._addRelease(conn);
+      callback(null, this.connection);
+    });
+  };
+
+  public end = (callback: (error: unknown) => void): void => {
+    if (this.connection) {
+      this.connection.end((err: QueryError) => {
+        this.connection = null;
+        callback(err);
+      });
+    } else {
+      callback(null);
+    }
+  };
+
+  private _addRelease = (connection: Connection): LazyMysqlPoolConnection =>
+    Object.assign(connection, {
+      release: () => {},
+    });
+}
+
+export class SQLClient<T = unknown> extends Kysely<T> {
+  private pool: LazyConnectionPool;
+
+  constructor(config: ConnectionOptions) {
+    const pool = new LazyConnectionPool(config);
+    super({
+      dialect: new MysqlDialect({
+        pool,
+      }),
+      plugins: [
+        new HandleEmptyInListsPlugin({
+          strategy: replaceWithNoncontingentExpression,
+        }),
+      ],
+    });
+    this.pool = pool;
+  }
+
+  public clearConnection = () =>
+    new Promise<void>((resolve) => {
+      this.pool.end(() => resolve());
+    });
+}
+
+export {
+  expressionBuilder,
+  sql,
+  type DeleteQueryBuilder,
+  type Expression,
+  type ExpressionBuilder,
+  type InsertQueryBuilder,
+  type NotNull,
+  type RawBuilder,
+  type SelectQueryBuilder,
+  type SqlBool,
+  type UpdateQueryBuilder,
+} from 'kysely';

package/src/middleware/index.ts

@@ -1,20 +1,21 @@
-import build from './build';
-
-import aws from './aws';
-import logger from './logger';
-import mysql from './mysql';
-import trace from './trace';
-
-export const middleware = {
-  build,
-  aws,
-  trace,
-  logger,
-  mysql,
-};
-
-export * from './base';
-export * from './aws';
-export * from './trace';
-export * from './logger';
-export * from './mysql';
+import build from './build';
+
+import aws from './aws';
+import logger from './logger';
+import mysql from './mysql';
+import trace from './trace';
+
+export const middleware = {
+  build,
+  aws,
+  trace,
+  logger,
+  mysql,
+};
+
+export * from './aws';
+export * from './base';
+export * from './database/index';
+export * from './logger';
+export * from './mysql';
+export * from './trace';