orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/typeorm/metadata-builder/EntityMetadataValidator.js

@@ -1,258 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityMetadataValidator = void 0;
-const MissingPrimaryColumnError_1 = require("../error/MissingPrimaryColumnError");
-const CircularRelationsError_1 = require("../error/CircularRelationsError");
-const DepGraph_1 = require("../util/DepGraph");
-const DataTypeNotSupportedError_1 = require("../error/DataTypeNotSupportedError");
-const NoConnectionOptionError_1 = require("../error/NoConnectionOptionError");
-const InitializedRelationError_1 = require("../error/InitializedRelationError");
-const error_1 = require("../error");
-const DriverUtils_1 = require("../driver/DriverUtils");
-/// todo: add check if there are multiple tables with the same name
-/// todo: add checks when generated column / table names are too long for the specific driver
-// todo: type in function validation, inverse side function validation
-// todo: check on build for duplicate names, since naming checking was removed from MetadataStorage
-// todo: duplicate name checking for: table, relation, column, index, naming strategy, join tables/columns?
-// todo: check if multiple tree parent metadatas in validator
-// todo: tree decorators can be used only on closure table (validation)
-// todo: throw error if parent tree metadata was not specified in a closure table
-// todo: MetadataArgsStorage: type in function validation, inverse side function validation
-// todo: MetadataArgsStorage: check on build for duplicate names, since naming checking was removed from MetadataStorage
-// todo: MetadataArgsStorage: duplicate name checking for: table, relation, column, index, naming strategy, join tables/columns?
-// todo: MetadataArgsStorage: check for duplicate targets too since this check has been removed too
-// todo: check if relation decorator contains primary: true and nullable: true
-// todo: check column length, precision. scale
-// todo: MySQL index can be unique or spatial or fulltext
-/**
- * Validates built entity metadatas.
- */
-class EntityMetadataValidator {
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Validates all given entity metadatas.
-     */
-    validateMany(entityMetadatas, driver) {
-        entityMetadatas.forEach((entityMetadata) => this.validate(entityMetadata, entityMetadatas, driver));
-        this.validateDependencies(entityMetadatas);
-        this.validateEagerRelations(entityMetadatas);
-    }
-    /**
-     * Validates given entity metadata.
-     */
-    validate(entityMetadata, allEntityMetadatas, driver) {
-        // check if table metadata has an id
-        if (!entityMetadata.primaryColumns.length && !entityMetadata.isJunction)
-            throw new MissingPrimaryColumnError_1.MissingPrimaryColumnError(entityMetadata);
-        // if entity has multiple primary keys and uses custom constraint name,
-        // then all primary keys should have the same constraint name
-        if (entityMetadata.primaryColumns.length > 1) {
-            const areConstraintNamesEqual = entityMetadata.primaryColumns.every((columnMetadata, i, columnMetadatas) => columnMetadata.primaryKeyConstraintName ===
-                columnMetadatas[0].primaryKeyConstraintName);
-            if (!areConstraintNamesEqual) {
-                throw new error_1.TypeORMError(`Entity ${entityMetadata.name} has multiple primary columns with different constraint names. Constraint names should be the equal.`);
-            }
-        }
-        // validate if table is using inheritance it has a discriminator
-        // also validate if discriminator values are not empty and not repeated
-        if (entityMetadata.inheritancePattern === "STI" ||
-            entityMetadata.tableType === "entity-child") {
-            if (!entityMetadata.discriminatorColumn)
-                throw new error_1.TypeORMError(`Entity ${entityMetadata.name} using single-table inheritance, it should also have a discriminator column. Did you forget to put discriminator column options?`);
-            if (typeof entityMetadata.discriminatorValue === "undefined")
-                throw new error_1.TypeORMError(`Entity ${entityMetadata.name} has an undefined discriminator value. Discriminator value should be defined.`);
-            const sameDiscriminatorValueEntityMetadata = allEntityMetadatas.find((metadata) => {
-                return (metadata !== entityMetadata &&
-                    (metadata.inheritancePattern === "STI" ||
-                        metadata.tableType === "entity-child") &&
-                    metadata.tableName === entityMetadata.tableName &&
-                    metadata.discriminatorValue ===
-                        entityMetadata.discriminatorValue &&
-                    metadata.inheritanceTree.some((parent) => entityMetadata.inheritanceTree.indexOf(parent) !== -1));
-            });
-            if (sameDiscriminatorValueEntityMetadata)
-                throw new error_1.TypeORMError(`Entities ${entityMetadata.name} and ${sameDiscriminatorValueEntityMetadata.name} have the same discriminator values. Make sure they are different while using the @ChildEntity decorator.`);
-        }
-        entityMetadata.relationCounts.forEach((relationCount) => {
-            if (relationCount.relation.isManyToOne ||
-                relationCount.relation.isOneToOne)
-                throw new error_1.TypeORMError(`Relation count can not be implemented on ManyToOne or OneToOne relations.`);
-        });
-        if (!(driver.options.type === "mongodb")) {
-            entityMetadata.columns
-                .filter((column) => !column.isVirtualProperty)
-                .forEach((column) => {
-                const normalizedColumn = driver.normalizeType(column);
-                if (driver.supportedDataTypes.indexOf(normalizedColumn) ===
-                    -1)
-                    throw new DataTypeNotSupportedError_1.DataTypeNotSupportedError(column, normalizedColumn, driver.options.type);
-                if (column.length &&
-                    driver.withLengthColumnTypes.indexOf(normalizedColumn) === -1)
-                    throw new error_1.TypeORMError(`Column ${column.propertyName} of Entity ${entityMetadata.name} does not support length property.`);
-                if (column.type === "enum" &&
-                    !column.enum &&
-                    !column.enumName)
-                    throw new error_1.TypeORMError(`Column "${column.propertyName}" of Entity "${entityMetadata.name}" is defined as enum, but missing "enum" or "enumName" properties.`);
-            });
-        }
-        if (DriverUtils_1.DriverUtils.isMySQLFamily(driver) ||
-            driver.options.type === "aurora-mysql") {
-            const generatedColumns = entityMetadata.columns.filter((column) => column.isGenerated && column.generationStrategy !== "uuid");
-            if (generatedColumns.length > 1)
-                throw new error_1.TypeORMError(`Error in ${entityMetadata.name} entity. There can be only one auto-increment column in MySql table.`);
-        }
-        // for mysql we are able to not define a default selected database, instead all entities can have their database
-        // defined in their decorators. To make everything work either all entities must have database define and we
-        // can live without database set in the connection options, either database in the connection options must be set
-        if (DriverUtils_1.DriverUtils.isMySQLFamily(driver)) {
-            const metadatasWithDatabase = allEntityMetadatas.filter((metadata) => metadata.database);
-            if (metadatasWithDatabase.length === 0 && !driver.database)
-                throw new NoConnectionOptionError_1.NoConnectionOptionError("database");
-        }
-        if (driver.options.type === "mssql") {
-            const charsetColumns = entityMetadata.columns.filter((column) => column.charset);
-            if (charsetColumns.length > 1)
-                throw new error_1.TypeORMError(`Character set specifying is not supported in Sql Server`);
-        }
-        // Postgres supports only STORED generated columns.
-        if (driver.options.type === "postgres") {
-            const virtualColumn = entityMetadata.columns.find((column) => column.asExpression &&
-                (!column.generatedType ||
-                    column.generatedType === "VIRTUAL"));
-            if (virtualColumn)
-                throw new error_1.TypeORMError(`Column "${virtualColumn.propertyName}" of Entity "${entityMetadata.name}" is defined as VIRTUAL, but Postgres supports only STORED generated columns.`);
-        }
-        // check if relations are all without initialized properties
-        const entityInstance = entityMetadata.create(undefined, {
-            fromDeserializer: true,
-        });
-        entityMetadata.relations.forEach((relation) => {
-            if (relation.isManyToMany || relation.isOneToMany) {
-                // we skip relations for which persistence is disabled since initialization in them cannot harm somehow
-                if (relation.persistenceEnabled === false)
-                    return;
-                // get entity relation value and check if its an array
-                const relationInitializedValue = relation.getEntityValue(entityInstance);
-                if (Array.isArray(relationInitializedValue))
-                    throw new InitializedRelationError_1.InitializedRelationError(relation);
-            }
-        });
-        // validate relations
-        entityMetadata.relations.forEach((relation) => {
-            // check OnDeleteTypes
-            if (driver.supportedOnDeleteTypes &&
-                relation.onDelete &&
-                !driver.supportedOnDeleteTypes.includes(relation.onDelete)) {
-                throw new error_1.TypeORMError(`OnDeleteType "${relation.onDelete}" is not supported for ${driver.options.type}!`);
-            }
-            // check OnUpdateTypes
-            if (driver.supportedOnUpdateTypes &&
-                relation.onUpdate &&
-                !driver.supportedOnUpdateTypes.includes(relation.onUpdate)) {
-                throw new error_1.TypeORMError(`OnUpdateType "${relation.onUpdate}" is not valid for ${driver.options.type}!`);
-            }
-            // check join tables:
-            // using JoinTable is possible only on one side of the many-to-many relation
-            // todo(dima): fix
-            // if (relation.joinTable) {
-            //     if (!relation.isManyToMany)
-            //         throw new UsingJoinTableIsNotAllowedError(entityMetadata, relation);
-            //     // if there is inverse side of the relation, then check if it does not have join table too
-            //     if (relation.hasInverseSide && relation.inverseRelation.joinTable)
-            //         throw new UsingJoinTableOnlyOnOneSideAllowedError(entityMetadata, relation);
-            // }
-            // check join columns:
-            // using JoinColumn is possible only on one side of the relation and on one-to-one, many-to-one relation types
-            // first check if relation is one-to-one or many-to-one
-            // todo(dima): fix
-            /*if (relation.joinColumn) {
-
-                // join column can be applied only on one-to-one and many-to-one relations
-                if (!relation.isOneToOne && !relation.isManyToOne)
-                    throw new UsingJoinColumnIsNotAllowedError(entityMetadata, relation);
-
-                // if there is inverse side of the relation, then check if it does not have join table too
-                if (relation.hasInverseSide && relation.inverseRelation.joinColumn && relation.isOneToOne)
-                    throw new UsingJoinColumnOnlyOnOneSideAllowedError(entityMetadata, relation);
-
-                // check if join column really has referenced column
-                if (relation.joinColumn && !relation.joinColumn.referencedColumn)
-                    throw new TypeORMError(`Join column does not have referenced column set`);
-
-            }
-
-            // if its a one-to-one relation and JoinColumn is missing on both sides of the relation
-            // or its one-side relation without JoinColumn we should give an error
-            if (!relation.joinColumn && relation.isOneToOne && (!relation.hasInverseSide || !relation.inverseRelation.joinColumn))
-                throw new MissingJoinColumnError(entityMetadata, relation);*/
-            // if its a many-to-many relation and JoinTable is missing on both sides of the relation
-            // or its one-side relation without JoinTable we should give an error
-            // todo(dima): fix it
-            // if (!relation.joinTable && relation.isManyToMany && (!relation.hasInverseSide || !relation.inverseRelation.joinTable))
-            //     throw new MissingJoinTableError(entityMetadata, relation);
-            // todo: validate if its one-to-one and side which does not have join column MUST have inverse side
-            // todo: validate if its many-to-many and side which does not have join table MUST have inverse side
-            // todo: if there is a relation, and inverse side is specified only on one side, shall we give error
-            // todo: with message like: "Inverse side is specified only on one side of the relationship. Specify on other side too to prevent confusion".
-            // todo: add validation if there two entities with the same target, and show error message with description of the problem (maybe file was renamed/moved but left in output directory)
-            // todo: check if there are multiple columns on the same column applied.
-            // todo: check column type if is missing in relational databases (throw new TypeORMError(`Column type of ${type} cannot be determined.`);)
-            // todo: include driver-specific checks. for example in mongodb empty prefixes are not allowed
-            // todo: if multiple columns with same name - throw exception, including cases when columns are in embeds with same prefixes or without prefix at all
-            // todo: if multiple primary key used, at least one of them must be unique or @Index decorator must be set on entity
-            // todo: check if entity with duplicate names, some decorators exist
-        });
-        // make sure cascade remove is not set for both sides of relationships (can be set in OneToOne decorators)
-        entityMetadata.relations.forEach((relation) => {
-            const isCircularCascadeRemove = relation.isCascadeRemove &&
-                relation.inverseRelation &&
-                relation.inverseRelation.isCascadeRemove;
-            if (isCircularCascadeRemove)
-                throw new error_1.TypeORMError(`Relation ${entityMetadata.name}#${relation.propertyName} and ${relation.inverseRelation.entityMetadata.name}#${relation.inverseRelation.propertyName} both has cascade remove set. ` +
-                    `This may lead to unexpected circular removals. Please set cascade remove only from one side of relationship.`);
-        }); // todo: maybe better just deny removal from one to one relation without join column?
-        entityMetadata.eagerRelations.forEach((relation) => { });
-    }
-    /**
-     * Validates dependencies of the entity metadatas.
-     */
-    validateDependencies(entityMetadatas) {
-        const graph = new DepGraph_1.DepGraph();
-        entityMetadatas.forEach((entityMetadata) => {
-            graph.addNode(entityMetadata.name);
-        });
-        entityMetadatas.forEach((entityMetadata) => {
-            entityMetadata.relationsWithJoinColumns
-                .filter((relation) => !relation.isNullable)
-                .forEach((relation) => {
-                graph.addDependency(entityMetadata.name, relation.inverseEntityMetadata.name);
-            });
-        });
-        try {
-            graph.overallOrder();
-        }
-        catch (err) {
-            throw new CircularRelationsError_1.CircularRelationsError(err.toString().replace("Error: Dependency Cycle Found: ", ""));
-        }
-    }
-    /**
-     * Validates eager relations to prevent circular dependency in them.
-     */
-    validateEagerRelations(entityMetadatas) {
-        entityMetadatas.forEach((entityMetadata) => {
-            entityMetadata.eagerRelations.forEach((relation) => {
-                if (relation.inverseRelation &&
-                    relation.inverseRelation.isEager)
-                    throw new error_1.TypeORMError(`Circular eager relations are disallowed. ` +
-                        `${entityMetadata.targetName}#${relation.propertyPath} contains "eager: true", and its inverse side ` +
-                        `${relation.inverseEntityMetadata.targetName}#${relation.inverseRelation.propertyPath} contains "eager: true" as well.` +
-                        ` Remove "eager: true" from one side of the relation.`);
-            });
-        });
-    }
-}
-exports.EntityMetadataValidator = EntityMetadataValidator;
-
-//# sourceMappingURL=EntityMetadataValidator.js.map

package/.output/server/node_modules/typeorm/metadata-builder/JunctionEntityMetadataBuilder.js

@@ -1,287 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JunctionEntityMetadataBuilder = void 0;
-const ColumnMetadata_1 = require("../metadata/ColumnMetadata");
-const EntityMetadata_1 = require("../metadata/EntityMetadata");
-const ForeignKeyMetadata_1 = require("../metadata/ForeignKeyMetadata");
-const IndexMetadata_1 = require("../metadata/IndexMetadata");
-const error_1 = require("../error");
-const DriverUtils_1 = require("../driver/DriverUtils");
-/**
- * Creates EntityMetadata for junction tables.
- * Junction tables are tables generated by many-to-many relations.
- */
-class JunctionEntityMetadataBuilder {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(connection) {
-        this.connection = connection;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Builds EntityMetadata for the junction of the given many-to-many relation.
-     */
-    build(relation, joinTable) {
-        const referencedColumns = this.collectReferencedColumns(relation, joinTable);
-        const inverseReferencedColumns = this.collectInverseReferencedColumns(relation, joinTable);
-        const joinTableName = joinTable.name ||
-            this.connection.namingStrategy.joinTableName(relation.entityMetadata.tableNameWithoutPrefix, relation.inverseEntityMetadata.tableNameWithoutPrefix, relation.propertyPath, relation.inverseRelation
-                ? relation.inverseRelation.propertyName
-                : "");
-        const entityMetadata = new EntityMetadata_1.EntityMetadata({
-            connection: this.connection,
-            args: {
-                target: "",
-                name: joinTableName,
-                type: "junction",
-                database: joinTable.database || relation.entityMetadata.database,
-                schema: joinTable.schema || relation.entityMetadata.schema,
-                synchronize: joinTable.synchronize,
-            },
-        });
-        entityMetadata.build();
-        // create original side junction columns
-        const junctionColumns = referencedColumns.map((referencedColumn) => {
-            const joinColumn = joinTable.joinColumns
-                ? joinTable.joinColumns.find((joinColumnArgs) => {
-                    return ((!joinColumnArgs.referencedColumnName ||
-                        joinColumnArgs.referencedColumnName ===
-                            referencedColumn.propertyName) &&
-                        !!joinColumnArgs.name);
-                })
-                : undefined;
-            const columnName = joinColumn && joinColumn.name
-                ? joinColumn.name
-                : this.connection.namingStrategy.joinTableColumnName(relation.entityMetadata.tableNameWithoutPrefix, referencedColumn.propertyName, referencedColumn.databaseName);
-            return new ColumnMetadata_1.ColumnMetadata({
-                connection: this.connection,
-                entityMetadata: entityMetadata,
-                referencedColumn: referencedColumn,
-                args: {
-                    target: "",
-                    mode: "virtual",
-                    propertyName: columnName,
-                    options: {
-                        name: columnName,
-                        length: !referencedColumn.length &&
-                            (DriverUtils_1.DriverUtils.isMySQLFamily(this.connection.driver) ||
-                                this.connection.driver.options.type ===
-                                    "aurora-mysql") &&
-                            // some versions of mariadb support the column type and should not try to provide the length property
-                            this.connection.driver.normalizeType(referencedColumn) !== "uuid" &&
-                            (referencedColumn.generationStrategy === "uuid" ||
-                                referencedColumn.type === "uuid")
-                            ? "36"
-                            : referencedColumn.length, // fix https://github.com/typeorm/typeorm/issues/3604
-                        width: referencedColumn.width,
-                        type: referencedColumn.type,
-                        precision: referencedColumn.precision,
-                        scale: referencedColumn.scale,
-                        charset: referencedColumn.charset,
-                        collation: referencedColumn.collation,
-                        zerofill: referencedColumn.zerofill,
-                        unsigned: referencedColumn.zerofill
-                            ? true
-                            : referencedColumn.unsigned,
-                        enum: referencedColumn.enum,
-                        enumName: referencedColumn.enumName,
-                        foreignKeyConstraintName: joinColumn?.foreignKeyConstraintName,
-                        nullable: false,
-                        primary: true,
-                    },
-                },
-            });
-        });
-        // create inverse side junction columns
-        const inverseJunctionColumns = inverseReferencedColumns.map((inverseReferencedColumn) => {
-            const joinColumn = joinTable.inverseJoinColumns
-                ? joinTable.inverseJoinColumns.find((joinColumnArgs) => {
-                    return ((!joinColumnArgs.referencedColumnName ||
-                        joinColumnArgs.referencedColumnName ===
-                            inverseReferencedColumn.propertyName) &&
-                        !!joinColumnArgs.name);
-                })
-                : undefined;
-            const columnName = joinColumn && joinColumn.name
-                ? joinColumn.name
-                : this.connection.namingStrategy.joinTableInverseColumnName(relation.inverseEntityMetadata
-                    .tableNameWithoutPrefix, inverseReferencedColumn.propertyName, inverseReferencedColumn.databaseName);
-            return new ColumnMetadata_1.ColumnMetadata({
-                connection: this.connection,
-                entityMetadata: entityMetadata,
-                referencedColumn: inverseReferencedColumn,
-                args: {
-                    target: "",
-                    mode: "virtual",
-                    propertyName: columnName,
-                    options: {
-                        length: !inverseReferencedColumn.length &&
-                            (DriverUtils_1.DriverUtils.isMySQLFamily(this.connection.driver) ||
-                                this.connection.driver.options.type ===
-                                    "aurora-mysql") &&
-                            // some versions of mariadb support the column type and should not try to provide the length property
-                            this.connection.driver.normalizeType(inverseReferencedColumn) !== "uuid" &&
-                            (inverseReferencedColumn.generationStrategy ===
-                                "uuid" ||
-                                inverseReferencedColumn.type === "uuid")
-                            ? "36"
-                            : inverseReferencedColumn.length, // fix https://github.com/typeorm/typeorm/issues/3604
-                        width: inverseReferencedColumn.width, // fix https://github.com/typeorm/typeorm/issues/6442
-                        type: inverseReferencedColumn.type,
-                        precision: inverseReferencedColumn.precision,
-                        scale: inverseReferencedColumn.scale,
-                        charset: inverseReferencedColumn.charset,
-                        collation: inverseReferencedColumn.collation,
-                        zerofill: inverseReferencedColumn.zerofill,
-                        unsigned: inverseReferencedColumn.zerofill
-                            ? true
-                            : inverseReferencedColumn.unsigned,
-                        enum: inverseReferencedColumn.enum,
-                        enumName: inverseReferencedColumn.enumName,
-                        foreignKeyConstraintName: joinColumn?.foreignKeyConstraintName,
-                        name: columnName,
-                        nullable: false,
-                        primary: true,
-                    },
-                },
-            });
-        });
-        this.changeDuplicatedColumnNames(junctionColumns, inverseJunctionColumns);
-        // set junction table columns
-        entityMetadata.ownerColumns = junctionColumns;
-        entityMetadata.inverseColumns = inverseJunctionColumns;
-        entityMetadata.ownColumns = [
-            ...junctionColumns,
-            ...inverseJunctionColumns,
-        ];
-        entityMetadata.ownColumns.forEach((column) => (column.relationMetadata = relation));
-        // create junction table foreign keys
-        // Note: UPDATE CASCADE clause is not supported in Oracle.
-        // Note: UPDATE/DELETE CASCADE clauses are not supported in Spanner.
-        entityMetadata.foreignKeys = relation.createForeignKeyConstraints
-            ? [
-                new ForeignKeyMetadata_1.ForeignKeyMetadata({
-                    entityMetadata: entityMetadata,
-                    referencedEntityMetadata: relation.entityMetadata,
-                    columns: junctionColumns,
-                    referencedColumns: referencedColumns,
-                    name: junctionColumns[0]?.foreignKeyConstraintName,
-                    onDelete: this.connection.driver.options.type === "spanner"
-                        ? "NO ACTION"
-                        : relation.onDelete || "CASCADE",
-                    onUpdate: this.connection.driver.options.type === "oracle" ||
-                        this.connection.driver.options.type === "spanner"
-                        ? "NO ACTION"
-                        : relation.onUpdate || "CASCADE",
-                }),
-                new ForeignKeyMetadata_1.ForeignKeyMetadata({
-                    entityMetadata: entityMetadata,
-                    referencedEntityMetadata: relation.inverseEntityMetadata,
-                    columns: inverseJunctionColumns,
-                    referencedColumns: inverseReferencedColumns,
-                    name: inverseJunctionColumns[0]?.foreignKeyConstraintName,
-                    onDelete: this.connection.driver.options.type === "spanner"
-                        ? "NO ACTION"
-                        : relation.inverseRelation
-                            ? relation.inverseRelation.onDelete
-                            : "CASCADE",
-                    onUpdate: this.connection.driver.options.type === "oracle" ||
-                        this.connection.driver.options.type === "spanner"
-                        ? "NO ACTION"
-                        : relation.inverseRelation
-                            ? relation.inverseRelation.onUpdate
-                            : "CASCADE",
-                }),
-            ]
-            : [];
-        // create junction table indices
-        entityMetadata.ownIndices = [
-            new IndexMetadata_1.IndexMetadata({
-                entityMetadata: entityMetadata,
-                columns: junctionColumns,
-                args: {
-                    target: entityMetadata.target,
-                    synchronize: true,
-                },
-            }),
-            new IndexMetadata_1.IndexMetadata({
-                entityMetadata: entityMetadata,
-                columns: inverseJunctionColumns,
-                args: {
-                    target: entityMetadata.target,
-                    synchronize: true,
-                },
-            }),
-        ];
-        // finally return entity metadata
-        return entityMetadata;
-    }
-    // -------------------------------------------------------------------------
-    // Protected Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Collects referenced columns from the given join column args.
-     */
-    collectReferencedColumns(relation, joinTable) {
-        const hasAnyReferencedColumnName = joinTable.joinColumns
-            ? joinTable.joinColumns.find((joinColumn) => !!joinColumn.referencedColumnName)
-            : false;
-        if (!joinTable.joinColumns ||
-            (joinTable.joinColumns && !hasAnyReferencedColumnName)) {
-            return relation.entityMetadata.columns.filter((column) => column.isPrimary);
-        }
-        else {
-            return joinTable.joinColumns.map((joinColumn) => {
-                const referencedColumn = relation.entityMetadata.columns.find((column) => column.propertyName === joinColumn.referencedColumnName);
-                if (!referencedColumn)
-                    throw new error_1.TypeORMError(`Referenced column ${joinColumn.referencedColumnName} was not found in entity ${relation.entityMetadata.name}`);
-                return referencedColumn;
-            });
-        }
-    }
-    /**
-     * Collects inverse referenced columns from the given join column args.
-     */
-    collectInverseReferencedColumns(relation, joinTable) {
-        const hasInverseJoinColumns = !!joinTable.inverseJoinColumns;
-        const hasAnyInverseReferencedColumnName = hasInverseJoinColumns
-            ? joinTable.inverseJoinColumns.find((joinColumn) => !!joinColumn.referencedColumnName)
-            : false;
-        if (!hasInverseJoinColumns ||
-            (hasInverseJoinColumns && !hasAnyInverseReferencedColumnName)) {
-            return relation.inverseEntityMetadata.primaryColumns;
-        }
-        else {
-            return joinTable.inverseJoinColumns.map((joinColumn) => {
-                const referencedColumn = relation.inverseEntityMetadata.ownColumns.find((column) => column.propertyName ===
-                    joinColumn.referencedColumnName);
-                if (!referencedColumn)
-                    throw new error_1.TypeORMError(`Referenced column ${joinColumn.referencedColumnName} was not found in entity ${relation.inverseEntityMetadata.name}`);
-                return referencedColumn;
-            });
-        }
-    }
-    changeDuplicatedColumnNames(junctionColumns, inverseJunctionColumns) {
-        junctionColumns.forEach((junctionColumn) => {
-            inverseJunctionColumns.forEach((inverseJunctionColumn) => {
-                if (junctionColumn.givenDatabaseName ===
-                    inverseJunctionColumn.givenDatabaseName) {
-                    const junctionColumnName = this.connection.namingStrategy.joinTableColumnDuplicationPrefix(junctionColumn.propertyName, 1);
-                    junctionColumn.propertyName = junctionColumnName;
-                    junctionColumn.givenDatabaseName = junctionColumnName;
-                    const inverseJunctionColumnName = this.connection.namingStrategy.joinTableColumnDuplicationPrefix(inverseJunctionColumn.propertyName, 2);
-                    inverseJunctionColumn.propertyName =
-                        inverseJunctionColumnName;
-                    inverseJunctionColumn.givenDatabaseName =
-                        inverseJunctionColumnName;
-                }
-            });
-        });
-    }
-}
-exports.JunctionEntityMetadataBuilder = JunctionEntityMetadataBuilder;
-
-//# sourceMappingURL=JunctionEntityMetadataBuilder.js.map

package/.output/server/node_modules/typeorm/metadata-builder/MetadataUtils.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataUtils = void 0;
-/**
- * Metadata args utility functions.
- */
-class MetadataUtils {
-    /**
-     * Gets given's entity all inherited classes.
-     * Gives in order from parents to children.
-     * For example Post extends ContentModel which extends Unit it will give
-     * [Unit, ContentModel, Post]
-     */
-    static getInheritanceTree(entity) {
-        const tree = [entity];
-        const getPrototypeOf = (object) => {
-            const proto = Object.getPrototypeOf(object);
-            if (proto && proto.name) {
-                tree.push(proto);
-                getPrototypeOf(proto);
-            }
-        };
-        getPrototypeOf(entity);
-        return tree;
-    }
-    /**
-     * Checks if this table is inherited from another table.
-     */
-    static isInherited(target1, target2) {
-        return target1.prototype instanceof target2;
-    }
-    /**
-     * Filters given array of targets by a given classes.
-     * If classes are not given, then it returns array itself.
-     */
-    static filterByTarget(array, classes) {
-        if (!classes)
-            return array;
-        return array.filter((item) => item.target && classes.indexOf(item.target) !== -1);
-    }
-}
-exports.MetadataUtils = MetadataUtils;
-
-//# sourceMappingURL=MetadataUtils.js.map