orcaq 1.0.32 → 1.1.1

package/.output/server/node_modules/mysql2/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "mysql2",
+  "version": "3.22.2",
+  "description": "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
+  "main": "index.js",
+  "typings": "typings/mysql/index",
+  "type": "commonjs",
+  "scripts": {
+    "lint": "eslint . && prettier --check .",
+    "lint:fix": "eslint . --fix && prettier --write .",
+    "test": "poku",
+    "test:bun": "bun poku",
+    "test:deno": "deno run -A npm:poku",
+    "test:docker:up": "docker compose -f test/docker-compose.yml up --abort-on-container-exit --remove-orphans",
+    "test:docker:down": "docker compose -f test/docker-compose.yml down",
+    "test:docker:node": "npm run test:docker:up -- node && npm run test:docker:down",
+    "test:docker:bun": "npm run test:docker:up -- bun && npm run test:docker:down",
+    "test:docker:deno": "npm run test:docker:up -- deno && npm run test:docker:down",
+    "test:docker:coverage": "npm run test:docker:up -- coverage && npm run test:docker:down",
+    "test:coverage": "c8 npm test",
+    "test:build": "rollup -c",
+    "typecheck": "cd \"test/tsc-build\" && tsc -p \"tsconfig.json\" && cd .. && tsc -p \"tsconfig.json\" --noEmit",
+    "benchmark": "node ./benchmarks/benchmark.js",
+    "wait-port": "wait-on"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sidorares/node-mysql2.git"
+  },
+  "homepage": "https://sidorares.github.io/node-mysql2/docs",
+  "keywords": [
+    "mysql",
+    "client",
+    "server"
+  ],
+  "files": [
+    "lib",
+    "typings/mysql",
+    "index.js",
+    "index.d.ts",
+    "promise.js",
+    "promise.d.ts"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./promise": "./promise.js",
+    "./promise.js": "./promise.js"
+  },
+  "engines": {
+    "node": ">= 8.0"
+  },
+  "author": "Andrey Sidorov <andrey.sidorov@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "aws-ssl-profiles": "^1.1.2",
+    "denque": "^2.1.0",
+    "generate-function": "^2.3.1",
+    "iconv-lite": "^0.7.2",
+    "long": "^5.3.2",
+    "lru.min": "^1.1.4",
+    "named-placeholders": "^1.1.6",
+    "sql-escaper": "^1.3.3"
+  },
+  "peerDependencies": {
+    "@types/node": ">= 8"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.2",
+    "@eslint/markdown": "^8.0.1",
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
+    "@pokujs/multi-suite": "^1.0.0",
+    "@rollup/plugin-commonjs": "^29.0.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "assert-diff": "^3.0.4",
+    "benchmark": "^2.1.4",
+    "c8": "^11.0.0",
+    "error-stack-parser": "^2.1.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-async-await": "^0.0.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.3.0",
+    "poku": "^4.1.0",
+    "portfinder": "^1.0.38",
+    "prettier": "^3.8.1",
+    "rollup": "^4.59.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/.output/server/node_modules/mysql2/promise.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const SqlString = require('sql-escaper');
+const EventEmitter = require('events').EventEmitter;
+const parserCache = require('./lib/parsers/parser_cache.js');
+const PoolCluster = require('./lib/pool_cluster.js');
+const createConnection = require('./lib/create_connection.js');
+const createPool = require('./lib/create_pool.js');
+const createPoolCluster = require('./lib/create_pool_cluster.js');
+const PromiseConnection = require('./lib/promise/connection.js');
+const PromisePool = require('./lib/promise/pool.js');
+const {
+  captureStackHolder,
+  applyCapturedStack,
+} = require('./lib/promise/capture_local_err.js');
+const makeDoneCb = require('./lib/promise/make_done_cb.js');
+const PromisePoolConnection = require('./lib/promise/pool_connection.js');
+const inheritEvents = require('./lib/promise/inherit_events.js');
+const PromisePoolNamespace = require('./lib/promise/pool_cluster');
+
+function createConnectionPromise(opts) {
+  const coreConnection = createConnection(opts);
+  const stackHolder = captureStackHolder(createConnectionPromise);
+  const thePromise = opts.Promise || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+        'Use promise-enabled node version or pass userland Promise' +
+        " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+  return new thePromise((resolve, reject) => {
+    coreConnection.once('connect', () => {
+      resolve(new PromiseConnection(coreConnection, thePromise));
+    });
+    coreConnection.once('error', (err) => {
+      applyCapturedStack(err, stackHolder);
+      reject(err);
+    });
+  });
+}
+
+// note: the callback of "changeUser" is not called on success
+// hence there is no possibility to call "resolve"
+
+function createPromisePool(opts) {
+  const corePool = createPool(opts);
+  const thePromise = opts.Promise || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+        'Use promise-enabled node version or pass userland Promise' +
+        " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+
+  return new PromisePool(corePool, thePromise);
+}
+
+class PromisePoolCluster extends EventEmitter {
+  constructor(poolCluster, thePromise) {
+    super();
+    this.poolCluster = poolCluster;
+    this.Promise = thePromise || Promise;
+    inheritEvents(poolCluster, this, ['warn', 'remove', 'online', 'offline']);
+  }
+
+  getConnection(pattern, selector) {
+    const corePoolCluster = this.poolCluster;
+    return new this.Promise((resolve, reject) => {
+      corePoolCluster.getConnection(
+        pattern,
+        selector,
+        (err, coreConnection) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(new PromisePoolConnection(coreConnection, this.Promise));
+          }
+        }
+      );
+    });
+  }
+
+  query(sql, args) {
+    const corePoolCluster = this.poolCluster;
+    const stackHolder = captureStackHolder(PromisePoolCluster.prototype.query);
+    if (typeof args === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      corePoolCluster.query(sql, args, done);
+    });
+  }
+
+  execute(sql, args) {
+    const corePoolCluster = this.poolCluster;
+    const stackHolder = captureStackHolder(
+      PromisePoolCluster.prototype.execute
+    );
+    if (typeof args === 'function') {
+      throw new Error(
+        'Callback function is not available with promise clients.'
+      );
+    }
+    return new this.Promise((resolve, reject) => {
+      const done = makeDoneCb(resolve, reject, stackHolder);
+      corePoolCluster.execute(sql, args, done);
+    });
+  }
+
+  of(pattern, selector) {
+    return new PromisePoolNamespace(
+      this.poolCluster.of(pattern, selector),
+      this.Promise
+    );
+  }
+
+  end() {
+    const corePoolCluster = this.poolCluster;
+    const stackHolder = captureStackHolder(PromisePoolCluster.prototype.end);
+    return new this.Promise((resolve, reject) => {
+      corePoolCluster.end((err) => {
+        if (err) {
+          applyCapturedStack(err, stackHolder);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  async [Symbol.asyncDispose]() {
+    if (!this.poolCluster._closed) {
+      await this.end();
+    }
+  }
+}
+
+/**
+ * proxy poolCluster synchronous functions
+ */
+(function (functionsToWrap) {
+  for (let i = 0; functionsToWrap && i < functionsToWrap.length; i++) {
+    const func = functionsToWrap[i];
+
+    if (
+      typeof PoolCluster.prototype[func] === 'function' &&
+      PromisePoolCluster.prototype[func] === undefined
+    ) {
+      PromisePoolCluster.prototype[func] = (function factory(funcName) {
+        return function () {
+          return PoolCluster.prototype[funcName].apply(
+            this.poolCluster,
+            arguments
+          );
+        };
+      })(func);
+    }
+  }
+})(['add', 'remove']);
+
+function createPromisePoolCluster(opts) {
+  const corePoolCluster = createPoolCluster(opts);
+  const thePromise = (opts && opts.Promise) || Promise;
+  if (!thePromise) {
+    throw new Error(
+      'no Promise implementation available.' +
+        'Use promise-enabled node version or pass userland Promise' +
+        " implementation as parameter, for example: { Promise: require('bluebird') }"
+    );
+  }
+  return new PromisePoolCluster(corePoolCluster, thePromise);
+}
+
+exports.createConnection = createConnectionPromise;
+exports.createPool = createPromisePool;
+exports.createPoolCluster = createPromisePoolCluster;
+exports.escape = SqlString.escape;
+exports.escapeId = SqlString.escapeId;
+exports.format = SqlString.format;
+exports.raw = SqlString.raw;
+exports.Connection = PromiseConnection;
+exports.PoolConnection = PromisePoolConnection;
+exports.PromisePool = PromisePool;
+exports.PromiseConnection = PromiseConnection;
+exports.PromisePoolConnection = PromisePoolConnection;
+
+exports.__defineGetter__('Types', () => require('./lib/constants/types.js'));
+
+exports.__defineGetter__('Charsets', () =>
+  require('./lib/constants/charsets.js')
+);
+
+exports.__defineGetter__('CharsetToEncoding', () =>
+  require('./lib/constants/charset_encodings.js')
+);
+
+exports.setMaxParserCache = function (max) {
+  parserCache.setMaxCache(max);
+};
+
+exports.clearParserCache = function () {
+  parserCache.clearCache();
+};

package/.output/server/node_modules/named-placeholders/index.js

@@ -0,0 +1,179 @@
+'use strict';
+
+// based on code from Brian White @mscdex mariasql library - https://github.com/mscdex/node-mariasql/blob/master/lib/Client.js#L272-L332
+// License: https://github.com/mscdex/node-mariasql/blob/master/LICENSE
+
+const RE_PARAM = /(?:\?)|(?::(\d+|(?:[a-zA-Z][a-zA-Z0-9_]*)))/g,
+  DQUOTE = 34,
+  SQUOTE = 39,
+  BSLASH = 92;
+
+function parse(query) {
+  let ppos = RE_PARAM.exec(query);
+  let curpos = 0;
+  let start = 0;
+  let end;
+  const parts = [];
+  let inQuote = false;
+  let escape = false;
+  let qchr;
+  const tokens = [];
+  let qcnt = 0;
+  let lastTokenEndPos = 0;
+  let i;
+
+  if (ppos) {
+    do {
+      for (i = curpos, end = ppos.index; i < end; ++i) {
+        const chr = query.charCodeAt(i);
+        if (chr === BSLASH) escape = !escape;
+        else {
+          if (escape) {
+            escape = false;
+            continue;
+          }
+          if (inQuote && chr === qchr) {
+            if (query.charCodeAt(i + 1) === qchr) {
+              // quote escaped via "" or ''
+              ++i;
+              continue;
+            }
+            inQuote = false;
+          } else if (!inQuote && (chr === DQUOTE || chr === SQUOTE)) {
+            inQuote = true;
+            qchr = chr;
+          }
+        }
+      }
+      if (!inQuote) {
+        parts.push(query.substring(start, end));
+        tokens.push(ppos[0].length === 1 ? qcnt++ : ppos[1]);
+        start = end + ppos[0].length;
+        lastTokenEndPos = start;
+      }
+      curpos = end + ppos[0].length;
+    } while ((ppos = RE_PARAM.exec(query)));
+
+    if (tokens.length) {
+      if (curpos < query.length) {
+        parts.push(query.substring(lastTokenEndPos));
+      }
+      return [parts, tokens];
+    }
+  }
+  return [query];
+}
+
+function createCompiler(config) {
+  if (!config) config = {};
+  if (!config.placeholder) {
+    config.placeholder = '?';
+  }
+  let ncache = 100;
+  let cache;
+  if (typeof config.cache === 'number') {
+    ncache = config.cache;
+  }
+  if (typeof config.cache === 'object') {
+    cache = config.cache;
+  }
+  if (config.cache !== false && !cache) {
+    cache = require('lru.min').createLRU({ max: ncache });
+  }
+
+  function toArrayParams(tree, params) {
+    const arr = [];
+    if (tree.length === 1) {
+      return [tree[0], []];
+    }
+
+    if (typeof params === 'undefined')
+      throw new Error(
+        'Named query contains placeholders, but parameters object is undefined'
+      );
+
+    const tokens = tree[1];
+    for (let i = 0; i < tokens.length; ++i) {
+      arr.push(params[tokens[i]]);
+    }
+    return [tree[0], arr];
+  }
+
+  function noTailingSemicolon(s) {
+    if (s.slice(-1) === ':') {
+      return s.slice(0, -1);
+    }
+    return s;
+  }
+
+  function join(tree) {
+    if (tree.length === 1) {
+      return tree;
+    }
+
+    let unnamed = noTailingSemicolon(tree[0][0]);
+    for (let i = 1; i < tree[0].length; ++i) {
+      if (tree[0][i - 1].slice(-1) === ':') {
+        unnamed += config.placeholder;
+      }
+      unnamed += config.placeholder;
+      unnamed += noTailingSemicolon(tree[0][i]);
+    }
+
+    const last = tree[0][tree[0].length - 1];
+    if (tree[0].length === tree[1].length) {
+      if (last.slice(-1) === ':') {
+        unnamed += config.placeholder;
+      }
+      unnamed += config.placeholder;
+    }
+    return [unnamed, tree[1]];
+  }
+
+  function compile(query, paramsObj) {
+    let tree;
+    if (cache && (tree = cache.get(query))) {
+      return toArrayParams(tree, paramsObj);
+    }
+    tree = join(parse(query));
+    if (cache) {
+      cache.set(query, tree);
+    }
+    return toArrayParams(tree, paramsObj);
+  }
+
+  compile.parse = parse;
+  return compile;
+}
+
+// named :one :two to postgres-style numbered $1 $2 $3
+function toNumbered(q, params) {
+  const tree = parse(q);
+  const paramsArr = [];
+  if (tree.length === 1) {
+    return [tree[0], paramsArr];
+  }
+
+  const pIndexes = {};
+  let pLastIndex = 0;
+  let qs = '';
+  let varIndex;
+  const varNames = [];
+  for (let i = 0; i < tree[0].length; ++i) {
+    varIndex = pIndexes[tree[1][i]];
+    if (!varIndex) {
+      varIndex = ++pLastIndex;
+      pIndexes[tree[1][i]] = varIndex;
+    }
+    if (tree[1][i]) {
+      varNames[varIndex - 1] = tree[1][i];
+      qs += `${tree[0][i]}$${varIndex}`;
+    } else {
+      qs += tree[0][i];
+    }
+  }
+  return [qs, varNames.map((n) => params[n])];
+}
+
+module.exports = createCompiler;
+module.exports.toNumbered = toNumbered;

package/.output/server/node_modules/named-placeholders/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "named-placeholders",
+  "version": "1.1.6",
+  "description": "sql named placeholders to unnamed compiler",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --test",
+    "lint": "biome lint --error-on-warnings && prettier --check .",
+    "lint:fix": "biome lint --write && prettier --write .github/workflows/*.yml ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mysqljs/named-placeholders"
+  },
+  "keywords": [
+    "sql",
+    "pdo",
+    "named",
+    "placeholders",
+    "mysql",
+    "postgres"
+  ],
+  "engines": {
+    "node": ">=8.0.0"
+  },
+  "author": "Andrey Sidorov <sidorares@yandex.com>",
+  "files": [],
+  "license": "MIT",
+  "dependencies": {
+    "lru.min": "^1.1.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.8",
+    "prettier": "^3.7.4"
+  }
+}

package/.output/server/node_modules/oracledb/index.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2015, 2023, Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+module.exports = require('./lib/oracledb.js');