orcaq 1.0.20

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

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

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

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

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

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