orcaq 1.0.20

package/.output/server/node_modules/typeorm/naming-strategy/LegacyOracleNamingStrategy.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyOracleNamingStrategy = void 0;
+const RandomGenerator_1 = require("../util/RandomGenerator");
+const DefaultNamingStrategy_1 = require("./DefaultNamingStrategy");
+const error_1 = require("../error");
+/**
+ * Naming strategy for legacy Oracle database with 30 bytes identifier limit.
+ *
+ * Currently, only column name must be shorten in order to avoid ORA-00972.
+ * Issues with other identifiers were fixed.
+ */
+class LegacyOracleNamingStrategy extends DefaultNamingStrategy_1.DefaultNamingStrategy {
+    constructor(shortenStrategy = "hash") {
+        super();
+        this.IDENTIFIER_MAX_SIZE = 30;
+        this.DEFAULT_COLUMN_PREFIX = "COL_";
+        this.shortenStrategy = shortenStrategy;
+    }
+    columnName(propertyName, customName, embeddedPrefixes) {
+        const longName = super.columnName(propertyName, customName, embeddedPrefixes);
+        if (this.shortenStrategy === "truncate") {
+            return this.truncateIdentifier(longName);
+        }
+        else if (this.shortenStrategy === "hash") {
+            return this.hashIdentifier(longName, this.DEFAULT_COLUMN_PREFIX);
+        }
+        else {
+            throw new error_1.TypeORMError(`Invalid shortenStrategy`);
+        }
+    }
+    hashIdentifier(input, prefix) {
+        if (prefix.length >= this.IDENTIFIER_MAX_SIZE) {
+            throw new error_1.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+        }
+        return (prefix +
+            RandomGenerator_1.RandomGenerator.sha1(input).substring(0, this.IDENTIFIER_MAX_SIZE - prefix.length));
+    }
+    truncateIdentifier(input) {
+        if (input.length > this.IDENTIFIER_MAX_SIZE) {
+            return input.substring(0, this.IDENTIFIER_MAX_SIZE);
+        }
+        else {
+            return input;
+        }
+    }
+}
+exports.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+
+//# sourceMappingURL=LegacyOracleNamingStrategy.js.map

package/.output/server/node_modules/typeorm/package.json

@@ -0,0 +1,268 @@
+{
+  "name": "typeorm",
+  "version": "0.3.24",
+  "description": "Data-Mapper ORM for TypeScript and ES2021+. Supports MySQL/MariaDB, PostgreSQL, MS SQL Server, Oracle, SAP HANA, SQLite, MongoDB databases.",
+  "homepage": "https://typeorm.io",
+  "bugs": {
+    "url": "https://github.com/typeorm/typeorm/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/typeorm/typeorm.git"
+  },
+  "funding": "https://opencollective.com/typeorm",
+  "license": "MIT",
+  "author": {
+    "name": "Umed Khudoiberdiev",
+    "email": "pleerock.me@gmail.com"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "node": {
+        "import": "./index.mjs",
+        "require": "./index.js",
+        "types": "./index.d.ts"
+      },
+      "browser": {
+        "require": "./index.js",
+        "import": "./browser/index.js",
+        "default": "./index.js"
+      }
+    },
+    "./browser": {
+      "types": "./index.d.ts",
+      "default": "./browser/index.js"
+    },
+    "./*.js": "./*.js",
+    "./*": {
+      "require": "./*.js",
+      "import": "./*"
+    }
+  },
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "browser": {
+    "./browser/connection/ConnectionOptionsReader.js": "./browser/platform/BrowserConnectionOptionsReaderDummy.js",
+    "./browser/connection/options-reader/ConnectionOptionsXmlReader.js": "./browser/platform/BrowserConnectionOptionsReaderDummy.js",
+    "./browser/connection/options-reader/ConnectionOptionsYmlReader.js": "./browser/platform/BrowserConnectionOptionsReaderDummy.js",
+    "./browser/driver/aurora-data-api/AuroraDataApiDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/better-sqlite3/BetterSqlite3Driver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/cockroachdb/CockroachDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/mongodb/MongoDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/mongodb/MongoQueryRunner.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/mongodb/bson.typings.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/mongodb/typings.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/mysql/MysqlDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/oracle/OracleDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/postgres/PostgresDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/sap/SapDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/sqlite/SqliteDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/driver/sqlserver/SqlServerDriver.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/entity-manager/MongoEntityManager.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/logger/FileLogger.js": "./browser/platform/BrowserFileLoggerDummy.js",
+    "./browser/platform/PlatformTools.js": "./browser/platform/BrowserPlatformTools.js",
+    "./browser/repository/MongoRepository.js": "./browser/platform/BrowserDisabledDriversDummy.js",
+    "./browser/util/DirectoryExportedClassesLoader.js": "./browser/platform/BrowserDirectoryExportedClassesLoader.js",
+    "./index.js": "./browser/index.js",
+    "./index.mjs": "./browser/index.js"
+  },
+  "types": "./index.d.ts",
+  "bin": {
+    "typeorm": "./cli.js",
+    "typeorm-ts-node-commonjs": "./cli-ts-node-commonjs.js",
+    "typeorm-ts-node-esm": "./cli-ts-node-esm.js"
+  },
+  "scripts": {
+    "changelog": "standard-changelog",
+    "compile": "rimraf ./build && tsc",
+    "format": "prettier --cache --write \"./**/*.ts\"",
+    "format:ci": "prettier --check \"./**/*.ts\"",
+    "lint": "eslint .",
+    "pack": "gulp pack",
+    "package": "gulp package",
+    "pre-commit": "lint-staged",
+    "prepare": "husky",
+    "test": "npm run compile && npm run test:fast --",
+    "test:ci": "mocha --bail",
+    "test:fast": "mocha",
+    "watch": "tsc --watch",
+    "publish:preview": "pkg-pr-new publish './build/package' --pnpm --template='./sample/playground'"
+  },
+  "dependencies": {
+    "@sqltools/formatter": "^1.2.5",
+    "ansis": "^3.17.0",
+    "app-root-path": "^3.1.0",
+    "buffer": "^6.0.3",
+    "dayjs": "^1.11.13",
+    "debug": "^4.4.0",
+    "dedent": "^1.6.0",
+    "dotenv": "^16.4.7",
+    "glob": "^10.4.5",
+    "sha.js": "^2.4.11",
+    "sql-highlight": "^6.0.0",
+    "tslib": "^2.8.1",
+    "uuid": "^11.1.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.22.0",
+    "@sap/hana-client": "^2.24.21",
+    "@tsconfig/node16": "^16.1.3",
+    "@types/chai": "^4.3.20",
+    "@types/chai-as-promised": "^7.1.8",
+    "@types/debug": "^4.1.12",
+    "@types/gulp-rename": "^2.0.6",
+    "@types/gulp-sourcemaps": "^0.0.38",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^16.18.126",
+    "@types/sha.js": "^2.4.4",
+    "@types/sinon": "^10.0.20",
+    "@types/sinon-chai": "^4.0.0",
+    "@types/source-map-support": "^0.5.10",
+    "@types/yargs": "^17.0.33",
+    "better-sqlite3": "^8.7.0",
+    "chai": "^4.5.0",
+    "chai-as-promised": "^7.1.2",
+    "class-transformer": "^0.5.1",
+    "eslint": "^9.22.0",
+    "globals": "^16.0.0",
+    "gulp": "^4.0.2",
+    "gulp-rename": "^2.0.0",
+    "gulp-replace": "^1.1.4",
+    "gulp-shell": "^0.8.0",
+    "gulp-sourcemaps": "^3.0.0",
+    "gulp-typescript": "^6.0.0-alpha.1",
+    "gulpclass": "^0.2.0",
+    "hdb-pool": "^0.1.6",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.5.2",
+    "mocha": "^10.8.2",
+    "mongodb": "^6.15.0",
+    "mssql": "^11.0.1",
+    "mysql": "^2.18.1",
+    "mysql2": "^3.14.0",
+    "nyc": "^17.1.0",
+    "oracledb": "^6.8.0",
+    "pg": "^8.14.1",
+    "pg-query-stream": "^4.8.1",
+    "pkg-pr-new": "^0.0.43",
+    "prettier": "^2.8.8",
+    "redis": "^4.7.0",
+    "remap-istanbul": "^0.13.0",
+    "rimraf": "^5.0.10",
+    "sinon": "^15.2.0",
+    "sinon-chai": "^3.7.0",
+    "source-map-support": "^0.5.21",
+    "sql.js": "^1.13.0",
+    "sqlite3": "^5.1.7",
+    "standard-changelog": "^6.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.27.0"
+  },
+  "peerDependencies": {
+    "@google-cloud/spanner": "^5.18.0 || ^6.0.0 || ^7.0.0",
+    "@sap/hana-client": "^2.12.25",
+    "better-sqlite3": "^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+    "hdb-pool": "^0.1.6",
+    "ioredis": "^5.0.4",
+    "mongodb": "^5.8.0 || ^6.0.0",
+    "mssql": "^9.1.1 || ^10.0.1 || ^11.0.1",
+    "mysql2": "^2.2.5 || ^3.0.1",
+    "oracledb": "^6.3.0",
+    "pg": "^8.5.1",
+    "pg-native": "^3.0.0",
+    "pg-query-stream": "^4.0.0",
+    "redis": "^3.1.1 || ^4.0.0",
+    "reflect-metadata": "^0.1.14 || ^0.2.0",
+    "sql.js": "^1.4.0",
+    "sqlite3": "^5.0.3",
+    "ts-node": "^10.7.0",
+    "typeorm-aurora-data-api-driver": "^2.0.0 || ^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@google-cloud/spanner": {
+      "optional": true
+    },
+    "@sap/hana-client": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    },
+    "hdb-pool": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "mongodb": {
+      "optional": true
+    },
+    "mssql": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "oracledb": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "pg-native": {
+      "optional": true
+    },
+    "pg-query-stream": {
+      "optional": true
+    },
+    "redis": {
+      "optional": true
+    },
+    "sql.js": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    },
+    "ts-node": {
+      "optional": true
+    },
+    "typeorm-aurora-data-api-driver": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=16.13.0"
+  },
+  "collective": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/typeorm",
+    "logo": "https://opencollective.com/opencollective/logo.txt"
+  },
+  "readmeFilename": "README.md",
+  "tags": [
+    "orm",
+    "typescript",
+    "typescript-orm",
+    "mariadb",
+    "mariadb-orm",
+    "mysql",
+    "mysql-orm",
+    "oracle",
+    "oracle-orm",
+    "postgresql",
+    "postgresql-orm",
+    "sap-hana",
+    "sap-hana-orm",
+    "spanner",
+    "cloud-spanner",
+    "cloud-spanner-orm",
+    "sqlite",
+    "sqlite-orm",
+    "sql-server",
+    "sql-server-orm"
+  ]
+}

package/.output/server/node_modules/typeorm/persistence/EntityPersistExecutor.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityPersistExecutor = void 0;
+const MustBeEntityError_1 = require("../error/MustBeEntityError");
+const SubjectExecutor_1 = require("./SubjectExecutor");
+const CannotDetermineEntityError_1 = require("../error/CannotDetermineEntityError");
+const Subject_1 = require("./Subject");
+const OneToManySubjectBuilder_1 = require("./subject-builder/OneToManySubjectBuilder");
+const OneToOneInverseSideSubjectBuilder_1 = require("./subject-builder/OneToOneInverseSideSubjectBuilder");
+const ManyToManySubjectBuilder_1 = require("./subject-builder/ManyToManySubjectBuilder");
+const SubjectDatabaseEntityLoader_1 = require("./SubjectDatabaseEntityLoader");
+const CascadesSubjectBuilder_1 = require("./subject-builder/CascadesSubjectBuilder");
+const OrmUtils_1 = require("../util/OrmUtils");
+/**
+ * Persists a single entity or multiple entities - saves or removes them.
+ */
+class EntityPersistExecutor {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection, queryRunner, mode, target, entity, options) {
+        this.connection = connection;
+        this.queryRunner = queryRunner;
+        this.mode = mode;
+        this.target = target;
+        this.entity = entity;
+        this.options = options;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Executes persistence operation ob given entity or entities.
+     */
+    async execute() {
+        // check if entity we are going to save is valid and is an object
+        if (!this.entity || typeof this.entity !== "object")
+            return Promise.reject(new MustBeEntityError_1.MustBeEntityError(this.mode, this.entity));
+        // we MUST call "fake" resolve here to make sure all properties of lazily loaded relations are resolved
+        await Promise.resolve();
+        // if query runner is already defined in this class, it means this entity manager was already created for a single connection
+        // if its not defined we create a new query runner - single connection where we'll execute all our operations
+        const queryRunner = this.queryRunner || this.connection.createQueryRunner();
+        // save data in the query runner - this is useful functionality to share data from outside of the world
+        // with third classes - like subscribers and listener methods
+        const oldQueryRunnerData = queryRunner.data;
+        if (this.options && this.options.data) {
+            queryRunner.data = this.options.data;
+        }
+        try {
+            // collect all operate subjects
+            const entities = Array.isArray(this.entity)
+                ? this.entity
+                : [this.entity];
+            const entitiesInChunks = this.options && this.options.chunk && this.options.chunk > 0
+                ? OrmUtils_1.OrmUtils.chunk(entities, this.options.chunk)
+                : [entities];
+            // console.time("building subject executors...");
+            const executors = await Promise.all(entitiesInChunks.map(async (entities) => {
+                const subjects = [];
+                // create subjects for all entities we received for the persistence
+                entities.forEach((entity) => {
+                    const entityTarget = this.target
+                        ? this.target
+                        : entity.constructor;
+                    if (entityTarget === Object)
+                        throw new CannotDetermineEntityError_1.CannotDetermineEntityError(this.mode);
+                    const metadata = this.connection
+                        .getMetadata(entityTarget)
+                        .findInheritanceMetadata(entity);
+                    subjects.push(new Subject_1.Subject({
+                        metadata,
+                        entity: entity,
+                        canBeInserted: this.mode === "save",
+                        canBeUpdated: this.mode === "save",
+                        mustBeRemoved: this.mode === "remove",
+                        canBeSoftRemoved: this.mode === "soft-remove",
+                        canBeRecovered: this.mode === "recover",
+                    }));
+                });
+                // console.time("building cascades...");
+                // go through each entity with metadata and create subjects and subjects by cascades for them
+                const cascadesSubjectBuilder = new CascadesSubjectBuilder_1.CascadesSubjectBuilder(subjects);
+                subjects.forEach((subject) => {
+                    // next step we build list of subjects we will operate with
+                    // these subjects are subjects that we need to insert or update alongside with main persisted entity
+                    cascadesSubjectBuilder.build(subject, this.mode);
+                });
+                // console.timeEnd("building cascades...");
+                // load database entities for all subjects we have
+                // next step is to load database entities for all operate subjects
+                // console.time("loading...");
+                await new SubjectDatabaseEntityLoader_1.SubjectDatabaseEntityLoader(queryRunner, subjects).load(this.mode);
+                // console.timeEnd("loading...");
+                // console.time("other subjects...");
+                // build all related subjects and change maps
+                if (this.mode === "save" ||
+                    this.mode === "soft-remove" ||
+                    this.mode === "recover") {
+                    new OneToManySubjectBuilder_1.OneToManySubjectBuilder(subjects).build();
+                    new OneToOneInverseSideSubjectBuilder_1.OneToOneInverseSideSubjectBuilder(subjects).build();
+                    new ManyToManySubjectBuilder_1.ManyToManySubjectBuilder(subjects).build();
+                }
+                else {
+                    subjects.forEach((subject) => {
+                        if (subject.mustBeRemoved) {
+                            new ManyToManySubjectBuilder_1.ManyToManySubjectBuilder(subjects).buildForAllRemoval(subject);
+                        }
+                    });
+                }
+                // console.timeEnd("other subjects...");
+                // console.timeEnd("building subjects...");
+                // console.log("subjects", subjects);
+                // create a subject executor
+                return new SubjectExecutor_1.SubjectExecutor(queryRunner, subjects, this.options);
+            }));
+            // console.timeEnd("building subject executors...");
+            // make sure we have at least one executable operation before we create a transaction and proceed
+            // if we don't have operations it means we don't really need to update or remove something
+            const executorsWithExecutableOperations = executors.filter((executor) => executor.hasExecutableOperations);
+            if (executorsWithExecutableOperations.length === 0)
+                return;
+            // start execute queries in a transaction
+            // if transaction is already opened in this query runner then we don't touch it
+            // if its not opened yet then we open it here, and once we finish - we close it
+            let isTransactionStartedByUs = false;
+            try {
+                // open transaction if its not opened yet
+                if (!queryRunner.isTransactionActive) {
+                    if (this.connection.driver.transactionSupport !== "none" &&
+                        (!this.options || this.options.transaction !== false)) {
+                        // start transaction until it was not explicitly disabled
+                        isTransactionStartedByUs = true;
+                        await queryRunner.startTransaction();
+                    }
+                }
+                // execute all persistence operations for all entities we have
+                // console.time("executing subject executors...");
+                for (const executor of executorsWithExecutableOperations) {
+                    await executor.execute();
+                }
+                // console.timeEnd("executing subject executors...");
+                // commit transaction if it was started by us
+                // console.time("commit");
+                if (isTransactionStartedByUs === true)
+                    await queryRunner.commitTransaction();
+                // console.timeEnd("commit");
+            }
+            catch (error) {
+                // rollback transaction if it was started by us
+                if (isTransactionStartedByUs) {
+                    try {
+                        await queryRunner.rollbackTransaction();
+                    }
+                    catch (rollbackError) { }
+                }
+                throw error;
+            }
+        }
+        finally {
+            queryRunner.data = oldQueryRunnerData;
+            // release query runner only if its created by us
+            if (!this.queryRunner)
+                await queryRunner.release();
+        }
+    }
+}
+exports.EntityPersistExecutor = EntityPersistExecutor;
+
+//# sourceMappingURL=EntityPersistExecutor.js.map