orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/typeorm/repository/Repository.js

@@ -1,379 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
-const SqlTagUtils_1 = require("../util/SqlTagUtils");
-/**
- * Repository is supposed to work with your entity objects. Find entities, insert, update, delete, etc.
- */
-class Repository {
-    // -------------------------------------------------------------------------
-    // Accessors
-    // -------------------------------------------------------------------------
-    /**
-     * Entity metadata of the entity current repository manages.
-     */
-    get metadata() {
-        return this.manager.connection.getMetadata(this.target);
-    }
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(target, manager, queryRunner) {
-        this.target = target;
-        this.manager = manager;
-        this.queryRunner = queryRunner;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Creates a new query builder that can be used to build a SQL query.
-     */
-    createQueryBuilder(alias, queryRunner) {
-        return this.manager.createQueryBuilder(this.metadata.target, alias || this.metadata.targetName, queryRunner || this.queryRunner);
-    }
-    /**
-     * Checks if entity has an id.
-     * If entity composite compose ids, it will check them all.
-     */
-    hasId(entity) {
-        return this.manager.hasId(this.metadata.target, entity);
-    }
-    /**
-     * Gets entity mixed id.
-     */
-    getId(entity) {
-        return this.manager.getId(this.metadata.target, entity);
-    }
-    /**
-     * Creates a new entity instance or instances.
-     * Can copy properties from the given object into new entities.
-     */
-    create(plainEntityLikeOrPlainEntityLikes) {
-        return this.manager.create(this.metadata.target, plainEntityLikeOrPlainEntityLikes);
-    }
-    /**
-     * Merges multiple entities (or entity-like objects) into a given entity.
-     */
-    merge(mergeIntoEntity, ...entityLikes) {
-        return this.manager.merge(this.metadata.target, mergeIntoEntity, ...entityLikes);
-    }
-    /**
-     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
-     * it loads it (and everything related to it), replaces all values with the new ones from the given object
-     * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
-     * replaced from the new object.
-     *
-     * Note that given entity-like object must have an entity id / primary key to find entity by.
-     * Returns undefined if entity with given id was not found.
-     */
-    preload(entityLike) {
-        return this.manager.preload(this.metadata.target, entityLike);
-    }
-    /**
-     * Saves one or many given entities.
-     */
-    save(entityOrEntities, options) {
-        return this.manager.save(this.metadata.target, entityOrEntities, options);
-    }
-    /**
-     * Removes one or many given entities.
-     */
-    remove(entityOrEntities, options) {
-        return this.manager.remove(this.metadata.target, entityOrEntities, options);
-    }
-    /**
-     * Records the delete date of one or many given entities.
-     */
-    softRemove(entityOrEntities, options) {
-        return this.manager.softRemove(this.metadata.target, entityOrEntities, options);
-    }
-    /**
-     * Recovers one or many given entities.
-     */
-    recover(entityOrEntities, options) {
-        return this.manager.recover(this.metadata.target, entityOrEntities, options);
-    }
-    /**
-     * Inserts a given entity into the database.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient INSERT query.
-     * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
-     */
-    insert(entity) {
-        return this.manager.insert(this.metadata.target, entity);
-    }
-    /**
-     * Updates entity partially. Entity can be found by a given conditions.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient UPDATE query.
-     * Does not check if entity exist in the database.
-     */
-    update(criteria, partialEntity) {
-        return this.manager.update(this.metadata.target, criteria, partialEntity);
-    }
-    /**
-     * Updates all entities of target type, setting fields from supplied partial entity.
-     * This is a primitive operation without cascades, relations or other operations included.
-     * Executes fast and efficient UPDATE query without WHERE clause.
-     *
-     * WARNING! This method updates ALL rows in the target table.
-     */
-    updateAll(partialEntity) {
-        return this.manager.updateAll(this.metadata.target, partialEntity);
-    }
-    /**
-     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
-     */
-    upsert(entityOrEntities, conflictPathsOrOptions) {
-        return this.manager.upsert(this.metadata.target, entityOrEntities, conflictPathsOrOptions);
-    }
-    /**
-     * Deletes entities by a given criteria.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    delete(criteria) {
-        return this.manager.delete(this.metadata.target, criteria);
-    }
-    /**
-     * Deletes all entities of target type.
-     * This is a primitive operation without cascades, relations or other operations included.
-     * Executes fast and efficient DELETE query without WHERE clause.
-     *
-     * WARNING! This method deletes ALL rows in the target table.
-     */
-    deleteAll() {
-        return this.manager.deleteAll(this.metadata.target);
-    }
-    /**
-     * Records the delete date of entities by a given criteria.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient SOFT-DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    softDelete(criteria) {
-        return this.manager.softDelete(this.metadata.target, criteria);
-    }
-    /**
-     * Restores entities by a given criteria.
-     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
-     * Executes fast and efficient SOFT-DELETE query.
-     * Does not check if entity exist in the database.
-     */
-    restore(criteria) {
-        return this.manager.restore(this.metadata.target, criteria);
-    }
-    /**
-     * Checks whether any entity exists that matches the given options.
-     *
-     * @deprecated use `exists` method instead, for example:
-     *
-     * .exists()
-     */
-    exist(options) {
-        return this.manager.exists(this.metadata.target, options);
-    }
-    /**
-     * Checks whether any entity exists that matches the given options.
-     */
-    exists(options) {
-        return this.manager.exists(this.metadata.target, options);
-    }
-    /**
-     * Checks whether any entity exists that matches the given conditions.
-     */
-    existsBy(where) {
-        return this.manager.existsBy(this.metadata.target, where);
-    }
-    /**
-     * Counts entities that match given options.
-     * Useful for pagination.
-     */
-    count(options) {
-        return this.manager.count(this.metadata.target, options);
-    }
-    /**
-     * Counts entities that match given conditions.
-     * Useful for pagination.
-     */
-    countBy(where) {
-        return this.manager.countBy(this.metadata.target, where);
-    }
-    /**
-     * Return the SUM of a column
-     */
-    sum(columnName, where) {
-        return this.manager.sum(this.metadata.target, columnName, where);
-    }
-    /**
-     * Return the AVG of a column
-     */
-    average(columnName, where) {
-        return this.manager.average(this.metadata.target, columnName, where);
-    }
-    /**
-     * Return the MIN of a column
-     */
-    minimum(columnName, where) {
-        return this.manager.minimum(this.metadata.target, columnName, where);
-    }
-    /**
-     * Return the MAX of a column
-     */
-    maximum(columnName, where) {
-        return this.manager.maximum(this.metadata.target, columnName, where);
-    }
-    /**
-     * Finds entities that match given find options.
-     */
-    async find(options) {
-        return this.manager.find(this.metadata.target, options);
-    }
-    /**
-     * Finds entities that match given find options.
-     */
-    async findBy(where) {
-        return this.manager.findBy(this.metadata.target, where);
-    }
-    /**
-     * Finds entities that match given find options.
-     * Also counts all entities that match given conditions,
-     * but ignores pagination settings (from and take options).
-     */
-    findAndCount(options) {
-        return this.manager.findAndCount(this.metadata.target, options);
-    }
-    /**
-     * Finds entities that match given WHERE conditions.
-     * Also counts all entities that match given conditions,
-     * but ignores pagination settings (from and take options).
-     */
-    findAndCountBy(where) {
-        return this.manager.findAndCountBy(this.metadata.target, where);
-    }
-    /**
-     * Finds entities with ids.
-     * Optionally find options or conditions can be applied.
-     *
-     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findBy({
-     *     id: In([1, 2, 3])
-     * })
-     */
-    async findByIds(ids) {
-        return this.manager.findByIds(this.metadata.target, ids);
-    }
-    /**
-     * Finds first entity by a given find options.
-     * If entity was not found in the database - returns null.
-     */
-    async findOne(options) {
-        return this.manager.findOne(this.metadata.target, options);
-    }
-    /**
-     * Finds first entity that matches given where condition.
-     * If entity was not found in the database - returns null.
-     */
-    async findOneBy(where) {
-        return this.manager.findOneBy(this.metadata.target, where);
-    }
-    /**
-     * Finds first entity that matches given id.
-     * If entity was not found in the database - returns null.
-     *
-     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findOneBy({
-     *     id: 1 // where "id" is your primary column name
-     * })
-     */
-    async findOneById(id) {
-        return this.manager.findOneById(this.metadata.target, id);
-    }
-    /**
-     * Finds first entity by a given find options.
-     * If entity was not found in the database - rejects with error.
-     */
-    async findOneOrFail(options) {
-        return this.manager.findOneOrFail(this.metadata.target, options);
-    }
-    /**
-     * Finds first entity that matches given where condition.
-     * If entity was not found in the database - rejects with error.
-     */
-    async findOneByOrFail(where) {
-        return this.manager.findOneByOrFail(this.metadata.target, where);
-    }
-    /**
-     * Executes a raw SQL query and returns a raw database results.
-     * Raw query execution is supported only by relational databases (MongoDB is not supported).
-     *
-     * @see [Official docs](https://typeorm.io/repository-api) for examples.
-     */
-    query(query, parameters) {
-        return this.manager.query(query, parameters);
-    }
-    /**
-     * Tagged template function that executes raw SQL query and returns raw database results.
-     * Template expressions are automatically transformed into database parameters.
-     * Raw query execution is supported only by relational databases (MongoDB is not supported).
-     * Note: Don't call this as a regular function, it is meant to be used with backticks to tag a template literal.
-     * Example: repository.sql`SELECT * FROM table_name WHERE id = ${id}`
-     */
-    async sql(strings, ...values) {
-        const { query, parameters } = (0, SqlTagUtils_1.buildSqlTag)({
-            driver: this.manager.connection.driver,
-            strings: strings,
-            expressions: values,
-        });
-        return await this.query(query, parameters);
-    }
-    /**
-     * Clears all the data from the given table/collection (truncates/drops it).
-     *
-     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
-     * @see https://stackoverflow.com/a/5972738/925151
-     */
-    clear() {
-        return this.manager.clear(this.metadata.target);
-    }
-    /**
-     * Increments some column by provided value of the entities matched given conditions.
-     */
-    increment(conditions, propertyPath, value) {
-        return this.manager.increment(this.metadata.target, conditions, propertyPath, value);
-    }
-    /**
-     * Decrements some column by provided value of the entities matched given conditions.
-     */
-    decrement(conditions, propertyPath, value) {
-        return this.manager.decrement(this.metadata.target, conditions, propertyPath, value);
-    }
-    /**
-     * Extends repository with provided functions.
-     */
-    extend(customs) {
-        // return {
-        //     ...this,
-        //     ...custom
-        // };
-        const thisRepo = this.constructor;
-        const { target, manager, queryRunner } = this;
-        const ChildClass = class extends thisRepo {
-            constructor(target, manager, queryRunner) {
-                super(target, manager, queryRunner);
-            }
-        };
-        for (const custom in customs)
-            ChildClass.prototype[custom] = customs[custom];
-        return new ChildClass(target, manager, queryRunner);
-    }
-}
-exports.Repository = Repository;
-
-//# sourceMappingURL=Repository.js.map

package/.output/server/node_modules/typeorm/repository/SaveOptions.js

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

package/.output/server/node_modules/typeorm/repository/TreeRepository.js

@@ -1,255 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeRepository = void 0;
-const DriverUtils_1 = require("../driver/DriverUtils");
-const TypeORMError_1 = require("../error/TypeORMError");
-const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
-const TreeRepositoryUtils_1 = require("../util/TreeRepositoryUtils");
-const Repository_1 = require("./Repository");
-/**
- * Repository with additional functions to work with trees.
- *
- * @see Repository
- */
-class TreeRepository extends Repository_1.Repository {
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Gets complete trees for all roots in the table.
-     */
-    async findTrees(options) {
-        const roots = await this.findRoots(options);
-        await Promise.all(roots.map((root) => this.findDescendantsTree(root, options)));
-        return roots;
-    }
-    /**
-     * Roots are entities that have no ancestors. Finds them all.
-     */
-    findRoots(options) {
-        const escapeAlias = (alias) => this.manager.connection.driver.escape(alias);
-        const escapeColumn = (column) => this.manager.connection.driver.escape(column);
-        const joinColumn = this.metadata.treeParentRelation.joinColumns[0];
-        const parentPropertyName = joinColumn.givenDatabaseName || joinColumn.databaseName;
-        const qb = this.createQueryBuilder("treeEntity");
-        FindOptionsUtils_1.FindOptionsUtils.applyOptionsToTreeQueryBuilder(qb, options);
-        return qb
-            .where(`${escapeAlias("treeEntity")}.${escapeColumn(parentPropertyName)} IS NULL`)
-            .getMany();
-    }
-    /**
-     * Gets all children (descendants) of the given entity. Returns them all in a flat array.
-     */
-    findDescendants(entity, options) {
-        const qb = this.createDescendantsQueryBuilder("treeEntity", "treeClosure", entity);
-        FindOptionsUtils_1.FindOptionsUtils.applyOptionsToTreeQueryBuilder(qb, options);
-        return qb.getMany();
-    }
-    /**
-     * Gets all children (descendants) of the given entity. Returns them in a tree - nested into each other.
-     */
-    async findDescendantsTree(entity, options) {
-        // todo: throw exception if there is no column of this relation?
-        const qb = this.createDescendantsQueryBuilder("treeEntity", "treeClosure", entity);
-        FindOptionsUtils_1.FindOptionsUtils.applyOptionsToTreeQueryBuilder(qb, options);
-        const entities = await qb.getRawAndEntities();
-        const relationMaps = TreeRepositoryUtils_1.TreeRepositoryUtils.createRelationMaps(this.manager, this.metadata, "treeEntity", entities.raw);
-        TreeRepositoryUtils_1.TreeRepositoryUtils.buildChildrenEntityTree(this.metadata, entity, entities.entities, relationMaps, {
-            depth: -1,
-            ...options,
-        });
-        return entity;
-    }
-    /**
-     * Gets number of descendants of the entity.
-     */
-    countDescendants(entity) {
-        return this.createDescendantsQueryBuilder("treeEntity", "treeClosure", entity).getCount();
-    }
-    /**
-     * Creates a query builder used to get descendants of the entities in a tree.
-     */
-    createDescendantsQueryBuilder(alias, closureTableAlias, entity) {
-        // create shortcuts for better readability
-        const escape = (alias) => this.manager.connection.driver.escape(alias);
-        if (this.metadata.treeType === "closure-table") {
-            const joinCondition = this.metadata.closureJunctionTable.descendantColumns
-                .map((column) => {
-                return (escape(closureTableAlias) +
-                    "." +
-                    escape(column.propertyPath) +
-                    " = " +
-                    escape(alias) +
-                    "." +
-                    escape(column.referencedColumn.propertyPath));
-            })
-                .join(" AND ");
-            const parameters = {};
-            const whereCondition = this.metadata.closureJunctionTable.ancestorColumns
-                .map((column) => {
-                parameters[column.referencedColumn.propertyName] =
-                    column.referencedColumn.getEntityValue(entity);
-                return (escape(closureTableAlias) +
-                    "." +
-                    escape(column.propertyPath) +
-                    " = :" +
-                    column.referencedColumn.propertyName);
-            })
-                .join(" AND ");
-            return this.createQueryBuilder(alias)
-                .innerJoin(this.metadata.closureJunctionTable.tableName, closureTableAlias, joinCondition)
-                .where(whereCondition)
-                .setParameters(parameters);
-        }
-        else if (this.metadata.treeType === "nested-set") {
-            const whereCondition = alias +
-                "." +
-                this.metadata.nestedSetLeftColumn.propertyPath +
-                " BETWEEN " +
-                "joined." +
-                this.metadata.nestedSetLeftColumn.propertyPath +
-                " AND joined." +
-                this.metadata.nestedSetRightColumn.propertyPath;
-            const parameters = {};
-            const joinCondition = this.metadata
-                .treeParentRelation.joinColumns.map((joinColumn) => {
-                const parameterName = joinColumn.referencedColumn.propertyPath.replace(".", "_");
-                parameters[parameterName] =
-                    joinColumn.referencedColumn.getEntityValue(entity);
-                return ("joined." +
-                    joinColumn.referencedColumn.propertyPath +
-                    " = :" +
-                    parameterName);
-            })
-                .join(" AND ");
-            return this.createQueryBuilder(alias)
-                .innerJoin(this.metadata.targetName, "joined", whereCondition)
-                .where(joinCondition, parameters);
-        }
-        else if (this.metadata.treeType === "materialized-path") {
-            return this.createQueryBuilder(alias).where((qb) => {
-                const subQuery = qb
-                    .subQuery()
-                    .select(`${this.metadata.targetName}.${this.metadata.materializedPathColumn.propertyPath}`, "path")
-                    .from(this.metadata.target, this.metadata.targetName)
-                    .whereInIds(this.metadata.getEntityIdMap(entity));
-                if (DriverUtils_1.DriverUtils.isSQLiteFamily(this.manager.connection.driver)) {
-                    return `${alias}.${this.metadata.materializedPathColumn.propertyPath} LIKE ${subQuery.getQuery()} || '%'`;
-                }
-                else {
-                    return `${alias}.${this.metadata.materializedPathColumn.propertyPath} LIKE NULLIF(CONCAT(${subQuery.getQuery()}, '%'), '%')`;
-                }
-            });
-        }
-        throw new TypeORMError_1.TypeORMError(`Supported only in tree entities`);
-    }
-    /**
-     * Gets all parents (ancestors) of the given entity. Returns them all in a flat array.
-     */
-    findAncestors(entity, options) {
-        const qb = this.createAncestorsQueryBuilder("treeEntity", "treeClosure", entity);
-        FindOptionsUtils_1.FindOptionsUtils.applyOptionsToTreeQueryBuilder(qb, options);
-        return qb.getMany();
-    }
-    /**
-     * Gets all parents (ancestors) of the given entity. Returns them in a tree - nested into each other.
-     */
-    async findAncestorsTree(entity, options) {
-        // todo: throw exception if there is no column of this relation?
-        const qb = this.createAncestorsQueryBuilder("treeEntity", "treeClosure", entity);
-        FindOptionsUtils_1.FindOptionsUtils.applyOptionsToTreeQueryBuilder(qb, options);
-        const entities = await qb.getRawAndEntities();
-        const relationMaps = TreeRepositoryUtils_1.TreeRepositoryUtils.createRelationMaps(this.manager, this.metadata, "treeEntity", entities.raw);
-        TreeRepositoryUtils_1.TreeRepositoryUtils.buildParentEntityTree(this.metadata, entity, entities.entities, relationMaps);
-        return entity;
-    }
-    /**
-     * Gets number of ancestors of the entity.
-     */
-    countAncestors(entity) {
-        return this.createAncestorsQueryBuilder("treeEntity", "treeClosure", entity).getCount();
-    }
-    /**
-     * Creates a query builder used to get ancestors of the entities in the tree.
-     */
-    createAncestorsQueryBuilder(alias, closureTableAlias, entity) {
-        // create shortcuts for better readability
-        // const escape = (alias: string) => this.manager.connection.driver.escape(alias);
-        if (this.metadata.treeType === "closure-table") {
-            const joinCondition = this.metadata.closureJunctionTable.ancestorColumns
-                .map((column) => {
-                return (closureTableAlias +
-                    "." +
-                    column.propertyPath +
-                    " = " +
-                    alias +
-                    "." +
-                    column.referencedColumn.propertyPath);
-            })
-                .join(" AND ");
-            const parameters = {};
-            const whereCondition = this.metadata.closureJunctionTable.descendantColumns
-                .map((column) => {
-                parameters[column.referencedColumn.propertyName] =
-                    column.referencedColumn.getEntityValue(entity);
-                return (closureTableAlias +
-                    "." +
-                    column.propertyPath +
-                    " = :" +
-                    column.referencedColumn.propertyName);
-            })
-                .join(" AND ");
-            return this.createQueryBuilder(alias)
-                .innerJoin(this.metadata.closureJunctionTable.tableName, closureTableAlias, joinCondition)
-                .where(whereCondition)
-                .setParameters(parameters);
-        }
-        else if (this.metadata.treeType === "nested-set") {
-            const joinCondition = "joined." +
-                this.metadata.nestedSetLeftColumn.propertyPath +
-                " BETWEEN " +
-                alias +
-                "." +
-                this.metadata.nestedSetLeftColumn.propertyPath +
-                " AND " +
-                alias +
-                "." +
-                this.metadata.nestedSetRightColumn.propertyPath;
-            const parameters = {};
-            const whereCondition = this.metadata
-                .treeParentRelation.joinColumns.map((joinColumn) => {
-                const parameterName = joinColumn.referencedColumn.propertyPath.replace(".", "_");
-                parameters[parameterName] =
-                    joinColumn.referencedColumn.getEntityValue(entity);
-                return ("joined." +
-                    joinColumn.referencedColumn.propertyPath +
-                    " = :" +
-                    parameterName);
-            })
-                .join(" AND ");
-            return this.createQueryBuilder(alias)
-                .innerJoin(this.metadata.targetName, "joined", joinCondition)
-                .where(whereCondition, parameters);
-        }
-        else if (this.metadata.treeType === "materialized-path") {
-            // example: SELECT * FROM category category WHERE (SELECT mpath FROM `category` WHERE id = 2) LIKE CONCAT(category.mpath, '%');
-            return this.createQueryBuilder(alias).where((qb) => {
-                const subQuery = qb
-                    .subQuery()
-                    .select(`${this.metadata.targetName}.${this.metadata.materializedPathColumn.propertyPath}`, "path")
-                    .from(this.metadata.target, this.metadata.targetName)
-                    .whereInIds(this.metadata.getEntityIdMap(entity));
-                if (DriverUtils_1.DriverUtils.isSQLiteFamily(this.manager.connection.driver)) {
-                    return `${subQuery.getQuery()} LIKE ${alias}.${this.metadata.materializedPathColumn.propertyPath} || '%'`;
-                }
-                else {
-                    return `${subQuery.getQuery()} LIKE CONCAT(${alias}.${this.metadata.materializedPathColumn.propertyPath}, '%')`;
-                }
-            });
-        }
-        throw new TypeORMError_1.TypeORMError(`Supported only in tree entities`);
-    }
-}
-exports.TreeRepository = TreeRepository;
-
-//# sourceMappingURL=TreeRepository.js.map