@nestjs-kitchen/connextion-postgres 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 yikenman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,179 @@
+# @nestjs-kitchen/connextion-postgres
+
+[![NPM Version](https://img.shields.io/npm/v/%40nestjs-kitchen%2Fconnextion-postgres)
+](https://www.npmjs.com/package/@nestjs-kitchen/connextion-postgres)
+![NPM License](https://img.shields.io/npm/l/%40nestjs-kitchen%2Fconnextion-postgres)
+[![codecov](https://codecov.io/gh/yikenman/nestjs-kitchen/graph/badge.svg?token=43EG2T8LKS&flag=@nestjs-kitchen/connextion-postgres)](https://codecov.io/gh/yikenman/nestjs-kitchen)
+
+A flexible module to provide [node-postgres](https://node-postgres.com/) interface in NextJS.
+
+---
+
+## Install
+
+```bash
+$ npm install --save @nestjs-kitchen/connextion @nestjs-kitchen/connextion-postgres pg @types/pg
+```
+
+## Usage
+
+### Apply `PostgresModule`
+
+1. Export module, service & decorator. 
+
+    ```typescript
+    export const { Postgres, PostgresModule, Transaction } = definePostgres();
+    export type Postgres = InstanceType<typeof Postgres>;
+    ```
+
+2. Register postgres connection instance with options.
+
+    ```typescript
+    @Module({
+      imports: [
+        // By default it will register a connection instance called `default`.
+        PostgresModule.register({
+          // default's options...
+        })
+      ],
+      providers: [SampleService]
+    })
+    export class SampleModule {} 
+    ```
+
+3. Inject `Postgres` service.
+
+    ```typescript
+    import { Postgres } from './file-that-exported-postgres';
+    
+    @Injectable()
+    class SampleService {
+      constructor(
+        private readonly postgres: Postgres,
+      ) {}
+    
+      async sampleMethod() {
+        const result1 = await this.postgres.default.query(`select 1=1;`);
+      }
+    }
+    ```
+
+### Register multiple postgres instances
+
+1. Define postgres connection instance names and export module, service & decorator. 
+
+    e.g.: `instance_1`,`instance_2`.
+
+    ```typescript
+    export const { Postgres, PostgresModule, Transaction } = definePostgres<'instance_1' | 'instance_2'>();
+    export type Postgres = InstanceType<typeof Postgres>;
+    ```
+
+2. Register postgres connection instances with options.
+
+    ```typescript
+    @Module({
+      imports: [
+        PostgresModule.register({
+          connections: [
+            {
+              name: 'instance1',
+              // instance_1's options...
+            },
+            {
+              name: 'instance2',
+              // instance_2's options...
+            }
+          ]
+        })
+      ],
+      providers: [SampleService]
+    })
+    export class SampleModule {} 
+    ```
+
+3. Inject `Postgres` service.
+
+    ```typescript
+    import { Postgres } from './file-that-exported-postgres';
+    
+    @Injectable()
+    class SampleService {
+      constructor(
+        private readonly postgres: Postgres,
+      ) {}
+    
+      async sampleMethod() {
+        const result1 = await this.postgres.instance1.query(`select 1=1;`);
+      }
+    }
+    ```
+
+### Using with node-postgres [`Query`](https://node-postgres.com/apis/client#clientquery)
+
+```typescript
+import { Query } from 'pg';
+import { Postgres } from './file-that-exported-postgres';
+
+@Injectable()
+class SampleService {
+  constructor(
+    private readonly postgres: Postgres
+  ) {}
+
+  async sampleMethod() {
+    const query = new Query('select $1::text as name', ['brianc']);
+    const result = await this.postgres.default.query(query);
+
+    result.on('row', (row) => {
+      console.log('row!', row); // { name: 'brianc' }
+    })
+  }
+}
+```
+
+### Enable transaction
+
+Apply transaction on all postgres connection instances:
+
+```typescript
+import { Postgres, Transaction } from './file-that-exported-postgres';
+
+@Injectable()
+class SampleService {
+  constructor(
+    private readonly postgres: Postgres
+  ) {}
+
+  // Supposes we have connection instances: `instance1` and `instance2`.
+  // By default it will enable transaction for both `instance1` and `instance2` if not specified.
+  @Transaction()
+  async sampleMethod() {
+    const result = await this.postgres.instance1.query(`select 1=1;`);
+  }
+}
+```
+
+Apply transaction on specified postgres connection instances:
+
+```typescript
+import { Postgres, Transaction } from './file-that-exported-postgres';
+
+@Injectable()
+class SampleService {
+  constructor(
+    private readonly postgres: Postgres
+  ) {}
+
+  // Supposes we have connection instances: `instance1` and `instance2`.
+  // It will enable transaction for `instance1` as specified.
+  @Transaction(`instance1`)
+  async sampleMethod() {
+    const result = await this.postgres.instance1.query(`select 1=1;`);
+  }
+}
+```
+
+## License
+
+MIT License

package/dist/constants.d.ts

@@ -0,0 +1,9 @@
+declare const ALS: unique symbol;
+declare const GET_CLIENT: unique symbol;
+declare const DEFAULT_INSTANCE_NAME = "default";
+declare const MAX_LENGTH = 42;
+declare const CONNEXTION_POSTGRES_DEBUG = "CONNEXTION_POSTGRES_DEBUG";
+declare const DATE_FORMAT = "YYYY-MM-DD HH:mm:sssZ";
+declare const TRANSACTION_META = "postgres:transaction";
+
+export { ALS, CONNEXTION_POSTGRES_DEBUG, DATE_FORMAT, DEFAULT_INSTANCE_NAME, GET_CLIENT, MAX_LENGTH, TRANSACTION_META };

package/dist/constants.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  ALS: () => ALS,
+  CONNEXTION_POSTGRES_DEBUG: () => CONNEXTION_POSTGRES_DEBUG,
+  DATE_FORMAT: () => DATE_FORMAT,
+  DEFAULT_INSTANCE_NAME: () => DEFAULT_INSTANCE_NAME,
+  GET_CLIENT: () => GET_CLIENT,
+  MAX_LENGTH: () => MAX_LENGTH,
+  TRANSACTION_META: () => TRANSACTION_META
+});
+module.exports = __toCommonJS(constants_exports);
+const ALS = Symbol(`ALS`);
+const GET_CLIENT = Symbol(`GET_CLIENT`);
+const DEFAULT_INSTANCE_NAME = "default";
+const MAX_LENGTH = 42;
+const CONNEXTION_POSTGRES_DEBUG = "CONNEXTION_POSTGRES_DEBUG";
+const DATE_FORMAT = "YYYY-MM-DD HH:mm:sssZ";
+const TRANSACTION_META = "postgres:transaction";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALS,
+  CONNEXTION_POSTGRES_DEBUG,
+  DATE_FORMAT,
+  DEFAULT_INSTANCE_NAME,
+  GET_CLIENT,
+  MAX_LENGTH,
+  TRANSACTION_META
+});

package/dist/define-postgres.d.ts

@@ -0,0 +1,41 @@
+import { PostgresInstanceOptions } from './types.js';
+import * as _nestjs_common from '@nestjs/common';
+import * as _nestjs_kitchen_connextion from '@nestjs-kitchen/connextion';
+import { PostgresInstance } from './postgres.instance.js';
+import 'pg';
+import 'node:async_hooks';
+import './constants.js';
+
+/**
+ * Creates a set of Postgres services, modules, and their associated Transaction decorator.
+ */
+declare const definePostgres: <T extends string = "default">() => {
+    /**
+     * The Postgres service, responsible for managing all postgres connection instances registered by the module.
+     */
+    Postgres: _nestjs_common.Type<Record<_nestjs_kitchen_connextion.ConnectionOptionName<T>, Omit<PostgresInstance, keyof _nestjs_kitchen_connextion.ConnextionInstance<unknown>>>>;
+    /**
+     * The Postgres module, used to register and create postgres connection instances with options.
+     *
+     * This module can be configured using 2 static methods:
+     *
+     * - `register`
+     * - `registerAsync`
+     *
+     */
+    PostgresModule: {
+        new (): {};
+        register(options: _nestjs_kitchen_connextion.ModuleOptions<T, PostgresInstanceOptions>): _nestjs_common.DynamicModule;
+        registerAsync(options: _nestjs_kitchen_connextion.AsyncModuleOptions<T, PostgresInstanceOptions>): _nestjs_common.DynamicModule;
+    };
+    /**
+     * A decorator that automatically enables transactions for the specific Postgres
+     * service instances associated with the decorated method.
+     *
+     * - By default, transactions are enabled for all instances of the associated Postgres service.
+     * - If specific instances are specified, only those instances will have transactions enabled.
+     */
+    Transaction: (...rest: T[]) => (target: any, _propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+};
+
+export { definePostgres };

package/dist/define-postgres.js

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var define_postgres_exports = {};
+__export(define_postgres_exports, {
+  definePostgres: () => definePostgres
+});
+module.exports = __toCommonJS(define_postgres_exports);
+var import_connextion = require("@nestjs-kitchen/connextion");
+var import_constants = require("./constants");
+var import_postgres = require("./postgres.instance");
+var import_transaction = require("./transaction");
+const innerDefinePostgres = (0, import_connextion.defineConnextionBuilder)({
+  connextionName: "Postgres",
+  InstanceClass: import_postgres.PostgresInstance,
+  defaultInstanceName: import_constants.DEFAULT_INSTANCE_NAME
+});
+const definePostgres = /* @__PURE__ */ __name(() => {
+  const { Postgres, PostgresModule } = innerDefinePostgres();
+  return {
+    /**
+    * The Postgres service, responsible for managing all postgres connection instances registered by the module.
+    */
+    Postgres,
+    /**
+    * The Postgres module, used to register and create postgres connection instances with options.
+    *
+    * This module can be configured using 2 static methods:
+    *
+    * - `register`
+    * - `registerAsync`
+    *
+    */
+    PostgresModule,
+    /**
+    * A decorator that automatically enables transactions for the specific Postgres
+    * service instances associated with the decorated method.
+    *
+    * - By default, transactions are enabled for all instances of the associated Postgres service.
+    * - If specific instances are specified, only those instances will have transactions enabled.
+    */
+    Transaction: (0, import_transaction.createTransaction)(Postgres)
+  };
+}, "definePostgres");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  definePostgres
+});

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+import { ConnextionError } from '@nestjs-kitchen/connextion';
+
+/**
+ * Internal error type.
+ */
+declare class PostgresError extends ConnextionError {
+    cause?: unknown;
+    constructor(message?: string | Error, cause?: unknown);
+}
+
+export { PostgresError };

package/dist/errors.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var errors_exports = {};
+__export(errors_exports, {
+  PostgresError: () => PostgresError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_connextion = require("@nestjs-kitchen/connextion");
+const _PostgresError = class _PostgresError extends import_connextion.ConnextionError {
+  constructor(message, cause) {
+    super(typeof message === "string" ? message : message?.message);
+    __publicField(this, "cause");
+    this.name = "PostgresError";
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+__name(_PostgresError, "PostgresError");
+let PostgresError = _PostgresError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresError
+});

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { definePostgres } from './define-postgres.js';
+export { PostgresError } from './errors.js';
+import './types.js';
+import 'pg';
+import '@nestjs/common';
+import '@nestjs-kitchen/connextion';
+import './postgres.instance.js';
+import 'node:async_hooks';
+import './constants.js';

package/dist/index.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  PostgresError: () => import_errors.PostgresError,
+  definePostgres: () => import_define_postgres.definePostgres
+});
+module.exports = __toCommonJS(src_exports);
+var import_define_postgres = require("./define-postgres");
+var import_errors = require("./errors");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresError,
+  definePostgres
+});

package/dist/postgres.instance.d.ts

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ConnextionInstance } from '@nestjs-kitchen/connextion';
+import { PoolClient, Submittable, QueryArrayConfig, QueryConfigValues, QueryArrayResult, QueryResultRow, QueryConfig, QueryResult } from 'pg';
+import { ALS, GET_CLIENT } from './constants.js';
+import { PostgresInstanceOptions, ALSType } from './types.js';
+
+declare class PostgresInstance extends ConnextionInstance<PostgresInstanceOptions> {
+    private pool;
+    private logger;
+    private debug;
+    [ALS]: AsyncLocalStorage<ALSType>;
+    private listener1;
+    private listener2;
+    constructor(name: string, options?: PostgresInstanceOptions);
+    private end;
+    dispose(): Promise<void> | undefined;
+    create(options: PostgresInstanceOptions): void;
+    [GET_CLIENT](): Promise<PoolClient>;
+    query<T extends Submittable>(queryStream: T): Promise<T>;
+    query<R extends any[] = any[], I = any[]>(queryConfig: QueryArrayConfig<I>, values?: QueryConfigValues<I>): Promise<QueryArrayResult<R>>;
+    query<R extends QueryResultRow = any, I = any[]>(queryConfig: QueryConfig<I>): Promise<QueryResult<R>>;
+    query<R extends QueryResultRow = any, I = any[]>(queryTextOrConfig: string | QueryConfig<I>, values?: QueryConfigValues<I>): Promise<QueryResult<R>>;
+    private queryWithConfig;
+    private transactionQueryWithConfig;
+    private queryWithSubmittable;
+    private transactionQueryWithSubmittable;
+}
+
+export { PostgresInstance };

package/dist/postgres.instance.js

@@ -0,0 +1,213 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var postgres_instance_exports = {};
+__export(postgres_instance_exports, {
+  PostgresInstance: () => PostgresInstance
+});
+module.exports = __toCommonJS(postgres_instance_exports);
+var import_node_async_hooks = require("node:async_hooks");
+var import_connextion = require("@nestjs-kitchen/connextion");
+var import_common = require("@nestjs/common");
+var import_pg = require("pg");
+var import_uid = require("uid");
+var import_constants = require("./constants");
+var import_errors = require("./errors");
+var import_utils = require("./utils");
+var _a;
+const _PostgresInstance = class _PostgresInstance extends import_connextion.ConnextionInstance {
+  constructor(name, options) {
+    super(name, options);
+    __publicField(this, "pool");
+    __publicField(this, "logger");
+    __publicField(this, "debug");
+    // Every instance should have its own als to avoid accessing wrong context.
+    __publicField(this, _a, new import_node_async_hooks.AsyncLocalStorage());
+    __publicField(this, "listener1", /* @__PURE__ */ __name((_cli) => {
+      _cli.on("error", this.listener2);
+    }, "listener1"));
+    __publicField(this, "listener2", /* @__PURE__ */ __name((err) => {
+      this.logger.error(err);
+    }, "listener2"));
+    this.logger = new import_common.Logger(`Postgres][${name}`);
+    this.debug = Boolean(process.env[import_constants.CONNEXTION_POSTGRES_DEBUG]) || options?.debug;
+  }
+  async end(pool) {
+    if (!pool) {
+      return;
+    }
+    try {
+      await pool.end();
+      pool.off("connect", this.listener1);
+      pool.off("error", this.listener2);
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+  dispose() {
+    if (!this.pool) {
+      return;
+    }
+    const pool = this.pool;
+    this.pool = void 0;
+    return this.end(pool);
+  }
+  create(options) {
+    this.dispose();
+    const pool = new import_pg.Pool(options);
+    pool.on("connect", this.listener1);
+    pool.on("error", this.listener2);
+    this.pool = pool;
+  }
+  async [(_a = import_constants.ALS, import_constants.GET_CLIENT)]() {
+    if (!this.pool) {
+      throw new import_errors.PostgresError("pool not found");
+    }
+    if (!this.debug) {
+      const [client2, err2] = await (0, import_utils.plainPromise)(this.pool.connect());
+      if (err2) {
+        throw new import_errors.PostgresError(err2, err2);
+      }
+      if (!client2) {
+        throw new import_errors.PostgresError("client not found");
+      }
+      return client2;
+    }
+    const logger = (0, import_utils.createDebugLogger)(this.logger.debug.bind(this.logger), this.debug);
+    const debug = (0, import_utils.debugFactroy)(this.name, (0, import_uid.uid)(21), logger);
+    const [client, err] = await (0, import_utils.plainPromise)(debug.pool.connect(this.pool.connect.bind(this.pool))());
+    if (err) {
+      throw new import_errors.PostgresError(err, err);
+    }
+    if (!client) {
+      throw new import_errors.PostgresError("client not found");
+    }
+    return new Proxy(client, {
+      get(target, prop) {
+        if (debug.client[prop]) {
+          return debug.client[prop](target[prop].bind(target));
+        }
+        return target[prop];
+      }
+    });
+  }
+  async query(...rest) {
+    if (!rest.length) {
+      throw new import_errors.PostgresError(`empty parameters`);
+    }
+    const store = this[import_constants.ALS].getStore();
+    const methodMap = {
+      submittable: store ? this.transactionQueryWithSubmittable : this.queryWithSubmittable,
+      config: store ? this.transactionQueryWithConfig : this.queryWithConfig
+    };
+    const method = methodMap[(0, import_utils.isSubmittable)(rest[0]) ? "submittable" : "config"].bind(this);
+    return method(...rest);
+  }
+  async queryWithConfig(...rest) {
+    const client = await this[import_constants.GET_CLIENT]();
+    let err = void 0;
+    try {
+      return await client.query(...rest);
+    } catch (error) {
+      err = new import_errors.PostgresError(error, error);
+      throw err;
+    } finally {
+      client.release(err ?? true);
+    }
+  }
+  async transactionQueryWithConfig(...rest) {
+    const store = this[import_constants.ALS].getStore();
+    const client = await store.client;
+    let err = void 0;
+    const { promise, resolve } = Promise.withResolvers();
+    store.queries.push(promise);
+    try {
+      return await client.query(...rest);
+    } catch (error) {
+      err = new import_errors.PostgresError(error, error);
+      throw err;
+    } finally {
+      resolve(err ?? true);
+    }
+  }
+  async queryWithSubmittable(queryStream) {
+    const client = await this[import_constants.GET_CLIENT]();
+    let res = void 0;
+    let err = void 0;
+    try {
+      res = await client.query(queryStream);
+      return res;
+    } catch (error) {
+      err = new import_errors.PostgresError(error, error);
+      throw err;
+    } finally {
+      if (res) {
+        const onError = /* @__PURE__ */ __name((error) => {
+          res.off("end", onEnd);
+          client.release(new import_errors.PostgresError(error, error));
+        }, "onError");
+        const onEnd = /* @__PURE__ */ __name(() => {
+          res.off("error", onError);
+          client.release(true);
+        }, "onEnd");
+        res.once("end", onEnd);
+        res.once("error", onError);
+      } else {
+        client.release(err ?? true);
+      }
+    }
+  }
+  async transactionQueryWithSubmittable(queryStream) {
+    const store = this[import_constants.ALS].getStore();
+    const client = await store.client;
+    let res = void 0;
+    let err = void 0;
+    const { promise, resolve } = Promise.withResolvers();
+    store.queries.push(promise);
+    try {
+      res = await client.query(queryStream);
+      return res;
+    } catch (error) {
+      err = new import_errors.PostgresError(error, error);
+      throw err;
+    } finally {
+      if (res) {
+        const onError = /* @__PURE__ */ __name((error) => {
+          res.off("end", onEnd);
+          resolve(new import_errors.PostgresError(error, error));
+        }, "onError");
+        const onEnd = /* @__PURE__ */ __name(() => {
+          res.off("error", onError);
+          resolve(true);
+        }, "onEnd");
+        res.once("end", onEnd);
+        res.once("error", onError);
+      } else {
+        resolve(err ?? true);
+      }
+    }
+  }
+};
+__name(_PostgresInstance, "PostgresInstance");
+let PostgresInstance = _PostgresInstance;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresInstance
+});

package/dist/transaction.d.ts

@@ -0,0 +1,6 @@
+import { defineConnextionBuilder } from '@nestjs-kitchen/connextion';
+
+type Postgres = ReturnType<ReturnType<typeof defineConnextionBuilder<'Postgres', PostgresInstance>>>['Postgres'];
+declare const createTransaction: <T extends string>(Postgres: Postgres) => (...rest: T[]) => (target: any, _propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+
+export { createTransaction };

package/dist/transaction.js

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transaction_exports = {};
+__export(transaction_exports, {
+  createTransaction: () => createTransaction
+});
+module.exports = __toCommonJS(transaction_exports);
+var import_common = require("@nestjs/common");
+var import_constants = require("./constants");
+var import_errors = require("./errors");
+var import_utils = require("./utils");
+const createTransaction = /* @__PURE__ */ __name((Postgres) => {
+  const postgresPropName = Symbol("postgres");
+  return (...rest) => {
+    const injectPostgres = (0, import_common.Inject)(Postgres);
+    return (target, _propertyKey, propertyDescriptor) => {
+      injectPostgres(target, postgresPropName);
+      const originalMethod = propertyDescriptor.value;
+      if ((0, import_utils.getTransactionMetdata)(originalMethod)) {
+        throw new import_errors.PostgresError("Cannot reapply the same transaction decorator multiple times.");
+      }
+      (0, import_utils.setTransactionMetdata)(originalMethod);
+      propertyDescriptor.value = async function(...args) {
+        const that = this;
+        const postgres = that[postgresPropName];
+        const keys = rest.length ? rest : Object.keys(postgres.instanceTokens);
+        const validNames = [];
+        const invalidNames = [];
+        (0, import_utils.normalizeStrings)(keys).forEach((name) => {
+          if (postgres.instanceTokens[name]) {
+            validNames.push(name);
+          } else {
+            invalidNames.push(name);
+          }
+        });
+        if (invalidNames.length) {
+          throw new import_errors.PostgresError(`Invalid keys: ${invalidNames.join(", ")}`);
+        }
+        const list = validNames.map((name) => {
+          return {
+            name,
+            store: {
+              client: postgres[name][import_constants.GET_CLIENT](),
+              queries: []
+            },
+            als: postgres[name][import_constants.ALS],
+            inited: false
+          };
+        });
+        const initClients = /* @__PURE__ */ __name(async () => {
+          for (const ele of list) {
+            await ele.store.client;
+            ele.inited = true;
+          }
+        }, "initClients");
+        const runWithClients = /* @__PURE__ */ __name(async (fn) => {
+          for (const ele of list) {
+            if (ele.inited) {
+              const client = await ele.store.client;
+              await fn(client);
+            }
+          }
+        }, "runWithClients");
+        const releaseClients = /* @__PURE__ */ __name(async (err2) => runWithClients((client) => client.release(err2 ?? true)), "releaseClients");
+        const [_, initErr] = await (0, import_utils.plainPromise)(initClients());
+        if (initErr) {
+          await releaseClients();
+          throw initErr;
+        }
+        const executeQueries = list.reduce((next, ele) => () => ele.als.run(ele.store, next), () => originalMethod.apply(that, args));
+        const [result, err] = await (0, import_utils.plainPromise)((async () => {
+          const [result2, err2] = await (0, import_utils.plainPromise)(
+            // Start transaction and execute queries.
+            (async () => {
+              await runWithClients((client) => client.query("BEGIN"));
+              const result3 = await executeQueries();
+              const queryResults = await Promise.all(list.flatMap((c) => c.store.queries));
+              const queryFailures = queryResults.filter((res) => res !== true);
+              if (queryFailures.length) {
+                throw queryFailures[0];
+              }
+              return result3;
+            })()
+          );
+          await runWithClients((client) => client.query(err2 ? "ROLLBACK" : "COMMIT"));
+          if (err2) {
+            throw err2;
+          }
+          return result2;
+        })());
+        await releaseClients(err);
+        if (err) {
+          throw err;
+        }
+        return result;
+      };
+      (0, import_utils.copyMethodMetadata)(originalMethod, propertyDescriptor.value);
+      return propertyDescriptor;
+    };
+  };
+}, "createTransaction");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransaction
+});

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+import { PoolClient, PoolConfig } from 'pg';
+
+type ALSQueryType = Error | true;
+interface ALSType {
+    client: Promise<PoolClient>;
+    queries: Promise<ALSQueryType>[];
+}
+type PostgresInstanceOptions = PoolConfig & {
+    debug?: boolean | ((data: Record<any, any>) => void);
+};
+
+export type { ALSQueryType, ALSType, PostgresInstanceOptions };

package/dist/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/utils.d.ts

@@ -0,0 +1,26 @@
+import { Submittable, PoolClient } from 'pg';
+
+declare const isSubmittable: (val: any) => val is Submittable;
+declare const isObject: (val: any) => val is object;
+declare const normalizeStrings: (strs?: string[]) => string[];
+declare const plainPromise: <T>(promise: Promise<T> | T) => Promise<[T, undefined] | [undefined, any]>;
+declare const truncateString: (str: string, maxLength: number) => string;
+declare const printTable: (logData: Record<string, any>) => string;
+declare const getCurrentDateStr: () => string;
+declare const formatArray: (arr?: any) => string;
+declare const extraceQueryTextAndValues: (...rest: any[]) => [text: string, values: any[]];
+declare const createDebugLogger: (defaultLogger: (...rest: any) => void, customFormater?: Boolean | ((data: Record<any, any>) => void)) => (data: Record<any, any>) => void;
+declare const debugFactroy: (name: string, queryId: string, logger: (data: Record<any, any>) => void) => {
+    pool: {
+        connect: <T extends () => Promise<PoolClient>>(callback: T) => () => Promise<PoolClient>;
+    };
+    client: {
+        query: <T extends (...rest: unknown[]) => Promise<any>>(callback: T) => (...rest: Parameters<T>) => Promise<any>;
+        release: <T extends (...rest: unknown[]) => void>(callback: T) => (...rest: Parameters<T>) => void;
+    };
+};
+declare const copyMethodMetadata: (from: any, to: any) => void;
+declare const getTransactionMetdata: (target: any) => any;
+declare const setTransactionMetdata: (target: any) => void;
+
+export { copyMethodMetadata, createDebugLogger, debugFactroy, extraceQueryTextAndValues, formatArray, getCurrentDateStr, getTransactionMetdata, isObject, isSubmittable, normalizeStrings, plainPromise, printTable, setTransactionMetdata, truncateString };

package/dist/utils.js

@@ -0,0 +1,263 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  copyMethodMetadata: () => copyMethodMetadata,
+  createDebugLogger: () => createDebugLogger,
+  debugFactroy: () => debugFactroy,
+  extraceQueryTextAndValues: () => extraceQueryTextAndValues,
+  formatArray: () => formatArray,
+  getCurrentDateStr: () => getCurrentDateStr,
+  getTransactionMetdata: () => getTransactionMetdata,
+  isObject: () => isObject,
+  isSubmittable: () => isSubmittable,
+  normalizeStrings: () => normalizeStrings,
+  plainPromise: () => plainPromise,
+  printTable: () => printTable,
+  setTransactionMetdata: () => setTransactionMetdata,
+  truncateString: () => truncateString
+});
+module.exports = __toCommonJS(utils_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_constants = require("./constants");
+const isSubmittable = /* @__PURE__ */ __name((val) => {
+  return val && typeof val.submit === "function";
+}, "isSubmittable");
+const isObject = /* @__PURE__ */ __name((val) => {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}, "isObject");
+const normalizeStrings = /* @__PURE__ */ __name((strs) => {
+  if (!strs) {
+    return [];
+  }
+  return Array.from(new Set(strs.filter(Boolean).map((ele) => ele.trim())));
+}, "normalizeStrings");
+const plainPromise = /* @__PURE__ */ __name(async (promise) => {
+  let result = void 0;
+  let err = void 0;
+  try {
+    result = await promise;
+  } catch (error) {
+    err = error;
+  }
+  return [
+    result,
+    err
+  ];
+}, "plainPromise");
+const truncateString = /* @__PURE__ */ __name((str, maxLength) => {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  const truncatedLength = maxLength - 3;
+  if (truncatedLength <= 0) {
+    return "...";
+  }
+  return str.slice(0, truncatedLength) + "...";
+}, "truncateString");
+const printTable = /* @__PURE__ */ __name((logData) => {
+  const maxKeyLength = import_constants.MAX_LENGTH / 3;
+  const maxValueLength = import_constants.MAX_LENGTH;
+  const separatorTop = "\u2500".repeat(maxKeyLength + 2) + "\u252C" + "\u2500".repeat(maxValueLength + 2);
+  const separatorBottom = "\u2500".repeat(maxKeyLength + 2) + "\u2534" + "\u2500".repeat(maxValueLength + 2);
+  const lines = [
+    `\u250C${separatorTop}\u2510`,
+    ...Object.entries(logData).filter(([_, value]) => value).map(([key, value]) => `\u2502 ${key.padEnd(maxKeyLength)} \u2502 ${truncateString(String(value), import_constants.MAX_LENGTH).padEnd(maxValueLength)} \u2502`),
+    `\u2514${separatorBottom}\u2518`
+  ];
+  return lines.join("\n");
+}, "printTable");
+const getCurrentDateStr = /* @__PURE__ */ __name(() => {
+  return (0, import_dayjs.default)().format(import_constants.DATE_FORMAT);
+}, "getCurrentDateStr");
+const formatArray = /* @__PURE__ */ __name((arr) => {
+  return Array.isArray(arr) ? `[${arr.map(String).join(", ")}]` : "null";
+}, "formatArray");
+const extraceQueryTextAndValues = /* @__PURE__ */ __name((...rest) => {
+  const [arg0, arg1] = rest;
+  if (arg0 && (isSubmittable(arg0) || isObject(arg0))) {
+    return [
+      arg0.text,
+      arg1 ?? arg0.values
+    ];
+  }
+  return [
+    arg0,
+    arg1
+  ];
+}, "extraceQueryTextAndValues");
+const createDebugLogger = /* @__PURE__ */ __name((defaultLogger, customFormater) => {
+  if (typeof customFormater === "function") {
+    return (data) => {
+      defaultLogger(customFormater(data));
+    };
+  }
+  return (data) => {
+    const firstLine = `Executing Postgres command
+`;
+    defaultLogger(firstLine + printTable(data));
+  };
+}, "createDebugLogger");
+const debugFactroy = /* @__PURE__ */ __name((name, queryId, logger) => {
+  return {
+    pool: {
+      connect: /* @__PURE__ */ __name((callback) => {
+        return async () => {
+          const startOn = getCurrentDateStr();
+          let err = void 0;
+          try {
+            return await callback();
+          } catch (error) {
+            err = error;
+            throw err;
+          } finally {
+            logger({
+              Instance: name,
+              Client: queryId,
+              Type: "Request new client",
+              "Started On": startOn,
+              "Ended On": getCurrentDateStr(),
+              Status: err ? "Failed" : "Successful",
+              Error: err
+            });
+          }
+        };
+      }, "connect")
+    },
+    client: {
+      query: /* @__PURE__ */ __name((callback) => {
+        return async (...rest) => {
+          const [text, values] = extraceQueryTextAndValues(...rest);
+          const submittable = isSubmittable(rest[0]);
+          const startOn = getCurrentDateStr();
+          let err = void 0;
+          if (submittable) {
+            rest[0].on("end", () => {
+              logger({
+                Instance: name,
+                Client: queryId,
+                Type: "Submittable",
+                Text: text,
+                Values: formatArray(values),
+                "Started On": startOn,
+                "Ended On": getCurrentDateStr(),
+                Status: "Successful"
+              });
+            });
+            rest[0].on("error", (err2) => {
+              logger({
+                Instance: name,
+                Client: queryId,
+                Type: "Submittable",
+                Text: text,
+                Values: formatArray(values),
+                "Started On": startOn,
+                "Ended On": getCurrentDateStr(),
+                Status: "Failed",
+                Error: err2
+              });
+            });
+          }
+          try {
+            return await callback(...rest);
+          } catch (error) {
+            err = error;
+            throw err;
+          } finally {
+            if (!submittable) {
+              logger({
+                Instance: name,
+                Client: queryId,
+                Type: "Query",
+                Text: text,
+                Values: formatArray(values),
+                "Started On": startOn,
+                "Ended On": getCurrentDateStr(),
+                Status: err ? "Failed" : "Successful",
+                Error: err
+              });
+            }
+          }
+        };
+      }, "query"),
+      release: /* @__PURE__ */ __name((callback) => {
+        return (...rest) => {
+          const startOn = getCurrentDateStr();
+          let err = void 0;
+          try {
+            return callback(...rest);
+          } catch (error) {
+            err = error;
+            throw err;
+          } finally {
+            logger({
+              Instance: name,
+              Client: queryId,
+              Type: "Release client",
+              "Started On": startOn,
+              "Ended On": getCurrentDateStr(),
+              Status: err ? "Failed" : "Successful",
+              Error: err
+            });
+          }
+        };
+      }, "release")
+    }
+  };
+}, "debugFactroy");
+const copyMethodMetadata = /* @__PURE__ */ __name((from, to) => {
+  const metadataKeys = Reflect.getMetadataKeys(from);
+  metadataKeys.map((key) => {
+    const value = Reflect.getMetadata(key, from);
+    Reflect.defineMetadata(key, value, to);
+  });
+}, "copyMethodMetadata");
+const getTransactionMetdata = /* @__PURE__ */ __name((target) => {
+  return Reflect.getMetadata(import_constants.TRANSACTION_META, target);
+}, "getTransactionMetdata");
+const setTransactionMetdata = /* @__PURE__ */ __name((target) => {
+  return Reflect.defineMetadata(import_constants.TRANSACTION_META, true, target);
+}, "setTransactionMetdata");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyMethodMetadata,
+  createDebugLogger,
+  debugFactroy,
+  extraceQueryTextAndValues,
+  formatArray,
+  getCurrentDateStr,
+  getTransactionMetdata,
+  isObject,
+  isSubmittable,
+  normalizeStrings,
+  plainPromise,
+  printTable,
+  setTransactionMetdata,
+  truncateString
+});

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@nestjs-kitchen/connextion-postgres",
+  "private": false,
+  "description": "A flexible module to provide node-postgres interface in NextJS.",
+  "version": "1.0.0",
+  "homepage": "https://github.com/yikenman/nestjs-kitchen",
+  "repository": "https://github.com/yikenman/nestjs-kitchen",
+  "author": "yikenman",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "dayjs": "^1.11.13",
+    "uid": "^2.0.2"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.4.12",
+    "@nestjs/testing": "^10.4.12",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.1",
+    "@types/pg": "^8.11.10",
+    "@types/supertest": "^6.0.2",
+    "jest": "^29.7.0",
+    "pg": "^8.13.1",
+    "reflect-metadata": "^0.2.1",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "@nestjs-kitchen/connextion": "1.0.0"
+  },
+  "engines": {
+    "node": ">=20.13.0"
+  },
+  "keywords": [
+    "database",
+    "module",
+    "NextJS",
+    "node-postgres",
+    "NodeJS",
+    "pg",
+    "Postgres",
+    "SQL"
+  ],
+  "peerDependencies": {
+    "@nestjs/common": "^10.4.12",
+    "@types/pg": "^8.11.10",
+    "pg": "^8.13.1",
+    "reflect-metadata": "^0.2.1",
+    "@nestjs-kitchen/connextion": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "jest",
+    "test:ci": "jest --coverage",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/jest/bin/jest --runInBand",
+    "test:watch": "jest --watch"
+  }
+}