@lobb-js/core 0.14.0 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobb-js/core",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "license": "AGPL-3.0-only",
   "type": "module",
   "publishConfig": {

package/src/api/WebServer.ts

@@ -77,7 +77,15 @@ export class WebServer {
     this.server = Bun.serve({
       port: this.webConfig.port ?? 3000,
       hostname: this.webConfig.host ?? "0.0.0.0",
-      fetch: this.app.fetch,
+      fetch: (req, server) => {
+        // Bun closes idle connections after 10s by default.
+        // SSE connections (/api/events) are long-lived and may have quiet periods,
+        // so we disable the timeout per-request only for that route.
+        if (new URL(req.url).pathname.startsWith("/api/events")) {
+          server.timeout(req, 0);
+        }
+        return this.app.fetch(req);
+      },
     });
     this.port = this.server.port!;
   }

package/src/types/config/collectionFields.ts

@@ -15,8 +15,28 @@ const UiSchema = z.object({
   input: UiInputSchema.optional(),
 });
 
+export type FieldHookFn = (ctx: {
+  data: Record<string, any>;
+  context?: any;
+}) => any;
+
+export type FieldValidatorFn = (ctx: {
+  value: any;
+  data: Record<string, any>;
+  context?: any;
+}) => string | undefined | Promise<string | undefined>;
+
+const FieldHooksSchema = z.object({
+  beforeCreate: z.custom<FieldHookFn>((val) => typeof val === "function").optional(),
+  beforeUpdate: z.custom<FieldHookFn>((val) => typeof val === "function").optional(),
+  afterCreate: z.custom<FieldHookFn>((val) => typeof val === "function").optional(),
+  afterUpdate: z.custom<FieldHookFn>((val) => typeof val === "function").optional(),
+}).optional();
+
 // Base field schema
 export const CollectionFieldBaseSchema = z.object({
+  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(),

package/src/types/config/collectionsConfig.ts

@@ -4,6 +4,18 @@ import {
   CollectionIntegerFieldSchema,
 } from "./collectionFields.ts";
 
+export type CollectionHookFn = (ctx: {
+  data: Record<string, any>;
+  context?: any;
+}) => void | Promise<void>;
+
+const CollectionHooksSchema = z.object({
+  beforeCreate: z.custom<CollectionHookFn>((val) => typeof val === "function").optional(),
+  afterCreate: z.custom<CollectionHookFn>((val) => typeof val === "function").optional(),
+  beforeUpdate: z.custom<CollectionHookFn>((val) => typeof val === "function").optional(),
+  afterUpdate: z.custom<CollectionHookFn>((val) => typeof val === "function").optional(),
+}).optional();
+
 // CollectionIndexField
 export const CollectionIndexFieldSchema = z.object({
   order: z.enum(["asc", "desc"]),
@@ -33,6 +45,7 @@ export const CollectionFieldsSchema = z.intersection(
 export const CollectionConfigSchema = z.object({
   category: z.string().optional(),
   singleton: z.boolean().optional(),
+  hooks: CollectionHooksSchema,
   indexes: CollectionIndexesSchema,
   fields: CollectionFieldsSchema,
 });

package/src/workflows/coreWorkflows/index.ts

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

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

@@ -0,0 +1,60 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { Lobb } from "../../../Lobb.ts";
+
+async function runFieldHooks(
+  hookName: "beforeCreate" | "beforeUpdate" | "afterCreate" | "afterUpdate",
+  input: any,
+) {
+  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+    const hook = fieldConfig.hooks?.[hookName];
+    if (!hook) continue;
+    const result = await hook({ data: input.data, context: input.context });
+    if (result !== undefined) {
+      input.data[fieldName] = result;
+    }
+  }
+}
+
+export const hooksWorkflows: Workflow[] = [
+  {
+    name: "core_hooksBeforeCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => {
+      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      await hooks?.beforeCreate?.({ data: input.data, context: input.context });
+      await runFieldHooks("beforeCreate", input);
+      return input;
+    },
+  },
+  {
+    name: "core_hooksBeforeUpdate",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => {
+      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      await hooks?.beforeUpdate?.({ data: input.data, context: input.context });
+      await runFieldHooks("beforeUpdate", input);
+      return input;
+    },
+  },
+  {
+    name: "core_hooksAfterCreate",
+    eventName: "core.store.createOne",
+    handler: async (input) => {
+      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      await hooks?.afterCreate?.({ data: input.data, context: input.context });
+      await runFieldHooks("afterCreate", input);
+      return input;
+    },
+  },
+  {
+    name: "core_hooksAfterUpdate",
+    eventName: "core.store.updateOne",
+    handler: async (input) => {
+      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      await hooks?.afterUpdate?.({ data: input.data, context: input.context });
+      await runFieldHooks("afterUpdate", input);
+      return input;
+    },
+  },
+];

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

@@ -87,6 +87,7 @@ export async function validatePayloadWithSchema(
           }
         }
       }
+
     }
   }
 

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

@@ -0,0 +1,54 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+import { Lobb } from "../../../Lobb.ts";
+import { LobbError } from "../../../LobbError.ts";
+
+async function runFieldValidators(input: any, processAllFields: boolean) {
+  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  const data = input.data;
+  const errors: Record<string, string[]> = {};
+
+  const fieldNames = processAllFields ? Object.keys(fields) : Object.keys(data);
+
+  for (const fieldName of fieldNames) {
+    const fieldConfig = fields[fieldName];
+    if (!fieldConfig?.validator) continue;
+
+    const error = await fieldConfig.validator({
+      value: data[fieldName],
+      data,
+      context: input.context,
+    });
+
+    if (error) {
+      if (!errors[fieldName]) errors[fieldName] = [];
+      errors[fieldName].push(error);
+    }
+  }
+
+  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 validatorWorkflows: Workflow[] = [
+  {
+    name: "core_validatorOnCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => {
+      return await runFieldValidators(input, true);
+    },
+  },
+  {
+    name: "core_validatorOnUpdate",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => {
+      return await runFieldValidators(input, false);
+    },
+  },
+];