orcaq 1.0.20

package/.output/server/node_modules/typeorm/persistence/tree/MaterializedPathSubjectExecutor.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaterializedPathSubjectExecutor = void 0;
+const OrmUtils_1 = require("../../util/OrmUtils");
+const EntityMetadata_1 = require("../../metadata/EntityMetadata");
+const Brackets_1 = require("../../query-builder/Brackets");
+/**
+ * Executes subject operations for materialized-path tree entities.
+ */
+class MaterializedPathSubjectExecutor {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(queryRunner) {
+        this.queryRunner = queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Executes operations when subject is being inserted.
+     */
+    async insert(subject) {
+        let parent = subject.metadata.treeParentRelation.getEntityValue(subject.entity); // if entity was attached via parent
+        if (!parent && subject.parentSubject && subject.parentSubject.entity)
+            // if entity was attached via children
+            parent = subject.parentSubject.insertedValueSet
+                ? subject.parentSubject.insertedValueSet
+                : subject.parentSubject.entity;
+        const parentId = subject.metadata.getEntityIdMap(parent);
+        let parentPath = "";
+        if (parentId) {
+            parentPath = await this.getEntityPath(subject, parentId);
+        }
+        const insertedEntityId = subject.metadata
+            .treeParentRelation.joinColumns.map((joinColumn) => {
+            return joinColumn.referencedColumn.getEntityValue(subject.insertedValueSet);
+        })
+            .join("_");
+        await this.queryRunner.manager
+            .createQueryBuilder()
+            .update(subject.metadata.target)
+            .set({
+            [subject.metadata.materializedPathColumn.propertyPath]: parentPath + insertedEntityId + ".",
+        })
+            .where(subject.identifier)
+            .execute();
+    }
+    /**
+     * Executes operations when subject is being updated.
+     */
+    async update(subject) {
+        let newParent = subject.metadata.treeParentRelation.getEntityValue(subject.entity); // if entity was attached via parent
+        if (!newParent && subject.parentSubject && subject.parentSubject.entity)
+            // if entity was attached via children
+            newParent = subject.parentSubject.entity;
+        let entity = subject.databaseEntity; // if entity was attached via parent
+        if (!entity && newParent)
+            // if entity was attached via children
+            entity = subject.metadata
+                .treeChildrenRelation.getEntityValue(newParent)
+                .find((child) => {
+                return Object.entries(subject.identifier).every(([key, value]) => child[key] === value);
+            });
+        const oldParent = subject.metadata.treeParentRelation.getEntityValue(entity);
+        const oldParentId = this.getEntityParentReferencedColumnMap(subject, oldParent);
+        const newParentId = this.getEntityParentReferencedColumnMap(subject, newParent);
+        // Exit if the new and old parents are the same
+        if (OrmUtils_1.OrmUtils.compareIds(oldParentId, newParentId)) {
+            return;
+        }
+        let newParentPath = "";
+        if (newParentId) {
+            newParentPath = await this.getEntityPath(subject, newParentId);
+        }
+        let oldParentPath = "";
+        if (oldParentId) {
+            oldParentPath =
+                (await this.getEntityPath(subject, oldParentId)) || "";
+        }
+        const entityPath = subject.metadata
+            .treeParentRelation.joinColumns.map((joinColumn) => {
+            return joinColumn.referencedColumn.getEntityValue(entity);
+        })
+            .join("_");
+        const propertyPath = subject.metadata.materializedPathColumn.propertyPath;
+        await this.queryRunner.manager
+            .createQueryBuilder()
+            .update(subject.metadata.target)
+            .set({
+            [propertyPath]: () => `REPLACE(${this.queryRunner.connection.driver.escape(propertyPath)}, '${oldParentPath}${entityPath}.', '${newParentPath}${entityPath}.')`,
+        })
+            .where(`${propertyPath} LIKE :path`, {
+            path: `${oldParentPath}${entityPath}.%`,
+        })
+            .execute();
+    }
+    getEntityParentReferencedColumnMap(subject, entity) {
+        if (!entity)
+            return undefined;
+        return EntityMetadata_1.EntityMetadata.getValueMap(entity, subject.metadata
+            .treeParentRelation.joinColumns.map((column) => column.referencedColumn)
+            .filter((v) => v != null), { skipNulls: true });
+    }
+    getEntityPath(subject, id) {
+        const metadata = subject.metadata;
+        const normalized = (Array.isArray(id) ? id : [id]).map((id) => metadata.ensureEntityIdMap(id));
+        return this.queryRunner.manager
+            .createQueryBuilder()
+            .select(subject.metadata.targetName +
+            "." +
+            subject.metadata.materializedPathColumn.propertyPath, "path")
+            .from(subject.metadata.target, subject.metadata.targetName)
+            .where(new Brackets_1.Brackets((qb) => {
+            for (const data of normalized) {
+                qb.orWhere(new Brackets_1.Brackets((qb) => qb.where(data)));
+            }
+        }))
+            .getRawOne()
+            .then((result) => (result ? result["path"] : ""));
+    }
+}
+exports.MaterializedPathSubjectExecutor = MaterializedPathSubjectExecutor;
+
+//# sourceMappingURL=MaterializedPathSubjectExecutor.js.map

package/.output/server/node_modules/typeorm/persistence/tree/NestedSetSubjectExecutor.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedSetSubjectExecutor = void 0;
+const OrmUtils_1 = require("../../util/OrmUtils");
+const NestedSetMultipleRootError_1 = require("../../error/NestedSetMultipleRootError");
+class NestedSetIds {
+}
+/**
+ * Executes subject operations for nested set tree entities.
+ */
+class NestedSetSubjectExecutor {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(queryRunner) {
+        this.queryRunner = queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Executes operations when subject is being inserted.
+     */
+    async insert(subject) {
+        const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
+        const tableName = this.getTableName(subject.metadata.tablePath);
+        const leftColumnName = escape(subject.metadata.nestedSetLeftColumn.databaseName);
+        const rightColumnName = escape(subject.metadata.nestedSetRightColumn.databaseName);
+        let parent = subject.metadata.treeParentRelation.getEntityValue(subject.entity); // if entity was attached via parent
+        if (!parent && subject.parentSubject && subject.parentSubject.entity)
+            // if entity was attached via children
+            parent = subject.parentSubject.insertedValueSet
+                ? subject.parentSubject.insertedValueSet
+                : subject.parentSubject.entity;
+        const parentId = subject.metadata.getEntityIdMap(parent);
+        let parentNsRight = undefined;
+        if (parentId) {
+            parentNsRight = await this.queryRunner.manager
+                .createQueryBuilder()
+                .select(subject.metadata.targetName +
+                "." +
+                subject.metadata.nestedSetRightColumn.propertyPath, "right")
+                .from(subject.metadata.target, subject.metadata.targetName)
+                .whereInIds(parentId)
+                .getRawOne()
+                .then((result) => {
+                const value = result ? result["right"] : undefined;
+                // CockroachDB returns numeric types as string
+                return typeof value === "string" ? parseInt(value) : value;
+            });
+        }
+        if (parentNsRight !== undefined) {
+            await this.queryRunner.query(`UPDATE ${tableName} SET ` +
+                `${leftColumnName} = CASE WHEN ${leftColumnName} > ${parentNsRight} THEN ${leftColumnName} + 2 ELSE ${leftColumnName} END,` +
+                `${rightColumnName} = ${rightColumnName} + 2 ` +
+                `WHERE ${rightColumnName} >= ${parentNsRight}`);
+            OrmUtils_1.OrmUtils.mergeDeep(subject.insertedValueSet, subject.metadata.nestedSetLeftColumn.createValueMap(parentNsRight), subject.metadata.nestedSetRightColumn.createValueMap(parentNsRight + 1));
+        }
+        else {
+            const isUniqueRoot = await this.isUniqueRootEntity(subject, parent);
+            // Validate if a root entity already exits and throw an exception
+            if (!isUniqueRoot)
+                throw new NestedSetMultipleRootError_1.NestedSetMultipleRootError();
+            OrmUtils_1.OrmUtils.mergeDeep(subject.insertedValueSet, subject.metadata.nestedSetLeftColumn.createValueMap(1), subject.metadata.nestedSetRightColumn.createValueMap(2));
+        }
+    }
+    /**
+     * Executes operations when subject is being updated.
+     */
+    async update(subject) {
+        let parent = subject.metadata.treeParentRelation.getEntityValue(subject.entity); // if entity was attached via parent
+        if (!parent && subject.parentSubject && subject.parentSubject.entity)
+            // if entity was attached via children
+            parent = subject.parentSubject.entity;
+        let entity = subject.databaseEntity; // if entity was attached via parent
+        if (!entity && parent)
+            // if entity was attached via children
+            entity = subject.metadata
+                .treeChildrenRelation.getEntityValue(parent)
+                .find((child) => {
+                return Object.entries(subject.identifier).every(([key, value]) => child[key] === value);
+            });
+        // Exit if the parent or the entity where never set
+        if (entity === undefined || parent === undefined) {
+            return;
+        }
+        const oldParent = subject.metadata.treeParentRelation.getEntityValue(entity);
+        const oldParentId = subject.metadata.getEntityIdMap(oldParent);
+        const parentId = subject.metadata.getEntityIdMap(parent);
+        // Exit if the new and old parents are the same
+        if (OrmUtils_1.OrmUtils.compareIds(oldParentId, parentId)) {
+            return;
+        }
+        if (parent) {
+            const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
+            const tableName = this.getTableName(subject.metadata.tablePath);
+            const leftColumnName = escape(subject.metadata.nestedSetLeftColumn.databaseName);
+            const rightColumnName = escape(subject.metadata.nestedSetRightColumn.databaseName);
+            const entityId = subject.metadata.getEntityIdMap(entity);
+            let entityNs = undefined;
+            if (entityId) {
+                entityNs = (await this.getNestedSetIds(subject.metadata, entityId))[0];
+            }
+            let parentNs = undefined;
+            if (parentId) {
+                parentNs = (await this.getNestedSetIds(subject.metadata, parentId))[0];
+            }
+            if (entityNs !== undefined && parentNs !== undefined) {
+                const isMovingUp = parentNs.left > entityNs.left;
+                const treeSize = entityNs.right - entityNs.left + 1;
+                let entitySize;
+                if (isMovingUp) {
+                    entitySize = parentNs.left - entityNs.right;
+                }
+                else {
+                    entitySize = parentNs.right - entityNs.left;
+                }
+                // Moved entity logic
+                const updateLeftSide = `WHEN ${leftColumnName} >= ${entityNs.left} AND ` +
+                    `${leftColumnName} < ${entityNs.right} ` +
+                    `THEN ${leftColumnName} + ${entitySize} `;
+                const updateRightSide = `WHEN ${rightColumnName} > ${entityNs.left} AND ` +
+                    `${rightColumnName} <= ${entityNs.right} ` +
+                    `THEN ${rightColumnName} + ${entitySize} `;
+                // Update the surrounding entities
+                if (isMovingUp) {
+                    await this.queryRunner.query(`UPDATE ${tableName} ` +
+                        `SET ${leftColumnName} = CASE ` +
+                        `WHEN ${leftColumnName} > ${entityNs.right} AND ` +
+                        `${leftColumnName} <= ${parentNs.left} ` +
+                        `THEN ${leftColumnName} - ${treeSize} ` +
+                        updateLeftSide +
+                        `ELSE ${leftColumnName} ` +
+                        `END, ` +
+                        `${rightColumnName} = CASE ` +
+                        `WHEN ${rightColumnName} > ${entityNs.right} AND ` +
+                        `${rightColumnName} < ${parentNs.left} ` +
+                        `THEN ${rightColumnName} - ${treeSize} ` +
+                        updateRightSide +
+                        `ELSE ${rightColumnName} ` +
+                        `END`);
+                }
+                else {
+                    await this.queryRunner.query(`UPDATE ${tableName} ` +
+                        `SET ${leftColumnName} = CASE ` +
+                        `WHEN ${leftColumnName} < ${entityNs.left} AND ` +
+                        `${leftColumnName} > ${parentNs.right} ` +
+                        `THEN ${leftColumnName} + ${treeSize} ` +
+                        updateLeftSide +
+                        `ELSE ${leftColumnName} ` +
+                        `END, ` +
+                        `${rightColumnName} = CASE ` +
+                        `WHEN ${rightColumnName} < ${entityNs.left} AND ` +
+                        `${rightColumnName} >= ${parentNs.right} ` +
+                        `THEN ${rightColumnName} + ${treeSize} ` +
+                        updateRightSide +
+                        `ELSE ${rightColumnName} ` +
+                        `END`);
+                }
+            }
+        }
+        else {
+            const isUniqueRoot = await this.isUniqueRootEntity(subject, parent);
+            // Validate if a root entity already exits and throw an exception
+            if (!isUniqueRoot)
+                throw new NestedSetMultipleRootError_1.NestedSetMultipleRootError();
+        }
+    }
+    /**
+     * Executes operations when subject is being removed.
+     */
+    async remove(subjects) {
+        if (!Array.isArray(subjects))
+            subjects = [subjects];
+        const metadata = subjects[0].metadata;
+        const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
+        const tableName = this.getTableName(metadata.tablePath);
+        const leftColumnName = escape(metadata.nestedSetLeftColumn.databaseName);
+        const rightColumnName = escape(metadata.nestedSetRightColumn.databaseName);
+        const entitiesIds = [];
+        for (const subject of subjects) {
+            const entityId = metadata.getEntityIdMap(subject.entity);
+            if (entityId) {
+                entitiesIds.push(entityId);
+            }
+        }
+        const entitiesNs = await this.getNestedSetIds(metadata, entitiesIds);
+        for (const entity of entitiesNs) {
+            const treeSize = entity.right - entity.left + 1;
+            await this.queryRunner.query(`UPDATE ${tableName} ` +
+                `SET ${leftColumnName} = CASE ` +
+                `WHEN ${leftColumnName} > ${entity.left} THEN ${leftColumnName} - ${treeSize} ` +
+                `ELSE ${leftColumnName} ` +
+                `END, ` +
+                `${rightColumnName} = CASE ` +
+                `WHEN ${rightColumnName} > ${entity.right} THEN ${rightColumnName} - ${treeSize} ` +
+                `ELSE ${rightColumnName} ` +
+                `END`);
+        }
+    }
+    /**
+     * Get the nested set ids for a given entity
+     */
+    getNestedSetIds(metadata, ids) {
+        const select = {
+            left: `${metadata.targetName}.${metadata.nestedSetLeftColumn.propertyPath}`,
+            right: `${metadata.targetName}.${metadata.nestedSetRightColumn.propertyPath}`,
+        };
+        const queryBuilder = this.queryRunner.manager.createQueryBuilder();
+        Object.entries(select).forEach(([key, value]) => {
+            queryBuilder.addSelect(value, key);
+        });
+        return queryBuilder
+            .from(metadata.target, metadata.targetName)
+            .whereInIds(ids)
+            .orderBy(select.right, "DESC")
+            .getRawMany()
+            .then((results) => {
+            const data = [];
+            for (const result of results) {
+                const entry = {};
+                for (const key of Object.keys(select)) {
+                    const value = result ? result[key] : undefined;
+                    // CockroachDB returns numeric types as string
+                    entry[key] =
+                        typeof value === "string" ? parseInt(value) : value;
+                }
+                data.push(entry);
+            }
+            return data;
+        });
+    }
+    async isUniqueRootEntity(subject, parent) {
+        const escape = (alias) => this.queryRunner.connection.driver.escape(alias);
+        const tableName = this.getTableName(subject.metadata.tablePath);
+        const parameters = [];
+        const whereCondition = subject.metadata
+            .treeParentRelation.joinColumns.map((column) => {
+            const columnName = escape(column.databaseName);
+            const parameter = column.getEntityValue(parent);
+            if (parameter == null) {
+                return `${columnName} IS NULL`;
+            }
+            parameters.push(parameter);
+            const parameterName = this.queryRunner.connection.driver.createParameter("entity_" + column.databaseName, parameters.length - 1);
+            return `${columnName} = ${parameterName}`;
+        })
+            .join(" AND ");
+        const countAlias = "count";
+        const result = await this.queryRunner.query(`SELECT COUNT(1) AS ${escape(countAlias)} FROM ${tableName} WHERE ${whereCondition}`, parameters, true);
+        return parseInt(result.records[0][countAlias]) === 0;
+    }
+    /**
+     * Gets escaped table name with schema name if SqlServer or Postgres driver used with custom
+     * schema name, otherwise returns escaped table name.
+     */
+    getTableName(tablePath) {
+        return tablePath
+            .split(".")
+            .map((i) => {
+            // this condition need because in SQL Server driver when custom database name was specified and schema name was not, we got `dbName..tableName` string, and doesn't need to escape middle empty string
+            return i === ""
+                ? i
+                : this.queryRunner.connection.driver.escape(i);
+        })
+            .join(".");
+    }
+}
+exports.NestedSetSubjectExecutor = NestedSetSubjectExecutor;
+
+//# sourceMappingURL=NestedSetSubjectExecutor.js.map

package/.output/server/node_modules/typeorm/platform/PlatformTools.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformTools = exports.Writable = exports.Readable = exports.ReadStream = exports.EventEmitter = void 0;
+const tslib_1 = require("tslib");
+const ansis_1 = tslib_1.__importDefault(require("ansis"));
+const dotenv_1 = tslib_1.__importDefault(require("dotenv"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const sql_highlight_1 = require("sql-highlight");
+const formatter_1 = require("@sqltools/formatter");
+var events_1 = require("events");
+Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return events_1.EventEmitter; } });
+var fs_2 = require("fs");
+Object.defineProperty(exports, "ReadStream", { enumerable: true, get: function () { return fs_2.ReadStream; } });
+var stream_1 = require("stream");
+Object.defineProperty(exports, "Readable", { enumerable: true, get: function () { return stream_1.Readable; } });
+Object.defineProperty(exports, "Writable", { enumerable: true, get: function () { return stream_1.Writable; } });
+/**
+ * Platform-specific tools.
+ */
+class PlatformTools {
+    /**
+     * Gets global variable where global stuff can be stored.
+     */
+    static getGlobalVariable() {
+        return global;
+    }
+    /**
+     * Loads ("require"-s) given file or package.
+     * This operation only supports on node platform
+     */
+    static load(name) {
+        // if name is not absolute or relative, then try to load package from the node_modules of the directory we are currently in
+        // this is useful when we are using typeorm package globally installed and it accesses drivers
+        // that are not installed globally
+        try {
+            // switch case to explicit require statements for webpack compatibility.
+            switch (name) {
+                /**
+                 * spanner
+                 */
+                case "spanner":
+                    return require("@google-cloud/spanner");
+                /**
+                 * mongodb
+                 */
+                case "mongodb":
+                    return require("mongodb");
+                /**
+                 * hana
+                 */
+                case "@sap/hana-client":
+                    return require("@sap/hana-client");
+                case "@sap/hana-client/extension/Stream":
+                    return require("@sap/hana-client/extension/Stream");
+                case "hdb-pool":
+                    return require("hdb-pool");
+                /**
+                 * mysql
+                 */
+                case "mysql":
+                    return require("mysql");
+                case "mysql2":
+                    return require("mysql2");
+                /**
+                 * oracle
+                 */
+                case "oracledb":
+                    return require("oracledb");
+                /**
+                 * postgres
+                 */
+                case "pg":
+                    return require("pg");
+                case "pg-native":
+                    return require("pg-native");
+                case "pg-query-stream":
+                    return require("pg-query-stream");
+                case "typeorm-aurora-data-api-driver":
+                    return require("typeorm-aurora-data-api-driver");
+                /**
+                 * redis
+                 */
+                case "redis":
+                    return require("redis");
+                case "ioredis":
+                    return require("ioredis");
+                /**
+                 * better-sqlite3
+                 */
+                case "better-sqlite3":
+                    return require("better-sqlite3");
+                /**
+                 * sqlite
+                 */
+                case "sqlite3":
+                    return require("sqlite3");
+                /**
+                 * sql.js
+                 */
+                case "sql.js":
+                    return require("sql.js");
+                /**
+                 * sqlserver
+                 */
+                case "mssql":
+                    return require("mssql");
+                /**
+                 * react-native-sqlite
+                 */
+                case "react-native-sqlite-storage":
+                    return require("react-native-sqlite-storage");
+            }
+        }
+        catch (err) {
+            return require(path_1.default.resolve(process.cwd() + "/node_modules/" + name));
+        }
+        // If nothing above matched and we get here, the package was not listed within PlatformTools
+        // and is an Invalid Package.  To make it explicit that this is NOT the intended use case for
+        // PlatformTools.load - it's not just a way to replace `require` all willy-nilly - let's throw
+        // an error.
+        throw new TypeError(`Invalid Package for PlatformTools.load: ${name}`);
+    }
+    /**
+     * Normalizes given path. Does "path.normalize" and replaces backslashes with forward slashes on Windows.
+     */
+    static pathNormalize(pathStr) {
+        let normalizedPath = path_1.default.normalize(pathStr);
+        if (process.platform === "win32")
+            normalizedPath = normalizedPath.replace(/\\/g, "/");
+        return normalizedPath;
+    }
+    /**
+     * Gets file extension. Does "path.extname".
+     */
+    static pathExtname(pathStr) {
+        return path_1.default.extname(pathStr);
+    }
+    /**
+     * Resolved given path. Does "path.resolve".
+     */
+    static pathResolve(pathStr) {
+        return path_1.default.resolve(pathStr);
+    }
+    /**
+     * Synchronously checks if file exist. Does "fs.existsSync".
+     */
+    static fileExist(pathStr) {
+        return fs_1.default.existsSync(pathStr);
+    }
+    static readFileSync(filename) {
+        return fs_1.default.readFileSync(filename);
+    }
+    static appendFileSync(filename, data) {
+        fs_1.default.appendFileSync(filename, data);
+    }
+    static async writeFile(path, data) {
+        return fs_1.default.promises.writeFile(path, data);
+    }
+    /**
+     * Loads a dotenv file into the environment variables.
+     *
+     * @param path The file to load as a dotenv configuration
+     */
+    static dotenv(pathStr) {
+        dotenv_1.default.config({ path: pathStr });
+    }
+    /**
+     * Gets environment variable.
+     */
+    static getEnvVariable(name) {
+        return process.env[name];
+    }
+    /**
+     * Highlights sql string to be printed in the console.
+     */
+    static highlightSql(sql) {
+        return (0, sql_highlight_1.highlight)(sql, {
+            colors: {
+                keyword: ansis_1.default.blueBright.open,
+                function: ansis_1.default.magentaBright.open,
+                number: ansis_1.default.green.open,
+                string: ansis_1.default.white.open,
+                identifier: ansis_1.default.white.open,
+                special: ansis_1.default.white.open,
+                bracket: ansis_1.default.white.open,
+                comment: ansis_1.default.gray.open,
+                clear: ansis_1.default.reset.open,
+            },
+        });
+    }
+    /**
+     * Pretty-print sql string to be print in the console.
+     */
+    static formatSql(sql, dataSourceType) {
+        const databaseLanguageMap = {
+            oracle: "pl/sql",
+        };
+        const databaseLanguage = dataSourceType
+            ? databaseLanguageMap[dataSourceType] || "sql"
+            : "sql";
+        return (0, formatter_1.format)(sql, {
+            language: databaseLanguage,
+            indent: "    ",
+        });
+    }
+    /**
+     * Logging functions needed by AdvancedConsoleLogger
+     */
+    static logInfo(prefix, info) {
+        console.log(ansis_1.default.gray.underline(prefix), info);
+    }
+    static logError(prefix, error) {
+        console.log(ansis_1.default.underline.red(prefix), error);
+    }
+    static logWarn(prefix, warning) {
+        console.log(ansis_1.default.underline.yellow(prefix), warning);
+    }
+    static log(message) {
+        console.log(ansis_1.default.underline(message));
+    }
+    static info(info) {
+        return ansis_1.default.gray(info);
+    }
+    static error(error) {
+        return ansis_1.default.red(error);
+    }
+    static warn(message) {
+        return ansis_1.default.yellow(message);
+    }
+    static logCmdErr(prefix, err) {
+        console.log(ansis_1.default.black.bgRed(prefix));
+        if (err)
+            console.error(err);
+    }
+}
+exports.PlatformTools = PlatformTools;
+/**
+ * Type of the currently running platform.
+ */
+PlatformTools.type = "node";
+
+//# sourceMappingURL=PlatformTools.js.map

package/.output/server/node_modules/typeorm/query-builder/Alias.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alias = void 0;
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const error_1 = require("../error");
+/**
+ */
+class Alias {
+    constructor(alias) {
+        ObjectUtils_1.ObjectUtils.assign(this, alias || {});
+    }
+    get target() {
+        return this.metadata.target;
+    }
+    get hasMetadata() {
+        return !!this._metadata;
+    }
+    set metadata(metadata) {
+        this._metadata = metadata;
+    }
+    get metadata() {
+        if (!this._metadata)
+            throw new error_1.TypeORMError(`Cannot get entity metadata for the given alias "${this.name}"`);
+        return this._metadata;
+    }
+}
+exports.Alias = Alias;
+
+//# sourceMappingURL=Alias.js.map

package/.output/server/node_modules/typeorm/query-builder/Brackets.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Brackets = void 0;
+/**
+ * Syntax sugar.
+ * Allows to use brackets in WHERE expressions for better syntax.
+ */
+class Brackets {
+    /**
+     * Given WHERE query builder that will build a WHERE expression that will be taken into brackets.
+     */
+    constructor(whereFactory) {
+        this["@instanceof"] = Symbol.for("Brackets");
+        this.whereFactory = whereFactory;
+    }
+}
+exports.Brackets = Brackets;
+
+//# sourceMappingURL=Brackets.js.map