@lobb-js/core 0.13.0

package/src/api/collections/transactions.ts

@@ -0,0 +1,166 @@
+import type { CollectionService, TriggeredBy } from "./CollectionService.ts";
+import type { CollectionStore } from "./collectionStore.ts";
+import type { Context as HonoContext } from "hono";
+import type { PoolClient } from "pg";
+import { Lobb } from "../../Lobb.ts";
+import { LobbReturnError } from "../errorHandler.ts";
+
+// Helper: add Symbol.dispose to a pg PoolClient so `using` syntax works
+function asDisposable<T extends { release(): void }>(client: T): T & Disposable {
+  (client as any)[Symbol.dispose] = () => client.release();
+  return client as T & Disposable;
+}
+
+export type TransactionBody = {
+  [
+    K in keyof CollectionService as CollectionService[K] extends
+      (...args: any[]) => any ? K
+      : never
+  ]: {
+    method: K;
+    props: K extends keyof CollectionStore
+      ? Parameters<CollectionStore[K & keyof CollectionStore]>[0]
+      : Parameters<CollectionService[K]>[0];
+  };
+}[keyof CollectionService];
+
+export async function beginTransaction<T>(
+  func: (client: PoolClient) => Promise<T>,
+  localClient?: PoolClient,
+  rollback: boolean = false,
+): Promise<T> {
+  if (localClient) {
+    return await func(localClient);
+  }
+
+  const dbDriver = Lobb.instance.databaseService.getDriver();
+  const pool = dbDriver.getConnection();
+  const client = asDisposable(await pool.connect());
+  using _ = client;
+  await client.query("BEGIN");
+  let returnedValue;
+  try {
+    returnedValue = await func(client);
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  }
+
+  if (rollback) {
+    await client.query("ROLLBACK");
+  }
+
+  await client.query("COMMIT");
+
+  return returnedValue;
+}
+
+export async function transactions({
+  body,
+  rollback = false,
+  triggeredBy,
+  context,
+}: {
+  body: TransactionBody[];
+  rollback?: boolean;
+  triggeredBy?: TriggeredBy;
+  context?: HonoContext;
+}): Promise<any> {
+  // starting the transactions
+  const responses = await beginTransaction(
+    async (client) => {
+      const responses = [];
+      for (let index = 0; index < body.length; index++) {
+        const transaction = body[index];
+        transaction.props = Lobb.instance.utils.renderTemplateDeep(
+          transaction.props,
+          {
+            responses: responses,
+          },
+        );
+
+        if (transaction.method === "findAll") {
+          const res = await Lobb.instance.collectionService.findAll({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "findOne") {
+          const res = await Lobb.instance.collectionService.findOne({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "createOne") {
+          const res = await Lobb.instance.collectionService.createOne({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "updateOne") {
+          const res = await Lobb.instance.collectionService.updateOne({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "deleteOne") {
+          const res = await Lobb.instance.collectionService.deleteOne({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "createMany") {
+          const res = await Lobb.instance.collectionService.createMany({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "updateMany") {
+          const res = await Lobb.instance.collectionService.updateMany({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        } else if (transaction.method === "deleteMany") {
+          const res = await Lobb.instance.collectionService.deleteMany({
+            ...transaction.props,
+            context,
+            client,
+            triggeredBy,
+          });
+          responses.push(res);
+        }
+      }
+
+      return responses;
+    },
+    undefined,
+    rollback,
+  );
+
+  await Lobb.instance.eventSystem.emit(
+    `core.collection.transaction`,
+    {
+      body: body,
+      responses: responses,
+      rollback: rollback,
+      triggeredBy: triggeredBy,
+    },
+  );
+
+  return responses;
+}

package/src/api/collections/utils.ts

@@ -0,0 +1,73 @@
+import { Lobb } from "../../Lobb.ts";
+import { z } from "zod";
+
+export function getCollectionDocumentSchema(
+  collectionName?: string,
+) {
+  if (collectionName) {
+    const collection = Lobb.instance.configManager.getCollection(
+      collectionName,
+    );
+    const fieldNames = Object.keys(collection.fields);
+
+    const properties: Record<string, any> = {};
+    for (let index = 0; index < fieldNames.length; index++) {
+      const fieldName = fieldNames[index];
+      properties[fieldName] = getColFieldPropSchema(
+        collectionName,
+        fieldName,
+      );
+    }
+
+    return z.object(properties);
+  }
+
+  const schema = z.object({
+    id: z.number().int().optional(),
+  }).passthrough();
+
+  return schema;
+}
+
+export function getColFieldPropSchema(
+  collectionName: string,
+  fieldName: string,
+) {
+  const field = Lobb.instance.configManager.getField(
+    fieldName,
+    collectionName,
+  );
+  let fieldSchema;
+  if (field.type === "bool") {
+    fieldSchema = z.boolean();
+  } else if (field.type === "date") {
+    fieldSchema = z.date();
+  } else if (field.type === "time") {
+    fieldSchema = z.date();
+  } else if (field.type === "datetime") {
+    fieldSchema = z.date();
+  } else if (field.type === "decimal") {
+    fieldSchema = z.string();
+  } else if (field.type === "float") {
+    fieldSchema = z.number();
+  } else if (field.type === "integer") {
+    fieldSchema = z.number().int();
+  } else if (field.type === "long") {
+    fieldSchema = z.bigint();
+  } else if (field.type === "string") {
+    fieldSchema = z.string().max(field.type.length);
+  } else if (field.type === "text") {
+    fieldSchema = z.string();
+  } else {
+    throw new Error(
+      `The (${collectionName}.${fieldName}) field has a type thats not implemented in the genColPropsJsonSchema`,
+    );
+  }
+
+  const requiredField = Boolean(field.validators?.required);
+  if (!requiredField) {
+    fieldSchema = fieldSchema.optional();
+  }
+
+  return fieldSchema;
+}

package/src/api/errorHandler.ts

@@ -0,0 +1,73 @@
+import type { Context } from "hono";
+import { LobbError } from "../LobbError.ts";
+
+// pg errors have a 5-char SQLSTATE code and a detail property
+function isPgDatabaseError(error: any): error is { code: string; detail?: string; message: string } {
+  return (
+    error != null &&
+    typeof error.code === "string" &&
+    /^[0-9A-Z]{5}$/.test(error.code)
+  );
+}
+
+export class LobbReturnError extends Error {
+  public any: any;
+
+  constructor(any: any) {
+    super();
+    this.any = any;
+  }
+}
+
+export function errorHandler(error: any, c: Context) {
+  if (error instanceof LobbError) {
+    return c.json(
+      {
+        status: error.status,
+        code: error.code,
+        message: error.message,
+        details: error.details,
+      },
+      error.status as any,
+    );
+  } else if (isPgDatabaseError(error)) {
+    if (error.code === "23505") {
+      const match = error.detail?.match(/\((\w+)\)=\(/);
+      if (match) {
+        const uniqeFieldName = match[1];
+        throw new LobbError({
+          code: "CONFLICT",
+          message: `Violation of the uniqueness constraint.`,
+          details: {
+            [uniqeFieldName]: [
+              `Duplicate value found, this field must be unique.`,
+            ],
+          },
+        });
+      }
+      throw new LobbError({
+        code: "CONFLICT",
+        message: `One or more fields violate the uniqueness constraint.`,
+        details: error.detail,
+      });
+    } else if (error.code === "22P02") {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: error.message,
+      });
+    }
+  } else if (error instanceof LobbReturnError) {
+    return error.any;
+  }
+
+  // TODO: replace this with a better logging system
+  console.error(error);
+  return c.json(
+    {
+      status: 500,
+      code: "INTERNAL_ERROR",
+      message: "An unexpected error occurred. Please contact support.",
+    },
+    500,
+  );
+}

package/src/api/events/index.ts

@@ -0,0 +1,129 @@
+import { type Context, Hono } from "hono";
+import { stream } from "hono/streaming";
+import { Lobb } from "../../Lobb.ts";
+import { z } from "zod";
+import { Query } from "mingo";
+
+const eventSubscriptionSchema = z.object({
+  event: z.string(),
+  filter: z.record(z.unknown()).optional(),
+});
+
+const eventsRequestSchema = z.object({
+  subscriptions: z.array(eventSubscriptionSchema).min(1, "At least one subscription is required"),
+});
+
+interface EventPayload {
+  eventName: string;
+  payload: Record<string, unknown>;
+  timestamp: string;
+}
+
+export function getEventsRoute() {
+  const rest = new Hono();
+
+  rest.post("/", async (c: Context) => {
+    // Parse and validate request body
+    const body = await c.req.json();
+    const parseResult = eventsRequestSchema.safeParse(body);
+
+    if (!parseResult.success) {
+      return c.json({ error: parseResult.error.errors }, 400);
+    }
+
+    const { subscriptions } = parseResult.data;
+    const lobb = Lobb.instance;
+
+    // Validate that all requested events exist
+    for (const subscription of subscriptions) {
+      if (!lobb.eventSystem.eventExists(subscription.event)) {
+        return c.json({
+          error: `Event '${subscription.event}' does not exist`
+        }, 400);
+      }
+    }
+
+    return stream(c, async (stream) => {
+      const signal = c.req.raw.signal;
+      const subscriptionIds: string[] = [];
+      const eventQueue: EventPayload[] = [];
+      let isProcessing = false;
+
+      // Handler that queues events with optional filtering
+      const createHandler = (eventName: string, filter?: Record<string, unknown>) => async (input: Record<string, unknown>) => {
+        // Apply filter if provided
+        if (filter) {
+          const query = new Query(filter);
+          if (!query.test(input)) {
+            return input; // Filter didn't match, don't queue
+          }
+        }
+
+        eventQueue.push({
+          eventName,
+          payload: input,
+          timestamp: new Date().toISOString()
+        });
+
+        // Process queue if not already processing
+        if (!isProcessing && !signal.aborted) {
+          await processQueue();
+        }
+
+        return input;
+      };
+
+      // Process queued events
+      const processQueue = async () => {
+        if (isProcessing) return;
+        isProcessing = true;
+
+        while (eventQueue.length > 0 && !signal.aborted) {
+          const event = eventQueue.shift();
+          try {
+            await stream.write(JSON.stringify(event) + "\n");
+          } catch (_error) {
+            // Stream closed, stop processing
+            break;
+          }
+        }
+
+        isProcessing = false;
+      };
+
+      try {
+        // Send an initial empty object so Bun resolves the client's fetch() promise
+        // immediately (Bun waits for the first chunk before resolving a streaming fetch)
+        await stream.write("\n");
+
+        // Subscribe to all requested events with filters
+        for (const subscription of subscriptions) {
+          const subscriptionId = `stream_${crypto.randomUUID()}`;
+          subscriptionIds.push(subscriptionId);
+
+          lobb.eventSystem.subscribe({
+            name: subscriptionId,
+            eventName: subscription.event,
+            handler: createHandler(subscription.event, subscription.filter),
+          });
+        }
+
+        // Keep connection alive and wait for abort signal
+        await new Promise((resolve) => {
+          signal.addEventListener('abort', () => {
+            resolve(null);
+          }, { once: true });
+        });
+      } catch (_error) {
+        // Client disconnected - clean exit
+      } finally {
+        // Clean up all subscriptions
+        for (const subscriptionId of subscriptionIds) {
+          await lobb.eventSystem.unsubscribe(subscriptionId);
+        }
+      }
+    });
+  });
+
+  return rest;
+}

package/src/api/meta/route.ts

@@ -0,0 +1,66 @@
+import type { Context } from "hono";
+import { Hono } from "hono";
+import { MetaService } from "./service.ts";
+
+export const metaRoutePathDescription: any = {
+  "/api/meta": {
+    get: {
+      summary: `Get Meta`,
+      description: "Get meta data of the API",
+      tags: [
+        "meta",
+      ],
+      responses: {
+        200: {
+          description: "Successful response",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  collections: {
+                    type: "object",
+                    properties: {},
+                  },
+                  filter: {
+                    type: "object",
+                    properties: {},
+                  },
+                  extensions: {
+                    type: "object",
+                    properties: {},
+                  },
+                  dashboard_navs: {
+                    type: "object",
+                    properties: {},
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+export function getMetaRoute() {
+  const rest = new Hono();
+
+  rest.get("/", async (c: Context) => {
+    const returnedValue: any = {};
+
+    returnedValue["version"] = MetaService.getVersion();
+    returnedValue["relations"] = MetaService.getRelations();
+    returnedValue["collections"] = MetaService.getCollections();
+    returnedValue["extensions"] = await MetaService.getExtensions();
+    returnedValue["filter"] = MetaService.getFilter();
+    returnedValue["studio_workflows"] = MetaService.getStudioWorkflows();
+    returnedValue["events"] = MetaService.getEvents();
+    returnedValue["event_context_type"] = MetaService.getEventContextType();
+
+    return c.json(returnedValue);
+  });
+
+  return rest;
+}

package/src/api/meta/service.ts

@@ -0,0 +1,163 @@
+import {
+  basicFilterOperatorsSchema,
+  filterJsonSchema,
+  filterSchema,
+} from "../../types/index.ts";
+import { Lobb } from "../../Lobb.ts";
+import { convertSchemaToTypeString } from "../../utils/utils.ts";
+import { z, type ZodFunction } from "zod";
+import { LobbErrorSchema } from "../../LobbError.ts";
+import packageJson from "../../../package.json" with { type: "json" };
+
+export class MetaService {
+  public static getConfig() {
+    const { collections } = Lobb.instance.configManager.config;
+    const returnedData = { collections };
+    return returnedData;
+  }
+
+  public static getVersion() {
+    return packageJson.version;
+  }
+
+  public static getRelations() {
+    const relations = Lobb.instance.configManager.config.relations;
+    return relations;
+  }
+
+  public static getCollections() {
+    const collections: any = {};
+
+    const collectionsNames = Lobb.instance.configManager.getCollectionsNames();
+    for (let index = 0; index < collectionsNames.length; index++) {
+      const collectionName = collectionsNames[index];
+      const collection = Lobb.instance.configManager.getCollection(
+        collectionName,
+      );
+      collections[collectionName] = {};
+
+      // is collection singleton
+      collections[collectionName].singleton = Lobb.instance.configManager
+        .isCollectionSingleton(collectionName);
+
+      // filling the extension property
+      collections[collectionName].category = collection.category;
+      collections[collectionName].owner = Lobb.instance.utils
+        .getCollectionOwner(
+          collectionName,
+        );
+
+      // filling the fields
+      collections[collectionName].fields = {};
+      const fieldNames = Lobb.instance.configManager.getFieldNames(
+        collectionName,
+      );
+      for (let index = 0; index < fieldNames.length; index++) {
+        const fieldName = fieldNames[index];
+        const fieldConfig = Lobb.instance.configManager.getField(
+          fieldName,
+          collectionName,
+        );
+
+        const field: any = {};
+        field.type = fieldConfig.type;
+        field.label = fieldName;
+        field.key = fieldName;
+        field.validators = fieldConfig.validators;
+        field.pre_processors = fieldConfig.pre_processors;
+        field.ui = fieldConfig.ui;
+
+        collections[collectionName].fields[fieldName] = field;
+      }
+    }
+
+    return collections;
+  }
+
+  public static async getExtensions() {
+    const extensions: Record<string, any> = {};
+    if (Lobb.instance.configManager.config.extensions) {
+      const extensionNames = Lobb.instance.configManager.getExtensionNames();
+      for (let index = 0; index < extensionNames.length; index++) {
+        const extensionName = extensionNames[index];
+        const lobb = Lobb.instance;
+        const extensionMeta = await lobb.extensionSystem.getExtensionMeta(
+          extensionName,
+        );
+        extensions[extensionName] = extensionMeta;
+      }
+    }
+
+    return extensions;
+  }
+
+  public static getFilter() {
+    const filter: Record<string, any> = {};
+
+    filter.operators = Object.keys(basicFilterOperatorsSchema.shape);
+    // this is needed so that the AI in lobb studio knows how to generate a filter object
+    filter.filter_schema = filterJsonSchema;
+
+    return filter;
+  }
+
+  public static getStudioWorkflows() {
+    const workflows = Lobb.instance.workflowSystem.workflows;
+    const studio_workflows = workflows.filter((workflow) => {
+      return workflow.eventName?.startsWith("studio.");
+    });
+    return studio_workflows.map((workflow) => {
+      return {
+        ...workflow,
+        handler: workflow.handler.toString(),
+      };
+    });
+  }
+
+  public static getEvents() {
+    const events = Lobb.instance.eventSystem.events;
+    return events.map((event) => {
+      return {
+        ...event,
+        inputSchema: convertSchemaToTypeString(
+          "Input",
+          event.inputSchema,
+        ),
+        outputSchema: convertSchemaToTypeString(
+          "Output",
+          event.outputSchema,
+        ),
+      };
+    });
+  }
+
+  public static getEventContextType() {
+    const workflows = Lobb.instance.workflowSystem.workflows;
+
+    const workflowsObjectSchema: Record<string, ZodFunction<any, any>> = {};
+    for (let index = 0; index < workflows.length; index++) {
+      const workflow = workflows[index];
+      const inputSchema = workflow.inputSchema
+        ? workflow.inputSchema(z)
+        : z.any();
+      const outputSchema = workflow.outputSchema
+        ? workflow.outputSchema(z)
+        : z.any();
+      workflowsObjectSchema[workflow.name] = z.function().args(inputSchema)
+        .returns(z.promise(outputSchema));
+    }
+
+    const schema = z.object({
+      eventName: z.string(),
+      workflows: z.object(workflowsObjectSchema),
+      LobbError: z.function().args(LobbErrorSchema).returns(z.void()),
+    });
+
+    const typeString = convertSchemaToTypeString(
+      "Context",
+      schema,
+    );
+
+    return typeString;
+  }
+}