@nestjs-kitchen/connextion-postgres 2.0.2 → 2.0.4

package/dist/postgres.instance.js

@@ -1,218 +1,203 @@
-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");
+"use strict";
 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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresInstance = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+const connextion_1 = require("@nestjs-kitchen/connextion");
+const common_1 = require("@nestjs/common");
+const pg_1 = require("pg");
+const uid_1 = require("uid");
+const constants_1 = require("./constants");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+class PostgresInstance extends connextion_1.ConnextionInstance {
+    constructor(name, options) {
+        super(name, options);
+        this.pool = undefined;
+        // Every instance should have its own als to avoid accessing wrong context.
+        this[_a] = new node_async_hooks_1.AsyncLocalStorage();
+        this.listener1 = (_cli) => {
+            _cli.on('error', this.listener2);
+        };
+        this.listener2 = (err) => {
+            this.logger.error(err);
+        };
+        this.logger = new common_1.Logger(`Postgres][${name}`);
+        this.debug = Boolean(process.env[constants_1.CONNEXTION_POSTGRES_DEBUG]) || options?.debug;
     }
-    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();
-    try {
-      const pool = new import_pg.Pool(options);
-      pool.on("connect", this.listener1);
-      pool.on("error", this.listener2);
-      this.pool = pool;
-    } catch (error) {
-      this.logger.error(error.message);
-    }
-  }
-  async [(_a = import_constants.ALS, import_constants.GET_CLIENT)]() {
-    if (!this.pool) {
-      throw new import_errors.PostgresError("pool not found");
+    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);
+        }
     }
-    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;
+    dispose() {
+        if (!this.pool) {
+            return;
+        }
+        const pool = this.pool;
+        this.pool = undefined;
+        return this.end(pool);
     }
-    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);
+    create(options) {
+        this.dispose();
+        try {
+            const pool = new pg_1.Pool(options);
+            //https://github.com/brianc/node-postgres/issues/2439#issuecomment-757691278
+            pool.on('connect', this.listener1);
+            pool.on('error', this.listener2);
+            this.pool = pool;
+        }
+        catch (error) {
+            this.logger.error(error.message);
+        }
     }
-    if (!client) {
-      throw new import_errors.PostgresError("client not found");
+    async [(_a = constants_1.ALS, constants_1.GET_CLIENT)]() {
+        if (!this.pool) {
+            throw new errors_1.PostgresError('pool not found');
+        }
+        if (!this.debug) {
+            const [client, err] = await (0, utils_1.plainPromise)(this.pool.connect());
+            if (err) {
+                throw new errors_1.PostgresError(err, err);
+            }
+            if (!client) {
+                throw new errors_1.PostgresError('client not found');
+            }
+            return client;
+        }
+        // Debug mode
+        const logger = (0, utils_1.createDebugLogger)(this.logger.debug.bind(this.logger), this.debug);
+        const debug = (0, utils_1.debugFactroy)(this.name, (0, uid_1.uid)(21), logger);
+        const [client, err] = await (0, utils_1.plainPromise)(debug.pool.connect(this.pool.connect.bind(this.pool))());
+        if (err) {
+            throw new errors_1.PostgresError(err, err);
+        }
+        if (!client) {
+            throw new errors_1.PostgresError('client not found');
+        }
+        return new Proxy(client, {
+            get(target, prop, receiver) {
+                const value = Reflect.get(target, prop, receiver);
+                if (debug.client[prop]) {
+                    return debug.client[prop](value.bind(target));
+                }
+                return value;
+            }
+        });
     }
-    return new Proxy(client, {
-      get(target, prop, receiver) {
-        const value = Reflect.get(target, prop, receiver);
-        if (debug.client[prop]) {
-          return debug.client[prop](value.bind(target));
-        }
-        return value;
-      }
-    });
-  }
-  async query(...rest) {
-    if (!rest.length) {
-      throw new import_errors.PostgresError(`empty parameters`);
+    async query(...rest) {
+        if (!rest.length) {
+            throw new errors_1.PostgresError(`empty parameters`);
+        }
+        const store = this[constants_1.ALS].getStore();
+        const methodMap = {
+            submittable: store ? this.transactionQueryWithSubmittable : this.queryWithSubmittable,
+            config: store ? this.transactionQueryWithConfig : this.queryWithConfig
+        };
+        const method = methodMap[(0, utils_1.isSubmittable)(rest[0]) ? 'submittable' : 'config'].bind(this);
+        return method(...rest);
     }
-    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 queryWithConfig(...rest) {
+        const client = await this[constants_1.GET_CLIENT]();
+        let err = undefined;
+        try {
+            return (await client.query(...rest));
+        }
+        catch (error) {
+            err = new errors_1.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 transactionQueryWithConfig(...rest) {
+        const store = this[constants_1.ALS].getStore();
+        const client = await store.client;
+        let err = undefined;
+        const { promise, resolve } = Promise.withResolvers();
+        store.queries.push(promise);
+        try {
+            return (await client.query(...rest));
+        }
+        catch (error) {
+            err = new errors_1.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 queryWithSubmittable(queryStream) {
+        const client = await this[constants_1.GET_CLIENT]();
+        let res = undefined;
+        let err = undefined;
+        try {
+            res = (await client.query(queryStream));
+            return res;
+        }
+        catch (error) {
+            err = new errors_1.PostgresError(error, error);
+            throw err;
+        }
+        finally {
+            if (res) {
+                const onError = (error) => {
+                    res.off('end', onEnd);
+                    client.release(new errors_1.PostgresError(error, error));
+                };
+                const onEnd = () => {
+                    res.off('error', onError);
+                    client.release(true);
+                };
+                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);
-      }
+    async transactionQueryWithSubmittable(queryStream) {
+        const store = this[constants_1.ALS].getStore();
+        const client = await store.client;
+        let res = undefined;
+        let err = undefined;
+        const { promise, resolve } = Promise.withResolvers();
+        store.queries.push(promise);
+        try {
+            res = (await client.query(queryStream));
+            return res;
+        }
+        catch (error) {
+            err = new errors_1.PostgresError(error, error);
+            throw err;
+        }
+        finally {
+            if (res) {
+                const onError = (error) => {
+                    res.off('end', onEnd);
+                    resolve(new errors_1.PostgresError(error, error));
+                };
+                const onEnd = () => {
+                    res.off('error', onError);
+                    resolve(true);
+                };
+                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
-});
+}
+exports.PostgresInstance = PostgresInstance;

package/dist/transaction.d.ts

@@ -1,6 +1,5 @@
 import { defineConnextionBuilder } from '@nestjs-kitchen/connextion';
-
+import type { PostgresInstance } from './postgres.instance';
 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 };
+export declare const createTransaction: <T extends string>(Postgres: Postgres) => (...rest: T[]) => (target: any, _propertyKey: string, propertyDescriptor: PropertyDescriptor) => PropertyDescriptor;
+export {};

package/dist/transaction.js

@@ -1,121 +1,109 @@
-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);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransaction = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+const createTransaction = (Postgres) => {
+    const postgresPropName = Symbol('postgres');
+    return (...rest) => {
+        const injectPostgres = (0, common_1.Inject)(Postgres);
+        return (target, _propertyKey, propertyDescriptor) => {
+            // This is equivalent to property-based injection in the class.
+            // It will append a new injection to the class where the target method is located.
+            // Ref: https://stackoverflow.com/questions/52106406/in-nest-js-how-to-get-a-service-instance-inside-a-decorator
+            injectPostgres(target, postgresPropName);
+            const originalMethod = propertyDescriptor.value;
+            if ((0, utils_1.getTransactionMetdata)(originalMethod)) {
+                throw new errors_1.PostgresError('Cannot reapply the same transaction decorator multiple times.');
             }
-          }
-        }, "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;
+            (0, utils_1.setTransactionMetdata)(originalMethod);
+            propertyDescriptor.value = async function (...args) {
+                const that = this;
+                const postgres = that[postgresPropName];
+                // Enables transaction by default for all instances.
+                const keys = rest.length ? rest : Object.keys(postgres.instanceTokens);
+                const validNames = [];
+                const invalidNames = [];
+                (0, utils_1.normalizeStrings)(keys).forEach((name) => {
+                    if (postgres.instanceTokens[name]) {
+                        validNames.push(name);
+                    }
+                    else {
+                        invalidNames.push(name);
+                    }
+                });
+                if (invalidNames.length) {
+                    throw new errors_1.PostgresError(`Invalid keys: ${invalidNames.join(', ')}`);
+                }
+                const list = validNames.map((name) => {
+                    return {
+                        name,
+                        store: {
+                            client: postgres[name][constants_1.GET_CLIENT](),
+                            queries: []
+                        },
+                        als: postgres[name][constants_1.ALS],
+                        inited: false
+                    };
+                });
+                const initClients = async () => {
+                    for (const ele of list) {
+                        await ele.store.client;
+                        ele.inited = true;
+                    }
+                };
+                const runWithClients = async (fn) => {
+                    for (const ele of list) {
+                        if (ele.inited) {
+                            const client = await ele.store.client;
+                            await fn(client);
+                        }
+                    }
+                };
+                const releaseClients = async (err) => runWithClients((client) => client.release(err ?? true));
+                // Ensure all clients are available.
+                const [_, initErr] = await (0, utils_1.plainPromise)(initClients());
+                if (initErr) {
+                    // Error is not caused by the available clients. No need to pass the error.
+                    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, utils_1.plainPromise)((async () => {
+                    const [result, err] = await (0, utils_1.plainPromise)(
+                    // Start transaction and execute queries.
+                    (async () => {
+                        await runWithClients((client) => client.query('BEGIN'));
+                        const result = await executeQueries();
+                        // Collect query errors.
+                        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 result;
+                    })());
+                    // End transaction with thrown/query error.
+                    await runWithClients((client) => client.query(err ? 'ROLLBACK' : 'COMMIT'));
+                    if (err) {
+                        throw err;
+                    }
+                    return result;
+                })());
+                // Release all clients.
+                await releaseClients(err);
+                // Resume function call.
+                if (err) {
+                    throw err;
+                }
+                return result;
+            };
+            // Compatible with NestJS decorators.
+            (0, utils_1.copyMethodMetadata)(originalMethod, propertyDescriptor.value);
+            return propertyDescriptor;
+        };
     };
-  };
-}, "createTransaction");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createTransaction
-});
+};
+exports.createTransaction = createTransaction;