@lobb-js/core 0.22.0 → 0.23.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lobb-js/core",
   "license": "UNLICENSED",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/Lobb.ts

@@ -144,6 +144,7 @@ export class Lobb {
     process.chdir(config.project.context ?? ".");
 
     await Lobb.instance.extensionSystem.loadExtensionsCollections();
+    this.configManager.addUniqueIndexesFromFields();
     this.configManager.addRelationsFromIntegerRefrences();
   }
 }

package/src/api/meta/service.ts

@@ -68,8 +68,6 @@ export class MetaService {
         field.label = fieldName;
         field.key = fieldName;
         field.enum = "enum" in fieldConfig ? fieldConfig.enum : undefined;
-        field.validators = "validators" in fieldConfig ? fieldConfig.validators : undefined;
-        field.pre_processors = "pre_processors" in fieldConfig ? fieldConfig.pre_processors : undefined;
         field.ui = fieldConfig.ui;
 
         collections[collectionName].fields[fieldName] = field;

package/src/config/ConfigManager.ts

@@ -42,6 +42,31 @@ export class ConfigManager {
     };
   }
 
+  public addUniqueIndexesFromFields() {
+    for (
+      const [collectionName, collectionValue] of Object.entries(
+        this.config.collections,
+      )
+    ) {
+      if (collectionValue.virtual) continue;
+      for (
+        const [fieldName, fieldValue] of Object.entries(
+          (collectionValue as any).fields,
+        )
+      ) {
+        if (fieldValue.unique) {
+          const indexName = `${collectionName}_${fieldName}_unique_index`;
+          (collectionValue as any).indexes[indexName] = {
+            unique: true,
+            fields: {
+              [fieldName]: { order: "asc" },
+            },
+          };
+        }
+      }
+    }
+  }
+
   public addRelationsFromIntegerRefrences() {
     for (
       const [collectionName, collectionValue] of Object.entries(

package/src/coreCollections/collectionsCollection.ts

@@ -24,19 +24,13 @@ export function getCollectionsCollection(): CollectionConfig {
       "name": {
         "type": "string",
         "length": 255,
-        "validators": {
-          "required": true,
-        },
+        "required": true,
       },
       "value": {
         "type": "text",
-        "validators": {
-          "required": true,
-        },
-        "pre_processors": {
-          "default":
-            'async function collection(): Promise<Collection> {\n\treturn {\n\t\tindexes: {},\n\t\tfields: {\n\t\t\tid: {\n\t\t\t\ttype: "integer",\n\t\t\t},\n\t\t},\n\t};\n}',
-        },
+        "required": true,
+        "default":
+          'async function collection(): Promise<Collection> {\n\treturn {\n\t\tindexes: {},\n\t\tfields: {\n\t\t\tid: {\n\t\t\t\ttype: "integer",\n\t\t\t},\n\t\t},\n\t};\n}',
         "ui": {
           "input": {
             "type": "code",

package/src/coreCollections/workflowsCollection.ts

@@ -9,9 +9,7 @@ export const workflowsCollection: CollectionConfig = {
     "name": {
       "type": "string",
       "length": 255,
-      "validators": {
-        "required": true,
-      },
+      "required": true,
     },
     "event_name": {
       "type": "string",
@@ -23,9 +21,7 @@ export const workflowsCollection: CollectionConfig = {
     },
     "input_schema": {
       "type": "text",
-      "pre_processors": {
-        "default": "function schema(z) {\n\treturn z.object({});\n}",
-      },
+      "default": "function schema(z) {\n\treturn z.object({});\n}",
       "ui": {
         "input": {
           "type": "code",
@@ -38,9 +34,7 @@ export const workflowsCollection: CollectionConfig = {
     },
     "output_schema": {
       "type": "text",
-      "pre_processors": {
-        "default": "function schema(z) {\n\treturn z.object({});\n}",
-      },
+      "default": "function schema(z) {\n\treturn z.object({});\n}",
       "ui": {
         "input": {
           "type": "code",
@@ -53,13 +47,9 @@ export const workflowsCollection: CollectionConfig = {
     },
     "handler": {
       "type": "text",
-      "validators": {
-        "required": true,
-      },
-      "pre_processors": {
-        "default":
-          "async function workflow(input: Input, ctx: Context): Promise<Output> {\n\treturn input;\n}",
-      },
+      "required": true,
+      "default":
+        "async function workflow(input: Input, ctx: Context): Promise<Output> {\n\treturn input;\n}",
       "ui": {
         "input": {
           "type": "code",

package/src/index.ts

@@ -32,7 +32,6 @@ export type {
   EnumColor,
 } from "./types/config/collectionFields.ts";
 export type { Dashboard, Extension } from "./types/Extension.ts";
-export { Field } from "./types/Field.ts";
 export type { Migration, MigrationProps, Migrations } from "./types/migrations.ts";
 export type { Filter } from "./types/filterSchema.ts";
 export {
@@ -52,4 +51,3 @@ export type {
   RequestMessage,
   SubscribeMessage,
 } from "./types/websockets.ts";
-export type { ProcessorType } from "./types/workflows/processors.ts";

package/src/types/config/collectionFields.ts

@@ -54,11 +54,9 @@ const FieldHooksSchema = z.object({
 export const CollectionFieldBaseSchema = z.object({
   virtual: z.never().optional(),
   required: z.boolean().optional(),
+  unique: z.boolean().optional(),
   hooks: FieldHooksSchema,
   validator: z.custom<FieldValidatorFn>((val) => typeof val === "function").optional(),
-  pre_processors: z.record(z.any()).optional(),
-  post_processors: z.record(z.any()).optional(),
-  validators: z.record(z.any()).optional(),
   ui: UiSchema.optional(),
 });
 

package/src/types/index.ts

@@ -16,7 +16,6 @@ export type {
   CollectionFieldBase,
 } from "./config/collectionFields.ts";
 export type { Dashboard, Extension } from "./Extension.ts";
-export { Field } from "./Field.ts";
 export type { Migration, MigrationProps, Migrations } from "./migrations.ts";
 export type { Filter } from "./filterSchema.ts";
 export {
@@ -36,4 +35,3 @@ export type {
   RequestMessage,
   SubscribeMessage,
 } from "./websockets.ts";
-export type { ProcessorType } from "./workflows/processors.ts";

package/src/utils/lockCollectionToObject.ts

@@ -37,36 +37,28 @@ function generateSchemasForLockedCollections(
       "key": {
         "type": "string",
         "length": 255,
-        "validators": {
-          "required": true,
-        },
+        "required": true,
       },
       "value": {
         "type": "text",
-        "validators": {
-          "required": true,
-        },
-        "pre_processors": {
-          "default": "{}",
-        },
+        "required": true,
+        "default": "{}",
         "ui": {
           "input": {
             "type": "code",
             "args": {
               "type": "json",
               "height": 200,
-              // "types": "type Value = any",
             },
           },
         },
       },
       "static": {
         "type": "bool",
-        "pre_processors": {
-          "overwrite": false,
-        },
-        "validators": {
-          "required": true,
+        "required": true,
+        "hooks": {
+          "beforeCreate": () => false,
+          "beforeUpdate": () => false,
         },
       },
     },

package/src/utils/utils.ts

@@ -1,7 +1,5 @@
 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";
 
@@ -9,13 +7,8 @@ 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,
@@ -194,44 +187,6 @@ export const Utils = {
 
     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(
@@ -246,34 +201,6 @@ export const Utils = {
     }
     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"],

package/src/workflows/coreWorkflows/index.ts

@@ -1,25 +1,23 @@
 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 { hooksWorkflows } from "./processors/hooksWorkflows.ts";
 import { validatorWorkflows } from "./processors/validatorWorkflows.ts";
 import { requiredWorkflows } from "./processors/requiredWorkflows.ts";
 import { defaultWorkflows } from "./processors/defaultWorkflows.ts";
 import { enumWorkflows } from "./processors/enumWorkflows.ts";
+import { coerceAndValidateWorkflows } from "./processors/coerceAndValidateWorkflows.ts";
 import { coreWorkflowsCollectionWorkflows } from "./workflowsCollection/workflowsCollectionWorkflows.ts";
 import { getQueryCoreWorkflows } from "./queryCoreWorkflows.ts";
 
 export function getCoreWorkflows(): Array<Workflow> {
   return [
+    ...coerceAndValidateWorkflows,
     ...hooksWorkflows.filter((w) => w.name.startsWith("core_hooksBefore")),
     ...defaultWorkflows,
     ...requiredWorkflows,
     ...enumWorkflows,
     ...validatorWorkflows,
-    ...preOperationsWorkflows,
-    ...postOperationsWorkflows,
     ...hooksWorkflows.filter((w) => w.name.startsWith("core_hooksAfter")),
     ...coreWorkflowsCollectionWorkflows,
     ...getCollectionsTableWorkflows(),

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

@@ -0,0 +1,108 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { Lobb } from "../../../Lobb.ts";
+import { LobbError } from "../../../LobbError.ts";
+
+async function coerceAndValidate(input: any) {
+  if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+  const fields = Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
+  const data = input.data;
+  const errors: Record<string, string[]> = {};
+
+  for (const [fieldName, fieldConfig] of Object.entries(fields) as [string, any][]) {
+    if (!(fieldName in data)) continue;
+    const value = data[fieldName];
+
+    try {
+      if (value === null || value === undefined) continue;
+
+      if (fieldConfig.type === "string") {
+        if (typeof value !== "string") {
+          data[fieldName] = String(value);
+        }
+      } else if (fieldConfig.type === "text") {
+        if (typeof value !== "string") {
+          data[fieldName] = String(value);
+        }
+      } else if (fieldConfig.type === "integer") {
+        if (value === "") {
+          data[fieldName] = null;
+        } else {
+          const int = Number(value);
+          if (!Number.isFinite(int)) throw new Error(`${fieldName} must be a valid integer`);
+          data[fieldName] = Math.trunc(int);
+        }
+      } else if (fieldConfig.type === "long") {
+        if (value === "") {
+          data[fieldName] = null;
+        } else if (typeof value === "string" && !/^-?\d+$/.test(value.trim())) {
+          throw new Error(`${fieldName} must be a valid integer`);
+        }
+      } else if (fieldConfig.type === "float") {
+        if (value === "") {
+          data[fieldName] = null;
+        } else {
+          const float = Number(value);
+          if (!Number.isFinite(float)) throw new Error(`${fieldName} must be a valid number`);
+          data[fieldName] = float;
+        }
+      } else if (fieldConfig.type === "decimal") {
+        if (value === "") {
+          data[fieldName] = null;
+        } else if (typeof value === "string" && isNaN(Number(value))) {
+          throw new Error(`${fieldName} must be a valid decimal number`);
+        }
+      } else if (fieldConfig.type === "bool") {
+        if (value === "") {
+          data[fieldName] = null;
+        } else if (typeof value === "boolean") {
+          // already correct, nothing to do
+        } else if (typeof value === "string" && value.toLowerCase() === "true" || value === "1" || value === 1) {
+          data[fieldName] = true;
+        } else if (typeof value === "string" && value.toLowerCase() === "false" || value === "0" || value === 0) {
+          data[fieldName] = false;
+        } else {
+          throw new Error(`${fieldName} must be a valid boolean`);
+        }
+      } else if (fieldConfig.type === "date") {
+        if (value === "") {
+          data[fieldName] = null;
+        }
+      } else if (fieldConfig.type === "datetime") {
+        if (value === "") {
+          data[fieldName] = null;
+        }
+      } else if (fieldConfig.type === "time") {
+        if (value === "") {
+          data[fieldName] = null;
+        }
+      } else {
+        throw new Error(`coerceAndValidate: type "${fieldConfig.type}" is not implemented`);
+      }
+    } catch (e: any) {
+      errors[fieldName] = [e.message];
+    }
+  }
+
+  if (Object.keys(errors).length) {
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message: "Validation failed. Please check your inputs and try again.",
+      details: errors,
+    });
+  }
+
+  return input;
+}
+
+export const coerceAndValidateWorkflows: Workflow[] = [
+  {
+    name: "core_coerceAndValidateOnCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => coerceAndValidate(input),
+  },
+  {
+    name: "core_coerceAndValidateOnUpdate",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => coerceAndValidate(input),
+  },
+];

package/src/fields/ArrayField.ts

@@ -1,33 +0,0 @@
-// import { Field, type FieldOperatorsType } from "./Field.ts";
-
-// export class ArrayField extends Field {
-//   public static override type: string = "array";
-//   protected fieldName: string;
-//   protected collectionName: string;
-//   public fieldOperatorsType: FieldOperatorsType = "string";
-
-//   constructor(fieldName: string, collectionName: string) {
-//     super();
-//     this.fieldName = fieldName;
-//     this.collectionName = collectionName;
-//   }
-
-//   public override encodeFieldValue(value: any): any[] | null {
-//     if (value === null || value === undefined) {
-//       return null;
-//     }
-
-//     if (typeof value === "string") {
-//       try {
-//         value = JSON.parse(value);
-//       } catch (_error) {
-//         this.throwIncompatibleValueTypeError();
-//       }
-//     }
-
-//     if (!Array.isArray(value)) {
-//       this.throwIncompatibleValueTypeError();
-//     }
-//     return value;
-//   }
-// }

package/src/fields/BoolField.ts

@@ -1,34 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class BoolField extends Field {
-  public static override type: string = "bool";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-
-  public override encodeFieldValue(value: any): boolean | null {
-    if (value === null || value === undefined || value === "null") {
-      return null;
-    }
-
-    if (typeof value === "boolean") {
-      return value;
-    }
-
-    if (typeof value === "string") {
-      const lowerCaseValue = value.toLowerCase().trim();
-      if (lowerCaseValue === "true" || lowerCaseValue === "1") {
-        return true;
-      } else if (lowerCaseValue === "false" || lowerCaseValue === "0") {
-        return false;
-      }
-    }
-
-    this.throwIncompatibleValueTypeError();
-  }
-}

package/src/fields/DateField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class DateField extends Field {
-  public static override type: string = "date";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/DateTimeField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class DateTimeField extends Field {
-  public static override type: string = "datetime";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/DecimalField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class DecimalField extends Field {
-  public static override type: string = "decimal";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/FieldUtils.ts

@@ -1,56 +0,0 @@
-import type { Field } from "../types/index.ts";
-import { StringField } from "../fields/StringField.ts";
-import { TextField } from "../fields/TextField.ts";
-import { DateField } from "../fields/DateField.ts";
-import { LongField } from "../fields/LongField.ts";
-import { DecimalField } from "../fields/DecimalField.ts";
-import { FloatField } from "../fields/FloatField.ts";
-import { BoolField } from "../fields/BoolField.ts";
-import { IntegerField } from "../fields/IntegerField.ts";
-
-import { LobbError } from "../LobbError.ts";
-import { TimeField } from "./TimeField.ts";
-import { DateTimeField } from "./DateTimeField.ts";
-import { Lobb } from "../Lobb.ts";
-
-export class FieldUtils {
-  public static fieldClasses: any[] = [
-    StringField,
-    TextField,
-    LongField,
-    DecimalField,
-    FloatField,
-    BoolField,
-    IntegerField,
-    DateField,
-    TimeField,
-    DateTimeField,
-  ];
-
-  public static getFieldInstance(
-    fieldName: string,
-    collectionName: string,
-  ): Field {
-    const fieldConfig = Lobb.instance.configManager.getField(
-      fieldName,
-      collectionName,
-    );
-
-    for (let index = 0; index < this.fieldClasses.length; index++) {
-      const FieldClass = this.fieldClasses[index];
-      if (FieldClass.type === fieldConfig.type) {
-        return new FieldClass(fieldName, collectionName) as Field;
-      }
-    }
-
-    throw new LobbError({
-      code: "INTERNAL_SERVER_ERROR",
-      message:
-        `The ${fieldConfig.type} CollectionFieldType specified by the user doesnt exist`,
-    });
-  }
-
-  public static getFieldsTypes(): string[] {
-    return this.fieldClasses.map((Class) => Class.type);
-  }
-}

package/src/fields/FloatField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class FloatField extends Field {
-  public static override type: string = "float";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/IntegerField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class IntegerField extends Field {
-  public static override type: string = "integer";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/LongField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class LongField extends Field {
-  public static override type: string = "long";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/ObjectField.ts

@@ -1,15 +0,0 @@
-// import { Field, type FieldOperatorsType } from "./Field.ts";
-// import _ from "lodash";
-
-// export class ObjectField extends Field {
-//   public static override type: string = "object";
-//   protected fieldName: string;
-//   protected collectionName: string;
-//   public fieldOperatorsType: FieldOperatorsType = "string";
-
-//   constructor(fieldName: string, collectionName: string) {
-//     super();
-//     this.fieldName = fieldName;
-//     this.collectionName = collectionName;
-//   }
-// }

package/src/fields/StringField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class StringField extends Field {
-  public static override type: string = "string";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/TextField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class TextField extends Field {
-  public static override type: string = "text";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/fields/TimeField.ts

@@ -1,13 +0,0 @@
-import { Field } from "../types/index.ts";
-
-export class TimeField extends Field {
-  public static override type: string = "time";
-  protected fieldName: string;
-  protected collectionName: string;
-
-  constructor(fieldName: string, collectionName: string) {
-    super();
-    this.fieldName = fieldName;
-    this.collectionName = collectionName;
-  }
-}

package/src/types/Field.ts

@@ -1,29 +0,0 @@
-import { LobbError } from "../LobbError.ts";
-
-export abstract class Field {
-  protected abstract fieldName: string;
-  protected abstract collectionName: string;
-
-  // this forces all child classes to define a static 'type' property
-  static get type(): string {
-    throw new Error(
-      `(${this.name}) class must define a static 'type' property.`,
-    );
-  }
-
-  public encodeFieldValue(value: any): any {
-    return value;
-  }
-
-  public decodeFieldValue(value: any): any {
-    return value;
-  }
-
-  protected throwIncompatibleValueTypeError(): never {
-    throw new LobbError({
-      code: "BAD_REQUEST",
-      message:
-        `The value provided for the (${this.fieldName}) field is incompatible.`,
-    });
-  }
-}

package/src/types/workflows/processors.ts

@@ -1 +0,0 @@
-export type ProcessorType = "pre_processors" | "post_processors";

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

@@ -1,46 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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;
-    },
-  },
-];

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

@@ -1,13 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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.isCollectionVirtual(input.collectionName) ? {} as any : Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
-
-  input.data = await processPayloadWithSchema(
-    type,
-    input.data,
-    fieldsSchema,
-    processAllFields,
-    input.context,
-  );
-
-  return input;
-}

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

@@ -1,47 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

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

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

@@ -1,52 +0,0 @@
-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;
-      }
-    },
-  },
-};