@lobb-js/core 0.13.0

package/src/utils/utils.ts

@@ -0,0 +1,310 @@
+import type { Context } from "hono";
+import type { ApiCollectionAction } from "../types/index.ts";
+import type { ProcessorType } from "../types/index.ts";
+import type { CollectionFieldBase } from "../types/index.ts";
+import type { CollectionConfig, CollectionsConfig } from "../types/index.ts";
+import type { PoolClient } from "pg";
+
+import _ from "lodash";
+import nunjucks from "nunjucks";
+import { transform } from "sucrase";
+import { LobbError } from "../LobbError.ts";
+import { FieldUtils } from "../fields/FieldUtils.ts";
+import { coreCollections } from "../coreCollections/index.ts";
+import { Lobb } from "../Lobb.ts";
+import {
+  processPayloadWithSchema,
+  validatePayloadWithSchema,
+} from "../workflows/coreWorkflows/processors/utils.ts";
+import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
+import {
+  innerLockCollectionToObject,
+  LockCollectionToObjectProps,
+} from "./lockCollectionToObject.ts";
+
+export const Utils = {
+  isPlainInteger(value: any): boolean {
+    return (
+      _.isNumber(value) &&
+      _.isInteger(value) &&
+      value >= Number.MIN_SAFE_INTEGER &&
+      value <= Number.MAX_SAFE_INTEGER
+    );
+  },
+  setRequestBody(c: Context, data: any) {
+    c.set("body", data);
+  },
+  async getRequestBody(c: Context): Promise<any> {
+    // return the passed body if existed
+    const passedBody = c.get("body");
+    if (passedBody) {
+      return passedBody;
+    }
+
+    const contentType = c.req.header("Content-Type");
+    if (contentType) {
+      if (contentType.startsWith("multipart/form-data")) {
+        const formData = await c.req.formData();
+        let payload = formData.get("payload")?.toString();
+        if (!payload) {
+          payload = "{}";
+        }
+        try {
+          return JSON.parse(payload);
+        } catch (_error) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message:
+              "couldn't JSON.parse the data property in the multipart/form-data.",
+          });
+        }
+      } else if (contentType.startsWith("application/json")) {
+        return await c.req.json();
+      } else if (contentType.startsWith("text/plain")) {
+        try {
+          return await c.req.json();
+        } catch (_error) {
+          return await c.req.text();
+        }
+      } else {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message: "request body is not valid json.",
+        });
+      }
+    } else {
+      try {
+        return JSON.parse(await c.req.text());
+      } catch (_error) {
+        const textValue = await c.req.text();
+        if (!textValue) {
+          return {};
+        }
+        return textValue;
+      }
+    }
+  },
+  getApiCollectionAction(c: Context): ApiCollectionAction {
+    const pathSegments = c.req.path.split("/");
+    const pathSegmentsLength = pathSegments.length;
+    const pathSegmentsLastElement = pathSegments[pathSegmentsLength - 1];
+    const isMany = pathSegmentsLastElement === "many";
+    if (
+      c.req.method === "GET" &&
+      pathSegmentsLength === 4 &&
+      !isMany
+    ) {
+      return "findAll";
+    } else if (
+      c.req.method === "POST" &&
+      pathSegmentsLength === 5 &&
+      !isMany
+    ) {
+      return "findAll";
+    } else if (
+      c.req.method === "GET" &&
+      pathSegmentsLength === 5 &&
+      !isMany
+    ) {
+      return "findOne";
+    } else if (
+      c.req.method === "DELETE" &&
+      pathSegmentsLength === 5 &&
+      !isMany
+    ) {
+      return "deleteOne";
+    } else if (
+      c.req.method === "POST" &&
+      pathSegmentsLength === 4 &&
+      !isMany
+    ) {
+      return "createOne";
+    } else if (
+      c.req.method === "PATCH" &&
+      pathSegmentsLength === 5 &&
+      !isMany
+    ) {
+      return "updateOne";
+    } else if (
+      c.req.method === "DELETE" &&
+      pathSegmentsLength === 5 &&
+      isMany
+    ) {
+      return "deleteMany";
+    } else if (
+      c.req.method === "PATCH" &&
+      pathSegmentsLength === 5 &&
+      isMany
+    ) {
+      return "updateMany";
+    } else if (
+      c.req.method === "POST" &&
+      pathSegmentsLength === 5 &&
+      isMany
+    ) {
+      return "createMany";
+    } else {
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: "can't get the api collection action",
+      });
+    }
+  },
+  sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  },
+  renderTemplateDeep(data: any, context: any) {
+    return _.cloneDeepWith(data, (value: any) => {
+      if (typeof value === "function") {
+        return value(context);
+      }
+
+      if (typeof value === "string") {
+        return nunjucks.renderString(value, context);
+      }
+    });
+  },
+  fieldExists(
+    fieldName: string,
+    collectionName: string,
+  ): boolean {
+    return Lobb.instance.configManager.fieldExists(fieldName, collectionName);
+  },
+  moveElementAfter(
+    array: any[],
+    moveIndex: number,
+    afterIndex: number,
+  ) {
+    if (moveIndex < 0 || moveIndex >= array.length) {
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: `Invalid moveIndex: ${moveIndex}.`,
+      });
+    }
+    if (afterIndex < 0 || afterIndex >= array.length) {
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: `Invalid afterIndex: ${afterIndex}.`,
+      });
+    }
+
+    const [movedElement] = array.splice(moveIndex, 1);
+    const insertIndex = afterIndex >= moveIndex ? afterIndex : afterIndex + 1;
+    array.splice(insertIndex, 0, movedElement);
+
+    return array;
+  },
+  processDocumentsForDb(
+    type: "encode" | "decode",
+    collectionName: string,
+    data: any,
+  ) {
+    const isArray = Array.isArray(data);
+    const entries = isArray ? data : [data];
+    for (let index = 0; index < entries.length; index++) {
+      for (const fieldName of Object.keys(entries[index])) {
+        const fieldValue = entries[index][fieldName];
+        if (fieldValue === null) {
+          continue;
+        }
+        const doesFieldExists = Lobb.instance.configManager.fieldExists(
+          fieldName,
+          collectionName,
+        );
+        if (!doesFieldExists) {
+          continue;
+        }
+        const field = FieldUtils.getFieldInstance(
+          fieldName,
+          collectionName,
+        );
+        let result;
+        if (type === "encode") {
+          result = field.encodeFieldValue(fieldValue);
+        } else {
+          result = field.decodeFieldValue(fieldValue);
+        }
+        if (result !== undefined) {
+          entries[index][fieldName] = result;
+        }
+      }
+    }
+
+    return isArray ? entries : entries[0];
+  },
+  getCollectionOwner(collectionName: string) {
+    const lobbInstance = Lobb.instance;
+    const owner = lobbInstance.extensionSystem.getCollectionOwner(
+      collectionName,
+    );
+    if (owner) {
+      return owner;
+    }
+    const coreCollectionNames = Object.keys(coreCollections());
+    if (coreCollectionNames.includes(collectionName)) {
+      return "__core";
+    }
+    return "__project";
+  },
+  processPayloadWithSchema(
+    type: ProcessorType,
+    data: any,
+    fieldsSchema: Record<string, CollectionFieldBase>,
+    processAllFields: boolean = false,
+    context: any,
+  ) {
+    return processPayloadWithSchema(
+      type,
+      data,
+      fieldsSchema,
+      processAllFields,
+      context,
+    );
+  },
+  validatePayloadWithSchema(
+    data: any,
+    fieldsSchema: Record<string, CollectionFieldBase>,
+    processAllFields: boolean,
+    context: any,
+  ): Promise<any> {
+    return validatePayloadWithSchema(
+      data,
+      fieldsSchema,
+      processAllFields,
+      context,
+    );
+  },
+  parseFunction(functionString: string) {
+    const { code: vanillaJsFunctionString } = transform(functionString, {
+      transforms: ["typescript"],
+    });
+    const functionObj = new Function("return " + vanillaJsFunctionString)();
+    return functionObj;
+  },
+  async runParsedFunction(
+    functionString: string,
+    ...params: any[]
+  ): Promise<any> {
+    const func = this.parseFunction(functionString);
+    return await func(...params);
+  },
+
+  lockCollectionToObject(
+    props: LockCollectionToObjectProps,
+  ): CollectionConfig {
+    return innerLockCollectionToObject(props);
+  },
+};
+
+export function convertSchemaToTypeString(
+  identifier: string,
+  schema: any,
+): string {
+  const { node } = zodToTs(schema);
+  const typeAlias = createTypeAlias(
+    node,
+    identifier,
+  );
+  const nodeString = printNode(typeAlias);
+  return nodeString;
+}

package/src/workflows/WorkflowSystem.ts

@@ -0,0 +1,182 @@
+import type { Subscription } from "../events/EventSystem.ts";
+import type { ZodObject } from "zod";
+import type { z } from "zod";
+import { getCoreWorkflows } from "./coreWorkflows/index.ts";
+import { Lobb } from "../Lobb.ts";
+import { LobbError } from "../LobbError.ts";
+import { TransactionBody } from "../api/collections/transactions.ts";
+
+export interface Workflow {
+  name: string;
+  handler: Subscription["handler"];
+  eventName?: string;
+  inputSchema?: (zodObject: typeof z) => ZodObject<any>;
+  outputSchema?: (zodObject: typeof z) => ZodObject<any>;
+}
+
+export class WorkflowSystem {
+  public initialized: boolean = false;
+  public workflows: Workflow[] = [];
+  public queuedWorkflows: Workflow[] = [];
+
+  public async init() {
+    // get current project workflows
+    this.initialized = true;
+    this.addQueuedWorkflows();
+    await this.registerCollectionsWorkflows();
+    await this.importExtensionWorkflows();
+    await this.importProjectWorkflows();
+    await this.importCoreWorkflows();
+  }
+
+  public close() {
+    this.workflows = [];
+  }
+
+  public trigger(workflow: Workflow) {
+    // TODO
+  }
+
+  public add(workflow: Workflow) {
+    if (this.initialized) {
+      if (this.workflowExist(workflow.name)) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message:
+            `The workflow with the (${workflow.name}) name already exists`,
+        });
+      }
+      if (workflow.eventName) {
+        Lobb.instance.eventSystem.subscribe({
+          name: `${workflow.name}_${workflow.eventName}`,
+          eventName: workflow.eventName,
+          handler: workflow.handler,
+        });
+      }
+      this.workflows.push(workflow);
+    } else {
+      this.queuedWorkflows.push(workflow);
+    }
+  }
+
+  public async update(workflowName: string, newWorkflow: Workflow) {
+    await this.remove(workflowName);
+    await this.add(newWorkflow);
+  }
+
+  public async remove(workflowName: string) {
+    const workflowWeWillRemove = this.workflows.find(
+      (workflow) => workflow.name === workflowName,
+    );
+
+    if (!workflowWeWillRemove) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `The (${workflowName}) workflow doesnt exist`,
+      });
+    }
+
+    this.workflows = this.workflows.filter(
+      (workflow) => workflow.name !== workflowName,
+    );
+    // remove events that were issues by the workflow
+    await Lobb.instance.eventSystem.unsubscribe(
+      `${workflowWeWillRemove.name}_${workflowWeWillRemove.eventName}`,
+    );
+  }
+
+  public workflowExist(workflowName: string) {
+    return this.workflows.some((workflow) => workflow.name === workflowName);
+  }
+
+  private async addQueuedWorkflows() {
+    for (let index = 0; index < this.queuedWorkflows.length; index++) {
+      const queuedWorkflow = this.queuedWorkflows[index];
+      await this.add(queuedWorkflow);
+    }
+  }
+
+  private async importCoreWorkflows() {
+    const coreWorkflows = getCoreWorkflows();
+    for (let index = 0; index < coreWorkflows.length; index++) {
+      const coreWorkflow = coreWorkflows[index];
+      if (!coreWorkflow.name.startsWith("core")) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message:
+            `The (${coreWorkflow.name}) workflow should start with the (core) prefix`,
+        });
+      }
+      await this.add(coreWorkflow);
+    }
+  }
+
+  private async importExtensionWorkflows() {
+    const extensionNames = Lobb.instance.configManager.getExtensionNames();
+    for (let index = 0; index < extensionNames.length; index++) {
+      const extensionName = extensionNames[index];
+      const extensionWorkflows = Lobb.instance.extensionSystem.getWorkflows(
+        extensionName,
+      );
+      for (let index = 0; index < extensionWorkflows.length; index++) {
+        const extensionWorkflow = extensionWorkflows[index];
+        if (!extensionWorkflow.name.startsWith(`${extensionName}`)) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message:
+              `The (${extensionWorkflow.name}) workflow should start with the (${extensionName}) prefix`,
+          });
+        }
+        await this.add(extensionWorkflow);
+      }
+    }
+  }
+
+  private async importProjectWorkflows() {
+    const workflows = Lobb.instance.configManager.config.workflows;
+    if (workflows) {
+      for (let index = 0; index < workflows.length; index++) {
+        const coreWorkflow = workflows[index];
+        await this.add(coreWorkflow);
+      }
+    }
+  }
+
+  public async registerCollectionsWorkflows() {
+    await this.add({
+      name: `collectionService`,
+      handler: async (input: TransactionBody) => {
+        if (input.method === "findAll") {
+          return await Lobb.instance.collectionService.findAll(input.props);
+        } else if (input.method === "findOne") {
+          return await Lobb.instance.collectionService.findOne(input.props);
+        } else if (input.method === "createOne") {
+          return await Lobb.instance.collectionService.createOne(input.props);
+        } else if (input.method === "updateOne") {
+          return await Lobb.instance.collectionService.updateOne(input.props);
+        } else if (input.method === "deleteOne") {
+          return await Lobb.instance.collectionService.deleteOne(input.props);
+        } else if (input.method === "readSingleton") {
+          return await Lobb.instance.collectionService.readSingleton(
+            input.props,
+          );
+        } else if (input.method === "updateSingleton") {
+          return await Lobb.instance.collectionService.updateSingleton(
+            input.props,
+          );
+        } else if (input.method === "createMany") {
+          return await Lobb.instance.collectionService.createMany(input.props);
+        } else if (input.method === "updateMany") {
+          return await Lobb.instance.collectionService.updateMany(input.props);
+        } else if (input.method === "deleteMany") {
+          return await Lobb.instance.collectionService.deleteMany(input.props);
+        } else {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message: `The (${(input as any).method}) method is not supported`,
+          });
+        }
+      },
+    });
+  }
+}

package/src/workflows/coreWorkflows/collectionsTable/index.ts

@@ -0,0 +1,118 @@
+import { Lobb } from "../../../Lobb.ts";
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { Utils } from "../../../utils/utils.ts";
+
+let oldCollectionName: string | null = null;
+
+async function getCollectionNameById(id: string): Promise<string> {
+  const result = await Lobb.instance.collectionService.findOne({
+    collectionName: "core_collections",
+    id,
+  });
+  const collectionName = result.data.name;
+  return collectionName;
+}
+
+export function getCollectionsTableWorkflows(): Workflow[] {
+  const workflows: Workflow[] = [];
+
+  workflows.push({
+    name: `core_move_collections_from_db_to_lobb`,
+    eventName: "core.init",
+    handler: async () => {
+      const dbCollections = (await Lobb.instance.collectionService.findAll({
+        collectionName: "core_collections",
+      })).data;
+      for (let index = 0; index < dbCollections.length; index++) {
+        const collectionEntry = dbCollections[index];
+        const collectionParsedValue = await Utils.runParsedFunction(
+          collectionEntry.value,
+        );
+        await Lobb.instance.schemaService.createCollection(
+          collectionEntry.name,
+          collectionParsedValue,
+          false,
+        );
+      }
+    },
+  });
+
+  workflows.push({
+    name: "core_add_created_db_collection",
+    eventName: "core.store.createOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_collections") {
+        const collectionEntry = input.data;
+        const collectionParsedValue = await Utils.runParsedFunction(
+          collectionEntry.value,
+        );
+        await Lobb.instance.schemaService.createCollection(
+          collectionEntry.name,
+          collectionParsedValue,
+          false,
+        );
+      }
+      return input;
+    },
+  });
+
+  workflows.push({
+    name: "core_handle_db_collection_pre_update",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_collections") {
+        oldCollectionName = await getCollectionNameById(input.id);
+      }
+      return input;
+    },
+  });
+
+  workflows.push({
+    name: "core_handle_db_collection_post_update",
+    eventName: "core.store.updateOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_collections") {
+        const payload = input.data;
+        const collectionName = payload.name;
+        const collectionParsedValue = await Utils.runParsedFunction(
+          payload.value,
+        );
+        if (oldCollectionName && oldCollectionName !== collectionName) {
+          await Lobb.instance.schemaService.deleteCollection(
+            oldCollectionName,
+            false,
+          );
+          await Lobb.instance.schemaService.createCollection(
+            collectionName,
+            collectionParsedValue,
+            false,
+          );
+        } else {
+          await Lobb.instance.schemaService.updateCollection(
+            collectionName,
+            collectionParsedValue,
+            false,
+          );
+        }
+      }
+      return input;
+    },
+  });
+
+  workflows.push({
+    name: "core_handle_db_collection_delete",
+    eventName: "core.store.deleteOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_collections") {
+        const collectionEntry = input.data;
+        await Lobb.instance.schemaService.deleteCollection(
+          collectionEntry.name,
+          false,
+        );
+      }
+      return input;
+    },
+  });
+
+  return workflows;
+}

package/src/workflows/coreWorkflows/index.ts

@@ -0,0 +1,18 @@
+import type { Workflow } from "../WorkflowSystem.ts";
+import { getCollectionsTableWorkflows } from "./collectionsTable/index.ts";
+import { getUtilsCoreWorkflows } from "./utilsCoreWorkflows.ts";
+import { postOperationsWorkflows } from "./processors/postOperationsWorkflows.ts";
+import { preOperationsWorkflows } from "./processors/preOperationsWorkflows.ts";
+import { coreWorkflowsCollectionWorkflows } from "./workflowsCollection/workflowsCollectionWorkflows.ts";
+import { getQueryCoreWorkflows } from "./queryCoreWorkflows.ts";
+
+export function getCoreWorkflows(): Array<Workflow> {
+  return [
+    ...preOperationsWorkflows,
+    ...postOperationsWorkflows,
+    ...coreWorkflowsCollectionWorkflows,
+    ...getCollectionsTableWorkflows(),
+    ...getQueryCoreWorkflows(),
+    ...getUtilsCoreWorkflows(),
+  ];
+}

package/src/workflows/coreWorkflows/processors/postOperationsWorkflows.ts

@@ -0,0 +1,46 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { processorForDB } from "./processorForDB.ts";
+import { processor } from "./processors/processor.ts";
+
+export const postOperationsWorkflows: Workflow[] = [
+  {
+    name: "core_postProcessingForCreate",
+    eventName: "core.store.createOne",
+    handler: async (input) => {
+      input = processorForDB("decode", input);
+      input = await processor(input, "post_processors", true);
+
+      return input;
+    },
+  },
+  {
+    name: "core_postProcessingForRead",
+    eventName: "core.store.findOne",
+    handler: async (input) => {
+      input = processorForDB("decode", input);
+      input = await processor(input, "post_processors", true);
+
+      return input;
+    },
+  },
+  {
+    name: "core_postProcessingForUpdate",
+    eventName: "core.store.updateOne",
+    handler: async (input) => {
+      input = processorForDB("decode", input);
+      input = await processor(input, "post_processors", true);
+
+      return input;
+    },
+  },
+  {
+    name: "core_postProcessingForDelete",
+    eventName: "core.store.deleteOne",
+    handler: async (input) => {
+      input = processorForDB("decode", input);
+      input = await processor(input, "post_processors", true);
+
+      return input;
+    },
+  },
+];

package/src/workflows/coreWorkflows/processors/preOperationsWorkflows.ts

@@ -0,0 +1,27 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { processorForDB } from "./processorForDB.ts";
+import { processor } from "./processors/processor.ts";
+import { validator } from "./validator/validator.ts";
+
+export const preOperationsWorkflows: Workflow[] = [
+  {
+    name: "core_preProcessingForPreCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => {
+      input = await processor(input, "pre_processors", true);
+      await validator(input, true);
+      input = processorForDB("encode", input);
+      return input;
+    },
+  },
+  {
+    name: "core_preProcessingForPreUpdate",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => {
+      input = await processor(input, "pre_processors", false);
+      await validator(input, false);
+      input = processorForDB("encode", input);
+      return input;
+    },
+  },
+];