@lobb-js/core 0.22.1 → 0.24.0

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/workflows/coreWorkflows/processors/hooksWorkflows.ts

@@ -1,5 +1,17 @@
 import type { Workflow } from "../../WorkflowSystem.ts";
 import { Lobb } from "../../../Lobb.ts";
+import { LobbError } from "../../../LobbError.ts";
+
+async function runHook(hook: Function, args: any, label: string) {
+  try {
+    return await hook(args);
+  } catch (err: any) {
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message: `Hook "${label}" threw an error: ${err?.message ?? String(err)}`,
+    });
+  }
+}
 
 async function runFieldHooks(
   hookName: "beforeCreate" | "beforeUpdate" | "afterCreate" | "afterUpdate",
@@ -10,7 +22,11 @@ async function runFieldHooks(
   for (const [fieldName, fieldConfig] of Object.entries(fields)) {
     const hook = "hooks" in fieldConfig ? fieldConfig.hooks?.[hookName] : undefined;
     if (!hook) continue;
-    const result = await hook({ data: input.data, context: input.context });
+    const result = await runHook(
+      hook,
+      { data: input.data, context: input.context },
+      `${input.collectionName}.${fieldName}.${hookName}`,
+    );
     if (result !== undefined) {
       input.data[fieldName] = result;
     }
@@ -24,7 +40,9 @@ export const hooksWorkflows: Workflow[] = [
     handler: async (input) => {
       if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
       const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
-      await hooks?.beforeCreate?.({ data: input.data, context: input.context });
+      if (hooks?.beforeCreate) {
+        await runHook(hooks.beforeCreate, { data: input.data, context: input.context }, `${input.collectionName}.beforeCreate`);
+      }
       await runFieldHooks("beforeCreate", input);
       return input;
     },
@@ -35,7 +53,9 @@ export const hooksWorkflows: Workflow[] = [
     handler: async (input) => {
       if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
       const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
-      await hooks?.beforeUpdate?.({ data: input.data, context: input.context });
+      if (hooks?.beforeUpdate) {
+        await runHook(hooks.beforeUpdate, { data: input.data, context: input.context }, `${input.collectionName}.beforeUpdate`);
+      }
       await runFieldHooks("beforeUpdate", input);
       return input;
     },
@@ -46,7 +66,9 @@ export const hooksWorkflows: Workflow[] = [
     handler: async (input) => {
       if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
       const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
-      await hooks?.afterCreate?.({ data: input.data, context: input.context });
+      if (hooks?.afterCreate) {
+        await runHook(hooks.afterCreate, { data: input.data, context: input.context }, `${input.collectionName}.afterCreate`);
+      }
       await runFieldHooks("afterCreate", input);
       return input;
     },
@@ -57,7 +79,9 @@ export const hooksWorkflows: Workflow[] = [
     handler: async (input) => {
       if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
       const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
-      await hooks?.afterUpdate?.({ data: input.data, context: input.context });
+      if (hooks?.afterUpdate) {
+        await runHook(hooks.afterUpdate, { data: input.data, context: input.context }, `${input.collectionName}.afterUpdate`);
+      }
       await runFieldHooks("afterUpdate", input);
       return input;
     },