@lobb-js/core 0.13.0

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

@@ -0,0 +1,13 @@
+import { Lobb } from "../../../Lobb.ts";
+
+export function processorForDB(
+  type: "encode" | "decode",
+  input: any,
+) {
+  input.data = Lobb.instance.utils.processDocumentsForDb(
+    type,
+    input.collectionName,
+    input.data,
+  );
+  return input;
+}

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

@@ -0,0 +1,23 @@
+import type { ProcessorType } from "../../../../types/index.ts";
+import { Lobb } from "../../../../Lobb.ts";
+
+import { processPayloadWithSchema } from "../utils.ts";
+
+export async function processor(
+  input: any,
+  type: ProcessorType,
+  processAllFields: boolean,
+) {
+  const fieldsSchema =
+    Lobb.instance.configManager.getCollection(input.collectionName).fields;
+
+  input.data = await processPayloadWithSchema(
+    type,
+    input.data,
+    fieldsSchema,
+    processAllFields,
+    input.context,
+  );
+
+  return input;
+}

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

@@ -0,0 +1,47 @@
+import { Utils } from "../../../../utils/utils.ts";
+
+interface ProcessorInput {
+  value: any;
+  args?: any;
+  context?: any;
+}
+
+interface Processor {
+  handler: (input: ProcessorInput) => Promise<any>;
+}
+
+export const processorsFunctions: Record<string, Processor> = {
+  default: {
+    handler: (input) => {
+      input.args = Utils.renderTemplateDeep(
+        input.args,
+        {
+          value: input.value,
+          ctx: input.context,
+          now: (new Date()).toISOString(),
+        },
+      );
+      return typeof input.value === "undefined" || input.value === null
+        ? input.args
+        : input.value;
+    },
+  },
+  overwrite: {
+    handler: (input) => {
+      input.args = Utils.renderTemplateDeep(
+        input.args,
+        {
+          value: input.value,
+          ctx: input.context,
+          now: (new Date()).toISOString(),
+        },
+      );
+      return input.args;
+    },
+  },
+  remove: {
+    handler: async () => {
+      return undefined;
+    },
+  },
+};

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

@@ -0,0 +1,102 @@
+import type { CollectionFieldBase } from "../../../types/index.ts";
+import type { ProcessorType } from "../../../types/index.ts";
+import { LobbError } from "../../../LobbError.ts";
+import { processorsFunctions } from "./processors/processorsFunctions.ts";
+import { validatorsFunctions } from "./validator/validatorsFunction.ts";
+
+export async function processPayloadWithSchema(
+  type: ProcessorType,
+  data: any,
+  fieldsSchema: Record<string, CollectionFieldBase>,
+  processAllFields: boolean = false,
+  context: any,
+) {
+  const entries = Array.isArray(data) ? data : [data];
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    const fieldsNames = processAllFields
+      ? Object.keys(fieldsSchema)
+      : Object.keys(entry);
+    for (const fieldName of fieldsNames) {
+      const fieldConfig = fieldsSchema[fieldName];
+      if (!fieldConfig) {
+        continue;
+      }
+
+      const processors = fieldConfig[type];
+      if (processors) {
+        for (const processorName in processors) {
+          const processorArgs: any = processors[processorName];
+          const result = await processorsFunctions[processorName].handler({
+            value: entry[fieldName],
+            args: processorArgs,
+            context,
+          });
+          entry[fieldName] = result;
+        }
+      }
+    }
+  }
+
+  return data;
+}
+
+export async function validatePayloadWithSchema(
+  data: any,
+  fieldsSchema: Record<string, CollectionFieldBase>,
+  processAllFields: boolean,
+  context: any,
+) {
+  const entries = Array.isArray(data) ? data : [data];
+  const validationErrorsDetails: Record<string, any[]> = {};
+
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    const fieldsNames = processAllFields
+      ? Object.keys(fieldsSchema)
+      : Object.keys(entry);
+    for (const fieldName of fieldsNames) {
+      const fieldValue = entry[fieldName];
+      const fieldConfig = fieldsSchema[fieldName];
+      if (!fieldConfig) {
+        throw new LobbError({
+          code: "INTERNAL_SERVER_ERROR",
+          message:
+            `The (${fieldName}) fieldName that we will preprocess doesnt exist in the collections`,
+        });
+      }
+
+      const validators = fieldConfig.validators;
+      if (!validators) {
+        entry[fieldName] = fieldValue;
+      } else {
+        for (const validator in validators) {
+          const validatorArgs: any = validators[validator];
+          const valid = await validatorsFunctions[validator].handler({
+            value: fieldValue,
+            args: validatorArgs,
+            context,
+          });
+          if (!valid) {
+            if (!validationErrorsDetails[fieldName]) {
+              validationErrorsDetails[fieldName] = [];
+            }
+            validationErrorsDetails[fieldName].push(
+              `The value provided for (${fieldName}) is not valid according to the (${validator}) validator.`,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  if (Object.keys(validationErrorsDetails).length) {
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message: `Validation failed. Please check your inputs and try again.`,
+      details: validationErrorsDetails,
+    });
+  }
+
+  return validationErrorsDetails;
+}

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

@@ -0,0 +1,19 @@
+import { Lobb } from "../../../../Lobb.ts";
+import { validatePayloadWithSchema } from "../utils.ts";
+
+export async function validator(
+  input: any,
+  processAllFields: boolean = false,
+) {
+  const fieldsSchema =
+    Lobb.instance.configManager.getCollection(input.collectionName).fields;
+
+  await validatePayloadWithSchema(
+    input.data,
+    fieldsSchema,
+    processAllFields,
+    input.context,
+  );
+
+  return input;
+}

package/src/workflows/coreWorkflows/processors/validator/validatorsFunction.ts

@@ -0,0 +1,52 @@
+import validator from "validator";
+
+interface ValidatorInput {
+  value: any;
+  args?: any;
+  context?: any;
+}
+
+interface Validator {
+  handler: (input: ValidatorInput) => Promise<boolean>;
+}
+
+export const validatorsFunctions: Record<string, Validator> = {
+  enum: {
+    handler: async (input) => {
+      if (typeof input.value === "undefined" || input.value === null) {
+        return true;
+      }
+      return input.args.includes(input.value);
+    },
+  },
+  required: {
+    handler: async (input) => {
+      return typeof input.value !== "undefined" && input.value !== null;
+    },
+  },
+  maxLength: {
+    handler: async (input) => {
+      return input.value.length <= input.args;
+    },
+  },
+  regex: {
+    handler: async (input) => {
+      const regex = new RegExp(input.args);
+      return regex.test(input.value);
+    },
+  },
+  validator: {
+    handler: async (input) => {
+      const validatorFunc = (validator as any)[input.args.name];
+      if (!validatorFunc) {
+        return;
+      }
+
+      try {
+        return await validatorFunc(input.value, input.args.options);
+      } catch (_error) {
+        return false;
+      }
+    },
+  },
+};

package/src/workflows/coreWorkflows/queryCoreWorkflows.ts

@@ -0,0 +1,31 @@
+import type { Workflow } from "../WorkflowSystem.ts";
+
+export function getQueryCoreWorkflows(): Workflow[] {
+  return [
+    {
+      name: "core_query_preCreate",
+      eventName: "core.store.preCreateOne",
+      handler: async function (input, ctx) {
+        if (input.collectionName === "core_query") {
+          const entry = input.data;
+          const result = await ctx.workflows.core_query({
+            sql: entry.query,
+          });
+
+          throw new Response(
+            JSON.stringify({
+              data: result.rows,
+            }),
+            {
+              status: 200,
+              headers: {
+                "Content-Type": "application/json",
+              },
+            },
+          );
+        }
+        return input;
+      },
+    },
+  ];
+}

package/src/workflows/coreWorkflows/utilsCoreWorkflows.ts

@@ -0,0 +1,40 @@
+import { Lobb } from "../../Lobb.ts";
+import type { Workflow } from "../WorkflowSystem.ts";
+
+export function getUtilsCoreWorkflows(): Workflow[] {
+  return [
+    {
+      name: "core_query",
+      inputSchema: (z) => {
+        const dbPossibleValues = z.union([
+          z.string(),
+          z.number(),
+          z.boolean(),
+          z.null(),
+        ]);
+        return z.object({
+          sql: z.string(),
+          args: z.array(dbPossibleValues).optional(),
+        });
+      },
+      outputSchema: (z) => {
+        const dbPossibleValues = z.union([
+          z.string(),
+          z.number(),
+          z.boolean(),
+          z.null(),
+        ]);
+        return z.object({
+          rows: z.array(z.record(dbPossibleValues)),
+        });
+      },
+      handler: async function (input) {
+        const driver = await Lobb.instance.databaseService.getDriver();
+        const pool = await driver.getConnection();
+        using client = await pool.connect();
+        const result = await client.queryObject(input.sql, input.args);
+        return result;
+      },
+    },
+  ];
+}

package/src/workflows/coreWorkflows/workflowsCollection/workflowsCollectionWorkflows.ts

@@ -0,0 +1,101 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { Lobb } from "../../../Lobb.ts";
+import { Utils } from "../../../utils/utils.ts";
+import { LobbError } from "../../../LobbError.ts";
+
+async function parseWorkflowEntry(
+  workflowEntry: Record<string, any>,
+): Promise<Workflow> {
+  return {
+    name: workflowEntry.name,
+    eventName: workflowEntry.event_name,
+    inputSchema: Utils.parseFunction(workflowEntry.input_schema),
+    outputSchema: Utils.parseFunction(workflowEntry.output_schema),
+    handler: Utils.parseFunction(workflowEntry.handler),
+  };
+}
+
+let updateOldWorkflowName: string | null = null;
+
+export const coreWorkflowsCollectionWorkflows: Workflow[] = [
+  {
+    name: "core_get_all_workflows_from_db",
+    eventName: "core.init",
+    handler: async () => {
+      const findALlResult = await Lobb.instance.collectionService.findAll({
+        collectionName: "core_workflows",
+      });
+      const dbWorkflows = await Promise.all(
+        findALlResult.data.map((entry: Workflow) => parseWorkflowEntry(entry)),
+      ) as Workflow[];
+
+      for (let index = 0; index < dbWorkflows.length; index++) {
+        const dbWorkflow = dbWorkflows[index];
+        await Lobb.instance.workflowSystem.add(dbWorkflow);
+      }
+    },
+  },
+  {
+    name: "core_add_created_workflow",
+    eventName: "core.store.createOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_workflows") {
+        const workflowEntry = input.data;
+        const workflow = await parseWorkflowEntry(workflowEntry);
+        await Lobb.instance.workflowSystem.add(workflow);
+      }
+      return input;
+    },
+  },
+  {
+    name: "core_pre_update_workflow",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_workflows") {
+        const workflowId = input.id;
+        const oldWorkflowEntry = (await Lobb.instance.collectionService.findOne({
+          collectionName: "core_workflows",
+          id: workflowId,
+        })).data;
+        updateOldWorkflowName = oldWorkflowEntry.name;
+      }
+      return input;
+    },
+  },
+  {
+    name: "core_update_workflow",
+    eventName: "core.store.updateOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_workflows") {
+        if (!updateOldWorkflowName) {
+          throw new LobbError({
+            code: "BAD_REQUEST",
+            message:
+              "The old workflow name in null in the (core.collection.update.core_workflows) workflow",
+          });
+        }
+
+        const workflowEntry = input.data;
+        const workflow = await parseWorkflowEntry(workflowEntry);
+        await Lobb.instance.workflowSystem.update(
+          updateOldWorkflowName,
+          workflow,
+        );
+        updateOldWorkflowName = null;
+      }
+      return input;
+    },
+  },
+  {
+    name: "core_delete_workflow",
+    eventName: "core.store.deleteOne",
+    handler: async (input) => {
+      if (input.collectionName === "core_workflows") {
+        const workflowEntry = input.data;
+        const workflow = await parseWorkflowEntry(workflowEntry);
+        await Lobb.instance.workflowSystem.remove(workflow.name);
+      }
+      return input;
+    },
+  },
+];