@lobb-js/core 0.13.3 → 0.15.0

package/package.json

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

package/src/Lobb.ts

@@ -59,7 +59,6 @@ export class Lobb {
       };
     }
 
-    console.log("starting the app");
     const lobb = new Lobb();
     lobb.studio = studio;
     lobb.tempDatabase = isTempDatabase;
@@ -79,7 +78,7 @@ export class Lobb {
     lobb.schemaService = await SchemaService.init();
     const webPort = lobb.configManager.config.web_server.port ?? 3000;
     const studioPort = await studio.start(webPort);
-    lobb.webServer = await WebServer.init(studioPort);
+    lobb.webServer = await WebServer.init(studio.devPort !== null ? null : studioPort);
     lobb.collectionControllers = collectionControllers;
     lobb.transactions = transactions;
     await lobb.extensionSystem.executeExtensionsInitMethods();
@@ -90,7 +89,7 @@ export class Lobb {
     // generate types
     lobb.typesGenerator = await TypesGenerator.init();
 
-    console.log("The app is running");
+    console.log(`The app is running on http://localhost:${studioPort ?? lobb.webServer.port}`);
 
     return lobb;
   }

package/src/api/WebServer.ts

@@ -74,53 +74,11 @@ export class WebServer {
       this.app.all("/studio/*", studioProxy);
     }
 
-    const isDev = process.env.LOBB_MODE !== "prod";
-    const serveBase = {
+    this.server = Bun.serve({
       port: this.webConfig.port ?? 3000,
       hostname: this.webConfig.host ?? "0.0.0.0",
-    };
-
-    // In dev, forward WebSocket upgrade requests to the Vite dev server so that
-    // Vite's HMR can connect through the Lobb proxy instead of falling back to
-    // a direct connection (which causes a console warning).
-    if (isDev && studioPort) {
-      type WSData = { path: string; upstream?: WebSocket };
-      this.server = Bun.serve<WSData>({
-        ...serveBase,
-        fetch: (req, server) => {
-          if (req.headers.get("upgrade") === "websocket") {
-            const url = new URL(req.url);
-            if (url.pathname.startsWith("/studio")) {
-              const upgraded = server.upgrade(req, { data: { path: url.pathname + url.search } });
-              if (upgraded) return undefined;
-            }
-          }
-          return this.app.fetch(req);
-        },
-        websocket: {
-          open(ws) {
-            const upstream = new WebSocket(`ws://localhost:${studioPort}${ws.data.path.replace(/^\/studio/, "") || "/"}`);
-            ws.data.upstream = upstream;
-            upstream.addEventListener("message", (e) => ws.send(e.data as string | ArrayBuffer));
-            upstream.addEventListener("close", (e) => ws.close(e.code, e.reason));
-            upstream.addEventListener("error", () => ws.close());
-          },
-          message(ws, message) {
-            if (ws.data.upstream?.readyState === WebSocket.OPEN) {
-              ws.data.upstream.send(message as string | ArrayBuffer);
-            }
-          },
-          close(ws, code, reason) {
-            ws.data.upstream?.close(code, reason);
-          },
-        },
-      });
-    } else {
-      this.server = Bun.serve({
-        ...serveBase,
-        fetch: this.app.fetch,
-      });
-    }
+      fetch: this.app.fetch,
+    });
     this.port = this.server.port!;
   }
 }

package/src/studio/Studio.ts

@@ -7,6 +7,7 @@ import type { AddressInfo } from "node:net";
 export class Studio {
   private studioDir: string;
   private process: ReturnType<typeof Bun.spawn> | null = null;
+  public devPort: number | null = null;
 
   constructor(projectDir: string) {
     // Support flat structure (vite.config.ts at project root) and nested (studio/ subdir).
@@ -21,24 +22,17 @@ export class Studio {
   }
 
   public async start(webPort: number): Promise<number | null> {
+    if (this.process) return null;
     if (!await this.exists()) return null;
 
-    const mode = process.env.LOBB_MODE;
-
-    if (mode === "prod") {
-      const buildDir = `${this.studioDir}/build`;
-      try {
-        const s = await stat(buildDir);
-        if (!s.isDirectory()) throw new Error();
-      } catch {
-        throw new Error(
-          "Studio build not found. Run 'bun run build:studio' before starting in production mode."
-        );
-      }
-      return await this.serveBuild(webPort);
-    }
+    const buildDir = `${this.studioDir}/build`;
+    try {
+      const s = await stat(buildDir);
+      if (s.isDirectory()) return await this.serveBuild(webPort);
+    } catch {}
 
-    return await this.runDevServer(webPort);
+    await this.runDevServer(webPort);
+    return this.devPort;
   }
 
   private async exists(): Promise<boolean> {
@@ -51,13 +45,12 @@ export class Studio {
   }
 
   private async serveBuild(webPort: number): Promise<number> {
-    console.log("Studio: running production build.");
     const port = await Studio.getFreePort();
     this.process = Bun.spawn(["bun", "run", "build/index.js"], {
       cwd: this.studioDir,
       env: { ...process.env, PORT: String(port) },
-      stdin: "pipe",
-      stdout: "inherit",
+      stdin: "ignore",
+      stdout: "ignore",
       stderr: "inherit",
     });
     await Studio.waitForPort(port);
@@ -65,19 +58,18 @@ export class Studio {
     return port;
   }
 
-  private async runDevServer(webPort: number): Promise<number> {
-    const port = await Studio.getFreePort();
-    console.log("Studio: running dev server.");
-    this.process = Bun.spawn(["bun", "run", "dev:studio", "--port", String(port)], {
-      cwd: this.studioDir,
-      env: { ...process.env },
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "inherit",
-    });
-    await Studio.waitForPort(port);
-    console.log(`Studio: http://localhost:${webPort}/studio`);
-    return port;
+  private async runDevServer(webPort: number): Promise<void> {
+    this.devPort = await Studio.getAvailablePort(5173);
+    this.process = Bun.spawn(
+      ["bun", "run", "dev:studio", "--", "--port", String(this.devPort)],
+      {
+        cwd: this.studioDir,
+        stdin: "ignore",
+        stdout: "inherit",
+        stderr: "inherit",
+        env: { ...process.env, LOBB_PORT: String(webPort) },
+      }
+    );
   }
 
   private static getFreePort(): Promise<number> {
@@ -93,6 +85,24 @@ export class Studio {
     });
   }
 
+  // Like Vite's port resolution: try preferred port, increment on conflict.
+  // Predictable ports preserve browser sessions across restarts.
+  private static getAvailablePort(preferred: number): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const server = createServer();
+      server.listen(preferred, "127.0.0.1", () => {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve(preferred);
+        });
+      });
+      server.on("error", (err: NodeJS.ErrnoException) => {
+        if (err.code === "EADDRINUSE") resolve(Studio.getAvailablePort(preferred + 1));
+        else reject(err);
+      });
+    });
+  }
+
   private static async waitForPort(port: number, maxAttempts = 50): Promise<void> {
     for (let i = 0; i < maxAttempts; i++) {
       const connected = await new Promise<boolean>((resolve) => {

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