@aeriajs/core 0.0.138 → 0.0.140

package/dist/collection/reference.mjs

@@ -2,96 +2,34 @@
 import { throwIfError, getReferenceProperty } from "@aeriajs/common";
 import { getCollectionAsset } from "../assets.mjs";
 import { prepareCollectionName } from "../database.mjs";
+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;
-};
-export const getReferences = async (properties, options) => {
+export const getReferences = async (properties, options = {}) => {
   const {
     depth = 0,
+    maxDepth = 3,
     memoize
-  } = options || {};
+  } = options;
   if (memoize) {
     if (referenceMemo[memoize]) {
       return referenceMemo[memoize];
     }
   }
-  const references = {};
+  const refMap = {};
   for (const [propName, property] of Object.entries(properties)) {
     const refProperty = getReferenceProperty(property);
     const reference = {};
-    if (depth === 2 || refProperty && refProperty.populate && refProperty.populate.length === 0) {
+    if (depth === maxDepth || refProperty && refProperty.populate && refProperty.populate.length === 0) {
       continue;
     }
-    if (!refProperty) {
-      const entrypoint = "items" in property ? property.items : property;
-      if ("properties" in entrypoint) {
-        const deepReferences = await getReferences(entrypoint.properties, {
-          memoize: `${memoize}.${propName}`
-        });
-        if (Object.keys(deepReferences).length > 0) {
-          reference.deepReferences ??= {};
-          reference.deepReferences = deepReferences;
-        }
-      }
-    } else {
+    if (refProperty) {
       const description = throwIfError(await getCollectionAsset(refProperty.$ref, "description"));
       const deepReferences = await getReferences(description.properties, {
         depth: depth + 1,
+        maxDepth: refProperty.populateDepth || maxDepth,
         memoize: `${memoize}.${propName}`
       });
       if (Object.keys(deepReferences).length > 0) {
@@ -99,6 +37,17 @@ export const getReferences = async (properties, options) => {
       }
       const indexes = refProperty.indexes ? refProperty.indexes : description.indexes || [];
       reference.populatedProperties = (refProperty.populate || []).concat(indexes.filter((index) => typeof index === "string"));
+    } else {
+      const entrypoint = "items" in property ? property.items : property;
+      if ("properties" in entrypoint) {
+        const deepReferences = await getReferences(entrypoint.properties, {
+          memoize: `${memoize}.${propName}`
+        });
+        if (Object.keys(deepReferences).length > 0) {
+          reference.deepReferences ??= {};
+          reference.deepReferences = deepReferences;
+        }
+      }
     }
     if (!refProperty?.$ref && !reference.deepReferences) {
       continue;
@@ -106,6 +55,9 @@ export 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;
@@ -114,178 +66,255 @@ export 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;
 };
-const buildLookupStages = async (reference, propName, options) => {
-  const {
-    parent,
-    properties,
-    depth = 0,
-    maxDepth = 3
-  } = options;
-  const stages = [];
-  let refHasDeepReferences = false;
-  const withParent = (propName2) => {
-    return parent ? `${parent}.${propName2}` : propName2;
-  };
-  if (reference.referencedCollection) {
-    if (!reference.populatedProperties) {
-      stages.push({
-        $lookup: {
-          from: prepareCollectionName(reference.referencedCollection),
-          foreignField: "_id",
-          localField: withParent(propName),
-          as: withParent(propName)
-        }
-      });
-    } else {
-      const subPipeline = [];
-      if (reference.deepReferences) {
-        const subProperties = throwIfError(await getCollectionAsset(reference.referencedCollection, "description")).properties;
-        subPipeline.push(...await 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: prepareCollectionName(reference.referencedCollection),
-          let: {
-            "ids": !reference.isArray ? `$${withParent(propName)}` : {
-              $ifNull: [
-                `$${withParent(propName)}`,
-                []
+export 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}`,
+            {
+              $indexOfArray: [
+                `$${getTempName(path.slice(0, -1))}._id`,
+                parentElem
               ]
             }
-          },
-          as: withParent(propName),
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  [reference.isArray ? "$in" : "$eq"]: [
-                    "$_id",
-                    "$$ids"
-                  ]
-                }
-              }
-            },
-            ...subPipeline
           ]
         }
-      });
+      ]
+    };
+  } else {
+    indexOfArray = {
+      $indexOfArray: [
+        `$${getTempName(path)}._id`,
+        parentElem
+      ]
+    };
+  }
+  if (reference.isArray) {
+    const newElemName = `${refName}__elem`;
+    let mapIn;
+    if (reference.referencedCollection) {
+      mapIn = recurseSetStage({
+        ...reference,
+        isArray: false,
+        isArrayElement: true
+      }, path, `$$${newElemName}`);
+    } else {
+      mapIn = {
+        $mergeObjects: [
+          `$$${newElemName}`,
+          recurseSetStage({
+            ...reference,
+            isArray: false,
+            isArrayElement: true
+          }, path, `$$${newElemName}`)
+        ]
+      };
     }
-    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
+        ]
+      };
     }
-  } else if (reference.deepReferences && depth <= maxDepth) {
-    refHasDeepReferences = true;
-    stages.push({
-      $unwind: {
-        path: `$${withParent(propName)}`,
-        preserveNullAndEmptyArrays: true
-      }
-    });
-    for (const [refName, refMap] of Object.entries(reference.deepReferences)) {
-      if (!refMap) {
-        continue;
+    return {
+      $filter: {
+        input: {
+          $map: {
+            input: mapInput,
+            as: newElemName,
+            in: mapIn
+          }
+        },
+        as: "elem",
+        cond: {
+          $ne: [
+            "$$elem",
+            null
+          ]
+        }
       }
-      if (refMap.referencedCollection) {
-        const description = throwIfError(await getCollectionAsset(refMap.referencedCollection, "description"));
-        const { stages: result } = await buildLookupStages(refMap, refName, {
-          depth: depth + 1,
-          parent: withParent(propName),
-          properties: description.properties
-        });
-        stages.push(...result);
+    };
+  }
+  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 = recurseSetStage(subReference, path.concat(subRefName), newElem);
+      stages.push([
+        subRefName,
+        result
+      ]);
+    }
+    if (reference.referencedCollection) {
+      return {
+        $cond: [
+          {
+            $ne: [
+              indexOfArray,
+              -1
+            ]
+          },
+          {
+            $mergeObjects: [
+              recurseSetStage({
+                ...reference,
+                deepReferences: void 0
+              }, 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
+    ]
   };
 };
-export const buildLookupPipeline = async (referenceMap, options) => {
+export const buildLookupPipeline = (refMap, options = {}) => {
   const {
-    properties,
-    memoize: memoizeId,
-    project = []
+    rootPipeline = [],
+    path = [],
+    tempNames = [],
+    project,
+    memoize: memoizeId
   } = options;
-  const memoize = `${memoizeId}-${project.sort().join("-")}`;
-  if (memoizeId && lookupMemo[memoize]) {
-    const result = lookupMemo[memoize];
-    return project.length > 0 ? narrowLookupPipelineProjection(result, project) : result;
+  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) {
+      buildLookupPipeline(reference.deepReferences, {
+        rootPipeline,
+        tempNames,
+        path: path.concat(refName)
+      });
+      const result = 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: prepareCollectionName(reference.referencedCollection),
+          foreignField: "_id",
+          localField,
+          as: tempName,
+          pipeline: lookupPipeline
+        }
+      });
+      if (!reference.deepReferences) {
+        const result = 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;
 };
-export const getLookupPipeline = (description, _options) => {
-  const options = Object.assign(_options || {}, {
-    properties: description.properties
-  });
-  const references = getReferences(description.properties);
-  return buildLookupPipeline(references, options);
+export const getLookupPipeline = async (description, options) => {
+  const refMap = await getReferences(description.properties);
+  return buildLookupPipeline(refMap, options);
 };

package/dist/collection/traverseDocument.d.ts

@@ -29,7 +29,7 @@ type PhaseContext = {
     options: TraverseOptions & TraverseNormalized;
     isArray?: boolean;
 };
-export declare const traverseDocument: <const TWhat extends Record<string, unknown>>(what: TWhat, description: Description, _options: TraverseOptions) => Promise<{
+export declare const traverseDocument: <const TWhat extends Record<string, unknown> | null>(what: TWhat, description: Description, _options: TraverseOptions) => Promise<{
     readonly _tag: "Result";
     readonly error: undefined;
     readonly result: any;

package/dist/collection/traverseDocument.js

@@ -368,6 +368,9 @@ const recurse = async (target, ctx) => {
 const traverseDocument = async (what, description, _options) => {
     const options = Object.assign({}, _options);
     const functions = [];
+    if (!what) {
+        return types_1.Result.result(what);
+    }
     if (!options.validate && Object.keys(what).length === 0) {
         return types_1.Result.result({});
     }

package/dist/collection/traverseDocument.mjs

@@ -326,6 +326,9 @@ const recurse = async (target, ctx) => {
 export const traverseDocument = async (what, description, _options) => {
   const options = Object.assign({}, _options);
   const functions = [];
+  if (!what) {
+    return Result.result(what);
+  }
   if (!options.validate && Object.keys(what).length === 0) {
     return Result.result({});
   }

package/dist/functions/get.js

@@ -6,14 +6,14 @@ const types_1 = require("@aeriajs/types");
 const common_1 = require("@aeriajs/common");
 const index_js_1 = require("../collection/index.js");
 const internalGet = async (payload, context) => {
-    const { filters = {}, project = [], } = payload;
+    const { filters = {}, project, } = payload;
     if (Object.keys(filters).length === 0) {
         return context.error(types_1.HTTPStatus.BadRequest, {
             code: types_1.ACError.MalformedInput,
         });
     }
     const pipeline = [];
-    const references = await (0, index_js_1.getReferences)(context.description.properties, {
+    const refMap = await (0, index_js_1.getReferences)(context.description.properties, {
         memoize: context.description.$id,
     });
     pipeline.push({
@@ -22,18 +22,19 @@ const internalGet = async (payload, context) => {
             allowOperators: true,
         })),
     });
-    const projection = (0, index_js_1.normalizeProjection)(project, context.description);
-    if (projection) {
-        pipeline.push({
-            $project: projection,
-        });
+    if (project) {
+        const projection = (0, index_js_1.normalizeProjection)(project, context.description);
+        if (projection) {
+            pipeline.push({
+                $project: projection,
+            });
+        }
     }
-    pipeline.push(...await (0, index_js_1.buildLookupPipeline)(references, {
+    pipeline.push(...(0, index_js_1.buildLookupPipeline)(refMap, {
         memoize: context.description.$id,
         project: payload.populate
             ? payload.populate
             : project,
-        properties: context.description.properties,
     }));
     const doc = await context.collection.model.aggregate(pipeline).next();
     if (!doc) {
@@ -41,12 +42,12 @@ const internalGet = async (payload, context) => {
             code: types_1.ACError.ResourceNotFound,
         });
     }
-    const result = (0, index_js_1.fill)((0, common_1.throwIfError)(await (0, index_js_1.traverseDocument)(doc, context.description, {
+    const result = (0, common_1.throwIfError)(await (0, index_js_1.traverseDocument)(doc, context.description, {
         getters: true,
         fromProperties: true,
         recurseReferences: true,
         recurseDeep: true,
-    })), context.description);
+    }));
     return types_1.Result.result(result);
 };
 const get = async (payload, context, options = {}) => {

package/dist/functions/get.mjs

@@ -6,13 +6,12 @@ import {
   traverseDocument,
   normalizeProjection,
   getReferences,
-  buildLookupPipeline,
-  fill
+  buildLookupPipeline
 } from "../collection/index.mjs";
 const internalGet = async (payload, context) => {
   const {
     filters = {},
-    project = []
+    project
   } = payload;
   if (Object.keys(filters).length === 0) {
     return context.error(HTTPStatus.BadRequest, {
@@ -20,7 +19,7 @@ const internalGet = async (payload, context) => {
     });
   }
   const pipeline = [];
-  const references = await getReferences(context.description.properties, {
+  const refMap = await getReferences(context.description.properties, {
     memoize: context.description.$id
   });
   pipeline.push({
@@ -29,16 +28,17 @@ const internalGet = async (payload, context) => {
       allowOperators: true
     }))
   });
-  const projection = normalizeProjection(project, context.description);
-  if (projection) {
-    pipeline.push({
-      $project: projection
-    });
+  if (project) {
+    const projection = normalizeProjection(project, context.description);
+    if (projection) {
+      pipeline.push({
+        $project: projection
+      });
+    }
   }
-  pipeline.push(...await buildLookupPipeline(references, {
+  pipeline.push(...buildLookupPipeline(refMap, {
     memoize: context.description.$id,
-    project: payload.populate ? payload.populate : project,
-    properties: context.description.properties
+    project: payload.populate ? payload.populate : project
   }));
   const doc = await context.collection.model.aggregate(pipeline).next();
   if (!doc) {
@@ -46,12 +46,12 @@ const internalGet = async (payload, context) => {
       code: ACError.ResourceNotFound
     });
   }
-  const result = fill(throwIfError(await traverseDocument(doc, context.description, {
+  const result = throwIfError(await traverseDocument(doc, context.description, {
     getters: true,
     fromProperties: true,
     recurseReferences: true,
     recurseDeep: true
-  })), context.description);
+  }));
   return Result.result(result);
 };
 export const get = async (payload, context, options = {}) => {