@lobb-js/core 0.13.0

package/src/api/collections/CollectionControllers.ts

@@ -0,0 +1,485 @@
+import type { Context } from "hono";
+import type { CollectionControllers } from "../../types/index.ts";
+import type { ExposedManyServiceOutput } from "./CollectionService.ts";
+
+import qs from "qs";
+import { LobbError } from "../../LobbError.ts";
+import { Lobb } from "../../Lobb.ts";
+import { transactions } from "./transactions.ts";
+
+export const collectionControllers: CollectionControllers = {
+  async createOne(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.createOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.createOne.override", {
+        collectionName: collectionName,
+        body: body,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    // this needs to be prior to the body data check
+    (await Lobb.instance.eventSystem.emit("core.controllers.preCreateOne", {
+      collectionName: collectionName,
+      body: body,
+      context: c,
+    })) as ExposedManyServiceOutput;
+
+    if (!body.data) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "The request payload must include a (data) property",
+      });
+    }
+
+    if (Array.isArray(body.data)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          "The (data) property must be an object, not an array. Use the /many endpoint to create multiple records.",
+      });
+    }
+
+    const result = await Lobb.instance.collectionService.createOne({
+      collectionName,
+      context: c,
+      data: body.data,
+      triggeredBy: "API",
+    });
+
+    return c.json(result, 201);
+  },
+  async findAll(c: Context) {
+    const collectionName = param(c, "collectionName");
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `This collection is a singleton. (findAll) is not supported.`,
+      });
+    }
+
+    let params;
+    if (c.req.method === "POST") {
+      params = await Lobb.instance.utils.getRequestBody(c);
+    } else {
+      params = parseUrlQuery(c.req.url);
+    }
+
+    await Lobb.instance.eventSystem.emit(
+      "core.controllers.preFindAll",
+      {
+        collectionName: collectionName,
+        context: c,
+      },
+    );
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.findAll.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.findAll.override", {
+        collectionName,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    let result = await Lobb.instance.collectionService.findAll({
+      collectionName,
+      context: c,
+      params,
+      triggeredBy: "API",
+    });
+
+    const eventResult = await Lobb.instance.eventSystem.emit(
+      "core.controllers.findAll",
+      {
+        collectionName: collectionName,
+        response: result,
+        context: c,
+      },
+    );
+
+    if (eventResult) {
+      result = eventResult.response;
+    }
+
+    return c.json(result);
+  },
+  async findOne(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const id = param(c, "id");
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `This collection is a singleton. (findOne) is not supported.`,
+      });
+    }
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.findOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.findOne.override", {
+        collectionName: collectionName,
+        id: id,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const eventResult = await Lobb.instance.eventSystem.emit(
+      "core.controllers.preFindOne",
+      {
+        collectionName: collectionName,
+        id: id,
+        context: c,
+      },
+    );
+
+    const result = await Lobb.instance.collectionService.findOne({
+      collectionName,
+      context: c,
+      id: id,
+      triggeredBy: "API",
+    });
+
+    if (!result.data) {
+      throw new LobbError({
+        code: "NOT_FOUND",
+        message: `The record is not found`,
+      });
+    }
+
+    return c.json(result);
+  },
+  async updateOne(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const id = param(c, "id");
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `This collection is a singleton. (updateOne) is not supported.`,
+      });
+    }
+
+    if (!body.data) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "The request payload must include a (data) property",
+      });
+    }
+
+    if (body.data.id) {
+      throw new LobbError({
+        code: "FORBIDDEN",
+        message: `Updating the ID proprety is not allowed.`,
+      });
+    }
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.updateOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.updateOne.override", {
+        collectionName,
+        id,
+        body,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const result = await Lobb.instance.collectionService.updateOne({
+      collectionName,
+      context: c,
+      id,
+      data: body.data,
+      triggeredBy: "API",
+    });
+    return c.json(result, 200);
+  },
+  async deleteOne(c: Context) {
+    const id = param(c, "id");
+    const collectionName = param(c, "collectionName");
+    const force = c.req.query("force") !== undefined;
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `This collection is a singleton. (deleteOne) is not supported.`,
+      });
+    }
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.deleteOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.deleteOne.override", {
+        collectionName,
+        id,
+        force,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const result = await Lobb.instance.collectionService.deleteOne({
+      collectionName,
+      context: c,
+      id,
+      force,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+  async deleteMany(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const force = c.req.query("force") !== undefined;
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `This collection is a singleton. (deleteMany) is not supported.`,
+      });
+    }
+
+    (await Lobb.instance.eventSystem.emit("core.controllers.preDeleteMany", {
+      collectionName: collectionName,
+      body: body,
+      context: c,
+    })) as ExposedManyServiceOutput;
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.deleteMany.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.deleteMany.override", {
+        collectionName,
+        body,
+        force,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    if (!body.filter) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "You need to provide the filter object",
+      });
+    }
+
+    const result = await Lobb.instance.collectionService.deleteMany({
+      collectionName,
+      context: c,
+      filter: body.filter,
+      force,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+  async updateMany(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `This collection is a singleton. (updateMany) is not supported.`,
+      });
+    }
+
+    if (!body.filter) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "You need to provide the filter object",
+      });
+    } else if (!body.data) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "You need to provide the data object",
+      });
+    }
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.updateMany.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.updateMany.override", {
+        collectionName,
+        body,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const result = await Lobb.instance.collectionService.updateMany({
+      collectionName,
+      context: c,
+      data: body.data,
+      filter: body.filter,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+  async createMany(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (Lobb.instance.configManager.isCollectionSingleton(collectionName)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message:
+          `This collection is a singleton. (createMany) is not supported.`,
+      });
+    }
+
+    if (!body.data) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "You need to provide the data object",
+      });
+    }
+
+    if (!Array.isArray(body.data)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "The data object needs to be an array",
+      });
+    }
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.createMany.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.createMany.override", {
+        collectionName,
+        body,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const result = await Lobb.instance.collectionService.createMany({
+      collectionName,
+      context: c,
+      data: body.data,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+  async readSingleton(c: Context) {
+    const collectionName = param(c, "collectionName");
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.readSingleton.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.readSingleton.override", {
+        collectionName,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const result = await Lobb.instance.collectionService.readSingleton({
+      collectionName,
+      context: c,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+  async updateSingleton(c: Context) {
+    const collectionName = param(c, "collectionName");
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (!body?.data) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "You need to provide the data object",
+      });
+    }
+
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.controllers.updateSingleton.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.controllers.updateSingleton.override", {
+        collectionName,
+        body,
+        context: c,
+      }));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    const result = await Lobb.instance.collectionService.updateSingleton({
+      collectionName,
+      context: c,
+      data: body.data,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+  async transactions(c: Context) {
+    const rollback: boolean = c.req.query("rollback") !== undefined;
+    const body = await Lobb.instance.utils.getRequestBody(c);
+
+    if (!body) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "You need to provide the body",
+      });
+    }
+
+    if (!Array.isArray(body)) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: "The body should be an array",
+      });
+    }
+
+    const result = await transactions({
+      body,
+      rollback,
+      context: c,
+      triggeredBy: "API",
+    });
+
+    return c.json(result);
+  },
+};
+
+export function param(c: Context, paramName: string) {
+  return c.req.param(paramName) ?? c.get(paramName);
+}
+
+export function parseUrlQuery(url: string) {
+  const arr = url.split("?");
+  if (arr[1]) {
+    const queryString = arr[1];
+    return qs.parse(queryString);
+  }
+  return {};
+}

package/src/api/collections/CollectionService.ts

@@ -0,0 +1,162 @@
+import type { MassReturn } from "../../types/index.ts";
+
+import type {
+  ExposedServiceOutput,
+  ExposedManyServiceOutput,
+  TriggeredBy,
+  CollectionStore,
+} from "./collectionStore.ts";
+import { Lobb } from "../../Lobb.ts";
+
+export type { ExposedServiceOutput, ExposedManyServiceOutput, TriggeredBy };
+
+export type ServiceOp<TInput = unknown, TOutput = unknown> = {
+  input: TInput;
+  output: TOutput;
+};
+
+type P<M extends keyof CollectionStore> = Parameters<CollectionStore[M]>[0];
+type WithCollection<T> = T & { collectionName: string };
+type Without<M extends keyof CollectionStore> = Omit<P<M>, "collectionName">;
+
+export class CollectionService {
+  public async findAll<
+    T extends ServiceOp = ServiceOp<Without<"findAll">, ExposedManyServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.findAll.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.findAll.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.findAll(props) as Promise<T["output"]>;
+  }
+
+  public async findOne<
+    T extends ServiceOp = ServiceOp<Without<"findOne">, ExposedServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.findOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.findOne.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.findOne(props as unknown as P<"findOne">) as Promise<T["output"]>;
+  }
+
+  public async createOne<
+    T extends ServiceOp = ServiceOp<Without<"createOne">, ExposedServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.createOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.createOne.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.createOne(props as unknown as P<"createOne">) as Promise<T["output"]>;
+  }
+
+  public async updateOne<
+    T extends ServiceOp = ServiceOp<Without<"updateOne">, ExposedServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.updateOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.updateOne.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.updateOne(props as unknown as P<"updateOne">) as Promise<T["output"]>;
+  }
+
+  public async deleteOne<
+    T extends ServiceOp = ServiceOp<Without<"deleteOne">, ExposedServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.deleteOne.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.deleteOne.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.deleteOne(props as unknown as P<"deleteOne">) as Promise<T["output"]>;
+  }
+
+  public async readSingleton<
+    T extends ServiceOp = ServiceOp<Without<"readSingleton">, ExposedServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.readSingleton.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.readSingleton.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.readSingleton(props as unknown as P<"readSingleton">) as Promise<T["output"]>;
+  }
+
+  public async updateSingleton<
+    T extends ServiceOp = ServiceOp<Without<"updateSingleton">, ExposedServiceOutput>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.updateSingleton.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.updateSingleton.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.updateSingleton(props as unknown as P<"updateSingleton">) as Promise<T["output"]>;
+  }
+
+  public async deleteMany<
+    T extends ServiceOp = ServiceOp<Without<"deleteMany">, MassReturn>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.deleteMany.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.deleteMany.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.deleteMany(props as unknown as P<"deleteMany">) as Promise<T["output"]>;
+  }
+
+  public async updateMany<
+    T extends ServiceOp = ServiceOp<Without<"updateMany">, MassReturn>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.updateMany.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.updateMany.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.updateMany(props as unknown as P<"updateMany">) as Promise<T["output"]>;
+  }
+
+  public async createMany<
+    T extends ServiceOp = ServiceOp<Without<"createMany">, MassReturn>,
+  >(props: WithCollection<T["input"]>): Promise<T["output"]> {
+    if (Lobb.instance.eventSystem.eventHasSubscribers("core.service.createMany.override")) {
+      const result = (await Lobb.instance.eventSystem.emit("core.service.createMany.override", props));
+
+      if (result) {
+        return result;
+      }
+    }
+
+    return Lobb.instance.collectionStore.createMany(props as unknown as P<"createMany">) as Promise<T["output"]>;
+  }
+}