@nsshunt/stsdatamanagement 1.17.65 → 1.17.66

package/dist/cliworker-old.js

@@ -0,0 +1,914 @@
+"use strict";
+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 __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
+));
+
+// src/cliworker-old.ts
+var import_crypto = __toESM(require("crypto"));
+
+// src/pgpoolmanager.ts
+var import_stsconfig = require("@nsshunt/stsconfig");
+var import_stsutils = require("@nsshunt/stsutils");
+var import_debug = __toESM(require("debug"));
+var import_colors = require("colors");
+var import_cluster = __toESM(require("cluster"));
+var import_pg = require("pg");
+var { databaseUrl, connectionString, defaultDatabaseConnectionString, isProduction, poolSize } = (0, import_stsconfig.$Options)();
+var debug = (0, import_debug.default)(`proc:${process.pid}`);
+var PGPoolManager = class {
+  #options;
+  #observer = null;
+  #pool;
+  constructor(options) {
+    if (!options) {
+      options = {
+        usedefaultdb: false
+      };
+    }
+    this.#options = options;
+    const connectionStringURI = isProduction ? databaseUrl : options.usedefaultdb === true ? defaultDatabaseConnectionString : connectionString;
+    this.#pool = new import_pg.Pool({
+      connectionString: connectionStringURI,
+      ssl: isProduction,
+      max: poolSize
+      // Default is 10 - This will be the number in a pool per thread (worker)
+      // Consideration needs to be given for the max number of connections at the database.
+      // Max connections calculation = max pool size * max workers (threads) per instance/node * max instances in a cluster (k3s, k8s, swarm mode etc.)
+      /*
+       ssl: {
+      // rejectUnauthorized: true,   // Make this true for PROD
+      rejectUnauthorized: false,
+      //ca: fs.readFileSync('/path/to/server-certificates/root.crt').toString(),
+      //key: fs.readFileSync('/path/to/client-key/postgresql.key').toString(),
+      //cert: fs.readFileSync('/path/to/client-certificates/postgresql.crt').toString(),
+       }
+       */
+    });
+    const re = new RegExp("//(.*)@").exec(connectionStringURI);
+    let usernamepassword = "";
+    if (re) {
+      usernamepassword = re[1];
+    }
+    const sep = usernamepassword.split(":");
+    const usernamepasswordReplacement = usernamepassword.replace(sep[1], "*****************************");
+    const safeConnectionStringURI = connectionStringURI.replace(usernamepassword, usernamepasswordReplacement);
+    if (import_cluster.default.isPrimary) {
+      debug(`Created Database Pool with Master Thread, PID: [${process.pid}]`.yellow);
+    } else {
+      debug(`Created Database Pool with Worker Thread, PID: [${process.pid}]`.yellow);
+    }
+    debug(`Created Database Pool: Master Thread`.yellow);
+    debug(`  Connection URI: [${safeConnectionStringURI}]`.yellow);
+    debug(`  Maximum Pool Size: [${poolSize}]`.yellow);
+    debug(`  SSL Connection: [${isProduction}]`.yellow);
+    this.#pool.on("error", (error) => {
+      console.error(`Unexpected error on idle client: [${error}]`.red);
+      process.exit(-1);
+    });
+    this.#pool.on("connect", () => {
+      this.UpdateInstruments();
+    });
+    this.#pool.on("acquire", () => {
+      this.UpdateInstruments();
+    });
+    this.#pool.on("remove", () => {
+      this.UpdateInstruments();
+    });
+    this.AttachInstruments();
+  }
+  get pool() {
+    return this.#pool;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  UpdateInstruments() {
+  }
+  /*
+      UpdateInstruments()
+      {
+          if ($stsgd.app) {
+              $stsgd.app.UpdateInstrument(Gauge.CONNECTION_POOL_TOTAL_GAUGE, {
+                  val: this.pool.totalCount
+              } as InstrumentGaugeTelemetry);
+  
+              $stsgd.app.UpdateInstrument(Gauge.CONNECTION_POOL_IDLE_GAUGE, {
+                  val: this.pool.idleCount
+              } as InstrumentGaugeTelemetry);
+  
+              $stsgd.app.UpdateInstrument(Gauge.CONNECTION_POOL_WAITING_GAUGE, {
+                  val: this.pool.waitingCount
+              } as InstrumentGaugeTelemetry);
+          }
+      }
+      */
+  AttachInstruments(interval = 1e3) {
+    if (import_stsutils.$stsgd.app) {
+      this.#observer = setInterval(() => {
+        this.UpdateInstruments();
+      }, interval).unref();
+    }
+  }
+  DetachInstruments() {
+    clearInterval(this.#observer);
+    this.#observer = null;
+  }
+};
+
+// src/pgaccesslayer.ts
+var import_http_status_codes = require("http-status-codes");
+var import_ioredis = __toESM(require("ioredis"));
+var import_stsconfig2 = require("@nsshunt/stsconfig");
+var import_pg_copy_streams = __toESM(require("pg-copy-streams"));
+var streamex = __toESM(require("node:stream"));
+var fs = __toESM(require("node:fs/promises"));
+var import_debug2 = __toESM(require("debug"));
+var goptions = (0, import_stsconfig2.$Options)();
+var copyFrom = import_pg_copy_streams.default.from;
+var defaultConfigId = "defaultconfig";
+var systemUserId = "SystemUserID";
+var debug2 = (0, import_debug2.default)(`proc:${process.pid}:pgaccesslayer`);
+var { redisPort, redisServer, useRedis, endFlush, consoleLogErrors } = goptions;
+var PGAccessLayer = class {
+  #cache = null;
+  #pgpool = null;
+  #poolManager = null;
+  constructor(poolManager) {
+    this.#poolManager = poolManager;
+    this.#pgpool = poolManager.pool;
+    if (useRedis === true) {
+      this.#cache = new import_ioredis.default(parseInt(redisPort), redisServer);
+    }
+  }
+  #latestResourceVersion(inputfilter) {
+    const { resname, entname, vnum, filter, incdel, startdate, enddate, dbaction, dbactionuser } = inputfilter;
+    return resname !== void 0 && entname === void 0 && vnum === void 0 && filter === void 0 && incdel === void 0 && startdate === void 0 && enddate === void 0 && dbaction === void 0 && dbactionuser === void 0;
+  }
+  #buildQueryString(filters, restype) {
+    const { resname, entname, vnum, filter, incdel, startdate, enddate, dbaction, dbactionuser } = filters;
+    const qparams = [];
+    let qstring = " where ";
+    let sep = "";
+    let qnum = 0;
+    if (resname !== void 0) {
+      qparams.push(resname);
+      qstring += sep + "r.resname = $" + ++qnum;
+      sep = " and ";
+    }
+    if (entname !== void 0) {
+      qparams.push(entname);
+      qstring += sep + "e.entname = $" + ++qnum;
+      sep = " and ";
+    }
+    if (vnum !== void 0) {
+      qparams.push(vnum);
+      qstring += sep + restype + ".vnum = $" + ++qnum;
+      sep = " and ";
+    } else {
+      if (enddate === void 0) {
+        qstring += sep + restype + ".validto is null";
+        sep = " and ";
+      }
+    }
+    if (filter !== void 0) {
+      qparams.push(filter);
+      if (restype === "r") {
+        qstring += sep + restype + ".resname like $" + ++qnum;
+      } else {
+        qstring += sep + restype + ".entname like $" + ++qnum;
+      }
+      sep = " and ";
+    }
+    if (startdate !== void 0) {
+      qparams.push(startdate);
+      qstring += sep + restype + ".validfrom >= $" + ++qnum;
+      sep = " and ";
+    }
+    if (enddate !== void 0) {
+      qparams.push(enddate);
+      qstring += sep + restype + ".validto <= $" + ++qnum;
+      sep = " and ";
+    }
+    if (incdel === void 0 || incdel.toLowerCase() === "n") {
+      qparams.push(3);
+      qstring += sep + restype + ".dbaction != $" + ++qnum;
+      sep = " and ";
+    }
+    if (dbaction !== void 0) {
+      qparams.push(dbaction);
+      qstring += sep + restype + ".dbaction = $" + ++qnum;
+      sep = " and ";
+    }
+    if (dbactionuser !== void 0) {
+      qparams.push(dbactionuser);
+      qstring += sep + restype + ".dbactionuser = $" + ++qnum;
+      sep = " and ";
+    }
+    if (qnum === 0) {
+      return null;
+    } else {
+      return { qstring, qparams };
+    }
+  }
+  async getLatestResource(resid) {
+    return await this.getResource({ resname: resid });
+  }
+  async saveResource(userid2, resid, data) {
+    const retVal = await this.getLatestResource(resid);
+    if (retVal.status !== import_http_status_codes.StatusCodes.OK) {
+      return await this.createResource(userid2, resid, data);
+    } else {
+      const vnum = retVal.detail.vnum;
+      return await this.updateResource(userid2, resid, vnum, data);
+    }
+  }
+  async getDefaultConfig() {
+    return await this.getLatestResource(defaultConfigId);
+  }
+  async saveDefaultConfig(config) {
+    await this.saveResource(systemUserId, defaultConfigId, config);
+  }
+  async getResourceCount(filter = null) {
+    const fname = "getResourceCount";
+    try {
+      let createQuery = `select count(*) from stsresource r`;
+      if (filter !== null) {
+        createQuery += " where " + filter;
+      }
+      const client = await this.#pgpool?.connect();
+      try {
+        const { rows } = await client.query(createQuery);
+        const dbResponse = rows[0];
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async createResource(userid2, resourceid, payload) {
+    const fname = "createResource";
+    try {
+      let createQuery = null;
+      createQuery = `select * from create_stsresource($1, $2, $3)`;
+      const values = [
+        userid2,
+        resourceid,
+        payload
+      ];
+      const client = await this.#pgpool?.connect();
+      try {
+        await client.query("BEGIN");
+        const { rows } = await client.query(createQuery, values);
+        const dbResponse = rows[0];
+        await client.query("COMMIT");
+        return { status: import_http_status_codes.StatusCodes.CREATED, detail: dbResponse };
+      } catch (error) {
+        await client.query("ROLLBACK");
+        let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+        if (error.code === "23505") {
+          err = { status: import_http_status_codes.StatusCodes.CONFLICT, error: `[${fname}: resourceid [${resourceid}] already exists`, detail: error };
+        }
+        debug2(`Error: ${JSON.stringify(error)}`.red);
+        return err;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async beginX() {
+    const fname = "beginX";
+    try {
+      const client = await this.#pgpool?.connect();
+      await client.query("BEGIN");
+      return client;
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async commitX(client) {
+    const fname = "commitX";
+    try {
+      await client.query("COMMIT");
+      client.release();
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async rollbackX(client) {
+    const fname = "rollbackX";
+    try {
+      await client.query("ROLLBACK");
+      client.release();
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async createResourceX(client, userid2, resourceid, payload) {
+    const fname = "createResourceX";
+    const createQuery = `select * from create_stsresource($1, $2, $3)`;
+    const values = [
+      userid2,
+      resourceid,
+      payload
+    ];
+    try {
+      const { rows } = await client.query(createQuery, values);
+      const dbResponse = rows[0];
+      return { status: import_http_status_codes.StatusCodes.CREATED, detail: dbResponse };
+    } catch (error) {
+      let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      if (error.code === "23505") {
+        err = { status: import_http_status_codes.StatusCodes.CONFLICT, error: `[${fname}: resourceid [${resourceid}] already exists`, detail: error };
+      }
+      debug2(`Error: [${JSON.stringify(err)}]`.red);
+      return err;
+    }
+  }
+  async updateResource(userid2, resourceid, resourcevnum, payload) {
+    const fname = "updateResource";
+    try {
+      const createQuery = `select * from update_stsresource($1, $2, $3, $4)`;
+      const values = [
+        userid2,
+        resourceid,
+        resourcevnum,
+        payload
+      ];
+      const client = await this.#pgpool?.connect();
+      try {
+        await client.query("BEGIN");
+        const { rows } = await client.query(createQuery, values);
+        const dbResponse = rows[0];
+        await client.query("COMMIT");
+        if (this.#cache !== null) {
+          await this.#cache.del(resourceid);
+        }
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        await client.query("ROLLBACK");
+        let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+        if (error.code === "P0002") {
+          err = { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] and version [${resourcevnum}] not found or not current`, detail: error };
+        }
+        debug2(`Error: [${JSON.stringify(err)}]`.red);
+        return err;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async deleteLatestResource(userid2, resid) {
+    const fname = "deleteLatestResource";
+    const retVal = await this.getLatestResource(resid);
+    if (retVal.status !== import_http_status_codes.StatusCodes.OK) {
+      return { status: retVal.status, error: `[${fname}]: Operation was not successful: [${resid}]`, detail: retVal };
+    } else {
+      const vnum = retVal.detail.vnum;
+      await this.deleteResource(userid2, resid, vnum);
+    }
+  }
+  async deleteResource(userid2, resourceid, resourcevnum) {
+    const fname = "deleteResource";
+    try {
+      const createQuery = `select * from delete_stsresource($1, $2, $3)`;
+      const values = [
+        userid2,
+        resourceid,
+        resourcevnum
+      ];
+      const client = await this.#pgpool?.connect();
+      try {
+        await client.query("BEGIN");
+        const { rows } = await client.query(createQuery, values);
+        const dbResponse = rows[0];
+        await client.query("COMMIT");
+        if (this.#cache !== null) {
+          await this.#cache.del(resourceid);
+        }
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        await client.query("ROLLBACK");
+        let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+        if (error.code === "P0002") {
+          err = { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] and version [${resourcevnum}] not found or not current`, detail: error };
+        }
+        debug2(`Error: [${JSON.stringify(err)}]`.red);
+        return err;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async createEntity(userid2, resourceid, resourcevnum, entityid, payload) {
+    const fname = "createEntity";
+    try {
+      const createQuery = `select * from create_stsentity($1, $2, $3, $4, $5)`;
+      const values = [
+        userid2,
+        resourceid,
+        resourcevnum,
+        entityid,
+        payload
+      ];
+      const client = await this.#pgpool?.connect();
+      try {
+        await client.query("BEGIN");
+        const { rows } = await client.query(createQuery, values);
+        const dbResponse = rows[0];
+        await client.query("COMMIT");
+        return { status: import_http_status_codes.StatusCodes.CREATED, detail: dbResponse };
+      } catch (error) {
+        await client.query("ROLLBACK");
+        let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+        if (error.code === "23505") {
+          err = { status: import_http_status_codes.StatusCodes.CONFLICT, error: `[${fname}: entityid [${entityid}] already exists`, detail: error };
+        }
+        debug2(`Error: [${JSON.stringify(err)}]`.red);
+        return err;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async updateEntity(userid2, resourceid, resourcevnum, entityid, entityvnum, payload) {
+    const fname = "updateEntity";
+    try {
+      const createQuery = `select * from update_stsentity($1, $2, $3, $4, $5, $6)`;
+      const values = [
+        userid2,
+        resourceid,
+        resourcevnum,
+        entityid,
+        entityvnum,
+        payload
+      ];
+      const client = await this.#pgpool?.connect();
+      try {
+        await client.query("BEGIN");
+        const { rows } = await client.query(createQuery, values);
+        const dbResponse = rows[0];
+        await client.query("COMMIT");
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        await client.query("ROLLBACK");
+        let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+        if (error.code === "P0002") {
+          err = { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}:${resourcevnum}], entityid [${entityid}:${entityvnum}] not found or not current`, detail: error };
+        }
+        debug2(`Error: [${JSON.stringify(err)}]`.red);
+        return err;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async deleteEntity(userid2, resourceid, resourcevnum, entityid, entityvnum) {
+    const fname = "deleteEntity";
+    try {
+      const createQuery = `select * from delete_stsentity($1, $2, $3, $4, $5)`;
+      const values = [
+        userid2,
+        resourceid,
+        resourcevnum,
+        entityid,
+        entityvnum
+      ];
+      const client = await this.#pgpool?.connect();
+      try {
+        await client.query("BEGIN");
+        const { rows } = await client.query(createQuery, values);
+        const dbResponse = rows[0];
+        await client.query("COMMIT");
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        await client.query("ROLLBACK");
+        let err = { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+        if (error.code === "P0002") {
+          err = { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}:${resourcevnum}], entityid [${entityid}:${entityvnum}] not found or not current`, detail: error };
+        }
+        debug2(`Error: [${JSON.stringify(err)}]`.red);
+        return err;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  // get single resource and all associated entities for this resource
+  async getResource(filters) {
+    const fname = "getResource";
+    try {
+      let query = "select r.oid::bigint, r.resname, r.resdesc, r.vnum::bigint, r.validfrom, r.validto, r.dbaction, r.dbactionuser from stsresource r";
+      let values = [];
+      const resourceid = filters.resname;
+      const qs = this.#buildQueryString(filters, "r");
+      if (qs !== null) {
+        query += qs.qstring;
+        values = qs.qparams;
+      }
+      if (this.#cache !== null) {
+        if (this.#latestResourceVersion(filters)) {
+          const cacheVal = await this.#cache.get(resourceid);
+          if (cacheVal !== null) {
+            const cacheResponse = JSON.parse(cacheVal);
+            return { status: import_http_status_codes.StatusCodes.OK, usedcache: true, detail: cacheResponse };
+          }
+        }
+      }
+      query += " limit 2";
+      const client = await this.#pgpool?.connect();
+      try {
+        const { rows } = await client.query(query, values);
+        if (rows.length === 0) {
+          return { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] (current version) not found`, detail: null };
+        }
+        if (rows.length > 1) {
+          return { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`, detail: null };
+        }
+        const dbResponse = rows[0];
+        if (this.#cache !== null) {
+          this.#cache.set(resourceid, JSON.stringify(dbResponse));
+        }
+        return { status: import_http_status_codes.StatusCodes.OK, usedcache: false, detail: dbResponse };
+      } catch (error) {
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  // get single resource and all associated entities for this resource
+  async getEntity(filters) {
+    const fname = "getEntity";
+    try {
+      let query = "select e.* from stsentity e join stsresource r on e.stsresourceoid = r.oid";
+      let values = [];
+      const qs = this.#buildQueryString(filters, "e");
+      const resourceid = filters.resname;
+      if (qs !== null) {
+        query += qs.qstring;
+        values = qs.qparams;
+      }
+      query += " limit 2";
+      const client = await this.#pgpool?.connect();
+      try {
+        const { rows } = await client.query(query, values);
+        if (rows.length === 0) {
+          return { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] (current version) not found`, detail: null };
+        }
+        if (rows.length > 1) {
+          return { status: import_http_status_codes.StatusCodes.NOT_FOUND, error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`, detail: null };
+        }
+        const dbResponse = rows[0];
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  // get single resource and all associated entities for this resource
+  async getEntities(filters) {
+    const fname = "getEntities";
+    try {
+      let query = `select * from stsentity e
+		join stsresource r on
+		e.stsresourceoid = r.oid`;
+      let values = [];
+      const qs = this.#buildQueryString(filters, "e");
+      if (qs !== null) {
+        query += qs.qstring;
+        values = qs.qparams;
+      }
+      query += " limit 10";
+      const client = await this.#pgpool?.connect();
+      try {
+        const { rows } = await client.query(query, values);
+        const dbResponse = rows;
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  // get current resource
+  async getResources(filters) {
+    const fname = "getResources";
+    try {
+      let query = "select * from stsresource r";
+      let values = [];
+      const qs = this.#buildQueryString(filters, "r");
+      if (qs !== null) {
+        query += qs.qstring;
+        values = qs.qparams;
+      }
+      query += " limit 10";
+      const client = await this.#pgpool?.connect();
+      try {
+        const { rows } = await client.query(query, values);
+        const dbResponse = rows;
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async deleteResources(resname, actionuser) {
+    const fname = "deleteResources";
+    try {
+      const client = await this.#pgpool?.connect();
+      try {
+        const query = "delete from stsresource where resname like $1 and dbactionuser = $2";
+        const values = [resname, actionuser];
+        await client.query("BEGIN");
+        await client.query(query, values);
+        await client.query("COMMIT");
+        return { status: import_http_status_codes.StatusCodes.OK };
+      } catch (error) {
+        if (consoleLogErrors)
+          console.error(`[${fname}]: Failed to delete resources: ${error}`);
+        await client.query("ROLLBACK");
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async deleteAllResources() {
+    const fname = "createResource";
+    try {
+      const client = await this.#pgpool?.connect();
+      try {
+        const query = "delete from stsresource";
+        await client.query("BEGIN");
+        await client.query(query);
+        await client.query("COMMIT");
+        return { status: import_http_status_codes.StatusCodes.OK };
+      } catch (error) {
+        if (consoleLogErrors)
+          console.error(`[${fname}]: Failed to truncate table(s): ${error}`);
+        await client.query("ROLLBACK");
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async getTotalResources() {
+    const fname = "getTotalResources";
+    try {
+      const client = await this.#pgpool?.connect();
+      try {
+        const query = "select count(*) from stsresource";
+        const { rows } = await client.query(query);
+        const dbResponse = rows[0];
+        return { status: import_http_status_codes.StatusCodes.OK, detail: dbResponse };
+      } catch (error) {
+        if (consoleLogErrors)
+          console.error(`[${fname}]: Could not get count from stsresource table: ${error}`);
+        await client.query("ROLLBACK");
+        return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`[${fname}]: Could not get client from pool: ${error}`);
+      return { status: import_http_status_codes.StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+    }
+  }
+  async executedbscript(scriptfile) {
+    try {
+      const fname = "executedbscript";
+      const queryText = await fs.readFile(scriptfile, "utf-8");
+      try {
+        const client = await this.#pgpool?.connect();
+        try {
+          await client.query("BEGIN");
+          await client.query(queryText);
+          await client.query("COMMIT");
+          return `Completed executing file: ${scriptfile}`;
+        } catch (e) {
+          await client.query("ROLLBACK");
+          console.error(`Error executing script: [${scriptfile}]`);
+          console.error(e);
+          throw e;
+        } finally {
+          client.release();
+        }
+      } catch (error) {
+        if (consoleLogErrors)
+          console.error(`[${fname}]: Could not get client from pool: ${error}`);
+        throw error;
+      }
+    } catch (error) {
+      if (consoleLogErrors)
+        console.error(`Error executing script: [${scriptfile}]`);
+      throw error;
+    }
+  }
+  // Method only used for testing. Ensure that if redis is being used that the cache is always flushed.
+  async startdatabase() {
+    if (this.#cache !== null) {
+      await this.#cache.flushall();
+    }
+  }
+  async enddatabase() {
+    debug2(`Ending database for process PID: ${process.pid}`);
+    await this.#pgpool?.end();
+    if (this.#cache !== null) {
+      if (endFlush === true) {
+        await this.#cache.flushall();
+        debug2(`Redis cache flushed.`.magenta);
+      }
+      await this.#cache.quit();
+      this.#cache = null;
+    }
+    this.#pgpool = null;
+    this.#poolManager?.DetachInstruments();
+    this.#poolManager = null;
+  }
+  bulkInsert(fakerdata) {
+    return new Promise((resolve, reject) => {
+      this.#pgpool?.connect().then((client) => {
+        const done = () => {
+          client.release();
+          resolve("Completed");
+        };
+        const stream = client.query(copyFrom("COPY stsresource (resname,resdesc,vnum,validfrom,dbaction,dbactionuser) FROM STDIN"));
+        const rs = new streamex.Readable();
+        let currentIndex = 0;
+        rs._read = function() {
+          if (currentIndex === fakerdata.length) {
+            rs.push(null);
+          } else {
+            const data = fakerdata[currentIndex];
+            rs.push(
+              //data.oid
+              data.resname + "	" + data.resdesc + "	" + data.vnum + "	" + data.validfrom + "	" + data.dbaction + "	" + data.dbactionuser + "\n"
+            );
+            currentIndex++;
+          }
+        };
+        const onError = (strErr) => {
+          client.release();
+          reject(strErr);
+        };
+        rs.on("error", onError);
+        stream.on("error", onError);
+        stream.on("finish", done);
+        rs.pipe(stream);
+      }).catch((error) => {
+        console.log(error);
+      });
+    });
+  }
+};
+
+// src/cliworker-old.ts
+var userid = "dbinitrunner";
+var resfakerprefix = "RESFK-";
+var rescopyprefix = "RESCP-";
+var CliWorker = class {
+  fakerdataarray = [];
+  fakerdataarray2 = [];
+  totalDataSize = 0;
+  avgDataSize = 0;
+  copybatchsize = 250;
+  run = async (data) => {
+    const { start, iterations, datamin } = data.data;
+    let { datamax } = data.data;
+    let count = start;
+    const accesslayer = new PGAccessLayer(new PGPoolManager());
+    if (datamax > 0) {
+      datamax = datamax <= datamin ? datamin + 1 : datamax;
+    }
+    for (let i = 0; i < iterations; i++) {
+      const coreRecordSizeRange = import_crypto.default.randomInt(128, 192);
+      const coreRecordSize = Math.floor(coreRecordSizeRange / 2);
+      let randcard = import_crypto.default.randomBytes(coreRecordSize).toString("hex");
+      if (datamax > 0) {
+        const n = import_crypto.default.randomInt(datamin, datamax);
+        const n2 = Math.floor(n / 2);
+        const rndid = import_crypto.default.randomBytes(n2).toString("hex");
+        randcard += rndid;
+      }
+      const randcardstring = randcard;
+      this.totalDataSize += randcardstring.length;
+      this.avgDataSize = Math.floor(this.totalDataSize / (i + 1));
+      const pn = ("" + count++).padStart(10, "0");
+      const id = resfakerprefix + pn;
+      const cpid = rescopyprefix + pn;
+      const datanow = (/* @__PURE__ */ new Date()).toISOString();
+      const fakerdata = {
+        //oid: i
+        resname: id,
+        resdesc: randcardstring,
+        vnum: 1,
+        validfrom: datanow,
+        validto: null,
+        dbaction: 1,
+        dbactionuser: userid
+      };
+      this.fakerdataarray.push(fakerdata);
+      const fakerdata2 = Object.assign({}, fakerdata);
+      fakerdata2.resname = cpid;
+      this.fakerdataarray2.push(fakerdata2);
+      if ((i + 1) % this.copybatchsize === 0) {
+        await accesslayer.bulkInsert(this.fakerdataarray);
+        await accesslayer.bulkInsert(this.fakerdataarray2);
+        this.fakerdataarray = [];
+        this.fakerdataarray2 = [];
+      }
+    }
+    if (this.fakerdataarray.length > 0) {
+      await accesslayer.bulkInsert(this.fakerdataarray);
+      await accesslayer.bulkInsert(this.fakerdataarray2);
+    }
+  };
+};
+var worker = new CliWorker();
+onmessage = async function(data) {
+  worker.run(data);
+};