@aeriajs/core 0.0.276 → 0.0.278

package/dist/collection/traverseDocument.mjs

@@ -1,451 +0,0 @@
-"use strict";
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import { Result, ACError, ValidationErrorCode, TraverseError } from "@aeriajs/types";
-import { throwIfError, isReference, getReferenceProperty, getValueFromPath } from "@aeriajs/common";
-import { makeValidationError, validatePropertyWithRefs, validateWholeness } from "@aeriajs/validation";
-import { getCollection } from "@aeriajs/entrypoint";
-import { ObjectId } from "mongodb";
-import { getCollectionAsset } from "../assets.mjs";
-import { createContext } from "../context.mjs";
-import { preloadDescription } from "./preload.mjs";
-import { getReferences } from "./reference.mjs";
-import { preferredRemove } from "./cascadingRemove.mjs";
-const escapeRegExp = (text) => {
-  return text.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
-};
-const getProperty = (propName, parentProperty) => {
-  if (propName === "_id") {
-    return {
-      type: "string"
-    };
-  }
-  if ("items" in parentProperty && "properties" in parentProperty.items && propName in parentProperty.items.properties) {
-    return parentProperty.items.properties[propName];
-  }
-  if ("additionalProperties" in parentProperty && typeof parentProperty.additionalProperties === "object") {
-    return parentProperty.additionalProperties;
-  }
-  if ("properties" in parentProperty) {
-    return parentProperty.properties[propName];
-  }
-};
-const cleanupReferences = async (value, ctx) => {
-  if (ctx.root._id) {
-    const refProperty = getReferenceProperty(ctx.property);
-    if (refProperty && (refProperty.$ref === "file" || refProperty.inline)) {
-      if (ctx.isArray && !Array.isArray(value)) {
-        return Result.result(value);
-      }
-      const context = ctx.options.context;
-      const doc = await context.collections[ctx.options.description.$id].model.findOne({
-        _id: new ObjectId(ctx.root._id)
-      }, {
-        projection: {
-          [ctx.propPath]: 1
-        }
-      });
-      if (!doc) {
-        return Result.error(TraverseError.InvalidDocumentId);
-      }
-      let referenceIds = getValueFromPath(doc, ctx.propPath);
-      if (!referenceIds) {
-        return Result.result(value);
-      }
-      if (Array.isArray(referenceIds)) {
-        if (!Array.isArray(value)) {
-          throw new Error();
-        }
-        referenceIds = referenceIds.filter((oldId) => !value.some((valueId) => valueId.equals(oldId)));
-      } else {
-        if (referenceIds.equals(value)) {
-          return Result.result(value);
-        }
-      }
-      const refMap = await getReferences({
-        [ctx.propName]: ctx.property
-      });
-      await preferredRemove(referenceIds, refMap[ctx.propName], await createContext({
-        parentContext: context,
-        collectionName: refProperty.$ref
-      }));
-    }
-  }
-  return Result.result(value);
-};
-const autoCast = (value, ctx) => {
-  switch (typeof value) {
-    case "boolean": {
-      return Result.result(!!value);
-    }
-    case "string": {
-      if (isReference(ctx.property)) {
-        return Result.result(ObjectId.isValid(value) ? new ObjectId(value) : value);
-      }
-      if ("format" in ctx.property) {
-        if (ctx.property.format === "date" || ctx.property.format === "date-time") {
-          const timestamp = Date.parse(value);
-          return Result.result(!Number.isNaN(timestamp) ? new Date(timestamp) : null);
-        }
-      }
-      break;
-    }
-    case "number": {
-      if ("type" in ctx.property && ctx.property.type === "integer") {
-        return Result.result(parseInt(value.toString()));
-      }
-      if ("format" in ctx.property) {
-        if (ctx.property.format === "date" || ctx.property.format === "date-time") {
-          return Result.result(new Date(value));
-        }
-      }
-      break;
-    }
-    case "object": {
-      if (!value || value instanceof ObjectId) {
-        return Result.result(value);
-      }
-      if (!("description" in ctx.options) || !ctx.options.recurseDeep) {
-        if (Array.isArray(value)) {
-          return Result.result(value.map((v) => throwIfError(autoCast(v, ctx))));
-        }
-        if (Object.keys(value).length > 0) {
-          const entries = {};
-          for (const [k, v] of Object.entries(value)) {
-            const subProperty = !k.startsWith("$") ? getProperty(k, ctx.property) : ctx.property;
-            if (!subProperty) {
-              continue;
-            }
-            entries[k] = throwIfError(autoCast(v, {
-              ...ctx,
-              property: subProperty
-            }));
-          }
-          return Result.result(entries);
-        }
-      }
-    }
-  }
-  return Result.result(value);
-};
-const getters = async (value, ctx) => {
-  if ("getter" in ctx.property) {
-    if (!ctx.options.context) {
-      throw new Error();
-    }
-    if (!ctx.property.getter) {
-      return Result.result(void 0);
-    }
-    return Result.result(await ctx.property.getter(ctx.target, ctx.options.context));
-  }
-  return Result.result(value);
-};
-const validate = async (value, ctx) => {
-  if (ctx.options.recurseDeep) {
-    if ("properties" in ctx.property) {
-      return Result.result(value);
-    }
-  }
-  if ("$ref" in ctx.property && ctx.property.$ref === "file") {
-    return Result.result(value);
-  }
-  const { error } = await validatePropertyWithRefs(value, ctx.property, {
-    checkObjectIds: true,
-    context: ctx.options.context,
-    objectIdConstructor: ObjectId
-  });
-  if (error) {
-    return Result.error({
-      [ctx.propName]: error
-    });
-  }
-  return Result.result(value);
-};
-const isValidTempFile = (value) => {
-  if (value && typeof value === "object") {
-    if (value instanceof ObjectId) {
-      return true;
-    }
-    return "tempId" in value && (typeof value.tempId === "string" || value.tempId instanceof ObjectId);
-  }
-  return !!(value === void 0 || value === null);
-};
-const isMissingPropertyError = (error) => {
-  return "code" in error && error.code === ValidationErrorCode.MissingProperties;
-};
-const moveFiles = async (value, ctx) => {
-  if (!("$ref" in ctx.property) || ctx.property.$ref !== "file") {
-    return Result.result(value);
-  }
-  const tempFileCollection = await getCollection("tempFile");
-  if (!tempFileCollection) {
-    throw new Error('The "tempFile" collection is absent, yet it is required to upload files.');
-  }
-  if (!isValidTempFile(value)) {
-    return Result.error(TraverseError.InvalidTempfile);
-  }
-  if (!value) {
-    return Result.result(null);
-  }
-  if (value instanceof ObjectId) {
-    return Result.result(value);
-  }
-  if (!ctx.options.context) {
-    throw new Error();
-  }
-  const tempFile = await ctx.options.context.collections.tempFile.model.findOne({
-    _id: new ObjectId(value.tempId)
-  });
-  if (!tempFile) {
-    return Result.error(TraverseError.InvalidTempfile);
-  }
-  const { _id: fileId, ...newFile } = tempFile;
-  newFile.absolute_path = `${ctx.options.context.config.storage.fs}/${tempFile.absolute_path.split(path.sep).at(-1)}`;
-  newFile.owner = ctx.options.context.token.sub;
-  await fs.rename(tempFile.absolute_path, newFile.absolute_path);
-  const file = await ctx.options.context.collections.file.model.insertOne(newFile);
-  return Result.result(file.insertedId);
-};
-const recurseDeep = async (value, ctx) => {
-  if (!value) {
-    return Result.result(value);
-  }
-  if ("properties" in ctx.property) {
-    if (ctx.options.validateWholeness) {
-      const wholenessError = validateWholeness(value, ctx.property);
-      if (wholenessError) {
-        return Result.error(wholenessError);
-      }
-    }
-    return recurse(value, ctx);
-  }
-  if ("items" in ctx.property) {
-    if (!Array.isArray(value)) {
-      return Result.result(value);
-    }
-    const items = [];
-    for (const item of value) {
-      const { error, result } = await ctx.options.pipe(item, {
-        ...ctx,
-        property: ctx.property.items,
-        isArray: true
-      });
-      if (!error) {
-        items.push(result);
-      }
-    }
-    return Result.result(items);
-  }
-  return Result.result(value);
-};
-const recurse = async (target, ctx) => {
-  const entries = {};
-  const entrypoint = ctx.options.fromProperties && "properties" in ctx.property ? {
-    _id: null,
-    ...ctx.property.properties
-  } : target;
-  entrypoint: for (const propName in entrypoint) {
-    const value = target[propName];
-    const property = getProperty(propName, ctx.property);
-    if (propName === "_id") {
-      if (value) {
-        if (ctx.options.autoCast) {
-          entries[propName] = throwIfError(autoCast(value, {
-            ...ctx,
-            target,
-            propName,
-            property: {
-              $ref: ""
-            }
-          }));
-        } else {
-          entries[propName] = value;
-        }
-      }
-      continue;
-    }
-    if (ctx.options.undefinedToNull) {
-      if (value === void 0) {
-        entries[propName] = null;
-        continue;
-      }
-    }
-    if (value && typeof value === "object") {
-      for (const key in value) {
-        if (key.startsWith("$")) {
-          if (!ctx.options.allowOperators) {
-            return Result.error(ACError.InsecureOperator);
-          }
-          if (key === "$regex" && typeof value[key] === "string") {
-            if (!ctx.options.noRegExpEscaping) {
-              entries[propName] = {
-                ...value,
-                $regex: escapeRegExp(value[key])
-              };
-              continue entrypoint;
-            }
-          }
-        }
-      }
-    }
-    if (!property) {
-      if (value && (value.constructor === Object || value.constructor === Array)) {
-        if (Array.isArray(value)) {
-          const operations = [];
-          for (const operation of value) {
-            const { error: error2, result } = await recurse(operation, ctx);
-            if (error2) {
-              return Result.error(error2);
-            }
-            operations.push(result);
-          }
-          entries[propName] = operations;
-          continue;
-        }
-        const { error, result: operator } = await recurse(value, ctx);
-        if (error) {
-          return Result.error(error);
-        }
-        entries[propName] = operator;
-        continue;
-      }
-      entries[propName] = value;
-    } else {
-      if (!ctx.options.preserveHidden && property.hidden) {
-        continue;
-      }
-      if ("getters" in ctx.options && ctx.options.getters && "getter" in property) {
-        if (property.requires) {
-          const missing = property.requires.some((requiredPropName) => !(requiredPropName in target));
-          if (missing) {
-            continue;
-          }
-        }
-      }
-      if (ctx.options.recurseReferences) {
-        const propCast = "items" in property ? property.items : property;
-        if ("$ref" in propCast && value && !(value instanceof ObjectId)) {
-          const targetDescription = await preloadDescription(throwIfError(await getCollectionAsset(propCast.$ref, "description")));
-          if (Array.isArray(value)) {
-            const documents = [];
-            for (const elem of value) {
-              if (elem instanceof ObjectId) {
-                documents.push(elem);
-                continue;
-              }
-              if (typeof elem === "string") {
-                documents.push(new ObjectId(elem));
-                continue;
-              }
-              const { error: error3, result: result2 } = await traverseDocument(elem, targetDescription, ctx.options);
-              if (error3) {
-                return Result.error(error3);
-              }
-              documents.push(result2);
-            }
-            entries[propName] = documents;
-            continue;
-          }
-          const { error: error2, result: doc } = await traverseDocument(value, targetDescription, ctx.options);
-          if (error2) {
-            return Result.error(error2);
-          }
-          entries[propName] = doc;
-          continue;
-        }
-      }
-      const { error, result } = await ctx.options.pipe(value, {
-        ...ctx,
-        target,
-        propName,
-        propPath: ctx.propPath ? `${ctx.propPath}.${propName}` : propName,
-        property
-      });
-      if (!error) {
-        entries[propName] = result;
-      }
-    }
-  }
-  return Result.result(entries);
-};
-export const traverseDocument = async (what, description, _options) => {
-  if (!what) {
-    return Result.result(what);
-  }
-  const whatCopy = Object.assign({}, what);
-  const options = Object.assign({
-    description
-  }, _options);
-  const functions = [];
-  if (!options.validate && Object.keys(whatCopy).length === 0) {
-    return Result.result(whatCopy);
-  }
-  if (options.recurseDeep) {
-    functions.push(recurseDeep);
-  }
-  if (options.autoCast) {
-    functions.push(autoCast);
-  }
-  if ("getters" in options && options.getters) {
-    functions.push(getters);
-  }
-  if (options.validate) {
-    if (options.validateWholeness === true) {
-      const wholenessError = validateWholeness(whatCopy, options.description);
-      if (wholenessError) {
-        return Result.error(wholenessError);
-      }
-    }
-    functions.push(validate);
-  }
-  if (options.cleanupReferences) {
-    functions.push(cleanupReferences);
-  }
-  if ("moveFiles" in options && options.moveFiles) {
-    functions.push(moveFiles);
-  }
-  let traverseError, validationError;
-  options.pipe = async (initialValue, ctx) => {
-    let value = initialValue;
-    for (const fn of functions) {
-      const { error: error2, result: result2 } = await fn(value, ctx);
-      if (error2) {
-        const narrowedError = error2;
-        switch (narrowedError) {
-          case TraverseError.InvalidDocumentId:
-          case TraverseError.InvalidTempfile:
-            traverseError = narrowedError;
-            break;
-          default: {
-            validationError = narrowedError;
-          }
-        }
-        return Result.error(error2);
-      }
-      value = ctx.target[ctx.propName] = result2;
-    }
-    return Result.result(value);
-  };
-  const { error, result } = await recurse(whatCopy, {
-    root: whatCopy,
-    property: description,
-    propPath: "",
-    options
-  });
-  if (error) {
-    return Result.error(error);
-  }
-  if (traverseError) {
-    return Result.error(traverseError);
-  }
-  if (validationError) {
-    if (isMissingPropertyError(validationError)) {
-      return Result.error(validationError);
-    }
-    return Result.error(makeValidationError({
-      code: ValidationErrorCode.InvalidProperties,
-      details: validationError
-    }));
-  }
-  return Result.result(result);
-};

package/dist/context.mjs

@@ -1,120 +0,0 @@
-"use strict";
-import { throwIfError, endpointError } from "@aeriajs/common";
-import { getCollections } from "@aeriajs/entrypoint";
-import { limitRate } from "@aeriajs/security";
-import { getDatabaseCollection } from "./database.mjs";
-import { preloadDescription } from "./collection/preload.mjs";
-const indepthCollection = (collectionName, collections, parentContext) => {
-  const candidate = collections[collectionName];
-  const collection = typeof candidate === "function" ? candidate() : candidate;
-  const proxiedFunctions = new Proxy({}, {
-    get: (_, functionName) => {
-      if (typeof functionName !== "string") {
-        throw new Error();
-      }
-      const fn = collection.functions?.[functionName];
-      if (!fn) {
-        return null;
-      }
-      return async (props, ...args) => {
-        const childContext = await createContext({
-          parentContext,
-          collectionName,
-          inherited: true
-        });
-        return fn(props, childContext, ...args);
-      };
-    }
-  });
-  return {
-    ...collection,
-    context: () => createContext({
-      parentContext,
-      collectionName
-    }),
-    functions: proxiedFunctions,
-    originalFunctions: collection.functions,
-    model: getDatabaseCollection(collectionName)
-  };
-};
-const isCollectionContext = (_context, collectionName) => {
-  return !!collectionName;
-};
-export const createContext = async (_options) => {
-  const options = _options || {};
-  const {
-    collectionName,
-    parentContext,
-    token = parentContext?.token || {
-      authenticated: false,
-      sub: null
-    }
-  } = options;
-  const { getCollectionAsset } = await import("./assets.mjs");
-  const collections = await getCollections();
-  let config;
-  if (options.config) {
-    config = options.config;
-  } else if (parentContext?.config) {
-    config = parentContext.config;
-  } else {
-    config = {
-      security: {
-        mutableUserProperties: []
-      }
-    };
-  }
-  let request = options.request, response = options.response, inherited = !!options.inherited;
-  if (parentContext) {
-    request ??= parentContext.request;
-    response ??= parentContext.response;
-    inherited ||= parentContext.inherited;
-  } else {
-    request ??= {};
-    response ??= {};
-  }
-  const context = {
-    token,
-    config,
-    inherited,
-    request,
-    response,
-    collections: new Proxy({}, {
-      get: (_, collectionName2) => {
-        if (typeof collectionName2 !== "string") {
-          throw new Error();
-        }
-        return indepthCollection(collectionName2, collections, context);
-      }
-    }),
-    log: async (message, details) => {
-      return getDatabaseCollection("log").insertOne({
-        message,
-        details,
-        context: collectionName,
-        owner: token.sub,
-        created_at: /* @__PURE__ */ new Date()
-      });
-    },
-    error: (httpStatus, error) => {
-      return endpointError(Object.assign({
-        httpStatus
-      }, error));
-    },
-    limitRate: (params) => {
-      return limitRate(params, context);
-    }
-  };
-  if (isCollectionContext(context, collectionName) && collectionName) {
-    const description = throwIfError(await getCollectionAsset(collectionName, "description"));
-    context.description = await preloadDescription(description);
-    context.collectionName = collectionName;
-    if (!options.calledFunction && parentContext && "calledFunction" in parentContext) {
-      context.calledFunction = parentContext.calledFunction;
-    } else {
-      context.calledFunction = options.calledFunction;
-    }
-    context.collection = indepthCollection(collectionName, collections, context);
-  }
-  return context;
-};

package/dist/database.mjs

@@ -1,49 +0,0 @@
-"use strict";
-import { getConfig } from "@aeriajs/entrypoint";
-import { inspect } from "node:util";
-import { MongoClient } from "mongodb";
-export {
-  ObjectId
-} from "mongodb";
-const dbMemo = {};
-export const getDatabase = async () => {
-  if (!dbMemo.db) {
-    const config = await getConfig();
-    const mongodbUri = await (async () => {
-      const envUri = config.database?.mongodbUrl;
-      if (!envUri) {
-        console.warn("mongo URI wasn't supplied, fallbacking to memory storage (this means your data will only be alive during runtime)");
-        const { MongoMemoryServer } = await import("mongodb-memory-server");
-        const mongod = await MongoMemoryServer.create();
-        return mongod.getUri();
-      }
-      return envUri;
-    })();
-    const logQueries = config.database?.logQueries || false;
-    const client = new MongoClient(mongodbUri, {
-      monitorCommands: logQueries
-    });
-    if (logQueries) {
-      client.on("commandStarted", (event) => {
-        console.debug(inspect(event, {
-          colors: true,
-          compact: false,
-          depth: Infinity
-        }));
-      });
-    }
-    dbMemo.client = client;
-    dbMemo.db = client.db();
-  }
-  return dbMemo;
-};
-export const getDatabaseSync = () => {
-  if (!dbMemo.db) {
-    throw new Error("getDatabaseSync() called with no active database");
-  }
-  return dbMemo.db;
-};
-export const getDatabaseCollection = (collectionName) => {
-  const db = getDatabaseSync();
-  return db.collection(collectionName);
-};

package/dist/endpoints.mjs

@@ -1,52 +0,0 @@
-"use strict";
-import { getCollections, getRouter, getAvailableRoles } from "@aeriajs/entrypoint";
-import { deepMerge } from "@aeriajs/common";
-import { isFunctionExposed, FunctionExposedStatus } from "./accessControl.mjs";
-import * as builtinFunctions from "./functions/index.mjs";
-export const getEndpoints = async () => {
-  const router = await getRouter();
-  const collections = await getCollections();
-  const functions = {};
-  for (const collectionName in collections) {
-    const candidate = collections[collectionName];
-    const collection = typeof candidate === "function" ? candidate() : candidate;
-    const {
-      description,
-      functions: collectionFunctions,
-      contracts,
-      exposedFunctions = {}
-    } = collection;
-    if (collectionFunctions) {
-      for (const fnName in collectionFunctions) {
-        const exposedStatus = await isFunctionExposed(collection, fnName);
-        if (exposedStatus !== FunctionExposedStatus.FunctionAccessible) {
-          continue;
-        }
-        const endpoint = `/${description.$id}/${fnName}`;
-        const exposed = exposedFunctions[fnName];
-        const roles = Array.isArray(exposed) ? exposed : exposed ? await getAvailableRoles() : [];
-        const endpointContracts = {
-          POST: null
-        };
-        if (roles.length) {
-          endpointContracts.POST ??= {};
-          endpointContracts.POST.roles = roles;
-        }
-        if (contracts && fnName in contracts) {
-          endpointContracts.POST ??= {};
-          Object.assign(endpointContracts.POST, contracts[fnName]);
-        }
-        if (fnName in builtinFunctions) {
-          endpointContracts.POST ??= {};
-          endpointContracts.POST.builtin = true;
-        }
-        functions[endpoint] = endpointContracts;
-      }
-    }
-  }
-  const result = deepMerge(
-    functions,
-    router?.routesMeta || {}
-  );
-  return result;
-};