@lobb-js/core 0.22.1 → 0.23.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lobb-js/core",
   "license": "UNLICENSED",
-  "version": "0.22.1",
+  "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/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/types/config/collectionFields.ts

@@ -54,6 +54,7 @@ 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(),
   ui: UiSchema.optional(),

package/src/workflows/coreWorkflows/index.ts

@@ -6,11 +6,13 @@ 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,

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),
+  },
+];