orcaq 1.0.26 → 1.0.28

package/.output/server/node_modules/typeorm/query-builder/result/InsertResult.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InsertResult = void 0;
-/**
- * Result object returned by InsertQueryBuilder execution.
- */
-class InsertResult {
-    constructor() {
-        /**
-         * Contains inserted entity id.
-         * Has entity-like structure (not just column database name and values).
-         */
-        this.identifiers = [];
-        /**
-         * Generated values returned by a database.
-         * Has entity-like structure (not just column database name and values).
-         */
-        this.generatedMaps = [];
-    }
-    static from(queryResult) {
-        const result = new this();
-        result.raw = queryResult.raw;
-        return result;
-    }
-}
-exports.InsertResult = InsertResult;
-
-//# sourceMappingURL=InsertResult.js.map

package/.output/server/node_modules/typeorm/query-builder/result/UpdateResult.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateResult = void 0;
-/**
- * Result object returned by UpdateQueryBuilder execution.
- */
-class UpdateResult {
-    constructor() {
-        /**
-         * Contains inserted entity id.
-         * Has entity-like structure (not just column database name and values).
-         */
-        // identifier: ObjectLiteral[] = [];
-        /**
-         * Generated values returned by a database.
-         * Has entity-like structure (not just column database name and values).
-         */
-        this.generatedMaps = [];
-    }
-    static from(queryResult) {
-        const result = new this();
-        result.raw = queryResult.records;
-        result.affected = queryResult.affected;
-        return result;
-    }
-}
-exports.UpdateResult = UpdateResult;
-
-//# sourceMappingURL=UpdateResult.js.map

package/.output/server/node_modules/typeorm/query-builder/transformer/DocumentToEntityTransformer.js

@@ -1,196 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentToEntityTransformer = void 0;
-/**
- * Transforms raw document into entity object.
- * Entity is constructed based on its entity metadata.
- */
-class DocumentToEntityTransformer {
-    // -------------------------------------------------------------------------
-    // Constructor
-    // -------------------------------------------------------------------------
-    constructor(
-    // private selectionMap: AliasMap,
-    // private joinMappings: JoinMapping[],
-    // private relationCountMetas: RelationCountAttribute[],
-    enableRelationIdValues = false) {
-        this.enableRelationIdValues = enableRelationIdValues;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    transformAll(documents, metadata) {
-        return documents.map((document) => this.transform(document, metadata));
-    }
-    transform(document, metadata) {
-        const entity = metadata.create(undefined, {
-            fromDeserializer: true,
-        });
-        let hasData = false;
-        // handle _id property the special way
-        if (metadata.objectIdColumn) {
-            // todo: we can't use driver in this class
-            // do we really need prepare hydrated value here? If no then no problem. If yes then think maybe prepareHydratedValue process should be extracted out of driver class?
-            // entity[metadata.ObjectIdColumn.propertyName] = this.driver.prepareHydratedValue(document[metadata.ObjectIdColumn.name"], metadata.ObjectIdColumn);
-            const { databaseNameWithoutPrefixes, propertyName } = metadata.objectIdColumn;
-            const documentIdWithoutPrefixes = document[databaseNameWithoutPrefixes];
-            const documentIdWithPropertyName = document[propertyName];
-            if (documentIdWithoutPrefixes) {
-                entity[propertyName] = documentIdWithoutPrefixes;
-                hasData = true;
-            }
-            else if (documentIdWithPropertyName) {
-                entity[propertyName] = documentIdWithPropertyName;
-                hasData = true;
-            }
-        }
-        // add special columns that contains relation ids
-        if (this.enableRelationIdValues) {
-            metadata.columns
-                .filter((column) => !!column.relationMetadata)
-                .forEach((column) => {
-                const valueInObject = document[column.databaseNameWithoutPrefixes];
-                if (valueInObject !== undefined &&
-                    valueInObject !== null &&
-                    column.propertyName) {
-                    // todo: we can't use driver in this class
-                    // const value = this.driver.prepareHydratedValue(valueInObject, column);
-                    entity[column.propertyName] = valueInObject;
-                    hasData = true;
-                }
-            });
-        }
-        /*this.joinMappings
-            .filter(joinMapping => joinMapping.parentName === alias.name && !joinMapping.alias.relationOwnerSelection && joinMapping.alias.target)
-            .map(joinMapping => {
-                const relatedEntities = this.transformRawResultsGroup(rawSqlResults, joinMapping.alias);
-                const isResultArray = joinMapping.isMany;
-                const result = !isResultArray ? relatedEntities[0] : relatedEntities;
-
-                if (result && (!isResultArray || result.length > 0)) {
-                    entity[joinMapping.propertyName] = result;
-                    hasData = true;
-                }
-            });*/
-        // get value from columns selections and put them into object
-        metadata.ownColumns.forEach((column) => {
-            const valueInObject = document[column.databaseNameWithoutPrefixes];
-            if (valueInObject !== undefined &&
-                column.propertyName &&
-                !column.isVirtual) {
-                // const value = this.driver.prepareHydratedValue(valueInObject, column);
-                entity[column.propertyName] = valueInObject;
-                hasData = true;
-            }
-        });
-        const addEmbeddedValuesRecursively = (entity, document, embeddeds) => {
-            embeddeds.forEach((embedded) => {
-                if (!document[embedded.prefix])
-                    return;
-                if (embedded.isArray) {
-                    entity[embedded.propertyName] = document[embedded.prefix].map((subValue, index) => {
-                        const newItem = embedded.create({
-                            fromDeserializer: true,
-                        });
-                        embedded.columns.forEach((column) => {
-                            newItem[column.propertyName] =
-                                subValue[column.databaseNameWithoutPrefixes];
-                        });
-                        addEmbeddedValuesRecursively(newItem, document[embedded.prefix][index], embedded.embeddeds);
-                        return newItem;
-                    });
-                }
-                else {
-                    if (embedded.embeddeds.length &&
-                        !entity[embedded.propertyName])
-                        entity[embedded.propertyName] = embedded.create({
-                            fromDeserializer: true,
-                        });
-                    embedded.columns.forEach((column) => {
-                        const value = document[embedded.prefix][column.databaseNameWithoutPrefixes];
-                        if (value === undefined)
-                            return;
-                        if (!entity[embedded.propertyName])
-                            entity[embedded.propertyName] = embedded.create({
-                                fromDeserializer: true,
-                            });
-                        entity[embedded.propertyName][column.propertyName] =
-                            value;
-                    });
-                    addEmbeddedValuesRecursively(entity[embedded.propertyName], document[embedded.prefix], embedded.embeddeds);
-                }
-            });
-        };
-        addEmbeddedValuesRecursively(entity, document, metadata.embeddeds);
-        // if relation is loaded then go into it recursively and transform its values too
-        /*metadata.relations.forEach(relation => {
-            const relationAlias = this.selectionMap.findSelectionByParent(alias.name, relation.propertyName);
-            if (relationAlias) {
-                const joinMapping = this.joinMappings.find(joinMapping => joinMapping.type === "join" && joinMapping.alias === relationAlias);
-                const relatedEntities = this.transformRawResultsGroup(rawSqlResults, relationAlias);
-                const isResultArray = relation.isManyToMany || relation.isOneToMany;
-                const result = !isResultArray ? relatedEntities[0] : relatedEntities;
-
-                if (result) {
-                    let propertyName = relation.propertyName;
-                    if (joinMapping) {
-                        propertyName = joinMapping.propertyName;
-                    }
-
-                    if (relation.isLazy) {
-                        entity["__" + propertyName + "__"] = result;
-                    } else {
-                        entity[propertyName] = result;
-                    }
-
-                    if (!isResultArray || result.length > 0)
-                        hasData = true;
-                }
-            }
-
-            // if relation has id field then relation id/ids to that field.
-            if (relation.isManyToMany) {
-                if (relationAlias) {
-                    const ids: any[] = [];
-                    const joinMapping = this.joinMappings.find(joinMapping => joinMapping.type === "relationId" && joinMapping.alias === relationAlias);
-
-                    if (relation.idField || joinMapping) {
-                        const propertyName = joinMapping ? joinMapping.propertyName : relation.idField as string;
-                        const junctionMetadata = relation.junctionEntityMetadata;
-                        const columnName = relation.isOwning ? junctionMetadata.columns[1].name : junctionMetadata.columns[0].name;
-
-                        rawSqlResults.forEach(results => {
-                            if (relationAlias) {
-                                const resultsKey = relationAlias.name + "_" + columnName;
-                                const value = this.driver.prepareHydratedValue(results[resultsKey], relation.referencedColumn);
-                                if (value !== undefined && value !== null)
-                                    ids.push(value);
-                            }
-                        });
-
-                        if (ids && ids.length)
-                            entity[propertyName] = ids;
-                    }
-                }
-            } else if (relation.idField) {
-                const relationName = relation.name;
-                entity[relation.idField] = this.driver.prepareHydratedValue(rawSqlResults[0][alias.name + "_" + relationName], relation.referencedColumn);
-            }
-
-            // if relation counter
-            this.relationCountMetas.forEach(joinMeta => {
-                if (joinMeta.alias === relationAlias) {
-                    // console.log("relation count was found for relation: ", relation);
-                    // joinMeta.entity = entity;
-                    joinMeta.entities.push({ entity: entity, metadata: metadata });
-                    // console.log(joinMeta);
-                    // console.log("---------------------");
-                }
-            });
-        });*/
-        return hasData ? entity : null;
-    }
-}
-exports.DocumentToEntityTransformer = DocumentToEntityTransformer;
-
-//# sourceMappingURL=DocumentToEntityTransformer.js.map

package/.output/server/node_modules/typeorm/query-builder/transformer/PlainObjectToDatabaseEntityTransformer.js

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlainObjectToDatabaseEntityTransformer = void 0;
-/**
- */
-class LoadMapItem {
-    constructor(plainEntity, metadata, parentLoadMapItem, relation) {
-        this.plainEntity = plainEntity;
-        this.metadata = metadata;
-        this.parentLoadMapItem = parentLoadMapItem;
-        this.relation = relation;
-    }
-    get target() {
-        return this.metadata.target;
-    }
-    get id() {
-        return this.metadata.getEntityIdMixedMap(this.plainEntity);
-    }
-}
-class LoadMap {
-    constructor() {
-        this.loadMapItems = [];
-    }
-    get mainLoadMapItem() {
-        return this.loadMapItems.find((item) => !item.relation && !item.parentLoadMapItem);
-    }
-    addLoadMap(newLoadMap) {
-        const item = this.loadMapItems.find((item) => item.target === newLoadMap.target && item.id === newLoadMap.id);
-        if (!item)
-            this.loadMapItems.push(newLoadMap);
-    }
-    fillEntities(target, entities) {
-        entities.forEach((entity) => {
-            const item = this.loadMapItems.find((loadMapItem) => {
-                return (loadMapItem.target === target &&
-                    loadMapItem.metadata.compareEntities(entity, loadMapItem.plainEntity));
-            });
-            if (item)
-                item.entity = entity;
-        });
-    }
-    groupByTargetIds() {
-        const groups = [];
-        this.loadMapItems.forEach((loadMapItem) => {
-            let group = groups.find((group) => group.target === loadMapItem.target);
-            if (!group) {
-                group = { target: loadMapItem.target, ids: [] };
-                groups.push(group);
-            }
-            group.ids.push(loadMapItem.id);
-        });
-        return groups;
-    }
-}
-/**
- * Transforms plain old javascript object
- * Entity is constructed based on its entity metadata.
- */
-class PlainObjectToDatabaseEntityTransformer {
-    constructor(manager) {
-        this.manager = manager;
-    }
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    async transform(plainObject, metadata) {
-        // if plain object does not have id then nothing to load really
-        if (!metadata.hasAllPrimaryKeys(plainObject))
-            return Promise.reject("Given object does not have a primary column, cannot transform it to database entity.");
-        // create a special load map that will hold all metadata that will be used to operate with entities easily
-        const loadMap = new LoadMap();
-        const fillLoadMap = (entity, entityMetadata, parentLoadMapItem, relation) => {
-            const item = new LoadMapItem(entity, entityMetadata, parentLoadMapItem, relation);
-            loadMap.addLoadMap(item);
-            entityMetadata
-                .extractRelationValuesFromEntity(entity, metadata.relations)
-                .filter((value) => value !== null && value !== undefined)
-                .forEach(([relation, value, inverseEntityMetadata]) => fillLoadMap(value, inverseEntityMetadata, item, relation));
-        };
-        fillLoadMap(plainObject, metadata);
-        // load all entities and store them in the load map
-        await Promise.all(loadMap.groupByTargetIds().map((targetWithIds) => {
-            // todo: fix type hinting
-            return this.manager
-                .findByIds(targetWithIds.target, targetWithIds.ids)
-                .then((entities) => loadMap.fillEntities(targetWithIds.target, entities));
-        }));
-        // go through each item in the load map and set their entity relationship using metadata stored in load map
-        loadMap.loadMapItems.forEach((loadMapItem) => {
-            if (!loadMapItem.relation ||
-                !loadMapItem.entity ||
-                !loadMapItem.parentLoadMapItem ||
-                !loadMapItem.parentLoadMapItem.entity)
-                return;
-            if (loadMapItem.relation.isManyToMany ||
-                loadMapItem.relation.isOneToMany) {
-                if (!loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName])
-                    loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName] = [];
-                loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName].push(loadMapItem.entity);
-            }
-            else {
-                loadMapItem.parentLoadMapItem.entity[loadMapItem.relation.propertyName] = loadMapItem.entity;
-            }
-        });
-        return loadMap.mainLoadMapItem
-            ? loadMap.mainLoadMapItem.entity
-            : undefined;
-    }
-}
-exports.PlainObjectToDatabaseEntityTransformer = PlainObjectToDatabaseEntityTransformer;
-
-//# sourceMappingURL=PlainObjectToDatabaseEntityTransformer.js.map

package/.output/server/node_modules/typeorm/query-builder/transformer/PlainObjectToNewEntityTransformer.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlainObjectToNewEntityTransformer = void 0;
-const ObjectUtils_1 = require("../../util/ObjectUtils");
-/**
- * Transforms plain old javascript object
- * Entity is constructed based on its entity metadata.
- */
-class PlainObjectToNewEntityTransformer {
-    // -------------------------------------------------------------------------
-    // Public Methods
-    // -------------------------------------------------------------------------
-    transform(newEntity, object, metadata, getLazyRelationsPromiseValue = false) {
-        // console.log("groupAndTransform entity:", newEntity);
-        // console.log("groupAndTransform object:", object);
-        this.groupAndTransform(newEntity, object, metadata, getLazyRelationsPromiseValue);
-        // console.log("result:", newEntity);
-        return newEntity;
-    }
-    // -------------------------------------------------------------------------
-    // Private Methods
-    // -------------------------------------------------------------------------
-    /**
-     * Since db returns a duplicated rows of the data where accuracies of the same object can be duplicated
-     * we need to group our result and we must have some unique id (primary key in our case)
-     */
-    groupAndTransform(entity, object, metadata, getLazyRelationsPromiseValue = false) {
-        // console.log("groupAndTransform entity:", entity);
-        // console.log("groupAndTransform object:", object);
-        // copy regular column properties from the given object
-        metadata.nonVirtualColumns.forEach((column) => {
-            const objectColumnValue = column.getEntityValue(object);
-            if (objectColumnValue !== undefined)
-                column.setEntityValue(entity, objectColumnValue);
-        });
-        // // copy relation properties from the given object
-        if (metadata.relations.length) {
-            metadata.relations.forEach((relation) => {
-                let entityRelatedValue = relation.getEntityValue(entity);
-                const objectRelatedValue = relation.getEntityValue(object, getLazyRelationsPromiseValue);
-                if (objectRelatedValue === undefined)
-                    return;
-                if (relation.isOneToMany || relation.isManyToMany) {
-                    if (!Array.isArray(objectRelatedValue))
-                        return;
-                    if (!entityRelatedValue) {
-                        entityRelatedValue = [];
-                        relation.setEntityValue(entity, entityRelatedValue);
-                    }
-                    objectRelatedValue.forEach((objectRelatedValueItem) => {
-                        // check if we have this item from the merging object in the original entity we merge into
-                        let objectRelatedValueEntity = entityRelatedValue.find((entityRelatedValueItem) => {
-                            return relation.inverseEntityMetadata.compareEntities(objectRelatedValueItem, entityRelatedValueItem);
-                        });
-                        const inverseEntityMetadata = relation.inverseEntityMetadata.findInheritanceMetadata(objectRelatedValueItem);
-                        // if such item already exist then merge new data into it, if its not we create a new entity and merge it into the array
-                        if (!objectRelatedValueEntity) {
-                            objectRelatedValueEntity =
-                                inverseEntityMetadata.create(undefined, {
-                                    fromDeserializer: true,
-                                });
-                            entityRelatedValue.push(objectRelatedValueEntity);
-                        }
-                        this.groupAndTransform(objectRelatedValueEntity, objectRelatedValueItem, inverseEntityMetadata, getLazyRelationsPromiseValue);
-                    });
-                }
-                else {
-                    // if related object isn't an object (direct relation id for example)
-                    // we just set it to the entity relation, we don't need anything more from it
-                    // however we do it only if original entity does not have this relation set to object
-                    // to prevent full overriding of objects
-                    if (!ObjectUtils_1.ObjectUtils.isObject(objectRelatedValue)) {
-                        if (!ObjectUtils_1.ObjectUtils.isObject(entityRelatedValue))
-                            relation.setEntityValue(entity, objectRelatedValue);
-                        return;
-                    }
-                    const inverseEntityMetadata = relation.inverseEntityMetadata.findInheritanceMetadata(objectRelatedValue);
-                    if (!entityRelatedValue) {
-                        entityRelatedValue = inverseEntityMetadata.create(undefined, {
-                            fromDeserializer: true,
-                        });
-                        relation.setEntityValue(entity, entityRelatedValue);
-                    }
-                    this.groupAndTransform(entityRelatedValue, objectRelatedValue, inverseEntityMetadata, getLazyRelationsPromiseValue);
-                }
-            });
-        }
-    }
-}
-exports.PlainObjectToNewEntityTransformer = PlainObjectToNewEntityTransformer;
-
-//# sourceMappingURL=PlainObjectToNewEntityTransformer.js.map