@aeriajs/core 0.0.139 → 0.0.140

package/dist/collection/preload.js

@@ -57,7 +57,7 @@ const recurseProperty = async (_property, propertyName, description) => {
                 return typeof index === 'string';
             });
             if (!indexes) {
-                throw new Error(`neither indexes or inline are present on reference property or indexes is set on target description on ${description.$id}.${propertyName}`);
+                reference.indexes = Object.keys(referenceDescription.properties).slice(0, 1);
             }
         }
     }

package/dist/collection/preload.mjs

@@ -32,7 +32,7 @@ const recurseProperty = async (_property, propertyName, description) => {
         return typeof index === "string";
       });
       if (!indexes) {
-        throw new Error(`neither indexes or inline are present on reference property or indexes is set on target description on ${description.$id}.${propertyName}`);
+        reference.indexes = Object.keys(referenceDescription.properties).slice(0, 1);
       }
     }
   }

package/dist/collection/reference.d.ts

@@ -6,20 +6,25 @@ export type GetReferenceOptions = {
 };
 export type Reference = {
     isArray?: boolean;
+    isArrayElement?: boolean;
     isInline?: boolean;
+    isRecursive?: boolean;
     deepReferences?: ReferenceMap;
     referencedCollection?: string;
     populatedProperties?: string[];
 };
 export type ReferenceMap = Record<string, Reference | undefined>;
-export type BuildLookupOptions = {
-    properties: FixedObjectProperty['properties'];
-    parent?: string;
-    depth?: number;
-    maxDepth?: number;
+export type PipelineStage = {};
+export type BuildLookupPipelineOptions = {
+    rootPipeline?: PipelineStage[];
+    path?: string[];
+    tempNames?: string[];
     memoize?: string;
     project?: string[];
 };
 export declare const getReferences: (properties: FixedObjectProperty["properties"], options?: GetReferenceOptions) => Promise<{}>;
-export declare const buildLookupPipeline: (referenceMap: ReferenceMap | {}, options: BuildLookupOptions) => Promise<any[]>;
-export declare const getLookupPipeline: (description: Description, _options?: Omit<BuildLookupOptions, "properties">) => Promise<any[]>;
+export declare const recurseSetStage: (reference: Reference, path: string[], parentElem: {}, options?: {
+    noCond: boolean;
+}) => PipelineStage;
+export declare const buildLookupPipeline: (refMap: ReferenceMap, options?: BuildLookupPipelineOptions) => PipelineStage[];
+export declare const getLookupPipeline: (description: Description, options: BuildLookupPipelineOptions) => Promise<PipelineStage[]>;

package/dist/collection/reference.js

@@ -1,79 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLookupPipeline = exports.buildLookupPipeline = exports.getReferences = void 0;
+exports.getLookupPipeline = exports.buildLookupPipeline = exports.recurseSetStage = exports.getReferences = void 0;
 const common_1 = require("@aeriajs/common");
 const assets_js_1 = require("../assets.js");
 const database_js_1 = require("../database.js");
+const getTempName = (path) => {
+    return `_${path.join('_')}`;
+};
 const referenceMemo = {};
 const lookupMemo = {};
-const narrowLookupPipelineProjection = (pipeline, projection) => {
-    const hasAny = (propName) => {
-        return propName.includes('.') || projection.includes(propName);
-    };
-    return pipeline.filter((stage) => {
-        if (stage.$lookup) {
-            return hasAny(stage.$lookup.as);
-        }
-        if (stage.$unwind) {
-            return hasAny(stage.$unwind.path.slice(1));
-        }
-        return true;
-    });
-};
-const buildGroupStages = (referenceMap, properties) => {
-    const $group = Object.keys(properties).reduce((a, propName) => {
-        const refMap = referenceMap[propName] || {};
-        const groupType = !refMap.referencedCollection && refMap.isArray
-            ? 'push'
-            : 'first';
-        return {
-            ...a,
-            [propName]: {
-                [`$${groupType}`]: `$${propName}`,
-            },
-        };
-    }, {
-        _id: '$_id',
-    });
-    return {
-        $group,
-    };
-};
-const buildArrayCleanupStages = (referenceMap) => {
-    const $set = Object.entries(referenceMap).reduce((a, [refName, refMap]) => {
-        if (!refMap.isArray || refMap.referencedCollection) {
-            return a;
-        }
-        return {
-            ...a,
-            [refName]: {
-                $filter: {
-                    input: `$${refName}`,
-                    as: `${refName}_elem`,
-                    cond: {
-                        $ne: [
-                            `$$${refName}_elem`,
-                            {},
-                        ],
-                    },
-                },
-            },
-        };
-    }, {});
-    return Object.keys($set).length > 0
-        ? {
-            $set,
-        }
-        : null;
-};
-const getReferences = async (properties, options) => {
-    const { depth = 0, maxDepth = 3, memoize, } = options || {};
+const getReferences = async (properties, options = {}) => {
+    const { depth = 0, maxDepth = 3, memoize, } = options;
     if (memoize) {
         if (referenceMemo[memoize]) {
             return referenceMemo[memoize];
         }
     }
-    const references = {};
+    const refMap = {};
     for (const [propName, property] of Object.entries(properties)) {
         const refProperty = (0, common_1.getReferenceProperty)(property);
         const reference = {};
@@ -120,6 +63,9 @@ const getReferences = async (properties, options) => {
         if ('items' in property) {
             reference.isArray = true;
         }
+        if (depth > 0) {
+            reference.isRecursive = true;
+        }
         if (refProperty) {
             if (refProperty.$ref) {
                 reference.referencedCollection = refProperty.$ref;
@@ -128,185 +74,262 @@ const getReferences = async (properties, options) => {
                 reference.isInline = true;
             }
         }
-        references[propName] = reference;
+        refMap[propName] = reference;
     }
     if (memoize) {
-        referenceMemo[memoize] = references;
+        referenceMemo[memoize] = refMap;
     }
-    return references;
+    return refMap;
 };
 exports.getReferences = getReferences;
-const buildLookupStages = async (reference, propName, options) => {
-    const { parent, properties, depth = 0, maxDepth = 3, } = options;
-    const stages = [];
-    let refHasDeepReferences = false;
-    const withParent = (propName) => {
-        return parent
-            ? `${parent}.${propName}`
-            : propName;
-    };
-    if (reference.referencedCollection) {
-        if (!reference.populatedProperties) {
-            stages.push({
-                $lookup: {
-                    from: (0, database_js_1.prepareCollectionName)(reference.referencedCollection),
-                    foreignField: '_id',
-                    localField: withParent(propName),
-                    as: withParent(propName),
-                },
-            });
-        }
-        else {
-            const subPipeline = [];
-            if (reference.deepReferences) {
-                const subProperties = (0, common_1.throwIfError)(await (0, assets_js_1.getCollectionAsset)(reference.referencedCollection, 'description')).properties;
-                subPipeline.push(...await (0, exports.buildLookupPipeline)(reference.deepReferences, {
-                    project: reference.populatedProperties,
-                    properties: subProperties,
-                }));
-            }
-            if (reference.populatedProperties.length > 0) {
-                subPipeline.push({
-                    $project: Object.fromEntries(reference.populatedProperties.map((index) => [
-                        index,
-                        1,
-                    ])),
-                });
-            }
-            stages.push({
-                $lookup: {
-                    from: (0, database_js_1.prepareCollectionName)(reference.referencedCollection),
-                    let: {
-                        'ids': !reference.isArray
-                            ? `$${withParent(propName)}`
-                            : {
-                                $ifNull: [
-                                    `$${withParent(propName)}`,
-                                    [],
-                                ],
-                            },
-                    },
-                    as: withParent(propName),
-                    pipeline: [
+const recurseSetStage = (reference, path, parentElem, options = {
+    noCond: false,
+}) => {
+    const refName = path.at(-1);
+    let indexOfArray;
+    if (reference.isRecursive && !reference.isArrayElement) {
+        indexOfArray = {
+            $indexOfArray: [
+                `$${getTempName(path)}._id`,
+                {
+                    $arrayElemAt: [
+                        `$${getTempName(path.slice(0, -1))}.${refName}`,
                         {
-                            $match: {
-                                $expr: {
-                                    [reference.isArray
-                                        ? '$in'
-                                        : '$eq']: [
-                                        '$_id',
-                                        '$$ids',
-                                    ],
-                                },
-                            },
+                            $indexOfArray: [
+                                `$${getTempName(path.slice(0, -1))}._id`,
+                                parentElem,
+                            ],
                         },
-                        ...subPipeline,
                     ],
                 },
-            });
+            ],
+        };
+    }
+    else {
+        indexOfArray = {
+            $indexOfArray: [
+                `$${getTempName(path)}._id`,
+                parentElem,
+            ],
+        };
+    }
+    if (reference.isArray) {
+        const newElemName = `${refName}__elem`;
+        let mapIn;
+        if (reference.referencedCollection) {
+            mapIn = (0, exports.recurseSetStage)({
+                ...reference,
+                isArray: false,
+                isArrayElement: true,
+            }, path, `$$${newElemName}`);
         }
-        if (!reference.isArray) {
-            stages.push({
-                $unwind: {
-                    path: `$${withParent(propName)}`,
-                    preserveNullAndEmptyArrays: true,
-                },
-            });
+        else {
+            mapIn = {
+                $mergeObjects: [
+                    `$$${newElemName}`,
+                    (0, exports.recurseSetStage)({
+                        ...reference,
+                        isArray: false,
+                        isArrayElement: true,
+                    }, path, `$$${newElemName}`),
+                ],
+            };
         }
-    }
-    else if (reference.deepReferences && depth <= maxDepth) {
-        refHasDeepReferences = true;
-        if (reference.isArray) {
-            stages.push({
-                $unwind: {
-                    path: `$${withParent(propName)}`,
-                    preserveNullAndEmptyArrays: true,
-                },
-            });
+        let mapInput = parentElem;
+        if (reference.isRecursive) {
+            mapInput = {
+                $arrayElemAt: [
+                    `$${getTempName(path.slice(0, -1))}.${refName}`,
+                    indexOfArray,
+                ],
+            };
         }
-        for (const [refName, refMap] of Object.entries(reference.deepReferences)) {
-            if (!refMap) {
-                continue;
-            }
-            if (refMap.referencedCollection) {
-                const description = (0, common_1.throwIfError)(await (0, assets_js_1.getCollectionAsset)(refMap.referencedCollection, 'description'));
-                const { stages: result } = await buildLookupStages(refMap, refName, {
-                    depth: depth + 1,
-                    parent: withParent(propName),
-                    properties: description.properties,
-                });
-                stages.push(...result);
+        return {
+            $filter: {
+                input: {
+                    $map: {
+                        input: mapInput,
+                        as: newElemName,
+                        in: mapIn,
+                    },
+                },
+                as: 'elem',
+                cond: {
+                    $ne: [
+                        '$$elem',
+                        null,
+                    ],
+                },
+            },
+        };
+    }
+    if (reference.deepReferences) {
+        const stages = [];
+        for (const [subRefName, subReference] of Object.entries(reference.deepReferences)) {
+            if (!subReference) {
                 continue;
             }
-            const refProperties = properties[propName];
-            if ('properties' in refProperties) {
-                const { stages: refStages } = await buildLookupStages(refMap, refName, {
-                    depth: depth + 1,
-                    parent: withParent(propName),
-                    properties: refProperties.properties,
-                });
-                stages.push(...refStages);
-            }
-            else if ('items' in refProperties) {
-                if (!('properties' in refProperties.items)) {
-                    throw new Error();
-                }
-                const { stages: refStages } = await buildLookupStages(refMap, refName, {
-                    depth: depth + 1,
-                    parent: withParent(propName),
-                    properties: refProperties.items.properties,
-                });
-                stages.push(...refStages);
+            let newElem;
+            if (reference.isRecursive) {
+                newElem = {
+                    $arrayElemAt: [
+                        `$${getTempName(path.slice(0, -1))}.${refName}`,
+                        indexOfArray,
+                    ],
+                };
             }
             else {
-                throw new Error();
+                newElem = reference.referencedCollection
+                    ? parentElem
+                    : `${parentElem}.${subRefName}`;
             }
+            const result = (0, exports.recurseSetStage)(subReference, path.concat(subRefName), newElem);
+            stages.push([
+                subRefName,
+                result,
+            ]);
         }
+        if (reference.referencedCollection) {
+            return {
+                $cond: [
+                    {
+                        $ne: [
+                            indexOfArray,
+                            -1,
+                        ],
+                    },
+                    {
+                        $mergeObjects: [
+                            (0, exports.recurseSetStage)({
+                                ...reference,
+                                deepReferences: undefined,
+                            }, path, parentElem, {
+                                noCond: true,
+                            }),
+                            Object.fromEntries(stages),
+                        ],
+                    },
+                    null,
+                ],
+            };
+        }
+        return Object.fromEntries(stages);
+    }
+    const arrayElemAt = {
+        $arrayElemAt: [
+            `$${getTempName(path)}`,
+            indexOfArray,
+        ],
+    };
+    if (options.noCond) {
+        return arrayElemAt;
     }
     return {
-        stages,
-        refHasDeepReferences,
+        $cond: [
+            {
+                $ne: [
+                    indexOfArray,
+                    -1,
+                ],
+            },
+            arrayElemAt,
+            null,
+        ],
     };
 };
-const buildLookupPipeline = async (referenceMap, options) => {
-    const { properties, memoize: memoizeId, project = [], } = options;
-    const memoize = `${memoizeId}-${project.sort().join('-')}`;
-    if (memoizeId && lookupMemo[memoize]) {
-        const result = lookupMemo[memoize];
-        return project.length > 0
-            ? narrowLookupPipelineProjection(result, project)
-            : result;
+exports.recurseSetStage = recurseSetStage;
+const buildLookupPipeline = (refMap, options = {}) => {
+    const { rootPipeline = [], path = [], tempNames = [], project, memoize: memoizeId, } = options;
+    const memoize = project
+        ? `${memoizeId}-${project.sort().join('-')}`
+        : memoizeId;
+    if (memoize) {
+        if (lookupMemo[memoize]) {
+            return lookupMemo[memoize];
+        }
     }
-    let hasDeepReferences = false;
     const pipeline = [];
-    for (const [propName, reference] of Object.entries(referenceMap)) {
+    const setProperties = [];
+    for (const [refName, reference] of Object.entries(refMap)) {
         if (!reference) {
             continue;
         }
-        const { stages, refHasDeepReferences, } = await buildLookupStages(reference, propName, options);
-        hasDeepReferences = hasDeepReferences || refHasDeepReferences;
-        pipeline.push(...stages);
-    }
-    if (hasDeepReferences) {
-        pipeline.push(buildGroupStages(referenceMap, properties));
-        const arrayCleanupStages = buildArrayCleanupStages(referenceMap);
-        if (arrayCleanupStages) {
-            pipeline.push(arrayCleanupStages);
+        if (project) {
+            if (!project.includes(refName)) {
+                continue;
+            }
+        }
+        if (reference.deepReferences) {
+            (0, exports.buildLookupPipeline)(reference.deepReferences, {
+                rootPipeline,
+                tempNames,
+                path: path.concat(refName),
+            });
+            const result = (0, exports.recurseSetStage)(reference, path.concat(refName), `$${refName}`);
+            setProperties.push([
+                refName,
+                result,
+            ]);
+        }
+        if (reference.referencedCollection) {
+            const tempName = getTempName(path.concat(refName));
+            const lookupPipeline = [];
+            tempNames.unshift(tempName);
+            if (reference.populatedProperties && reference.populatedProperties.length > 0) {
+                const lookupPopulate = reference.populatedProperties;
+                if (reference.deepReferences) {
+                    lookupPopulate.push(...Object.keys(reference.deepReferences));
+                }
+                lookupPipeline.push({
+                    $project: Object.fromEntries(reference.populatedProperties.map((index) => [
+                        index,
+                        1,
+                    ])),
+                });
+            }
+            const localField = reference.isRecursive
+                ? `${getTempName(path)}.${refName}`
+                : path.concat(refName).join('.');
+            rootPipeline.unshift({
+                $lookup: {
+                    from: (0, database_js_1.prepareCollectionName)(reference.referencedCollection),
+                    foreignField: '_id',
+                    localField,
+                    as: tempName,
+                    pipeline: lookupPipeline,
+                },
+            });
+            if (!reference.deepReferences) {
+                const result = (0, exports.recurseSetStage)(reference, path.concat(refName), `$${refName}`);
+                setProperties.push([
+                    refName,
+                    result,
+                ]);
+            }
         }
     }
-    if (memoizeId) {
-        lookupMemo[memoize] = pipeline;
+    if (path.length === 0) {
+        if (setProperties.length > 0) {
+            pipeline.push({
+                $set: Object.fromEntries(setProperties),
+            });
+        }
+        if (tempNames.length > 0) {
+            pipeline.push({
+                $unset: tempNames,
+            });
+        }
+        const finalPipeline = rootPipeline.concat(pipeline);
+        if (memoize) {
+            lookupMemo[memoize] = finalPipeline;
+        }
+        return finalPipeline;
     }
-    return project.length > 0
-        ? narrowLookupPipelineProjection(pipeline, project)
-        : pipeline;
+    return pipeline;
 };
 exports.buildLookupPipeline = buildLookupPipeline;
-const getLookupPipeline = (description, _options) => {
-    const options = Object.assign(_options || {}, {
-        properties: description.properties,
-    });
-    const references = (0, exports.getReferences)(description.properties);
-    return (0, exports.buildLookupPipeline)(references, options);
+const getLookupPipeline = async (description, options) => {
+    const refMap = await (0, exports.getReferences)(description.properties);
+    return (0, exports.buildLookupPipeline)(refMap, options);
 };
 exports.getLookupPipeline = getLookupPipeline;