orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/typeorm/entity-manager/SqljsEntityManager.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqljsEntityManager = void 0;
-const EntityManager_1 = require("./EntityManager");
-/**
- * A special EntityManager that includes import/export and load/save function
- * that are unique to Sql.js.
- */
-class SqljsEntityManager extends EntityManager_1.EntityManager {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(connection, queryRunner) {
-        super(connection, queryRunner);
-        this["@instanceof"] = Symbol.for("SqljsEntityManager");
-        this.driver = connection.driver;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Loads either the definition from a file (Node.js) or localstorage (browser)
-     * or uses the given definition to open a new database.
-     */
-    async loadDatabase(fileNameOrLocalStorageOrData) {
-        await this.driver.load(fileNameOrLocalStorageOrData);
-    }
-    /**
-     * Saves the current database to a file (Node.js) or localstorage (browser)
-     * if fileNameOrLocalStorage is not set options.location is used.
-     */
-    async saveDatabase(fileNameOrLocalStorage) {
-        await this.driver.save(fileNameOrLocalStorage);
-    }
-    /**
-     * Returns the current database definition.
-     */
-    exportDatabase() {
-        return this.driver.export();
-    }
-}
-exports.SqljsEntityManager = SqljsEntityManager;
-
-//# sourceMappingURL=SqljsEntityManager.js.map

package/.output/server/node_modules/typeorm/entity-schema/EntitySchema.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySchema = void 0;
-/**
- * Interface for entity metadata mappings stored inside "schemas" instead of models decorated by decorators.
- */
-class EntitySchema {
-    constructor(options) {
-        this.options = options;
-        this["@instanceof"] = Symbol.for("EntitySchema");
-    }
-}
-exports.EntitySchema = EntitySchema;
-
-//# sourceMappingURL=EntitySchema.js.map

package/.output/server/node_modules/typeorm/entity-schema/EntitySchemaEmbeddedColumnOptions.js

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

package/.output/server/node_modules/typeorm/entity-schema/EntitySchemaEmbeddedError.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySchemaEmbeddedError = void 0;
-const error_1 = require("../error");
-class EntitySchemaEmbeddedError extends error_1.TypeORMError {
-    static createEntitySchemaIsRequiredException(field) {
-        return new EntitySchemaEmbeddedError(`EntitySchema is required for ${field} embedded field`);
-    }
-    static createTargetIsRequired(field) {
-        return new EntitySchemaEmbeddedError(`Target field is required for ${field} embedded EntitySchema`);
-    }
-    constructor(message) {
-        super(message);
-    }
-}
-exports.EntitySchemaEmbeddedError = EntitySchemaEmbeddedError;
-
-//# sourceMappingURL=EntitySchemaEmbeddedError.js.map

package/.output/server/node_modules/typeorm/entity-schema/EntitySchemaOptions.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySchemaOptions = void 0;
-/**
- * Interface for entity metadata mappings stored inside "schemas" instead of models decorated by decorators.
- */
-class EntitySchemaOptions {
-}
-exports.EntitySchemaOptions = EntitySchemaOptions;
-
-//# sourceMappingURL=EntitySchemaOptions.js.map

package/.output/server/node_modules/typeorm/entity-schema/EntitySchemaTransformer.js

@@ -1,333 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySchemaTransformer = void 0;
-const MetadataArgsStorage_1 = require("../metadata-args/MetadataArgsStorage");
-const EntitySchemaEmbeddedError_1 = require("./EntitySchemaEmbeddedError");
-/**
- * Transforms entity schema into metadata args storage.
- * The result will be just like entities read from decorators.
- */
-class EntitySchemaTransformer {
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Transforms entity schema into new metadata args storage object.
-     */
-    transform(schemas) {
-        const metadataArgsStorage = new MetadataArgsStorage_1.MetadataArgsStorage();
-        schemas.forEach((entitySchema) => {
-            const options = entitySchema.options;
-            // add table metadata args from the schema
-            const tableMetadata = {
-                target: options.target || options.name,
-                name: options.tableName,
-                database: options.database,
-                schema: options.schema,
-                type: options.type || "regular",
-                orderBy: options.orderBy,
-                synchronize: options.synchronize,
-                withoutRowid: !!options.withoutRowid,
-                expression: options.expression,
-            };
-            metadataArgsStorage.tables.push(tableMetadata);
-            const { inheritance } = options;
-            if (inheritance) {
-                metadataArgsStorage.inheritances.push({
-                    target: options.target,
-                    pattern: inheritance.pattern ?? "STI",
-                    column: inheritance.column
-                        ? typeof inheritance.column === "string"
-                            ? { name: inheritance.column }
-                            : inheritance.column
-                        : undefined,
-                });
-            }
-            const { discriminatorValue } = options;
-            if (discriminatorValue) {
-                metadataArgsStorage.discriminatorValues.push({
-                    target: options.target || options.name,
-                    value: discriminatorValue,
-                });
-            }
-            this.transformColumnsRecursive(options, metadataArgsStorage);
-        });
-        return metadataArgsStorage;
-    }
-    transformColumnsRecursive(options, metadataArgsStorage) {
-        // add columns metadata args from the schema
-        Object.keys(options.columns).forEach((columnName) => {
-            const column = options.columns[columnName];
-            const regularColumn = column;
-            let mode = "regular";
-            if (regularColumn.createDate)
-                mode = "createDate";
-            if (regularColumn.updateDate)
-                mode = "updateDate";
-            if (regularColumn.deleteDate)
-                mode = "deleteDate";
-            if (regularColumn.version)
-                mode = "version";
-            if (regularColumn.treeChildrenCount)
-                mode = "treeChildrenCount";
-            if (regularColumn.treeLevel)
-                mode = "treeLevel";
-            if (regularColumn.objectId)
-                mode = "objectId";
-            const columnArgs = {
-                target: options.target || options.name,
-                mode: mode,
-                propertyName: columnName,
-                options: {
-                    type: regularColumn.type,
-                    name: regularColumn.objectId ? "_id" : regularColumn.name,
-                    primaryKeyConstraintName: regularColumn.primaryKeyConstraintName,
-                    length: regularColumn.length,
-                    width: regularColumn.width,
-                    nullable: regularColumn.nullable,
-                    readonly: regularColumn.readonly,
-                    update: regularColumn.update,
-                    select: regularColumn.select,
-                    insert: regularColumn.insert,
-                    primary: regularColumn.primary,
-                    unique: regularColumn.unique,
-                    comment: regularColumn.comment,
-                    default: regularColumn.default,
-                    onUpdate: regularColumn.onUpdate,
-                    precision: regularColumn.precision,
-                    scale: regularColumn.scale,
-                    zerofill: regularColumn.zerofill,
-                    unsigned: regularColumn.unsigned,
-                    charset: regularColumn.charset,
-                    collation: regularColumn.collation,
-                    enum: regularColumn.enum,
-                    enumName: regularColumn.enumName,
-                    asExpression: regularColumn.asExpression,
-                    generatedType: regularColumn.generatedType,
-                    hstoreType: regularColumn.hstoreType,
-                    array: regularColumn.array,
-                    transformer: regularColumn.transformer,
-                    spatialFeatureType: regularColumn.spatialFeatureType,
-                    srid: regularColumn.srid,
-                },
-            };
-            metadataArgsStorage.columns.push(columnArgs);
-            if (regularColumn.generated) {
-                const generationArgs = {
-                    target: options.target || options.name,
-                    propertyName: columnName,
-                    strategy: typeof regularColumn.generated === "string"
-                        ? regularColumn.generated
-                        : "increment",
-                };
-                metadataArgsStorage.generations.push(generationArgs);
-            }
-            if (regularColumn.unique)
-                metadataArgsStorage.uniques.push({
-                    target: options.target || options.name,
-                    columns: [columnName],
-                });
-            if (regularColumn.foreignKey) {
-                const foreignKey = regularColumn.foreignKey;
-                const foreignKeyArgs = {
-                    target: options.target || options.name,
-                    type: foreignKey.target,
-                    propertyName: columnName,
-                    inverseSide: foreignKey.inverseSide,
-                    name: foreignKey.name,
-                    onDelete: foreignKey.onDelete,
-                    onUpdate: foreignKey.onUpdate,
-                    deferrable: foreignKey.deferrable,
-                };
-                metadataArgsStorage.foreignKeys.push(foreignKeyArgs);
-            }
-        });
-        // add relation metadata args from the schema
-        if (options.relations) {
-            Object.keys(options.relations).forEach((relationName) => {
-                const relationSchema = options.relations[relationName];
-                const relation = {
-                    target: options.target || options.name,
-                    propertyName: relationName,
-                    relationType: relationSchema.type,
-                    isLazy: relationSchema.lazy || false,
-                    type: relationSchema.target,
-                    inverseSideProperty: relationSchema.inverseSide,
-                    isTreeParent: relationSchema.treeParent,
-                    isTreeChildren: relationSchema.treeChildren,
-                    options: {
-                        eager: relationSchema.eager || false,
-                        cascade: relationSchema.cascade,
-                        nullable: relationSchema.nullable,
-                        onDelete: relationSchema.onDelete,
-                        onUpdate: relationSchema.onUpdate,
-                        deferrable: relationSchema.deferrable,
-                        // primary: relationSchema.primary,
-                        createForeignKeyConstraints: relationSchema.createForeignKeyConstraints,
-                        persistence: relationSchema.persistence,
-                        orphanedRowAction: relationSchema.orphanedRowAction,
-                    },
-                };
-                metadataArgsStorage.relations.push(relation);
-                // add join column
-                if (relationSchema.joinColumn) {
-                    if (typeof relationSchema.joinColumn === "boolean") {
-                        const joinColumn = {
-                            target: options.target || options.name,
-                            propertyName: relationName,
-                        };
-                        metadataArgsStorage.joinColumns.push(joinColumn);
-                    }
-                    else {
-                        const joinColumnsOptions = Array.isArray(relationSchema.joinColumn)
-                            ? relationSchema.joinColumn
-                            : [relationSchema.joinColumn];
-                        for (const joinColumnOption of joinColumnsOptions) {
-                            const joinColumn = {
-                                target: options.target || options.name,
-                                propertyName: relationName,
-                                name: joinColumnOption.name,
-                                referencedColumnName: joinColumnOption.referencedColumnName,
-                                foreignKeyConstraintName: joinColumnOption.foreignKeyConstraintName,
-                            };
-                            metadataArgsStorage.joinColumns.push(joinColumn);
-                        }
-                    }
-                }
-                // add join table
-                if (relationSchema.joinTable) {
-                    if (typeof relationSchema.joinTable === "boolean") {
-                        const joinTable = {
-                            target: options.target || options.name,
-                            propertyName: relationName,
-                        };
-                        metadataArgsStorage.joinTables.push(joinTable);
-                    }
-                    else {
-                        const joinTable = {
-                            target: options.target || options.name,
-                            propertyName: relationName,
-                            name: relationSchema.joinTable.name,
-                            database: relationSchema.joinTable.database,
-                            schema: relationSchema.joinTable.schema,
-                            joinColumns: (relationSchema.joinTable.joinColumn
-                                ? [
-                                    relationSchema.joinTable.joinColumn,
-                                ]
-                                : relationSchema.joinTable.joinColumns),
-                            inverseJoinColumns: (relationSchema.joinTable.inverseJoinColumn
-                                ? [
-                                    relationSchema.joinTable.inverseJoinColumn,
-                                ]
-                                : relationSchema.joinTable.inverseJoinColumns),
-                        };
-                        metadataArgsStorage.joinTables.push(joinTable);
-                    }
-                }
-            });
-        }
-        // add relation id metadata args from the schema
-        if (options.relationIds) {
-            Object.keys(options.relationIds).forEach((relationIdName) => {
-                const relationIdOptions = options.relationIds[relationIdName];
-                const relationId = {
-                    propertyName: relationIdName,
-                    relation: relationIdOptions.relationName,
-                    target: options.target || options.name,
-                    alias: relationIdOptions.alias,
-                    queryBuilderFactory: relationIdOptions.queryBuilderFactory,
-                };
-                metadataArgsStorage.relationIds.push(relationId);
-            });
-        }
-        // add index metadata args from the schema
-        if (options.indices) {
-            options.indices.forEach((index) => {
-                const indexArgs = {
-                    target: options.target || options.name,
-                    name: index.name,
-                    unique: index.unique === true ? true : false,
-                    spatial: index.spatial === true ? true : false,
-                    fulltext: index.fulltext === true ? true : false,
-                    nullFiltered: index.nullFiltered === true ? true : false,
-                    parser: index.parser,
-                    synchronize: index.synchronize === false ? false : true,
-                    where: index.where,
-                    sparse: index.sparse,
-                    columns: index.columns,
-                };
-                metadataArgsStorage.indices.push(indexArgs);
-            });
-        }
-        if (options.foreignKeys) {
-            options.foreignKeys.forEach((foreignKey) => {
-                const foreignKeyArgs = {
-                    target: options.target || options.name,
-                    type: foreignKey.target,
-                    columnNames: foreignKey.columnNames,
-                    referencedColumnNames: foreignKey.referencedColumnNames,
-                    name: foreignKey.name,
-                    onDelete: foreignKey.onDelete,
-                    onUpdate: foreignKey.onUpdate,
-                    deferrable: foreignKey.deferrable,
-                };
-                metadataArgsStorage.foreignKeys.push(foreignKeyArgs);
-            });
-        }
-        // add unique metadata args from the schema
-        if (options.uniques) {
-            options.uniques.forEach((unique) => {
-                const uniqueArgs = {
-                    target: options.target || options.name,
-                    name: unique.name,
-                    columns: unique.columns,
-                    deferrable: unique.deferrable,
-                };
-                metadataArgsStorage.uniques.push(uniqueArgs);
-            });
-        }
-        // add check metadata args from the schema
-        if (options.checks) {
-            options.checks.forEach((check) => {
-                const checkArgs = {
-                    target: options.target || options.name,
-                    name: check.name,
-                    expression: check.expression,
-                };
-                metadataArgsStorage.checks.push(checkArgs);
-            });
-        }
-        // add exclusion metadata args from the schema
-        if (options.exclusions) {
-            options.exclusions.forEach((exclusion) => {
-                const exclusionArgs = {
-                    target: options.target || options.name,
-                    name: exclusion.name,
-                    expression: exclusion.expression,
-                };
-                metadataArgsStorage.exclusions.push(exclusionArgs);
-            });
-        }
-        if (options.embeddeds) {
-            Object.keys(options.embeddeds).forEach((columnName) => {
-                const embeddedOptions = options.embeddeds[columnName];
-                if (!embeddedOptions.schema)
-                    throw EntitySchemaEmbeddedError_1.EntitySchemaEmbeddedError.createEntitySchemaIsRequiredException(columnName);
-                const embeddedSchema = embeddedOptions.schema.options;
-                metadataArgsStorage.embeddeds.push({
-                    target: options.target || options.name,
-                    propertyName: columnName,
-                    isArray: embeddedOptions.array === true,
-                    prefix: embeddedOptions.prefix !== undefined
-                        ? embeddedOptions.prefix
-                        : undefined,
-                    type: () => embeddedSchema?.target || embeddedSchema.name,
-                });
-                this.transformColumnsRecursive(embeddedSchema, metadataArgsStorage);
-            });
-        }
-    }
-}
-exports.EntitySchemaTransformer = EntitySchemaTransformer;
-
-//# sourceMappingURL=EntitySchemaTransformer.js.map

package/.output/server/node_modules/typeorm/error/AlreadyHasActiveConnectionError.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AlreadyHasActiveConnectionError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when consumer tries to recreate connection with the same name, but previous connection was not closed yet.
- */
-class AlreadyHasActiveConnectionError extends TypeORMError_1.TypeORMError {
-    constructor(connectionName) {
-        super(`Cannot create a new connection named "${connectionName}", because connection with such name ` +
-            `already exist and it now has an active connection session.`);
-    }
-}
-exports.AlreadyHasActiveConnectionError = AlreadyHasActiveConnectionError;
-
-//# sourceMappingURL=AlreadyHasActiveConnectionError.js.map

package/.output/server/node_modules/typeorm/error/CannotAttachTreeChildrenEntityError.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotAttachTreeChildrenEntityError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when user saves tree children entity but its parent is not saved yet.
- */
-class CannotAttachTreeChildrenEntityError extends TypeORMError_1.TypeORMError {
-    constructor(entityName) {
-        super(`Cannot attach entity "${entityName}" to its parent. Please make sure parent ` +
-            `is saved in the database before saving children nodes.`);
-    }
-}
-exports.CannotAttachTreeChildrenEntityError = CannotAttachTreeChildrenEntityError;
-
-//# sourceMappingURL=CannotAttachTreeChildrenEntityError.js.map

package/.output/server/node_modules/typeorm/error/CannotConnectAlreadyConnectedError.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotConnectAlreadyConnectedError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when consumer tries to connect when he already connected.
- */
-class CannotConnectAlreadyConnectedError extends TypeORMError_1.TypeORMError {
-    constructor(connectionName) {
-        super(`Cannot create a "${connectionName}" connection because connection to the database already established.`);
-    }
-}
-exports.CannotConnectAlreadyConnectedError = CannotConnectAlreadyConnectedError;
-
-//# sourceMappingURL=CannotConnectAlreadyConnectedError.js.map

package/.output/server/node_modules/typeorm/error/CannotCreateEntityIdMapError.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotCreateEntityIdMapError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when user tries to create entity id map from the mixed id value,
- * but id value is a single value when entity requires multiple values.
- */
-class CannotCreateEntityIdMapError extends TypeORMError_1.TypeORMError {
-    constructor(metadata, id) {
-        super();
-        const objectExample = metadata.primaryColumns.reduce((object, column, index) => {
-            column.setEntityValue(object, index + 1);
-            return object;
-        }, {});
-        this.message = `Cannot use given entity id "${id}" because "${metadata.targetName}" contains multiple primary columns, you must provide object in following form: ${JSON.stringify(objectExample)} as an id.`;
-    }
-}
-exports.CannotCreateEntityIdMapError = CannotCreateEntityIdMapError;
-
-//# sourceMappingURL=CannotCreateEntityIdMapError.js.map

package/.output/server/node_modules/typeorm/error/CannotDetermineEntityError.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotDetermineEntityError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when user tries to save/remove/etc. constructor-less object (object literal) instead of entity.
- */
-class CannotDetermineEntityError extends TypeORMError_1.TypeORMError {
-    constructor(operation) {
-        super(`Cannot ${operation}, given value must be instance of entity class, ` +
-            `instead object literal is given. Or you must specify an entity target to method call.`);
-    }
-}
-exports.CannotDetermineEntityError = CannotDetermineEntityError;
-
-//# sourceMappingURL=CannotDetermineEntityError.js.map

package/.output/server/node_modules/typeorm/error/CannotExecuteNotConnectedError.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotExecuteNotConnectedError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when consumer tries to execute operation allowed only if connection is opened.
- */
-class CannotExecuteNotConnectedError extends TypeORMError_1.TypeORMError {
-    constructor(connectionName) {
-        super(`Cannot execute operation on "${connectionName}" connection because connection is not yet established.`);
-    }
-}
-exports.CannotExecuteNotConnectedError = CannotExecuteNotConnectedError;
-
-//# sourceMappingURL=CannotExecuteNotConnectedError.js.map

package/.output/server/node_modules/typeorm/error/CannotGetEntityManagerNotConnectedError.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotGetEntityManagerNotConnectedError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when consumer tries to access entity manager before connection is established.
- */
-class CannotGetEntityManagerNotConnectedError extends TypeORMError_1.TypeORMError {
-    constructor(connectionName) {
-        super(`Cannot get entity manager for "${connectionName}" connection because connection is not yet established.`);
-    }
-}
-exports.CannotGetEntityManagerNotConnectedError = CannotGetEntityManagerNotConnectedError;
-
-//# sourceMappingURL=CannotGetEntityManagerNotConnectedError.js.map

package/.output/server/node_modules/typeorm/error/CannotReflectMethodParameterTypeError.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CannotReflectMethodParameterTypeError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when ORM cannot get method parameter's type.
- * Basically, when reflect-metadata is not available or tsconfig is not properly setup.
- */
-class CannotReflectMethodParameterTypeError extends TypeORMError_1.TypeORMError {
-    constructor(target, methodName) {
-        super(`Cannot get reflected type for a "${methodName}" method's parameter of "${target.name}" class. ` +
-            `Make sure you have turned on an "emitDecoratorMetadata": true option in tsconfig.json. ` +
-            `Also make sure you have imported "reflect-metadata" on top of the main entry file in your application.`);
-    }
-}
-exports.CannotReflectMethodParameterTypeError = CannotReflectMethodParameterTypeError;
-
-//# sourceMappingURL=CannotReflectMethodParameterTypeError.js.map

package/.output/server/node_modules/typeorm/error/CircularRelationsError.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircularRelationsError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when circular relations detected with nullable set to false.
- */
-class CircularRelationsError extends TypeORMError_1.TypeORMError {
-    constructor(path) {
-        super(`Circular relations detected: ${path}. To resolve this issue you need to ` +
-            `set nullable: true somewhere in this dependency structure.`);
-    }
-}
-exports.CircularRelationsError = CircularRelationsError;
-
-//# sourceMappingURL=CircularRelationsError.js.map

package/.output/server/node_modules/typeorm/error/ColumnTypeUndefinedError.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ColumnTypeUndefinedError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when ORM cannot get column's type automatically.
- * Basically, when reflect-metadata is not available or tsconfig is not properly setup.
- */
-class ColumnTypeUndefinedError extends TypeORMError_1.TypeORMError {
-    constructor(object, propertyName) {
-        super(`Column type for ${object.constructor.name}#${propertyName} is not defined and cannot be guessed. ` +
-            `Make sure you have turned on an "emitDecoratorMetadata": true option in tsconfig.json. ` +
-            `Also make sure you have imported "reflect-metadata" on top of the main entry file in your application (before any entity imported).` +
-            `If you are using JavaScript instead of TypeScript you must explicitly provide a column type.`);
-    }
-}
-exports.ColumnTypeUndefinedError = ColumnTypeUndefinedError;
-
-//# sourceMappingURL=ColumnTypeUndefinedError.js.map

package/.output/server/node_modules/typeorm/error/ConnectionIsNotSetError.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionIsNotSetError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when user tries to execute operation that requires connection to be established.
- */
-class ConnectionIsNotSetError extends TypeORMError_1.TypeORMError {
-    constructor(dbType) {
-        super(`Connection with ${dbType} database is not established. Check connection configuration.`);
-    }
-}
-exports.ConnectionIsNotSetError = ConnectionIsNotSetError;
-
-//# sourceMappingURL=ConnectionIsNotSetError.js.map

package/.output/server/node_modules/typeorm/error/ConnectionNotFoundError.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionNotFoundError = void 0;
-const TypeORMError_1 = require("./TypeORMError");
-/**
- * Thrown when consumer tries to get connection that does not exist.
- */
-class ConnectionNotFoundError extends TypeORMError_1.TypeORMError {
-    constructor(name) {
-        super(`Connection "${name}" was not found.`);
-    }
-}
-exports.ConnectionNotFoundError = ConnectionNotFoundError;
-
-//# sourceMappingURL=ConnectionNotFoundError.js.map