@aeriajs/builtins 0.0.277 → 0.0.279

package/dist/collections/user/getRedefinePasswordLink.mjs

@@ -1,63 +0,0 @@
-"use strict";
-import { Result, HTTPStatus, resultSchema, functionSchemas, endpointErrorSchema, defineContract } from "@aeriajs/types";
-import { RedefinePasswordError } from "./redefinePassword.mjs";
-import { getActivationToken } from "./getActivationLink.mjs";
-export const getRedefinePasswordLinkContract = defineContract({
-  payload: {
-    type: "object",
-    required: ["userId"],
-    properties: {
-      userId: {
-        type: "string",
-        format: "objectid"
-      },
-      redirect: {
-        type: "string"
-      }
-    }
-  },
-  response: [
-    functionSchemas.getError(),
-    endpointErrorSchema({
-      httpStatus: [HTTPStatus.Forbidden],
-      code: [RedefinePasswordError.UserNotActive]
-    }),
-    resultSchema({
-      type: "object",
-      properties: {
-        url: {
-          type: "string"
-        }
-      }
-    })
-  ]
-});
-export const getRedefinePasswordLink = async (payload, context) => {
-  if (!context.config.webPublicUrl) {
-    throw new Error("config.webPublicUrl is not set");
-  }
-  const { error, result: user } = await context.collections.user.functions.get({
-    filters: {
-      _id: payload.userId
-    },
-    project: ["active"]
-  });
-  if (error) {
-    return Result.error(error);
-  }
-  if (!user.active) {
-    return context.error(HTTPStatus.Forbidden, {
-      code: RedefinePasswordError.UserNotActive
-    });
-  }
-  const redefineToken = await getActivationToken(payload.userId.toString(), context);
-  const url = new URL(`${context.config.webPublicUrl}/user/redefine-password`);
-  url.searchParams.set("step", "password"), url.searchParams.set("u", payload.userId.toString());
-  url.searchParams.set("t", redefineToken);
-  if (payload.redirect) {
-    url.searchParams.set("next", payload.redirect);
-  }
-  return Result.result({
-    url: url.toString()
-  });
-};

package/dist/collections/user/index.mjs

@@ -1,71 +0,0 @@
-"use strict";
-import { defineCollection, get, getAll, remove, upload, removeFile } from "@aeriajs/core";
-import { description } from "./description.mjs";
-import { authenticate, authenticateContract } from "./authenticate.mjs";
-import { activate, activateContract } from "./activate.mjs";
-import { insert } from "./insert.mjs";
-import { createAccount, createAccountContract } from "./createAccount.mjs";
-import { getInfo, getInfoContract } from "./getInfo.mjs";
-import { getCurrentUser, getCurrentUserContract } from "./getCurrentUser.mjs";
-import { getActivationLink, getActivationLinkContract } from "./getActivationLink.mjs";
-import { redefinePassword, redefinePasswordContract } from "./redefinePassword.mjs";
-import { getRedefinePasswordLink, getRedefinePasswordLinkContract } from "./getRedefinePasswordLink.mjs";
-import { editProfile, editProfileContract } from "./editProfile.mjs";
-const functions = {
-  get,
-  getAll,
-  remove,
-  upload,
-  removeFile,
-  insert,
-  editProfile,
-  authenticate,
-  activate,
-  createAccount,
-  getInfo,
-  getCurrentUser,
-  getActivationLink,
-  getRedefinePasswordLink,
-  redefinePassword
-};
-const exposedFunctions = {
-  get: true,
-  getAll: ["root"],
-  remove: ["root"],
-  upload: true,
-  removeFile: true,
-  insert: ["root"],
-  editProfile: true,
-  authenticate: "unauthenticated",
-  activate: [
-    "unauthenticated",
-    "root"
-  ],
-  createAccount: "unauthenticated",
-  getInfo: "unauthenticated",
-  getCurrentUser: true,
-  getActivationLink: ["root"],
-  getRedefinePasswordLink: ["root"],
-  redefinePassword: [
-    "unauthenticated",
-    "root"
-  ]
-};
-export const user = defineCollection({
-  description,
-  functions
-});
-Object.assign(user, {
-  exposedFunctions,
-  contracts: {
-    activate: activateContract,
-    authenticate: authenticateContract,
-    createAccount: createAccountContract,
-    editProfile: editProfileContract,
-    getActivationLink: getActivationLinkContract,
-    getCurrentUser: getCurrentUserContract,
-    getInfo: getInfoContract,
-    getRedefinePasswordLink: getRedefinePasswordLinkContract,
-    redefinePassword: redefinePasswordContract
-  }
-});

package/dist/collections/user/insert.mjs

@@ -1,70 +0,0 @@
-"use strict";
-import { HTTPStatus, ACError } from "@aeriajs/types";
-import { arraysIntersect } from "@aeriajs/common";
-import { ObjectId, insert as originalInsert } from "@aeriajs/core";
-import * as bcrypt from "bcryptjs";
-const isRoleAllowed = (targetRole, context) => {
-  if (!context.config.security.rolesHierarchy) {
-    return true;
-  }
-  if (!context.token.authenticated) {
-    throw new Error();
-  }
-  for (const role of context.token.roles) {
-    if (role in context.config.security.rolesHierarchy) {
-      const hierarchy = context.config.security.rolesHierarchy[role];
-      if (!hierarchy) {
-        continue;
-      }
-      if (hierarchy === true || hierarchy.includes(targetRole)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-export const insert = async (payload, context) => {
-  if (!context.token.authenticated) {
-    throw new Error();
-  }
-  if ("roles" in payload.what) {
-    if (context.config.security.rolesHierarchy) {
-      if (!arraysIntersect(context.token.roles, Object.keys(context.config.security.rolesHierarchy))) {
-        return context.error(HTTPStatus.Forbidden, {
-          code: ACError.AuthorizationError,
-          message: "user is not allowed to edit other users roles"
-        });
-      }
-      if (Array.isArray(payload.what.roles)) {
-        const allowed = payload.what.roles.every((role) => isRoleAllowed(role, context));
-        if (!allowed) {
-          return context.error(HTTPStatus.Forbidden, {
-            code: ACError.AuthorizationError,
-            message: "tried to set unallowed roles"
-          });
-        }
-      }
-    }
-  }
-  if ("_id" in payload.what && typeof payload.what._id === "string") {
-    const user = await context.collections.user.model.findOne({
-      _id: new ObjectId(payload.what._id)
-    });
-    if (!user) {
-      return context.error(HTTPStatus.NotFound, {
-        code: ACError.ResourceNotFound
-      });
-    }
-    const allowed = user.roles.every((role) => isRoleAllowed(role, context));
-    if (!allowed) {
-      return context.error(HTTPStatus.Forbidden, {
-        code: ACError.AuthorizationError,
-        message: "tried to edit an user with a role higher in the hierarchy"
-      });
-    }
-  }
-  if ("password" in payload.what && typeof payload.what.password === "string") {
-    payload.what.password = await bcrypt.hash(payload.what.password, 10);
-  }
-  return originalInsert(payload, context);
-};

package/dist/collections/user/redefinePassword.mjs

@@ -1,110 +0,0 @@
-"use strict";
-import { decodeToken, ObjectId } from "@aeriajs/core";
-import { Result, ACError, HTTPStatus, resultSchema, functionSchemas, endpointErrorSchema, defineContract } from "@aeriajs/types";
-import * as bcrypt from "bcryptjs";
-export const RedefinePasswordError = {
-  UserNotFound: "USER_NOT_FOUND",
-  UserNotActive: "USER_NOT_ACTIVE",
-  InvalidLink: "INVALID_LINK",
-  InvalidToken: "INVALID_TOKEN"
-};
-export const redefinePasswordContract = defineContract({
-  payload: {
-    type: "object",
-    required: [],
-    properties: {
-      userId: {
-        type: "string",
-        format: "objectid"
-      },
-      password: {
-        type: "string"
-      },
-      token: {
-        type: "string"
-      }
-    }
-  },
-  response: [
-    functionSchemas.getError(),
-    endpointErrorSchema({
-      httpStatus: [
-        HTTPStatus.NotFound,
-        HTTPStatus.Forbidden,
-        HTTPStatus.Unauthorized,
-        HTTPStatus.UnprocessableContent
-      ],
-      code: [
-        ACError.MalformedInput,
-        RedefinePasswordError.InvalidLink,
-        RedefinePasswordError.InvalidToken,
-        RedefinePasswordError.UserNotFound,
-        RedefinePasswordError.UserNotActive
-      ]
-    }),
-    resultSchema({
-      type: "object",
-      properties: {
-        userId: {
-          type: "string",
-          format: "objectid"
-        }
-      }
-    })
-  ]
-});
-export const redefinePassword = async (payload, context) => {
-  const {
-    userId,
-    token,
-    password
-  } = payload;
-  if (!context.config.secret) {
-    throw new Error("config.secret is not set");
-  }
-  if (!userId || !token) {
-    return context.error(HTTPStatus.NotFound, {
-      code: RedefinePasswordError.InvalidLink
-    });
-  }
-  const user = await context.collection.model.findOne({
-    _id: new ObjectId(userId)
-  }, {
-    projection: {
-      password: 1,
-      active: 1
-    }
-  });
-  if (!user) {
-    return context.error(HTTPStatus.NotFound, {
-      code: RedefinePasswordError.UserNotFound
-    });
-  }
-  if (!user.active) {
-    return context.error(HTTPStatus.Forbidden, {
-      code: RedefinePasswordError.UserNotActive
-    });
-  }
-  const decoded = await decodeToken(token, context.config.secret);
-  if (!decoded) {
-    return context.error(HTTPStatus.Unauthorized, {
-      code: RedefinePasswordError.InvalidToken
-    });
-  }
-  if (!password) {
-    return context.error(HTTPStatus.UnprocessableContent, {
-      code: ACError.MalformedInput
-    });
-  }
-  await context.collection.model.updateOne({
-    _id: user._id
-  }, {
-    $set: {
-      active: true,
-      password: await bcrypt.hash(password, 10)
-    }
-  });
-  return Result.result({
-    userId: user._id
-  });
-};

package/dist/functions/describe.mjs

@@ -1,95 +0,0 @@
-"use strict";
-import { createContext, preloadDescription, getEndpoints } from "@aeriajs/core";
-import { getCollections, getAvailableRoles } from "@aeriajs/entrypoint";
-import { Result, ACError, HTTPStatus } from "@aeriajs/types";
-import { serialize, endpointError, isValidCollection } from "@aeriajs/common";
-import { validator } from "@aeriajs/validation";
-import { authenticate } from "../collections/user/authenticate.mjs";
-const [Payload, validatePayload] = validator({
-  type: "object",
-  required: [],
-  additionalProperties: true,
-  properties: {
-    collections: {
-      type: "array",
-      items: {
-        type: "string"
-      }
-    },
-    noSerialize: {
-      type: "boolean"
-    },
-    revalidate: {
-      type: "boolean"
-    },
-    roles: {
-      type: "boolean"
-    },
-    router: {
-      type: "boolean"
-    }
-  }
-});
-export const describe = async (contextOrPayload) => {
-  const result = {
-    descriptions: {}
-  };
-  let props;
-  if ("request" in contextOrPayload) {
-    const { error, result: validatedPayload } = validatePayload(contextOrPayload.request.payload);
-    if (error) {
-      return endpointError({
-        httpStatus: HTTPStatus.UnprocessableContent,
-        code: ACError.MalformedInput,
-        details: error
-      });
-    }
-    props = validatedPayload;
-  } else {
-    props = contextOrPayload;
-  }
-  if ("request" in contextOrPayload && props.revalidate) {
-    const { error, result: auth } = await authenticate({
-      revalidate: true
-    }, await createContext({
-      collectionName: "user",
-      parentContext: contextOrPayload
-    }));
-    if (error) {
-      return Result.error(error);
-    }
-    result.auth = JSON.parse(JSON.stringify(auth));
-  }
-  const collections = await getCollections();
-  const retrievedCollections = props.collections?.length ? Object.fromEntries(Object.entries(collections).filter(([key]) => props.collections.includes(key))) : collections;
-  const descriptions = {};
-  result.descriptions = descriptions;
-  for (const collectionName in retrievedCollections) {
-    const candidate = retrievedCollections[collectionName];
-    const collection = typeof candidate === "function" ? candidate() : candidate;
-    if (!isValidCollection(collection)) {
-      throw new Error(`The "${collectionName}" symbol exported from the entrypoint doesn't seem like a valid collection. Make sure only collections are exported from the "import('.').collections".`);
-    }
-    const { description: rawDescription } = collection;
-    const description = await preloadDescription(rawDescription);
-    descriptions[description.$id] = description;
-  }
-  if (props.roles) {
-    const userCandidate = collections.user;
-    const userCollection = typeof userCandidate === "function" ? userCandidate() : userCandidate;
-    const userRolesProperty = userCollection.description.properties.roles;
-    const userRoles = "enum" in userRolesProperty.items ? userRolesProperty.items.enum : [];
-    result.roles = Array.from(new Set(userRoles.concat(await getAvailableRoles())));
-    if ("config" in contextOrPayload) {
-      result.rolesHierarchy = contextOrPayload.config.security.rolesHierarchy;
-    }
-  }
-  if (props.router) {
-    result.router = await getEndpoints();
-  }
-  if (props.noSerialize || !("response" in contextOrPayload)) {
-    return Result.result(result);
-  }
-  contextOrPayload.response.setHeader("content-type", "application/bson");
-  return contextOrPayload.response.end(serialize(result));
-};

package/dist/functions/index.mjs

@@ -1,2 +0,0 @@
-"use strict";
-export * from "./describe.mjs";

package/dist/index.mjs

@@ -1,21 +0,0 @@
-"use strict";
-export * as builtinFunctions from "./functions/index.mjs";
-export * from "./collections/index.mjs";
-export * from "./authentication.mjs";
-export {
-  insert as insertUser
-} from "./collections/user/insert.mjs";
-import {
-  file,
-  tempFile,
-  log,
-  resourceUsage,
-  user
-} from "./collections/index.mjs";
-export const collections = {
-  file,
-  tempFile,
-  log,
-  resourceUsage,
-  user
-};