orcaq 1.0.20

package/.output/server/node_modules/typeorm/connection/ConnectionMetadataBuilder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionMetadataBuilder = void 0;
+const DirectoryExportedClassesLoader_1 = require("../util/DirectoryExportedClassesLoader");
+const OrmUtils_1 = require("../util/OrmUtils");
+const container_1 = require("../container");
+const globals_1 = require("../globals");
+const EntityMetadataBuilder_1 = require("../metadata-builder/EntityMetadataBuilder");
+const EntitySchemaTransformer_1 = require("../entity-schema/EntitySchemaTransformer");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+/**
+ * Builds migration instances, subscriber instances and entity metadatas for the given classes.
+ */
+class ConnectionMetadataBuilder {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(connection) {
+        this.connection = connection;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Builds migration instances for the given classes or directories.
+     */
+    async buildMigrations(migrations) {
+        const [migrationClasses, migrationDirectories] = OrmUtils_1.OrmUtils.splitClassesAndStrings(migrations);
+        const allMigrationClasses = [
+            ...migrationClasses,
+            ...(await (0, DirectoryExportedClassesLoader_1.importClassesFromDirectories)(this.connection.logger, migrationDirectories)),
+        ];
+        return allMigrationClasses.map((migrationClass) => (0, container_1.getFromContainer)(migrationClass));
+    }
+    /**
+     * Builds subscriber instances for the given classes or directories.
+     */
+    async buildSubscribers(subscribers) {
+        const [subscriberClasses, subscriberDirectories] = OrmUtils_1.OrmUtils.splitClassesAndStrings(subscribers || []);
+        const allSubscriberClasses = [
+            ...subscriberClasses,
+            ...(await (0, DirectoryExportedClassesLoader_1.importClassesFromDirectories)(this.connection.logger, subscriberDirectories)),
+        ];
+        return (0, globals_1.getMetadataArgsStorage)()
+            .filterSubscribers(allSubscriberClasses)
+            .map((metadata) => (0, container_1.getFromContainer)(metadata.target));
+    }
+    /**
+     * Builds entity metadatas for the given classes or directories.
+     */
+    async buildEntityMetadatas(entities) {
+        // todo: instead we need to merge multiple metadata args storages
+        const [entityClassesOrSchemas, entityDirectories] = OrmUtils_1.OrmUtils.splitClassesAndStrings(entities || []);
+        const entityClasses = entityClassesOrSchemas.filter((entityClass) => !InstanceChecker_1.InstanceChecker.isEntitySchema(entityClass));
+        const entitySchemas = entityClassesOrSchemas.filter((entityClass) => InstanceChecker_1.InstanceChecker.isEntitySchema(entityClass));
+        const allEntityClasses = [
+            ...entityClasses,
+            ...(await (0, DirectoryExportedClassesLoader_1.importClassesFromDirectories)(this.connection.logger, entityDirectories)),
+        ];
+        allEntityClasses.forEach((entityClass) => {
+            // if we have entity schemas loaded from directories
+            if (InstanceChecker_1.InstanceChecker.isEntitySchema(entityClass)) {
+                entitySchemas.push(entityClass);
+            }
+        });
+        const decoratorEntityMetadatas = new EntityMetadataBuilder_1.EntityMetadataBuilder(this.connection, (0, globals_1.getMetadataArgsStorage)()).build(allEntityClasses);
+        const metadataArgsStorageFromSchema = new EntitySchemaTransformer_1.EntitySchemaTransformer().transform(entitySchemas);
+        const schemaEntityMetadatas = new EntityMetadataBuilder_1.EntityMetadataBuilder(this.connection, metadataArgsStorageFromSchema).build();
+        return [...decoratorEntityMetadatas, ...schemaEntityMetadatas];
+    }
+}
+exports.ConnectionMetadataBuilder = ConnectionMetadataBuilder;
+
+//# sourceMappingURL=ConnectionMetadataBuilder.js.map

package/.output/server/node_modules/typeorm/connection/ConnectionOptionsReader.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionOptionsReader = void 0;
+const tslib_1 = require("tslib");
+const app_root_path_1 = tslib_1.__importDefault(require("app-root-path"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const error_1 = require("../error");
+const PlatformTools_1 = require("../platform/PlatformTools");
+const ImportUtils_1 = require("../util/ImportUtils");
+const PathUtils_1 = require("../util/PathUtils");
+const ConnectionOptionsEnvReader_1 = require("./options-reader/ConnectionOptionsEnvReader");
+/**
+ * Reads connection options from the ormconfig.
+ */
+class ConnectionOptionsReader {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(options) {
+        this.options = options;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Returns all connection options read from the ormconfig.
+     */
+    async all() {
+        const options = await this.load();
+        if (!options)
+            throw new error_1.TypeORMError(`No connection options were found in any orm configuration files.`);
+        return options;
+    }
+    /**
+     * Gets a connection with a given name read from ormconfig.
+     * If connection with such name would not be found then it throw error.
+     */
+    async get(name) {
+        const allOptions = await this.all();
+        const targetOptions = allOptions.find((options) => options.name === name || (name === "default" && !options.name));
+        if (!targetOptions)
+            throw new error_1.TypeORMError(`Cannot find connection ${name} because its not defined in any orm configuration files.`);
+        return targetOptions;
+    }
+    /**
+     * Checks if there is a TypeORM configuration file.
+     */
+    async has(name) {
+        const allOptions = await this.load();
+        if (!allOptions)
+            return false;
+        const targetOptions = allOptions.find((options) => options.name === name || (name === "default" && !options.name));
+        return !!targetOptions;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Loads all connection options from a configuration file.
+     *
+     * todo: get in count NODE_ENV somehow
+     */
+    async load() {
+        let connectionOptions = undefined;
+        const fileFormats = [
+            "env",
+            "js",
+            "mjs",
+            "cjs",
+            "ts",
+            "mts",
+            "cts",
+            "json",
+        ];
+        // Detect if baseFilePath contains file extension
+        const possibleExtension = this.baseFilePath.substr(this.baseFilePath.lastIndexOf("."));
+        const fileExtension = fileFormats.find((extension) => `.${extension}` === possibleExtension);
+        // try to find any of following configuration formats
+        const foundFileFormat = fileExtension ||
+            fileFormats.find((format) => {
+                return PlatformTools_1.PlatformTools.fileExist(this.baseFilePath + "." + format);
+            });
+        // Determine config file name
+        const configFile = fileExtension
+            ? this.baseFilePath
+            : this.baseFilePath + "." + foundFileFormat;
+        // if .env file found then load all its variables into process.env using dotenv package
+        if (foundFileFormat === "env") {
+            PlatformTools_1.PlatformTools.dotenv(configFile);
+        }
+        else if (PlatformTools_1.PlatformTools.fileExist(this.baseDirectory + "/.env")) {
+            PlatformTools_1.PlatformTools.dotenv(this.baseDirectory + "/.env");
+        }
+        // try to find connection options from any of available sources of configuration
+        if (PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CONNECTION") ||
+            PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_URL")) {
+            connectionOptions = await new ConnectionOptionsEnvReader_1.ConnectionOptionsEnvReader().read();
+        }
+        else if (foundFileFormat === "js" ||
+            foundFileFormat === "mjs" ||
+            foundFileFormat === "cjs" ||
+            foundFileFormat === "ts" ||
+            foundFileFormat === "mts" ||
+            foundFileFormat === "cts") {
+            const [importOrRequireResult, moduleSystem] = await (0, ImportUtils_1.importOrRequireFile)(configFile);
+            const configModule = await importOrRequireResult;
+            if (moduleSystem === "esm" ||
+                (configModule &&
+                    "__esModule" in configModule &&
+                    "default" in configModule)) {
+                connectionOptions = configModule.default;
+            }
+            else {
+                connectionOptions = configModule;
+            }
+        }
+        else if (foundFileFormat === "json") {
+            connectionOptions = require(configFile);
+        }
+        // normalize and return connection options
+        if (connectionOptions) {
+            return this.normalizeConnectionOptions(connectionOptions);
+        }
+        return undefined;
+    }
+    /**
+     * Normalize connection options.
+     */
+    normalizeConnectionOptions(connectionOptions) {
+        if (!Array.isArray(connectionOptions))
+            connectionOptions = [connectionOptions];
+        connectionOptions.forEach((options) => {
+            options.baseDirectory = this.baseDirectory;
+            if (options.entities) {
+                const entities = options.entities.map((entity) => {
+                    if (typeof entity === "string" &&
+                        entity.substr(0, 1) !== "/")
+                        return this.baseDirectory + "/" + entity;
+                    return entity;
+                });
+                Object.assign(connectionOptions, { entities: entities });
+            }
+            if (options.subscribers) {
+                const subscribers = options.subscribers.map((subscriber) => {
+                    if (typeof subscriber === "string" &&
+                        subscriber.substr(0, 1) !== "/")
+                        return this.baseDirectory + "/" + subscriber;
+                    return subscriber;
+                });
+                Object.assign(connectionOptions, { subscribers: subscribers });
+            }
+            if (options.migrations) {
+                const migrations = options.migrations.map((migration) => {
+                    if (typeof migration === "string" &&
+                        migration.substr(0, 1) !== "/")
+                        return this.baseDirectory + "/" + migration;
+                    return migration;
+                });
+                Object.assign(connectionOptions, { migrations: migrations });
+            }
+            // make database path file in sqlite relative to package.json
+            if (options.type === "sqlite" ||
+                options.type === "better-sqlite3") {
+                if (typeof options.database === "string" &&
+                    !(0, PathUtils_1.isAbsolute)(options.database) &&
+                    options.database.substr(0, 1) !== "/" && // unix absolute
+                    options.database.substr(1, 2) !== ":\\" && // windows absolute
+                    options.database !== ":memory:") {
+                    Object.assign(options, {
+                        database: this.baseDirectory + "/" + options.database,
+                    });
+                }
+            }
+        });
+        return connectionOptions;
+    }
+    /**
+     * Gets directory where configuration file should be located and configuration file name.
+     */
+    get baseFilePath() {
+        return path_1.default.resolve(this.baseDirectory, this.baseConfigName);
+    }
+    /**
+     * Gets directory where configuration file should be located.
+     */
+    get baseDirectory() {
+        return this.options?.root ?? app_root_path_1.default.path;
+    }
+    /**
+     * Gets configuration file name.
+     */
+    get baseConfigName() {
+        return this.options?.configName ?? "ormconfig";
+    }
+}
+exports.ConnectionOptionsReader = ConnectionOptionsReader;
+
+//# sourceMappingURL=ConnectionOptionsReader.js.map

package/.output/server/node_modules/typeorm/connection/options-reader/ConnectionOptionsEnvReader.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionOptionsEnvReader = void 0;
+const PlatformTools_1 = require("../../platform/PlatformTools");
+const OrmUtils_1 = require("../../util/OrmUtils");
+/**
+ * Reads connection options from environment variables.
+ * Environment variables can have only a single connection.
+ * Its strongly required to define TYPEORM_CONNECTION env variable.
+ *
+ * @deprecated
+ */
+class ConnectionOptionsEnvReader {
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Reads connection options from environment variables.
+     */
+    async read() {
+        return [
+            {
+                type: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CONNECTION") ||
+                    (PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_URL")
+                        ? PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_URL").split("://")[0]
+                        : undefined),
+                url: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_URL"),
+                host: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_HOST"),
+                port: this.stringToNumber(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_PORT")),
+                username: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_USERNAME"),
+                password: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_PASSWORD"),
+                database: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_DATABASE"),
+                sid: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_SID"),
+                schema: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_SCHEMA"),
+                extra: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_DRIVER_EXTRA")
+                    ? JSON.parse(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_DRIVER_EXTRA"))
+                    : undefined,
+                synchronize: OrmUtils_1.OrmUtils.toBoolean(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_SYNCHRONIZE")),
+                dropSchema: OrmUtils_1.OrmUtils.toBoolean(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_DROP_SCHEMA")),
+                migrationsRun: OrmUtils_1.OrmUtils.toBoolean(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_MIGRATIONS_RUN")),
+                entities: this.stringToArray(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_ENTITIES")),
+                migrations: this.stringToArray(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_MIGRATIONS")),
+                migrationsTableName: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_MIGRATIONS_TABLE_NAME"),
+                metadataTableName: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_METADATA_TABLE_NAME"),
+                subscribers: this.stringToArray(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_SUBSCRIBERS")),
+                logging: this.transformLogging(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_LOGGING")),
+                logger: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_LOGGER"),
+                entityPrefix: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_ENTITY_PREFIX"),
+                maxQueryExecutionTime: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_MAX_QUERY_EXECUTION_TIME"),
+                debug: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_DEBUG"),
+                cache: this.transformCaching(),
+                uuidExtension: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_UUID_EXTENSION"),
+            },
+        ];
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Transforms logging string into real logging value connection requires.
+     */
+    transformLogging(logging) {
+        if (logging === "true" || logging === "TRUE" || logging === "1")
+            return true;
+        if (logging === "all")
+            return "all";
+        return this.stringToArray(logging);
+    }
+    /**
+     * Transforms caching option into real caching value option requires.
+     */
+    transformCaching() {
+        const caching = PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CACHE");
+        if (caching === "true" || caching === "TRUE" || caching === "1")
+            return true;
+        if (caching === "false" || caching === "FALSE" || caching === "0")
+            return false;
+        if (caching === "redis" ||
+            caching === "ioredis" ||
+            caching === "database")
+            return {
+                type: caching,
+                options: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CACHE_OPTIONS")
+                    ? JSON.parse(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CACHE_OPTIONS"))
+                    : undefined,
+                alwaysEnabled: PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CACHE_ALWAYS_ENABLED"),
+                duration: parseInt(PlatformTools_1.PlatformTools.getEnvVariable("TYPEORM_CACHE_DURATION")),
+            };
+        return undefined;
+    }
+    /**
+     * Converts a string which contains multiple elements split by comma into a string array of strings.
+     */
+    stringToArray(variable) {
+        if (!variable)
+            return [];
+        return variable.split(",").map((str) => str.trim());
+    }
+    /**
+     * Converts a string which contains a number into a javascript number
+     */
+    stringToNumber(value) {
+        if (!value) {
+            return undefined;
+        }
+        return parseInt(value);
+    }
+}
+exports.ConnectionOptionsEnvReader = ConnectionOptionsEnvReader;
+
+//# sourceMappingURL=ConnectionOptionsEnvReader.js.map

package/.output/server/node_modules/typeorm/container.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContainer = useContainer;
+exports.getFromContainer = getFromContainer;
+/**
+ * Container to be used by this library for inversion control. If container was not implicitly set then by default
+ * container simply creates a new instance of the given class.
+ *
+ * @deprecated
+ */
+const defaultContainer = new (class {
+    constructor() {
+        this.instances = [];
+    }
+    get(someClass) {
+        let instance = this.instances.find((i) => i.type === someClass);
+        if (!instance) {
+            instance = {
+                type: someClass,
+                object: new someClass(),
+            };
+            this.instances.push(instance);
+        }
+        return instance.object;
+    }
+})();
+let userContainer;
+let userContainerOptions;
+/**
+ * Sets container to be used by this library.
+ *
+ * @deprecated
+ */
+function useContainer(iocContainer, options) {
+    userContainer = iocContainer;
+    userContainerOptions = options;
+}
+/**
+ * Gets the IOC container used by this library.
+ *
+ * @deprecated
+ */
+function getFromContainer(someClass) {
+    if (userContainer) {
+        try {
+            const instance = userContainer.get(someClass);
+            if (instance)
+                return instance;
+            if (!userContainerOptions || !userContainerOptions.fallback)
+                return instance;
+        }
+        catch (error) {
+            if (!userContainerOptions || !userContainerOptions.fallbackOnErrors)
+                throw error;
+        }
+    }
+    return defaultContainer.get(someClass);
+}
+
+//# sourceMappingURL=container.js.map