orcaq 1.0.20

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

@@ -0,0 +1,44 @@
+"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

@@ -0,0 +1,15 @@
+"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

@@ -0,0 +1,8 @@
+"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

@@ -0,0 +1,18 @@
+"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

@@ -0,0 +1,11 @@
+"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

@@ -0,0 +1,333 @@
+"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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,15 @@
+"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

@@ -0,0 +1,21 @@
+"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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,15 @@
+"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

@@ -0,0 +1,15 @@
+"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

@@ -0,0 +1,18 @@
+"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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,19 @@
+"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

@@ -0,0 +1,15 @@
+"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

@@ -0,0 +1,15 @@
+"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