@lobb-js/core 0.13.0

package/src/api/collections/collectionStore.ts

@@ -0,0 +1,647 @@
+import type { FindAllParamsInput } from "../../types/index.ts";
+import type { DatabaseDriver } from "../../types/index.ts";
+import type { MassReturn } from "../../types/index.ts";
+import type { PoolClient } from "pg";
+import type { Context as HonoContext } from "hono";
+
+import { findAllParamsSchema } from "../../types/index.ts";
+import { ZodError } from "zod";
+import { LobbError } from "../../LobbError.ts";
+import { Lobb } from "../../Lobb.ts";
+import { beginTransaction } from "./transactions.ts";
+
+export interface ExposedServiceOutput {
+  data: any;
+  meta?: any;
+}
+
+export interface ExposedManyServiceOutput {
+  data: any[];
+  meta?: any;
+}
+
+export type TriggeredBy = "INTERNAL" | "API";
+
+export class CollectionStore {
+  private get dbDriver(): DatabaseDriver {
+    return Lobb.instance.databaseService.getDriver();
+  }
+
+  public async findAll({
+    collectionName,
+    params,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    params?: FindAllParamsInput;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<ExposedManyServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        const eventResult = await Lobb.instance.eventSystem.emit(
+          `core.store.preFindAll`,
+          {
+            collectionName: collectionName,
+            params: params,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        );
+
+        if (eventResult.filter) {
+          if (!params) {
+            params = {};
+          }
+          if (params.filter) {
+            params.filter = {
+              $and: [
+                params.filter,
+                eventResult.filter,
+              ],
+            };
+          } else {
+            params.filter = eventResult.filter;
+          }
+        }
+
+        if (params?.filter) {
+          params.filter = {
+            $and: [params.filter],
+          };
+
+          params.filter = Lobb.instance.utils.renderTemplateDeep(
+            params.filter,
+            {
+              ctx: context,
+            },
+          );
+        }
+
+        const parsedParams = findAllParamsSchema.parse(params);
+
+        try {
+          const result = await this.dbDriver.findAll(
+            collectionName,
+            parsedParams,
+            client,
+          );
+
+          result.data = (await Lobb.instance.eventSystem.emit(
+            `core.store.findAll`,
+            {
+              data: result.data,
+              params: params,
+              collectionName: collectionName,
+              context: context,
+              triggeredBy: triggeredBy,
+              transaction: client,
+            },
+          )).data;
+
+          return result;
+        } catch (error: any) {
+          if (error instanceof ZodError) {
+            throw new LobbError({
+              code: "BAD_REQUEST",
+              message: "Invalid query schema",
+              details: error.errors[0],
+            });
+          }
+
+          throw error;
+        }
+      },
+      client,
+    );
+  }
+
+  public async findOne({
+    collectionName,
+    id,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    id: string;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<ExposedServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        const eventResult: any = await Lobb.instance.eventSystem.emit(
+          `core.store.preFindOne`,
+          {
+            collectionName: collectionName,
+            id: id,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        );
+
+        const params: FindAllParamsInput = {};
+
+        params.filter = {
+          id: eventResult.id,
+        };
+
+        if (eventResult.filter) {
+          if (params.filter) {
+            params.filter = {
+              $and: [
+                params.filter,
+                eventResult.filter,
+              ],
+            };
+          } else {
+            params.filter = eventResult.filter;
+          }
+        }
+
+        const parsedParams = findAllParamsSchema.parse(params);
+
+        let data = (await this.dbDriver.findAll(
+          collectionName,
+          parsedParams,
+          client,
+        )).data[0];
+
+        if (!data) {
+          throw new LobbError({
+            code: "NOT_FOUND",
+            message: "The entry you are looking for does not exist.",
+          });
+        }
+
+        data = (await Lobb.instance.eventSystem.emit(
+          `core.store.findOne`,
+          {
+            data,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        )).data;
+
+        return {
+          data,
+        };
+      },
+      client,
+    );
+  }
+
+  public async createOne({
+    collectionName,
+    data,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    data: Record<string, any>;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<ExposedServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        await this.handleSingletonCollection(collectionName, context, client);
+
+        const result = await Lobb.instance.eventSystem.emit(
+          `core.store.preCreateOne`,
+          {
+            data,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        );
+        data = await this.dbDriver.createOne(
+          collectionName,
+          this.filterPayload(collectionName, result.data),
+          client,
+        );
+        data = (await Lobb.instance.eventSystem.emit(
+          `core.store.createOne`,
+          {
+            data,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        )).data;
+
+        return {
+          data,
+        };
+      },
+      client,
+    );
+  }
+
+  public async updateOne({
+    collectionName,
+    id,
+    data,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    id: string;
+    data: Record<string, any> | null;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<ExposedServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        const result = await Lobb.instance.eventSystem.emit(
+          `core.store.preUpdateOne`,
+          {
+            id,
+            data,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        );
+        data = await this.dbDriver.updateOne(
+          collectionName,
+          result.id,
+          this.filterPayload(collectionName, result.data),
+          client,
+        );
+        data = (await Lobb.instance.eventSystem.emit(
+          `core.store.updateOne`,
+          {
+            id,
+            data,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        )).data;
+
+        return {
+          data,
+        };
+      },
+      client,
+    );
+  }
+
+  public async deleteOne(
+    {
+      collectionName,
+      id,
+      force = false,
+      triggeredBy = "INTERNAL",
+      context,
+      client,
+    }: {
+      collectionName: string;
+      id: string;
+      force?: boolean;
+      triggeredBy?: TriggeredBy;
+      context?: HonoContext;
+      client?: PoolClient;
+    },
+  ): Promise<ExposedServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        const result: any = await Lobb.instance.eventSystem.emit(
+          `core.store.preDeleteOne`,
+          {
+            id,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        );
+
+        // check if the record has children
+        const childRelations = Lobb.instance.configManager.getChildRelations(
+          collectionName,
+        );
+        for (let index = 0; index < childRelations.length; index++) {
+          const childRelation = childRelations[index];
+          const childCollection = childRelation.from.collection;
+          const childField = childRelation.from.field;
+          const ids = await this.dbDriver.getIdsByFilter(
+            childCollection,
+            {
+              [childField]: result.id,
+            },
+            client,
+          );
+
+          if (ids.length) {
+            if (force) {
+              for (let index = 0; index < ids.length; index++) {
+                const id = ids[index];
+                await Lobb.instance.collectionService.deleteOne({
+                  collectionName: childCollection,
+                  context,
+                  client,
+                  id,
+                  force,
+                });
+              }
+            } else {
+              throw new LobbError({
+                code: "BAD_REQUEST",
+                message:
+                  `Record has children of the (${childCollection}) collection and cannot be deleted`,
+              });
+            }
+          }
+        }
+
+        // delete the record
+        let data = await this.dbDriver.deleteOne(
+          collectionName,
+          result.id,
+          client,
+        );
+        data = (await Lobb.instance.eventSystem.emit(
+          `core.store.deleteOne`,
+          {
+            id,
+            data,
+            collectionName: collectionName,
+            context: context,
+            triggeredBy: triggeredBy,
+            transaction: client,
+          },
+        )).data;
+
+        return {
+          data,
+        };
+      },
+      client,
+    );
+  }
+
+  public async readSingleton({
+    collectionName,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<ExposedServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        const singletonId = (await this.dbDriver.getIdsByFilter(
+          collectionName,
+          {},
+          client,
+        ))[0] as string | undefined;
+
+        if (!singletonId) {
+          throw new LobbError({
+            code: "NOT_FOUND",
+            message:
+              "The the singleton you are trying to read is not created yet",
+          });
+        }
+
+        const data = await this.findOne({
+          collectionName,
+          id: singletonId,
+          triggeredBy,
+          context,
+          client,
+        });
+
+        return data;
+      },
+      client,
+    );
+  }
+
+  public async updateSingleton({
+    collectionName,
+    data,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    data: Record<string, any>;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<ExposedServiceOutput> {
+    return await beginTransaction(
+      async (client) => {
+        const singletonId = (await this.dbDriver.getIdsByFilter(
+          collectionName,
+          {},
+          client,
+        ))[0] as string | undefined;
+
+        if (!singletonId) {
+          return await this.createOne({
+            collectionName,
+            data: data,
+            triggeredBy,
+            context,
+            client,
+          });
+        }
+
+        return await this.updateOne({
+          collectionName,
+          id: singletonId,
+          data: data,
+          triggeredBy,
+          context,
+          client,
+        });
+      },
+      client,
+    );
+  }
+
+  // many operations
+  public async deleteMany(
+    {
+      collectionName,
+      filter,
+      force = false,
+      triggeredBy = "INTERNAL",
+      context,
+      client,
+    }: {
+      collectionName: string;
+      filter?: any;
+      force?: boolean;
+      triggeredBy?: TriggeredBy;
+      context?: HonoContext;
+      client?: PoolClient;
+    },
+  ): Promise<MassReturn> {
+    return await beginTransaction(
+      async (client) => {
+        const ids = await this.dbDriver.getIdsByFilter(
+          collectionName,
+          filter,
+          client,
+        );
+
+        for (let index = 0; index < ids.length; index++) {
+          const id = ids[index];
+          await this.deleteOne({
+            collectionName,
+            id,
+            force,
+            triggeredBy,
+            context,
+            client,
+          });
+        }
+
+        return {
+          affectedCount: ids.length,
+        };
+      },
+      client,
+    );
+  }
+
+  public async updateMany({
+    collectionName,
+    filter,
+    data,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    data: Record<string, any>;
+    filter?: any;
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<MassReturn> {
+    return await beginTransaction(
+      async (client) => {
+        const ids = await this.dbDriver.getIdsByFilter(
+          collectionName,
+          filter,
+          client,
+        );
+
+        for (let index = 0; index < ids.length; index++) {
+          const id = ids[index];
+          await this.updateOne({
+            collectionName,
+            id,
+            data,
+            triggeredBy,
+            context,
+            client,
+          });
+        }
+
+        return {
+          affectedCount: ids.length,
+        };
+      },
+      client,
+    );
+  }
+
+  public async createMany({
+    collectionName,
+    data,
+    triggeredBy = "INTERNAL",
+    context,
+    client,
+  }: {
+    collectionName: string;
+    data: Record<string, any>[];
+    triggeredBy?: TriggeredBy;
+    context?: HonoContext;
+    client?: PoolClient;
+  }): Promise<MassReturn> {
+    return await beginTransaction(
+      async (client) => {
+        for (let index = 0; index < data.length; index++) {
+          const entry = data[index];
+          await this.createOne({
+            collectionName,
+            data: entry,
+            triggeredBy,
+            context,
+            client,
+          });
+        }
+
+        return {
+          affectedCount: data.length,
+        };
+      },
+      client,
+    );
+  }
+
+  // utils
+  public filterPayload(
+    collectionName: string,
+    payload: Record<string, any>,
+  ): Record<string, any> {
+    // Get the list of valid field names for this collection
+    const fieldNames = Lobb.instance.configManager.getFieldNames(
+      collectionName,
+    );
+
+    // Filter the payload
+    const filteredPayload: Record<string, any> = {};
+    for (const key of Object.keys(payload)) {
+      if (fieldNames.includes(key)) {
+        filteredPayload[key] = payload[key];
+      }
+    }
+
+    return filteredPayload;
+  }
+
+  private async handleSingletonCollection(
+    collectionName: string,
+    context?: HonoContext,
+    client?: PoolClient,
+  ) {
+    if (
+      Lobb.instance.configManager.isCollectionSingleton(collectionName)
+    ) {
+      const result = await this.findAll({ collectionName, context, client });
+      if (result.meta.totalCount > 0) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message: "Only one record is allowed in this singleton collection.",
+        });
+      }
+    }
+  }
+}