@lobb-js/core 0.13.0

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@lobb-js/core",
+  "version": "0.13.0",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src"
+  ],
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "bun test tests",
+    "dev": "bun run src/index.ts"
+  },
+  "dependencies": {
+    "@faker-js/faker": "^9.8.0",
+    "@scalar/hono-api-reference": "^0.7.2",
+    "cron": "^4.4.0",
+    "cron-validator": "^1.4.0",
+    "hono": "^4.7.0",
+    "just-diff": "^6.0.2",
+    "lodash": "^4.17.21",
+    "mingo": "^6.4.15",
+    "nunjucks": "^3.2.4",
+    "openapi-types": "^12.1.3",
+    "pg": "^8.13.3",
+    "pg-format": "^1.0.4",
+    "qs": "^6.12.1",
+    "sucrase": "^3.35.0",
+    "validator": "^13.12.0",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.6",
+    "zod-to-ts": "^1.2.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.0",
+    "@types/nunjucks": "^3.2.6",
+    "@types/pg": "^8.11.0",
+    "@types/pg-format": "^1.0.5",
+    "@types/qs": "^6.9.0",
+    "@types/validator": "^13.12.0",
+    "bun-types": "latest"
+  }
+}

package/src/Lobb.ts

@@ -0,0 +1,150 @@
+import type { CollectionControllers } from "./types/index.ts";
+import type { Config } from "./types/index.ts";
+
+import { ExtensionSystem } from "./extension/ExtensionSystem.ts";
+import { DatabaseService } from "./database/DatabaseService.ts";
+import { WorkflowSystem } from "./workflows/WorkflowSystem.ts";
+import { DatabaseSyncManager } from "./database/DatabaseSyncManager.ts";
+import { WebServer } from "./api/WebServer.ts";
+import { collectionControllers } from "./api/collections/CollectionControllers.ts";
+import { ConfigManager } from "./config/ConfigManager.ts";
+import { Utils } from "./utils/utils.ts";
+import { transactions } from "./api/collections/transactions.ts";
+import { EventSystem } from "./events/EventSystem.ts";
+import { SchemaService } from "./api/schema/SchemaService.ts";
+import { TypesGenerator } from "./TypesGenerator.ts";
+import { CollectionService } from "./api/collections/CollectionService.ts";
+import { CollectionStore } from "./api/collections/collectionStore.ts";
+import { Studio } from "./studio/Studio.ts";
+import { dirname } from "node:path";
+
+export function run(config: Config) {
+  return Lobb.init(config);
+}
+
+export class Lobb {
+  public static instance: Lobb;
+  public configManager!: ConfigManager;
+  public databaseService!: DatabaseService;
+  public workflowSystem!: WorkflowSystem;
+  public eventSystem!: EventSystem;
+  public databaseSyncManager!: DatabaseSyncManager;
+  public schemaService!: SchemaService;
+  public webServer!: WebServer;
+  public extensionSystem!: ExtensionSystem;
+  public utils = Utils;
+  public collectionControllers!: CollectionControllers;
+  public transactions!: typeof transactions;
+  public typesGenerator!: TypesGenerator;
+  public collectionStore!: CollectionStore;
+  public collectionService!: CollectionService;
+  private studio!: Studio;
+  private tempDatabase = false;
+
+  constructor() {}
+
+  public static async init(config: Config) {
+    const projectDir = dirname(Bun.main);
+
+    const studio = new Studio(projectDir);
+
+    const isTempDatabase = config.database.database === "*";
+    if (isTempDatabase) {
+      config = {
+        ...config,
+        database: {
+          ...config.database,
+          database: `lobb_test_${crypto.randomUUID().replace(/-/g, "")}`,
+        },
+      };
+    }
+
+    console.log("starting the app");
+    const lobb = new Lobb();
+    lobb.studio = studio;
+    lobb.tempDatabase = isTempDatabase;
+    Lobb.instance = lobb;
+    lobb.eventSystem = new EventSystem();
+    lobb.workflowSystem = new WorkflowSystem();
+    lobb.extensionSystem = ExtensionSystem.init();
+    lobb.initShutdownSignalListeners();
+    lobb.configManager = await ConfigManager.init(config);
+    await lobb.afterConfigInit();
+    lobb.databaseService = await DatabaseService.init();
+    lobb.collectionStore = new CollectionStore();
+    lobb.collectionService = new CollectionService();
+    await lobb.eventSystem.init();
+    await lobb.workflowSystem.init();
+    lobb.databaseSyncManager = await DatabaseSyncManager.init();
+    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.collectionControllers = collectionControllers;
+    lobb.transactions = transactions;
+    await lobb.extensionSystem.executeExtensionsInitMethods();
+
+    // emit the core.init event
+    await lobb.eventSystem.emit("core.init", {});
+
+    // generate types
+    lobb.typesGenerator = await TypesGenerator.init();
+
+    console.log("The app is running");
+
+    return lobb;
+  }
+
+  public async close() {
+    // execute the close methods of the extensions
+    await this.extensionSystem.executeExtensionsCloseMethods();
+
+    await this.workflowSystem.close();
+    await this.eventSystem.close();
+    if (this.webServer) await this.webServer.close();
+    if (this.databaseService) await this.databaseService.close();
+    if (this.tempDatabase) await this.databaseService.dropDatabase();
+    this.studio?.stop();
+
+    if (process.platform === "win32") {
+      process.off("SIGBREAK", this.onGracefulShutdown);
+    } else {
+      process.off("SIGTERM", this.onGracefulShutdown);
+    }
+    process.off("SIGINT", this.onGracefulShutdown);
+
+    // reset to the real current working directory if it was changed
+    // by the context property in the project section
+    process.chdir((globalThis as any).currentDirectory);
+  }
+
+  private initShutdownSignalListeners() {
+    if (process.platform === "win32") {
+      process.on("SIGBREAK", this.onGracefulShutdown);
+    } else {
+      process.on("SIGTERM", this.onGracefulShutdown);
+    }
+    process.on("SIGINT", this.onGracefulShutdown);
+  }
+
+  private onGracefulShutdown = async () => {
+    console.log("Performing graceful shutdown tasks...");
+
+    await this.close();
+
+    console.log("Done Performing graceful shutdown tasks!");
+
+    // exit so that all recources and ports are freed
+    process.exit(0);
+  };
+
+  private async afterConfigInit() {
+    // change the current directory
+    const config = Lobb.instance.configManager.config;
+    (globalThis as any).currentDirectory = process.cwd();
+    process.chdir(config.project.context ?? ".");
+
+    await Lobb.instance.extensionSystem.loadExtensionsCollections();
+    this.configManager.addRelationsFromIntegerRefrences();
+  }
+}

package/src/LobbError.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+
+export const LobbStatusCodes = {
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
+
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
+
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  SWITCH_PROXY: 306, // unused
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511,
+};
+
+// Reuse your ErrorCode union
+const ErrorCodeSchema = z.enum(
+  Object.keys(LobbStatusCodes) as [
+    keyof typeof LobbStatusCodes,
+    ...Array<keyof typeof LobbStatusCodes>,
+  ],
+);
+
+export const LobbErrorSchema = z.object({
+  code: ErrorCodeSchema,
+  message: z.string(),
+  details: z.any().optional(),
+});
+type ErrorCode = z.infer<typeof ErrorCodeSchema>;
+export type LobbErrorOptions = z.infer<typeof LobbErrorSchema>;
+
+export class LobbError extends Error {
+  public status: number;
+  public code: ErrorCode;
+  public details?: any;
+
+  constructor({ code, message, details }: LobbErrorOptions) {
+    super(message);
+    this.name = "LobbError";
+    this.status = LobbStatusCodes[code];
+    this.code = code;
+    this.details = details;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, LobbError);
+    }
+  }
+}

package/src/TypesGenerator.ts

@@ -0,0 +1,11 @@
+export class TypesGenerator {
+  constructor() {}
+
+  public static async init() {
+    return new TypesGenerator();
+  }
+
+  public async generate() {
+    // TODO
+  }
+}

package/src/api/WebServer.ts

@@ -0,0 +1,126 @@
+import type { WebConfig } from "../types/index.ts";
+
+import { Hono } from "hono";
+import type { Context } from "hono";
+import { cors } from "hono/cors";
+import { proxy } from "hono/proxy";
+import { getCollectionRoute } from "./collections/collectionRoutes.ts";
+import { getMetaRoute } from "./meta/route.ts";
+import { errorHandler } from "./errorHandler.ts";
+import * as middlewares from "./middlewares.ts";
+import { getOpenApiRoute } from "./openApiRoute.ts";
+import { Lobb } from "../Lobb.ts";
+import { getSchemaRoutes } from "./schema/schemaRoutes.ts";
+import { getEventsRoute } from "./events/index.ts";
+
+export class WebServer {
+  private webConfig!: WebConfig;
+  public app!: Hono;
+  public port!: number;
+  private server!: ReturnType<typeof Bun.serve>;
+
+  public static async init(studioPort: number | null = null) {
+    const webServer = new WebServer();
+    webServer.webConfig = Lobb.instance.configManager.config.web_server;
+    webServer.app = new Hono();
+    await webServer.start(studioPort);
+    return webServer;
+  }
+
+  public close() {
+    // closing all opened sockets
+    this.server.stop(true);
+  }
+
+  public async start(studioPort: number | null = null) {
+    this.app.onError(errorHandler);
+
+    // pre middlwares
+    this.app.use(middlewares.extensionContext);
+    this.app.use(middlewares.workflowsMiddlewares);
+
+    const corsConfig = Lobb.instance.configManager.config.web_server.cors;
+    if (corsConfig) {
+      this.app.use(cors(corsConfig));
+    }
+
+    // post middlwares
+    this.app.use(middlewares.pick);
+
+    this.app.get("/", (c) => {
+      return c.json({ status: "ok", message: "API is available at /api" });
+    });
+
+    this.app.get("/api", (c) => {
+      return c.json({ status: "ok", message: "Lobb API is up and running." });
+    });
+
+    this.app.route("/api/meta", getMetaRoute());
+    this.app.route("/api/schema", getSchemaRoutes());
+    this.app.route("/api/collections", getCollectionRoute());
+    this.app.route("/api/openapi", getOpenApiRoute());
+    this.app.route("/api/extensions", Lobb.instance.extensionSystem.routes());
+    this.app.route("/api/events", getEventsRoute());
+
+    if (studioPort) {
+      const port = studioPort;
+      const studioProxy = (c: Context) => {
+        const targetUrl = new URL(c.req.url);
+        targetUrl.host = `localhost:${port}`;
+        return proxy(targetUrl.toString(), { headers: c.req.header() });
+      };
+      this.app.all("/studio", (c) => c.redirect("/studio/", 308));
+      this.app.all("/studio/", studioProxy);
+      this.app.all("/studio/*", studioProxy);
+    }
+
+    const isDev = process.env.LOBB_MODE !== "prod";
+    const serveBase = {
+      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,
+      });
+    }
+    this.port = this.server.port!;
+  }
+}