@aeriajs/core 0.0.276 → 0.0.278

package/dist/collection/cascadingRemove.mjs

@@ -1,71 +0,0 @@
-"use strict";
-import { ObjectId } from "mongodb";
-import { createContext } from "../context.mjs";
-import { getFunction } from "../assets.mjs";
-import { getDatabaseCollection } from "../database.mjs";
-import { getReferences } from "./reference.mjs";
-const internalCascadingRemove = async (target, refMap, context) => {
-  for (const refName in refMap) {
-    const reference = refMap[refName];
-    if (!target[refName]) {
-      continue;
-    }
-    if (reference.referencedCollection) {
-      if (reference.isInline || reference.referencedCollection === "file") {
-        if (target[refName] instanceof ObjectId || Array.isArray(target[refName])) {
-          await preferredRemove(target[refName], reference, context);
-        }
-      }
-    } else if (reference.deepReferences) {
-      if (Array.isArray(target[refName])) {
-        for (const elem of target[refName]) {
-          await internalCascadingRemove(elem, reference.deepReferences, context);
-        }
-        continue;
-      }
-      await internalCascadingRemove(target[refName], reference.deepReferences, context);
-    }
-  }
-};
-export const preferredRemove = async (targetId, reference, parentContext) => {
-  if (!reference.referencedCollection) {
-    return;
-  }
-  const coll = getDatabaseCollection(reference.referencedCollection);
-  const context = await createContext({
-    parentContext,
-    collectionName: reference.referencedCollection
-  });
-  if (Array.isArray(targetId)) {
-    if (targetId.length === 0) {
-      return;
-    }
-    const nonNullable = targetId.filter((id) => !!id);
-    const { result: removeAll } = await getFunction(reference.referencedCollection, "removeAll");
-    if (removeAll) {
-      return removeAll({
-        filters: nonNullable
-      }, context);
-    }
-    return coll.deleteMany({
-      _id: {
-        $in: nonNullable
-      }
-    });
-  }
-  const { result: remove } = await getFunction(reference.referencedCollection, "remove");
-  if (remove) {
-    return remove({
-      filters: {
-        _id: targetId
-      }
-    }, context);
-  }
-  return coll.deleteOne({
-    _id: targetId
-  });
-};
-export const cascadingRemove = async (target, context) => {
-  const refMap = await getReferences(context.description.properties);
-  return internalCascadingRemove(target, refMap, context);
-};

package/dist/collection/define.mjs

@@ -1,13 +0,0 @@
-"use strict";
-import { deepMerge, freshItem } from "@aeriajs/common";
-export const defineCollection = (collection) => {
-  return Object.assign(
-    {
-      item: freshItem(collection.description)
-    },
-    collection
-  );
-};
-export const extendCollection = (left, right) => {
-  return deepMerge(left, right);
-};

package/dist/collection/description.mjs

@@ -1,8 +0,0 @@
-"use strict";
-export const defineDescription = (description) => {
-  return description;
-};
-export const defineDescriptionTuple = (description) => [
-  {},
-  description
-];

package/dist/collection/index.mjs

@@ -1,9 +0,0 @@
-"use strict";
-export * from "./cascadingRemove.mjs";
-export * from "./define.mjs";
-export * from "./description.mjs";
-export * from "./makePagination.mjs";
-export * from "./normalizeProjection.mjs";
-export * from "./preload.mjs";
-export * from "./reference.mjs";
-export * from "./traverseDocument.mjs";

package/dist/collection/makePagination.mjs

@@ -1,20 +0,0 @@
-"use strict";
-import { throwIfError } from "@aeriajs/common";
-import { count } from "../functions/count.mjs";
-export const makePagination = async (payload, documents, context) => {
-  const {
-    offset = 0,
-    limit = context.config.defaultPaginationLimit
-  } = payload;
-  const recordsTotal = typeof context.collection.functions.count === "function" ? throwIfError(await context.collection.functions.count({
-    filters: payload.filters
-  })) : throwIfError(await count({
-    filters: payload.filters
-  }, context));
-  return {
-    recordsCount: documents.length,
-    recordsTotal,
-    offset,
-    limit
-  };
-};

package/dist/collection/normalizeProjection.mjs

@@ -1,17 +0,0 @@
-"use strict";
-export const normalizeProjection = (properties, description) => {
-  const target = Array.from(properties);
-  if (target.length === 0) {
-    target.push(...Object.keys(description.properties));
-  }
-  const projection = target.reduce((a, key) => {
-    if (key !== "_id" && description.properties[key].hidden) {
-      return a;
-    }
-    return {
-      ...a,
-      [key]: 1
-    };
-  }, {});
-  return Object.keys(projection).length === 0 ? void 0 : projection;
-};

package/dist/collection/preload.mjs

@@ -1,88 +0,0 @@
-"use strict";
-import { getReferenceProperty, deepMerge, serialize } from "@aeriajs/common";
-import { getCollectionAsset } from "../assets.mjs";
-import { presets } from "../presets/index.mjs";
-const preloadMemo = {};
-const recurseProperty = async (_property, propName, description) => {
-  const property = Object.assign({}, _property);
-  if ("items" in property) {
-    property.items = await recurseProperty(property.items, propName, description);
-    return property;
-  }
-  if ("properties" in property) {
-    return preloadDescription(property, {
-      memoize: false,
-      timestamps: false
-    });
-  }
-  if ("getter" in property) {
-    return {
-      ...property,
-      readOnly: true
-    };
-  }
-  const reference = getReferenceProperty(property);
-  if (reference) {
-    if (!reference.indexes && !reference.inline) {
-      const { error, result: referenceDescription } = await getCollectionAsset(reference.$ref, "description");
-      if (error) {
-        throw new Error(`description of ${reference.$ref} not found`);
-      }
-      const indexes = reference.indexes = referenceDescription.indexes?.filter((index) => {
-        return typeof index === "string";
-      });
-      if (!indexes) {
-        reference.indexes = Object.keys(referenceDescription.properties).slice(0, 1);
-      }
-    }
-  }
-  return property;
-};
-export const applyPreset = (entry, presetName, parentName) => {
-  const preset = presets[presetName];
-  const presetObject = Object.assign({}, parentName ? preset[parentName] : preset);
-  return deepMerge(entry, presetObject, {
-    callback: (_, left) => {
-      if (left === null) {
-        return left;
-      }
-    }
-  });
-};
-export const preloadDescription = async (originalDescription, options) => {
-  const {
-    memoize = !!originalDescription.$id,
-    timestamps = true
-  } = options || {};
-  if (memoize && preloadMemo[originalDescription.$id]) {
-    const description2 = preloadMemo[originalDescription.$id];
-    return options?.serialize ? serialize(description2) : description2;
-  }
-  const description = Object.assign({}, originalDescription);
-  const descriptionPresets = [];
-  if (description.presets) {
-    descriptionPresets.push(...description.presets);
-  }
-  if (description.owned) {
-    descriptionPresets.push("owned");
-  }
-  if (description.timestamps !== false && timestamps !== false) {
-    descriptionPresets.push("timestamped");
-  }
-  if (descriptionPresets.length > 0) {
-    const merge = descriptionPresets.reduce(
-      (a, presetName) => applyPreset(a, presetName),
-      description
-    );
-    Object.assign(description, merge);
-  }
-  if (description.properties) {
-    for (const [propName, property] of Object.entries(description.properties)) {
-      description.properties[propName] = await recurseProperty(property, propName, description);
-    }
-  }
-  if (memoize) {
-    preloadMemo[originalDescription.$id] = description;
-  }
-  return options?.serialize ? serialize(description) : description;
-};

package/dist/collection/reference.mjs

@@ -1,374 +0,0 @@
-"use strict";
-import { throwIfError, getReferenceProperty } from "@aeriajs/common";
-import { getCollectionAsset } from "../assets.mjs";
-const getTempName = (path) => {
-  return `_${path.map(([segment]) => segment).join("_")}`;
-};
-const referenceMemo = {};
-const lookupMemo = {};
-export const getReferences = async (properties, options = {}) => {
-  const {
-    depth = 0,
-    maxDepth = 3,
-    memoize,
-    populate,
-    isArrayOrArrayElement
-  } = options;
-  if (memoize) {
-    if (referenceMemo[memoize]) {
-      return referenceMemo[memoize];
-    }
-  }
-  const refMap = {};
-  for (const [propName, property] of Object.entries(properties)) {
-    const reference = {};
-    const refProperty = getReferenceProperty(property);
-    if (depth === maxDepth || populate && !populate.includes(propName)) {
-      continue;
-    }
-    if (refProperty) {
-      const description = throwIfError(await getCollectionAsset(refProperty.$ref, "description"));
-      if (refProperty.inline || refProperty.populate) {
-        if (refProperty.populate && refProperty.populate.length === 0) {
-          continue;
-        }
-        const deepReferences = await getReferences(description.properties, {
-          depth: depth + 1,
-          maxDepth: refProperty.populateDepth || maxDepth,
-          memoize: `${memoize}.${propName}`,
-          populate: refProperty.populate ? Array.from(refProperty.populate) : void 0,
-          isArrayOrArrayElement: "items" in property
-        });
-        if (Object.keys(deepReferences).length > 0) {
-          reference.deepReferences = deepReferences;
-        }
-      }
-      const { indexes = description.indexes || [] } = refProperty;
-      reference.populate = (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 && !reference.deepReferences) {
-      continue;
-    }
-    if ("items" in property) {
-      reference.isArray = true;
-    }
-    if ("items" in property || isArrayOrArrayElement) {
-      reference.isArrayOrArrayElement = true;
-    }
-    if (depth > 0) {
-      reference.isRecursive = true;
-    }
-    if (refProperty) {
-      if (refProperty.$ref) {
-        reference.referencedCollection = refProperty.$ref;
-      }
-      if (refProperty.inline) {
-        reference.isInline = true;
-      }
-    }
-    refMap[propName] = reference;
-  }
-  if (memoize) {
-    referenceMemo[memoize] = refMap;
-  }
-  return refMap;
-};
-export const recurseSetStage = (reference, path, parentElem, options = {
-  noCond: false
-}) => {
-  const [refName, isRef] = path.at(-1);
-  const shouldUseArrayIndex = reference.isRecursive && !(reference.isArrayOrArrayElement && reference.isArray === false);
-  let indexOfArray;
-  if (shouldUseArrayIndex) {
-    if (isRef) {
-      indexOfArray = {
-        $indexOfArray: [
-          `$${getTempName(path)}._id`,
-          {
-            $arrayElemAt: [
-              `$${getTempName(path.slice(0, -1))}.${refName}`,
-              {
-                $indexOfArray: [
-                  `$${getTempName(path.slice(0, -1))}._id`,
-                  parentElem
-                ]
-              }
-            ]
-          }
-        ]
-      };
-    } else {
-      indexOfArray = {
-        $indexOfArray: [
-          `$${getTempName(path.slice(0, -1))}._id`,
-          parentElem
-        ]
-      };
-    }
-  } else {
-    indexOfArray = {
-      $indexOfArray: [
-        `$${getTempName(path)}._id`,
-        parentElem
-      ]
-    };
-  }
-  if (reference.isArray) {
-    const newElemName = `${refName}__elem`;
-    let mapIn;
-    if (reference.referencedCollection) {
-      mapIn = recurseSetStage({
-        ...reference,
-        isArray: false
-      }, path, `$$${newElemName}`);
-    } else {
-      mapIn = {
-        $mergeObjects: [
-          `$$${newElemName}`,
-          recurseSetStage({
-            ...reference,
-            isArray: false
-          }, path, `$$${newElemName}`)
-        ]
-      };
-    }
-    let mapInput = parentElem;
-    if (reference.isRecursive) {
-      if (reference.isArrayOrArrayElement) {
-        mapInput = {
-          $arrayElemAt: [
-            `$${getTempName(path.slice(0, -1))}.${refName}`,
-            {
-              $indexOfArray: [
-                `$${getTempName(path.slice(0, -1))}._id`,
-                parentElem
-              ]
-            }
-          ]
-        };
-      } else {
-        mapInput = {
-          $arrayElemAt: [
-            `$${getTempName(path.slice(0, -1))}.${refName}`,
-            indexOfArray
-          ]
-        };
-      }
-    }
-    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)) {
-      let newElem;
-      if (shouldUseArrayIndex) {
-        if (isRef) {
-          newElem = {
-            $arrayElemAt: [
-              `$${getTempName(path.slice(0, -1))}.${refName}`,
-              {
-                $indexOfArray: [
-                  `$${getTempName(path.slice(0, -1))}._id`,
-                  parentElem
-                ]
-              }
-            ]
-          };
-        } else {
-          newElem = {
-            $arrayElemAt: [
-              `$${getTempName(path.slice(0, -1))}.${refName}.${subRefName}`,
-              indexOfArray
-            ]
-          };
-        }
-      } else {
-        newElem = reference.referencedCollection ? parentElem : `${parentElem}.${subRefName}`;
-      }
-      const result = recurseSetStage(subReference, path.concat([
-        [
-          subRefName,
-          "referencedCollection" in subReference
-        ]
-      ]), newElem);
-      stages[subRefName] = result;
-    }
-    if (reference.referencedCollection) {
-      return {
-        $cond: [
-          {
-            $ne: [
-              indexOfArray,
-              -1
-            ]
-          },
-          {
-            $mergeObjects: [
-              recurseSetStage({
-                ...reference,
-                deepReferences: void 0
-              }, path, parentElem, {
-                noCond: true
-              }),
-              stages
-            ]
-          },
-          null
-        ]
-      };
-    }
-    return stages;
-  }
-  const arrayElemAt = {
-    $arrayElemAt: [
-      `$${getTempName(path)}`,
-      indexOfArray
-    ]
-  };
-  if (options.noCond) {
-    return arrayElemAt;
-  }
-  return {
-    $cond: [
-      {
-        $ne: [
-          indexOfArray,
-          -1
-        ]
-      },
-      arrayElemAt,
-      null
-    ]
-  };
-};
-export 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];
-    }
-  }
-  const pipeline = [];
-  const setProperties = {};
-  for (const [refName, reference] of Object.entries(refMap)) {
-    if (project) {
-      if (!project.includes(refName)) {
-        continue;
-      }
-    }
-    const newPath = path.concat([
-      [
-        refName,
-        "referencedCollection" in reference
-      ]
-    ]);
-    if (reference.deepReferences) {
-      buildLookupPipeline(reference.deepReferences, {
-        rootPipeline,
-        tempNames,
-        path: newPath
-      });
-      const result = recurseSetStage(reference, newPath, `$${refName}`);
-      setProperties[refName] = result;
-    }
-    if (reference.referencedCollection) {
-      const tempName = getTempName(newPath);
-      const lookupPipeline = [];
-      tempNames.unshift(tempName);
-      if (reference.populate && reference.populate.length > 0 && !reference.isInline) {
-        lookupPipeline.push({
-          $project: Object.fromEntries(reference.populate.map((index) => [
-            index,
-            1
-          ]))
-        });
-      }
-      let localField;
-      if (reference.isRecursive) {
-        localField = `${getTempName(path)}.${refName}`;
-      } else {
-        let separator = "_";
-        localField = path[0] && path[0][1] ? "_" : "";
-        for (let i = 0; i < newPath.length; i++) {
-          localField += newPath[i][0];
-          if (newPath[i + 1]) {
-            if (!newPath[i][1] || !newPath[i + 1][1]) {
-              separator = ".";
-            }
-            localField += separator;
-          }
-        }
-      }
-      rootPipeline.unshift({
-        $lookup: {
-          from: reference.referencedCollection,
-          foreignField: "_id",
-          localField,
-          as: tempName,
-          pipeline: lookupPipeline
-        }
-      });
-      if (!reference.deepReferences) {
-        const result = recurseSetStage(reference, newPath, `$${refName}`);
-        setProperties[refName] = result;
-      }
-    }
-  }
-  if (path.length === 0) {
-    if (Object.keys(setProperties).length > 0) {
-      pipeline.push({
-        $set: setProperties
-      });
-    }
-    if (tempNames.length > 0) {
-      pipeline.push({
-        $unset: tempNames
-      });
-    }
-    const finalPipeline = rootPipeline.concat(pipeline);
-    if (memoize) {
-      lookupMemo[memoize] = finalPipeline;
-    }
-    return finalPipeline;
-  }
-  return pipeline;
-};
-export const getLookupPipeline = async (description, options) => {
-  const refMap = await getReferences(description.properties);
-  return buildLookupPipeline(refMap, options);
-};