@aeriajs/builtins 0.0.276 → 0.0.278

package/dist/authentication.mjs

@@ -1,58 +0,0 @@
-"use strict";
-import { signToken } from "@aeriajs/core";
-export const AuthenticationError = {
-  InvalidCredentials: "INVALID_CREDENTIALS",
-  InactiveUser: "INACTIVE_USER"
-};
-export const successfulAuthentication = async (user, context) => {
-  const tokenContent = {
-    sub: user._id,
-    roles: user.roles,
-    picture: user.picture,
-    userinfo: {}
-  };
-  if (context.config.security.authenticationRateLimiting) {
-  }
-  if (context.config.security.logSuccessfulAuthentications) {
-    await context.log("successful authentication", {
-      email: user.email,
-      roles: user.roles,
-      _id: user._id
-    });
-  }
-  if (context.config.tokenUserProperties) {
-    const userinfo = {};
-    for (const prop of context.config.tokenUserProperties) {
-      userinfo[prop] = user[prop];
-    }
-    tokenContent.userinfo = userinfo;
-  }
-  const token = await signToken(tokenContent);
-  return {
-    user,
-    token: {
-      type: "bearer",
-      content: token
-    }
-  };
-};
-export const defaultSuccessfulAuthentication = async () => {
-  const token = await signToken({
-    sub: null,
-    roles: ["root"],
-    userinfo: {}
-  });
-  return {
-    user: {
-      _id: null,
-      name: "God Mode",
-      email: "",
-      roles: ["root"],
-      active: true
-    },
-    token: {
-      type: "bearer",
-      content: token
-    }
-  };
-};

package/dist/collections/file/description.mjs

@@ -1,75 +0,0 @@
-"use strict";
-import { ObjectId } from "mongodb";
-import { defineDescription } from "@aeriajs/core";
-import { getConfig } from "@aeriajs/entrypoint";
-const timestamp = (lastModified) => lastModified instanceof Date ? new Date(lastModified).getTime() : "fresh";
-export const getFileLink = async (fileId) => {
-  const config = await getConfig();
-  return `${config.publicUrl || ""}/file/${fileId}`;
-};
-export const description = defineDescription({
-  $id: "file",
-  icon: "paperclip",
-  owned: "always",
-  presets: ["owned"],
-  indexes: [
-    "name",
-    "link",
-    "type",
-    "size"
-  ],
-  properties: {
-    type: {
-      type: "string"
-    },
-    size: {
-      type: "number"
-    },
-    last_modified: {
-      type: "string",
-      format: "date-time"
-    },
-    name: {
-      type: "string"
-    },
-    absolute_path: {
-      type: "string"
-    },
-    relative_path: {
-      type: "string"
-    },
-    immutable: {
-      type: "boolean"
-    },
-    link: {
-      type: "getter",
-      getter: async (doc) => {
-        if ("_id" in doc && "last_modified" in doc && doc._id instanceof ObjectId) {
-          return `${await getFileLink(doc._id)}/${timestamp(doc.last_modified)}`;
-        }
-      }
-    },
-    download_link: {
-      type: "getter",
-      getter: async (doc) => {
-        if ("_id" in doc && "last_modified" in doc && doc._id instanceof ObjectId) {
-          return `${await getFileLink(doc._id)}/download/${timestamp(doc.last_modified)}`;
-        }
-      }
-    }
-  },
-  actions: {
-    deleteAll: {
-      label: "Remover",
-      ask: true,
-      selection: true
-    }
-  },
-  individualActions: {
-    remove: {
-      label: "Remover",
-      icon: "trash",
-      ask: true
-    }
-  }
-});

package/dist/collections/file/download.mjs

@@ -1,115 +0,0 @@
-"use strict";
-import { HTTPStatus, ACError, defineContract, endpointErrorSchema } from "@aeriajs/types";
-import { ObjectId } from "@aeriajs/core";
-import * as fs from "node:fs";
-export const DownloadError = {
-  RangeNotSatisfiable: "RANGE_NOT_SATISFIABLE"
-};
-export const downloadContract = defineContract({
-  payload: {
-    type: "object",
-    required: ["fileId"],
-    properties: {
-      fileId: {
-        type: "string"
-      },
-      options: {
-        type: "array",
-        items: {
-          enum: [
-            "picture",
-            "download"
-          ]
-        }
-      },
-      noHeaders: {
-        type: "boolean"
-      }
-    }
-  },
-  response: [
-    endpointErrorSchema({
-      httpStatus: [
-        HTTPStatus.NotFound,
-        HTTPStatus.RangeNotSatisfiable
-      ],
-      code: [
-        ACError.ResourceNotFound,
-        DownloadError.RangeNotSatisfiable
-      ]
-    }),
-    {
-      type: "object",
-      additionalProperties: true
-    }
-  ]
-});
-export const download = async (payload, context) => {
-  const { fileId, options = [] } = payload;
-  const file = await context.collection.model.findOne({
-    _id: new ObjectId(fileId)
-  }, {
-    projection: {
-      absolute_path: 1,
-      name: 1,
-      type: 1
-    }
-  });
-  if (!file) {
-    if (!payload.noHeaders) {
-      context.response.writeHead(HTTPStatus.NotFound, {
-        "content-type": "application/json"
-      });
-    }
-    return context.error(HTTPStatus.NotFound, {
-      code: ACError.ResourceNotFound
-    });
-  }
-  let stat;
-  try {
-    stat = await fs.promises.stat(file.absolute_path);
-  } catch (e) {
-    context.response.writeHead(404, {
-      "content-type": "application/json"
-    });
-    return context.error(HTTPStatus.NotFound, {
-      code: ACError.ResourceNotFound
-    });
-  }
-  const range = context.request.headers.range;
-  if (typeof range === "string") {
-    const parts = range.replace(/bytes=/, "").split("-");
-    const start = parseInt(parts[0]);
-    const end = parts[1] ? parseInt(parts[1]) : stat.size - 1;
-    if (start >= stat.size || end >= stat.size) {
-      context.response.writeHead(HTTPStatus.RangeNotSatisfiable, {
-        "content-type": "application/json",
-        "content-range": `bytes */${stat.size}`
-      });
-      return context.error(HTTPStatus.RangeNotSatisfiable, {
-        code: DownloadError.RangeNotSatisfiable
-      });
-    }
-    const chunkSize = end - start + 1;
-    if (!payload.noHeaders) {
-      context.response.writeHead(206, {
-        "accept-ranges": "bytes",
-        "content-range": `bytes ${start}-${end}/${stat.size}`,
-        "content-length": chunkSize,
-        "content-type": file.type,
-        "content-disposition": `${options.includes("download") ? "attachment; " : ""}name=${encodeURI(file.name)}`
-      });
-    }
-    return fs.createReadStream(file.absolute_path, {
-      start,
-      end
-    });
-  }
-  if (!payload.noHeaders) {
-    context.response.writeHead(HTTPStatus.Ok, {
-      "content-type": file.type,
-      "content-disposition": `${options.includes("download") ? "attachment; " : ""}name=${encodeURI(file.name)}`
-    });
-  }
-  return fs.createReadStream(file.absolute_path);
-};

package/dist/collections/file/index.mjs

@@ -1,59 +0,0 @@
-"use strict";
-import { defineCollection, get } from "@aeriajs/core";
-import { description } from "./description.mjs";
-import { insert } from "./insert.mjs";
-import { download, downloadContract } from "./download.mjs";
-import { remove } from "./remove.mjs";
-import { removeAll } from "./removeAll.mjs";
-export const tempFile = defineCollection({
-  description: {
-    $id: "tempFile",
-    icon: "file",
-    hidden: true,
-    temporary: {
-      index: "created_at",
-      expireAfterSeconds: 3600
-    },
-    properties: {
-      created_at: {
-        type: "string",
-        format: "date-time"
-      },
-      absolute_path: {
-        type: "string"
-      },
-      size: {
-        type: "number"
-      },
-      mime: {
-        type: "number"
-      },
-      collection: {
-        type: "string"
-      },
-      filename: {
-        type: "string"
-      }
-    }
-  }
-});
-export const file = defineCollection({
-  description,
-  functions: {
-    get,
-    insert,
-    download,
-    remove,
-    removeAll
-  },
-  exposedFunctions: {
-    get: "unauthenticated",
-    insert: true,
-    download: "unauthenticated",
-    remove: true,
-    removeAll: true
-  },
-  contracts: {
-    download: downloadContract
-  }
-});

package/dist/collections/file/insert.mjs

@@ -1,44 +0,0 @@
-"use strict";
-import { createHash } from "node:crypto";
-import { writeFile, unlink } from "node:fs/promises";
-import { insert as originalInsert } from "@aeriajs/core";
-export const insert = async (payload, context) => {
-  if (!context.token.authenticated) {
-    throw new Error("");
-  }
-  const { content, ...what } = Object.assign({}, payload.what);
-  if (context.token.sub) {
-    what.owner = context.token.sub;
-  }
-  const extension = what.name.split(".").at(-1);
-  if (!context.config.storage) {
-    throw new Error("config.storage is not set");
-  }
-  const tempPath = context.config.storage.tempFs || context.config.storage.fs;
-  if (!tempPath) {
-    throw new Error("config.storage.fs and config.storage.tempFs are not set");
-  }
-  if (!extension) {
-    throw new Error("filename lacks extension");
-  }
-  const oldFile = await context.collection.model.findOne(
-    {
-      _id: payload.what._id
-    },
-    {
-      projection: {
-        absolute_path: 1
-      }
-    }
-  );
-  if (oldFile && oldFile.absolute_path) {
-    await unlink(oldFile.absolute_path).catch(console.trace);
-  }
-  const filenameHash = createHash("sha1").update(what.name + Date.now()).digest("hex");
-  what.absolute_path = `${tempPath}/${filenameHash}.${extension}`;
-  await writeFile(what.absolute_path, Buffer.from(content.split(",").at(-1), "base64"));
-  return originalInsert({
-    ...payload,
-    what
-  }, context);
-};

package/dist/collections/file/remove.mjs

@@ -1,21 +0,0 @@
-"use strict";
-import { Result } from "@aeriajs/types";
-import { remove as originalRemove, get } from "@aeriajs/core";
-import * as fs from "node:fs/promises";
-export const remove = async (payload, context) => {
-  const { error, result: file } = await get({
-    filters: {
-      _id: payload.filters._id
-    },
-    project: ["absolute_path"]
-  }, context);
-  if (error) {
-    return Result.error(error);
-  }
-  try {
-    await fs.unlink(file.absolute_path);
-  } catch (err) {
-    console.trace(err);
-  }
-  return originalRemove(payload, context);
-};

package/dist/collections/file/removeAll.mjs

@@ -1,22 +0,0 @@
-"use strict";
-import { ObjectId, removeAll as originalRemoveAll } from "@aeriajs/core";
-import * as fs from "node:fs/promises";
-export const removeAll = async (payload, context) => {
-  const files = context.collection.model.find({
-    _id: {
-      $in: payload.filters.map((oid) => new ObjectId(oid))
-    }
-  }, {
-    projection: {
-      absolute_path: 1
-    }
-  });
-  for await (const file of files) {
-    try {
-      await fs.unlink(file.absolute_path);
-    } catch (err) {
-      console.trace(err);
-    }
-  }
-  return originalRemoveAll(payload, context);
-};

package/dist/collections/index.mjs

@@ -1,5 +0,0 @@
-"use strict";
-export * from "./file/index.mjs";
-export * from "./log/index.mjs";
-export * from "./resourceUsage/index.mjs";
-export * from "./user/index.mjs";

package/dist/collections/log/index.mjs

@@ -1,55 +0,0 @@
-"use strict";
-import { defineCollection, get, getAll, insert } from "@aeriajs/core";
-export const log = defineCollection({
-  description: {
-    $id: "log",
-    icon: "magnifying-glass",
-    required: [
-      "context",
-      "message"
-    ],
-    table: [
-      "owner",
-      "context",
-      "message",
-      "created_at"
-    ],
-    properties: {
-      owner: {
-        // don't use "owned: true", we want it this way
-        $ref: "user",
-        noForm: true
-      },
-      context: {
-        type: "string"
-      },
-      message: {
-        type: "string"
-      },
-      details: {
-        type: "object",
-        additionalProperties: true
-      },
-      created_at: {
-        type: "string",
-        format: "date-time"
-      }
-    },
-    presets: ["view"],
-    filters: [
-      "context",
-      "message",
-      "owner"
-    ]
-  },
-  functions: {
-    get,
-    getAll,
-    insert
-  },
-  exposedFunctions: {
-    get: true,
-    getAll: true,
-    insert: true
-  }
-});

package/dist/collections/resourceUsage/index.mjs

@@ -1,39 +0,0 @@
-"use strict";
-import { defineCollection } from "@aeriajs/core";
-export const resourceUsage = defineCollection({
-  description: {
-    $id: "resourceUsage",
-    icon: "wrench",
-    required: ["usage"],
-    properties: {
-      user: {
-        $ref: "user"
-      },
-      address: {
-        type: "string"
-      },
-      usage: {
-        type: "object",
-        additionalProperties: {
-          type: "object",
-          properties: {
-            hits: {
-              type: "integer"
-            },
-            points: {
-              type: "integer"
-            },
-            last_reach: {
-              type: "string",
-              format: "date-time"
-            },
-            last_maximum_reach: {
-              type: "string",
-              format: "date-time"
-            }
-          }
-        }
-      }
-    }
-  }
-});

package/dist/collections/user/activate.mjs

@@ -1,119 +0,0 @@
-"use strict";
-import { decodeToken, ObjectId } from "@aeriajs/core";
-import { Result, ACError, HTTPStatus, defineContract, resultSchema, endpointErrorSchema } from "@aeriajs/types";
-import * as bcrypt from "bcryptjs";
-export const ActivationError = {
-  UserNotFound: "USER_NOT_FOUND",
-  AlreadyActiveUser: "ALREADY_ACTIVE_USER",
-  InvalidLink: "INVALID_LINK",
-  InvalidToken: "INVALID_TOKEN"
-};
-export const activateContract = defineContract({
-  payload: {
-    type: "object",
-    required: [],
-    properties: {
-      password: {
-        type: "string"
-      },
-      userId: {
-        type: "string"
-      },
-      token: {
-        type: "string"
-      }
-    }
-  },
-  response: [
-    endpointErrorSchema({
-      httpStatus: [
-        HTTPStatus.NotFound,
-        HTTPStatus.Forbidden,
-        HTTPStatus.Unauthorized,
-        HTTPStatus.UnprocessableContent
-      ],
-      code: [
-        ACError.ResourceNotFound,
-        ACError.MalformedInput,
-        ActivationError.AlreadyActiveUser,
-        ActivationError.InvalidLink,
-        ActivationError.InvalidToken,
-        ActivationError.UserNotFound
-      ]
-    }),
-    resultSchema({
-      type: "object",
-      properties: {
-        userId: {
-          type: "string",
-          format: "objectid"
-        }
-      }
-    })
-  ]
-});
-export const activate = 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: ActivationError.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: ActivationError.UserNotFound
-    });
-  }
-  if (user.active) {
-    return context.error(HTTPStatus.Forbidden, {
-      code: ActivationError.AlreadyActiveUser
-    });
-  }
-  const decoded = await decodeToken(token, context.config.secret);
-  if (!decoded) {
-    return context.error(HTTPStatus.Unauthorized, {
-      code: ActivationError.InvalidToken
-    });
-  }
-  if (!user.password) {
-    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)
-      }
-    });
-  } else {
-    await context.collection.model.updateOne({
-      _id: user._id
-    }, {
-      $set: {
-        active: true
-      }
-    });
-  }
-  return Result.result({
-    userId: user._id
-  });
-};