orcaq 1.0.20

package/.output/server/node_modules/typeorm/subscriber/event/QueryEvent.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+
+//# sourceMappingURL=QueryEvent.js.map

package/.output/server/node_modules/typeorm/util/ApplyValueTransformers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplyValueTransformers = void 0;
+class ApplyValueTransformers {
+    static transformFrom(transformer, databaseValue) {
+        if (Array.isArray(transformer)) {
+            const reverseTransformers = transformer.slice().reverse();
+            return reverseTransformers.reduce((transformedValue, _transformer) => {
+                return _transformer.from(transformedValue);
+            }, databaseValue);
+        }
+        return transformer.from(databaseValue);
+    }
+    static transformTo(transformer, entityValue) {
+        if (Array.isArray(transformer)) {
+            return transformer.reduce((transformedValue, _transformer) => {
+                return _transformer.to(transformedValue);
+            }, entityValue);
+        }
+        return transformer.to(entityValue);
+    }
+}
+exports.ApplyValueTransformers = ApplyValueTransformers;
+
+//# sourceMappingURL=ApplyValueTransformers.js.map

package/.output/server/node_modules/typeorm/util/DateUtils.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateUtils = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+/**
+ * Provides utilities to transform hydrated and persisted data.
+ */
+class DateUtils {
+    // -------------------------------------------------------------------------
+    // Public Static Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Normalizes date object hydrated from the database.
+     */
+    static normalizeHydratedDate(mixedDate) {
+        if (!mixedDate)
+            return mixedDate;
+        return typeof mixedDate === "string"
+            ? new Date(mixedDate)
+            : mixedDate;
+    }
+    /**
+     * Converts given value into date string in a "YYYY-MM-DD" format.
+     */
+    static mixedDateToDateString(value) {
+        if (value instanceof Date) {
+            return (this.formatZerolessValue(value.getFullYear(), 4) +
+                "-" +
+                this.formatZerolessValue(value.getMonth() + 1) +
+                "-" +
+                this.formatZerolessValue(value.getDate()));
+        }
+        return value;
+    }
+    /**
+     * Converts given value into date object.
+     */
+    static mixedDateToDate(mixedDate, toUtc = false, useMilliseconds = true) {
+        /**
+         * new Date(ISOString) is not a reliable parser to date strings.
+         * It's better to use 'date-fns' parser to parser string in ISO Format.
+         *
+         * The problem here is with wrong timezone.
+         *
+         * For example:
+         *
+         * ``new Date('2021-04-28')`` will generate `2021-04-28T00:00:00.000Z`
+         * in my timezone, which is not true for my timezone (GMT-0300). It should
+         * be `2021-04-28T03:00:00.000Z` as `new Date(2021, 3, 28)` generates.
+         *
+         * https://stackoverflow.com/a/2587398
+         */
+        let date = typeof mixedDate === "string"
+            ? (0, dayjs_1.default)(mixedDate).toDate()
+            : mixedDate;
+        if (toUtc)
+            date = new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());
+        if (!useMilliseconds)
+            date.setUTCMilliseconds(0);
+        return date;
+    }
+    /**
+     * Converts given value into time string in a "HH:mm:ss" format.
+     */
+    static mixedDateToTimeString(value, skipSeconds = false) {
+        if (value instanceof Date)
+            return (this.formatZerolessValue(value.getHours()) +
+                ":" +
+                this.formatZerolessValue(value.getMinutes()) +
+                (!skipSeconds
+                    ? ":" + this.formatZerolessValue(value.getSeconds())
+                    : ""));
+        return value;
+    }
+    /**
+     * Converts given value into time string in a "HH:mm:ss" format.
+     */
+    static mixedTimeToDate(value) {
+        if (typeof value === "string") {
+            const [hours, minutes, seconds] = value.split(":");
+            const date = new Date();
+            if (hours)
+                date.setHours(parseInt(hours));
+            if (minutes)
+                date.setMinutes(parseInt(minutes));
+            if (seconds)
+                date.setSeconds(parseInt(seconds));
+            return date;
+        }
+        return value;
+    }
+    /**
+     * Converts given string value with "-" separator into a "HH:mm:ss" format.
+     */
+    static mixedTimeToString(value, skipSeconds = false) {
+        value =
+            value instanceof Date
+                ? value.getHours() +
+                    ":" +
+                    value.getMinutes() +
+                    (!skipSeconds ? ":" + value.getSeconds() : "")
+                : value;
+        if (typeof value === "string") {
+            return value
+                .split(":")
+                .map((v) => (v.length === 1 ? "0" + v : v)) // append zero at beginning if we have a first-zero-less number
+                .join(":");
+        }
+        return value;
+    }
+    /**
+     * Converts given value into datetime string in a "YYYY-MM-DD HH-mm-ss" format.
+     */
+    static mixedDateToDatetimeString(value, useMilliseconds) {
+        if (typeof value === "string") {
+            value = new Date(value);
+        }
+        if (value instanceof Date) {
+            let finalValue = this.formatZerolessValue(value.getFullYear(), 4) +
+                "-" +
+                this.formatZerolessValue(value.getMonth() + 1) +
+                "-" +
+                this.formatZerolessValue(value.getDate()) +
+                " " +
+                this.formatZerolessValue(value.getHours()) +
+                ":" +
+                this.formatZerolessValue(value.getMinutes()) +
+                ":" +
+                this.formatZerolessValue(value.getSeconds());
+            if (useMilliseconds)
+                finalValue += `.${this.formatMilliseconds(value.getMilliseconds())}`;
+            value = finalValue;
+        }
+        return value;
+    }
+    /**
+     * Converts given value into utc datetime string in a "YYYY-MM-DD HH-mm-ss.sss" format.
+     */
+    static mixedDateToUtcDatetimeString(value) {
+        if (typeof value === "string") {
+            value = new Date(value);
+        }
+        if (value instanceof Date) {
+            return (this.formatZerolessValue(value.getUTCFullYear(), 4) +
+                "-" +
+                this.formatZerolessValue(value.getUTCMonth() + 1) +
+                "-" +
+                this.formatZerolessValue(value.getUTCDate()) +
+                " " +
+                this.formatZerolessValue(value.getUTCHours()) +
+                ":" +
+                this.formatZerolessValue(value.getUTCMinutes()) +
+                ":" +
+                this.formatZerolessValue(value.getUTCSeconds()) +
+                "." +
+                this.formatMilliseconds(value.getUTCMilliseconds()));
+        }
+        return value;
+    }
+    /**
+     * Converts each item in the given array to string joined by "," separator.
+     */
+    static simpleArrayToString(value) {
+        if (Array.isArray(value)) {
+            return value.map((i) => String(i)).join(",");
+        }
+        return value;
+    }
+    /**
+     * Converts given string to simple array split by "," separator.
+     */
+    static stringToSimpleArray(value) {
+        if (typeof value === "string") {
+            if (value.length > 0) {
+                return value.split(",");
+            }
+            else {
+                return [];
+            }
+        }
+        return value;
+    }
+    static simpleJsonToString(value) {
+        return JSON.stringify(value);
+    }
+    static stringToSimpleJson(value) {
+        return typeof value === "string" ? JSON.parse(value) : value;
+    }
+    static simpleEnumToString(value) {
+        return "" + value;
+    }
+    static stringToSimpleEnum(value, columnMetadata) {
+        if (columnMetadata.enum &&
+            !isNaN(value) &&
+            columnMetadata.enum.indexOf(parseInt(value)) >= 0) {
+            // convert to number if that exists in poosible enum options
+            value = parseInt(value);
+        }
+        return value;
+    }
+    // -------------------------------------------------------------------------
+    // Private Static Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Formats given number to "0x" format, e.g. if the totalLength = 2 and the value is 1 then it will return "01".
+     */
+    static formatZerolessValue(value, totalLength = 2) {
+        const pad = "0".repeat(totalLength);
+        return String(`${pad}${value}`).slice(-totalLength);
+    }
+    /**
+     * Formats given number to "0x" format, e.g. if it is 1 then it will return "01".
+     */
+    static formatMilliseconds(value) {
+        if (value < 10) {
+            return "00" + value;
+        }
+        else if (value < 100) {
+            return "0" + value;
+        }
+        else {
+            return String(value);
+        }
+    }
+}
+exports.DateUtils = DateUtils;
+
+//# sourceMappingURL=DateUtils.js.map

package/.output/server/node_modules/typeorm/util/DepGraph.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * This source code is from https://github.com/jriecken/dependency-graph
+ * Just added "any" types here, wrapper everything into exported class.
+ * We cant use a package itself because we want to package "everything-in-it" for the frontend users of TypeORM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepGraph = void 0;
+/**
+ * A simple dependency graph
+ */
+const error_1 = require("../error");
+/**
+ * Helper for creating a Depth-First-Search on
+ * a set of edges.
+ *
+ * Detects cycles and throws an Error if one is detected.
+ *
+ * @param edges The set of edges to DFS through
+ * @param leavesOnly Whether to only return "leaf" nodes (ones who have no edges)
+ * @param result An array in which the results will be populated
+ */
+function createDFS(edges, leavesOnly, result) {
+    const currentPath = [];
+    const visited = {};
+    return function DFS(currentNode) {
+        visited[currentNode] = true;
+        currentPath.push(currentNode);
+        edges[currentNode].forEach(function (node) {
+            if (!visited[node]) {
+                DFS(node);
+            }
+            else if (currentPath.indexOf(node) >= 0) {
+                currentPath.push(node);
+                throw new error_1.TypeORMError(`Dependency Cycle Found: ${currentPath.join(" -> ")}`);
+            }
+        });
+        currentPath.pop();
+        if ((!leavesOnly || edges[currentNode].length === 0) &&
+            result.indexOf(currentNode) === -1) {
+            result.push(currentNode);
+        }
+    };
+}
+class DepGraph {
+    constructor() {
+        this.nodes = {};
+        this.outgoingEdges = {}; // Node -> [Dependency Node]
+        this.incomingEdges = {}; // Node -> [Dependant Node]
+    }
+    /**
+     * Add a node to the dependency graph. If a node already exists, this method will do nothing.
+     */
+    addNode(node, data) {
+        if (!this.hasNode(node)) {
+            // Checking the arguments length allows the user to add a node with undefined data
+            if (arguments.length === 2) {
+                this.nodes[node] = data;
+            }
+            else {
+                this.nodes[node] = node;
+            }
+            this.outgoingEdges[node] = [];
+            this.incomingEdges[node] = [];
+        }
+    }
+    /**
+     * Remove a node from the dependency graph. If a node does not exist, this method will do nothing.
+     */
+    removeNode(node) {
+        if (this.hasNode(node)) {
+            delete this.nodes[node];
+            delete this.outgoingEdges[node];
+            delete this.incomingEdges[node];
+            [this.incomingEdges, this.outgoingEdges].forEach(function (edgeList) {
+                Object.keys(edgeList).forEach(function (key) {
+                    const idx = edgeList[key].indexOf(node);
+                    if (idx >= 0) {
+                        edgeList[key].splice(idx, 1);
+                    }
+                });
+            });
+        }
+    }
+    /**
+     * Check if a node exists in the graph
+     */
+    hasNode(node) {
+        return this.nodes.hasOwnProperty(node);
+    }
+    /**
+     * Get the data associated with a node name
+     */
+    getNodeData(node) {
+        if (this.hasNode(node)) {
+            return this.nodes[node];
+        }
+        else {
+            throw new error_1.TypeORMError(`Node does not exist: ${node}`);
+        }
+    }
+    /**
+     * Set the associated data for a given node name. If the node does not exist, this method will throw an error
+     */
+    setNodeData(node, data) {
+        if (this.hasNode(node)) {
+            this.nodes[node] = data;
+        }
+        else {
+            throw new error_1.TypeORMError(`Node does not exist: ${node}`);
+        }
+    }
+    /**
+     * Add a dependency between two nodes. If either of the nodes does not exist,
+     * an Error will be thrown.
+     */
+    addDependency(from, to) {
+        if (!this.hasNode(from)) {
+            throw new error_1.TypeORMError(`Node does not exist: ${from}`);
+        }
+        if (!this.hasNode(to)) {
+            throw new error_1.TypeORMError(`Node does not exist: ${to}`);
+        }
+        if (this.outgoingEdges[from].indexOf(to) === -1) {
+            this.outgoingEdges[from].push(to);
+        }
+        if (this.incomingEdges[to].indexOf(from) === -1) {
+            this.incomingEdges[to].push(from);
+        }
+        return true;
+    }
+    /**
+     * Remove a dependency between two nodes.
+     */
+    removeDependency(from, to) {
+        let idx;
+        if (this.hasNode(from)) {
+            idx = this.outgoingEdges[from].indexOf(to);
+            if (idx >= 0) {
+                this.outgoingEdges[from].splice(idx, 1);
+            }
+        }
+        if (this.hasNode(to)) {
+            idx = this.incomingEdges[to].indexOf(from);
+            if (idx >= 0) {
+                this.incomingEdges[to].splice(idx, 1);
+            }
+        }
+    }
+    /**
+     * Get an array containing the nodes that the specified node depends on (transitively).
+     *
+     * Throws an Error if the graph has a cycle, or the specified node does not exist.
+     *
+     * If `leavesOnly` is true, only nodes that do not depend on any other nodes will be returned
+     * in the array.
+     */
+    dependenciesOf(node, leavesOnly) {
+        if (this.hasNode(node)) {
+            const result = [];
+            const DFS = createDFS(this.outgoingEdges, leavesOnly, result);
+            DFS(node);
+            const idx = result.indexOf(node);
+            if (idx >= 0) {
+                result.splice(idx, 1);
+            }
+            return result;
+        }
+        else {
+            throw new error_1.TypeORMError(`Node does not exist: ${node}`);
+        }
+    }
+    /**
+     * get an array containing the nodes that depend on the specified node (transitively).
+     *
+     * Throws an Error if the graph has a cycle, or the specified node does not exist.
+     *
+     * If `leavesOnly` is true, only nodes that do not have any dependants will be returned in the array.
+     */
+    dependantsOf(node, leavesOnly) {
+        if (this.hasNode(node)) {
+            const result = [];
+            const DFS = createDFS(this.incomingEdges, leavesOnly, result);
+            DFS(node);
+            const idx = result.indexOf(node);
+            if (idx >= 0) {
+                result.splice(idx, 1);
+            }
+            return result;
+        }
+        else {
+            throw new error_1.TypeORMError(`Node does not exist: ${node}`);
+        }
+    }
+    /**
+     * Construct the overall processing order for the dependency graph.
+     *
+     * Throws an Error if the graph has a cycle.
+     *
+     * If `leavesOnly` is true, only nodes that do not depend on any other nodes will be returned.
+     */
+    overallOrder(leavesOnly) {
+        const self = this;
+        const result = [];
+        const keys = Object.keys(this.nodes);
+        if (keys.length === 0) {
+            return result; // Empty graph
+        }
+        else {
+            // Look for cycles - we run the DFS starting at all the nodes in case there
+            // are several disconnected subgraphs inside this dependency graph.
+            const CycleDFS = createDFS(this.outgoingEdges, false, []);
+            keys.forEach(function (n) {
+                CycleDFS(n);
+            });
+            const DFS = createDFS(this.outgoingEdges, leavesOnly, result);
+            // Find all potential starting points (nodes with nothing depending on them) an
+            // run a DFS starting at these points to get the order
+            keys.filter(function (node) {
+                return self.incomingEdges[node].length === 0;
+            }).forEach(function (n) {
+                DFS(n);
+            });
+            return result;
+        }
+    }
+}
+exports.DepGraph = DepGraph;
+
+//# sourceMappingURL=DepGraph.js.map

package/.output/server/node_modules/typeorm/util/DirectoryExportedClassesLoader.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importClassesFromDirectories = importClassesFromDirectories;
+exports.importJsonsFromDirectories = importJsonsFromDirectories;
+const tslib_1 = require("tslib");
+const glob = tslib_1.__importStar(require("glob"));
+const PlatformTools_1 = require("../platform/PlatformTools");
+const ImportUtils_1 = require("./ImportUtils");
+const ObjectUtils_1 = require("./ObjectUtils");
+const InstanceChecker_1 = require("./InstanceChecker");
+/**
+ * Loads all exported classes from the given directory.
+ */
+async function importClassesFromDirectories(logger, directories, formats = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]) {
+    const logLevel = "info";
+    const classesNotFoundMessage = "No classes were found using the provided glob pattern: ";
+    const classesFoundMessage = "All classes found using provided glob pattern";
+    function loadFileClasses(exported, allLoaded) {
+        if (typeof exported === "function" ||
+            InstanceChecker_1.InstanceChecker.isEntitySchema(exported)) {
+            allLoaded.push(exported);
+        }
+        else if (Array.isArray(exported)) {
+            exported.forEach((value) => loadFileClasses(value, allLoaded));
+        }
+        else if (ObjectUtils_1.ObjectUtils.isObject(exported)) {
+            Object.values(exported).forEach((value) => loadFileClasses(value, allLoaded));
+        }
+        return allLoaded;
+    }
+    const allFiles = directories.reduce((allDirs, dir) => {
+        return allDirs.concat(glob.sync(PlatformTools_1.PlatformTools.pathNormalize(dir)));
+    }, []);
+    if (directories.length > 0 && allFiles.length === 0) {
+        logger.log(logLevel, `${classesNotFoundMessage} "${directories}"`);
+    }
+    else if (allFiles.length > 0) {
+        logger.log(logLevel, `${classesFoundMessage} "${directories}" : "${allFiles}"`);
+    }
+    const dirPromises = allFiles
+        .filter((file) => {
+        const dtsExtension = file.substring(file.length - 5, file.length);
+        return (formats.indexOf(PlatformTools_1.PlatformTools.pathExtname(file)) !== -1 &&
+            dtsExtension !== ".d.ts");
+    })
+        .map(async (file) => {
+        const [importOrRequireResult] = await (0, ImportUtils_1.importOrRequireFile)(PlatformTools_1.PlatformTools.pathResolve(file));
+        return importOrRequireResult;
+    });
+    const dirs = await Promise.all(dirPromises);
+    return loadFileClasses(dirs, []);
+}
+/**
+ * Loads all json files from the given directory.
+ */
+function importJsonsFromDirectories(directories, format = ".json") {
+    const allFiles = directories.reduce((allDirs, dir) => {
+        return allDirs.concat(glob.sync(PlatformTools_1.PlatformTools.pathNormalize(dir)));
+    }, []);
+    return allFiles
+        .filter((file) => PlatformTools_1.PlatformTools.pathExtname(file) === format)
+        .map((file) => require(PlatformTools_1.PlatformTools.pathResolve(file)));
+}
+
+//# sourceMappingURL=DirectoryExportedClassesLoader.js.map

package/.output/server/node_modules/typeorm/util/ImportUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importOrRequireFile = importOrRequireFile;
+const tslib_1 = require("tslib");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const url_1 = require("url");
+async function importOrRequireFile(filePath) {
+    const tryToImport = async () => {
+        // `Function` is required to make sure the `import` statement wil stay `import` after
+        // transpilation and won't be converted to `require`
+        return [
+            await Function("return filePath => import(filePath)")()(filePath.startsWith("file://")
+                ? filePath
+                : (0, url_1.pathToFileURL)(filePath).toString()),
+            "esm",
+        ];
+    };
+    const tryToRequire = async () => {
+        return [require(filePath), "commonjs"];
+    };
+    const extension = filePath.substring(filePath.lastIndexOf(".") + ".".length);
+    if (extension === "mjs" || extension === "mts")
+        return tryToImport();
+    else if (extension === "cjs" || extension === "cts")
+        return tryToRequire();
+    else if (extension === "js" || extension === "ts") {
+        const packageJson = await getNearestPackageJson(filePath);
+        if (packageJson != null) {
+            const isModule = packageJson?.type === "module";
+            if (isModule)
+                return tryToImport();
+            else
+                return tryToRequire();
+        }
+        else
+            return tryToRequire();
+    }
+    return tryToRequire();
+}
+async function getNearestPackageJson(filePath) {
+    let currentPath = filePath;
+    while (currentPath !== path_1.default.dirname(currentPath)) {
+        currentPath = path_1.default.dirname(currentPath);
+        const potentialPackageJson = path_1.default.join(currentPath, "package.json");
+        try {
+            const stats = await promises_1.default.stat(potentialPackageJson);
+            if (!stats.isFile()) {
+                continue;
+            }
+            try {
+                return JSON.parse(await promises_1.default.readFile(potentialPackageJson, "utf8"));
+            }
+            catch {
+                return null;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // the top of the file tree is reached
+    return null;
+}
+
+//# sourceMappingURL=ImportUtils.js.map