@lobb-js/core 0.13.0

package/src/fields/IntegerField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class IntegerField extends Field {
+  public static override type: string = "integer";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/LongField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class LongField extends Field {
+  public static override type: string = "long";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/ObjectField.ts

@@ -0,0 +1,15 @@
+// import { Field, type FieldOperatorsType } from "./Field.ts";
+// import _ from "lodash";
+
+// export class ObjectField extends Field {
+//   public static override type: string = "object";
+//   protected fieldName: string;
+//   protected collectionName: string;
+//   public fieldOperatorsType: FieldOperatorsType = "string";
+
+//   constructor(fieldName: string, collectionName: string) {
+//     super();
+//     this.fieldName = fieldName;
+//     this.collectionName = collectionName;
+//   }
+// }

package/src/fields/StringField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class StringField extends Field {
+  public static override type: string = "string";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/TextField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class TextField extends Field {
+  public static override type: string = "text";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/fields/TimeField.ts

@@ -0,0 +1,13 @@
+import { Field } from "../types/index.ts";
+
+export class TimeField extends Field {
+  public static override type: string = "time";
+  protected fieldName: string;
+  protected collectionName: string;
+
+  constructor(fieldName: string, collectionName: string) {
+    super();
+    this.fieldName = fieldName;
+    this.collectionName = collectionName;
+  }
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+// export lobb version
+import packageJson from "../package.json" with { type: "json" };
+export const version = packageJson.version;
+
+// export Lobb core
+export { run } from "./Lobb.ts";
+export { Lobb } from "./Lobb.ts";
+export { LobbError } from "./LobbError.ts";
+
+// export core types
+export type { Workflow } from "./workflows/WorkflowSystem.ts";
+export type { CollectionService, ExposedServiceOutput, ExposedManyServiceOutput, ServiceOp } from "./api/collections/CollectionService.ts";
+export type { EventContext } from "./events/EventSystem.ts";
+
+// export all types from types directory
+export { DatabaseDriver } from "./types/DatabaseDriver.ts";
+export type { FindAllResult, MassReturn } from "./types/DatabaseDriver.ts";
+export type { ApiCollectionAction } from "./types/apiSchema.ts";
+export type { Config, WebConfig } from "./types/config/config.ts";
+export type { RelationsConfig } from "./types/config/relations.ts";
+export type {
+  CollectionConfig,
+  CollectionIndex,
+  CollectionIndexes,
+  CollectionsConfig,
+} from "./types/config/collectionsConfig.ts";
+export type { CollectionFieldsWithoutId } from "./types/config/collectionsConfig.ts";
+export type {
+  CollectionField,
+  CollectionFieldBase,
+} from "./types/config/collectionFields.ts";
+export type { Dashboard, Extension } from "./types/Extension.ts";
+export { Field } from "./types/Field.ts";
+export type { Migration, MigrationProps, Migrations } from "./types/migrations.ts";
+export type { Filter } from "./types/filterSchema.ts";
+export {
+  basicFilterOperatorsSchema,
+  filterJsonSchema,
+  filterSchema,
+} from "./types/filterSchema.ts";
+export type {
+  FindAllParamsInput,
+  FindAllParamsOutput,
+} from "./types/collectionServiceSchema.ts";
+export { findAllParamsSchema } from "./types/collectionServiceSchema.ts";
+export { CollectionConfigSchema } from "./types/config/collectionsConfig.ts";
+export type { CollectionControllers } from "./types/CollectionControllers.ts";
+export type {
+  HeartBeatMessage,
+  RequestMessage,
+  SubscribeMessage,
+} from "./types/websockets.ts";
+export type { ProcessorType } from "./types/workflows/processors.ts";

package/src/studio/Studio.ts

@@ -0,0 +1,108 @@
+import { stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createServer, createConnection } from "node:net";
+import type { AddressInfo } from "node:net";
+
+export class Studio {
+  private studioDir: string;
+  private process: ReturnType<typeof Bun.spawn> | null = null;
+
+  constructor(projectDir: string) {
+    // Support flat structure (vite.config.ts at project root) and nested (studio/ subdir).
+    this.studioDir = existsSync(join(projectDir, "vite.config.ts"))
+      ? projectDir
+      : join(projectDir, "studio");
+  }
+
+  public stop(): void {
+    this.process?.kill();
+    this.process = null;
+  }
+
+  public async start(webPort: number): Promise<number | 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);
+    }
+
+    return await this.runDevServer(webPort);
+  }
+
+  private async exists(): Promise<boolean> {
+    try {
+      const s = await stat(this.studioDir);
+      return s.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  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",
+      stderr: "inherit",
+    });
+    await Studio.waitForPort(port);
+    console.log(`Studio: http://localhost:${webPort}/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 static getFreePort(): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const server = createServer();
+      server.listen(0, "127.0.0.1", () => {
+        const port = (server.address() as AddressInfo).port;
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve(port);
+        });
+      });
+    });
+  }
+
+  private static async waitForPort(port: number, maxAttempts = 50): Promise<void> {
+    for (let i = 0; i < maxAttempts; i++) {
+      const connected = await new Promise<boolean>((resolve) => {
+        const sock = createConnection({ port, host: "127.0.0.1" });
+        sock.once("connect", () => { sock.destroy(); resolve(true); });
+        sock.once("error", () => { sock.destroy(); resolve(false); });
+      });
+      if (connected) return;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    throw new Error(`Studio server did not start on port ${port}`);
+  }
+}

package/src/types/CollectionControllers.ts

@@ -0,0 +1,15 @@
+import type { Context } from "hono";
+
+export interface CollectionControllers {
+  findAll(c: Context): Promise<Response>;
+  findOne(c: Context): Promise<Response>;
+  createOne(c: Context): Promise<Response>;
+  updateOne(c: Context): Promise<Response>;
+  deleteOne(c: Context): Promise<Response>;
+  deleteMany(c: Context): Promise<Response>;
+  updateMany(c: Context): Promise<Response>;
+  createMany(c: Context): Promise<Response>;
+  readSingleton(c: Context): Promise<Response>;
+  updateSingleton(c: Context): Promise<Response>;
+  transactions(c: Context): Promise<Response>;
+}

package/src/types/DatabaseDriver.ts

@@ -0,0 +1,115 @@
+import type { FindAllParamsOutput } from "./collectionServiceSchema.ts";
+import type { PoolClient } from "pg";
+import type {
+  CollectionConfig,
+  CollectionIndex,
+  CollectionIndexes,
+  CollectionsConfig,
+} from "./config/collectionsConfig.ts";
+import type { DatabaseConfig } from "./config/config.ts";
+import type { CollectionField } from "./config/collectionFields.ts";
+
+export type Entry = {
+  id: string;
+  [key: string]: any;
+};
+
+export interface Meta {
+  totalCount: number;
+}
+
+export interface FindAllResult {
+  data: Entry[];
+  meta: Meta;
+}
+
+export interface MassReturn {
+  affectedCount: number;
+}
+
+export abstract class DatabaseDriver {
+  // Subclasses should set this in their constructor by accessing Lobb.instance
+  protected databaseConfig!: DatabaseConfig;
+
+  public abstract createConnection(): Promise<void>;
+  public abstract getConnection(): { connect(): Promise<any> };
+  public abstract close(): Promise<void>;
+  public abstract query<T>(sql: string): Promise<T[]>;
+  public abstract dropDatabase(): Promise<void>;
+  public abstract createCollection(
+    collectionName: string,
+    collectionConfig: CollectionConfig,
+  ): Promise<void>;
+  public abstract dropCollection(collectionName: string): Promise<void>;
+  public abstract addField(
+    collectionName: string,
+    fieldName: string,
+    field: CollectionField,
+  ): Promise<void>;
+  public abstract removeField(
+    collectionName: string,
+    fieldName: string,
+  ): Promise<void>;
+  public abstract getDbSchema(): Promise<CollectionsConfig>;
+  public abstract getIdsByFilter(
+    collectionName: string,
+    filter?: any,
+    client?: PoolClient,
+  ): Promise<string[]>;
+
+  /////////////////////////
+  // Indexes Operations //
+  ////////////////////////
+  public abstract createIndex(
+    collectionName: string,
+    indexName: string,
+    index: CollectionIndex,
+  ): Promise<void>;
+  public abstract dropIndex(
+    collectionName: string,
+    indexName: string,
+  ): Promise<any>;
+  public abstract getIndexes(
+    collectionName: string,
+  ): Promise<CollectionIndexes>;
+
+  /////////////////////
+  // CRUD Operations //
+  /////////////////////
+  public abstract findAll(
+    collectionName: string,
+    params: FindAllParamsOutput,
+    client?: PoolClient,
+  ): Promise<FindAllResult>;
+
+  public abstract createOne(
+    collectionName: string,
+    data: any,
+    client?: PoolClient,
+  ): Promise<Entry>;
+
+  public abstract updateOne(
+    collectionName: string,
+    id: string,
+    data: any,
+    client?: PoolClient,
+  ): Promise<Entry | null>;
+
+  public abstract deleteOne(
+    collectionName: string,
+    id: string,
+    client?: PoolClient,
+  ): Promise<Entry | null>;
+
+  ///////////////////////////////////////////////////////////
+  // parse some types of data to be compatible with the db //
+  //                used mainly for mongodb                //
+  ///////////////////////////////////////////////////////////
+  public encodeFieldValue(fieldType: string, value: any) {
+    return value;
+  }
+
+  public decodeFieldValue(fieldType: string, value: any) {
+    return value;
+  }
+}

package/src/types/Extension.ts

@@ -0,0 +1,46 @@
+import type { Hono, MiddlewareHandler } from "hono";
+import type { CollectionConfig } from "./config/collectionsConfig.ts";
+import type { Migrations } from "./migrations.ts";
+import type { OpenAPIV3_1 } from "openapi-types";
+import type { RelationsConfig } from "./config/relations.ts";
+import type { Lobb } from "../Lobb.ts";
+import type { Workflow } from "../workflows/WorkflowSystem.ts";
+
+interface OpenApiProperty {
+  paths: OpenAPIV3_1.Document["paths"];
+  components?: Record<string, any>;
+}
+
+export interface Dashboard {
+  extension?: string;
+}
+
+interface ExtensionBase {
+  name: string;
+  workflows?: Workflow[];
+  migrations?: Migrations;
+  init?: (lobb: Lobb) => Promise<void>;
+  close?: (lobb: Lobb) => Promise<void>;
+  collectionRoutes?: (routes: Hono) => void;
+  collectionMiddlewares?: Array<MiddlewareHandler>;
+  routes?: () => Hono;
+  collections?: (lobb: Lobb) => Record<string, CollectionConfig>;
+  relations?: (lobb: Lobb) => RelationsConfig;
+  meta?: (lobb: Lobb) => Promise<any>;
+  openapi?: OpenApiProperty;
+  services?: (lobb: Lobb) => object;
+}
+
+// Has dashboard → version is required
+interface ExtensionWithDashboard extends ExtensionBase {
+  dashboard: Dashboard;
+  version?: string;
+}
+
+// No dashboard → version is optional
+interface ExtensionWithoutDashboard extends ExtensionBase {
+  dashboard?: undefined;
+  version?: string;
+}
+
+export type Extension = ExtensionWithDashboard | ExtensionWithoutDashboard;

package/src/types/Field.ts

@@ -0,0 +1,29 @@
+import { LobbError } from "../LobbError.ts";
+
+export abstract class Field {
+  protected abstract fieldName: string;
+  protected abstract collectionName: string;
+
+  // this forces all child classes to define a static 'type' property
+  static get type(): string {
+    throw new Error(
+      `(${this.name}) class must define a static 'type' property.`,
+    );
+  }
+
+  public encodeFieldValue(value: any): any {
+    return value;
+  }
+
+  public decodeFieldValue(value: any): any {
+    return value;
+  }
+
+  protected throwIncompatibleValueTypeError(): never {
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message:
+        `The value provided for the (${this.fieldName}) field is incompatible.`,
+    });
+  }
+}

package/src/types/apiSchema.ts

@@ -0,0 +1,12 @@
+export type ApiCollectionAction =
+  | "findAll"
+  | "findOne"
+  | "deleteOne"
+  | "createOne"
+  | "updateOne"
+  | "createMany"
+  | "deleteMany"
+  | "updateMany"
+  | "transactions"
+  | "readSingleton"
+  | "updateSingleton";

package/src/types/collectionServiceSchema.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+export const findAllParamsSchema = z
+  .object({
+    sort: z.string().optional(),
+    limit: z.coerce.number().default(100),
+    offset: z.coerce.number().default(0),
+    page: z.coerce.number().optional(),
+    fields: z.string().default("*"),
+    filter: z.any(),
+  }).strict()
+  .default({
+    fields: "*",
+    limit: 100,
+    offset: 0,
+  });
+export type FindAllParamsInput = z.input<typeof findAllParamsSchema>;
+export type FindAllParamsOutput = z.output<typeof findAllParamsSchema>;

package/src/types/config/collectionFields.ts

@@ -0,0 +1,85 @@
+import { RelationCollectionFieldSchema } from "./relations.ts";
+
+import { z } from "zod";
+
+// Define the UiInput schema
+const UiInputSchema = z.object({
+  type: z.string(),
+  args: z.any().optional(),
+});
+
+// Defining the ui property schema
+const UiSchema = z.object({
+  disabled: z.boolean().optional(),
+  placeholder: z.string().optional(),
+  input: UiInputSchema.optional(),
+});
+
+// Base field schema
+export const CollectionFieldBaseSchema = z.object({
+  pre_processors: z.record(z.any()).optional(),
+  post_processors: z.record(z.any()).optional(),
+  validators: z.record(z.any()).optional(),
+  ui: UiSchema.optional(),
+});
+
+export type CollectionFieldBase = z.infer<typeof CollectionFieldBaseSchema>;
+
+// Specialized field schemas
+export const CollectionBoolFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("bool"),
+});
+
+export const CollectionDateFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("date"),
+});
+
+export const CollectionDateTimeFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("datetime"),
+});
+
+export const CollectionDecimalFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("decimal"),
+});
+
+export const CollectionFloatFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("float"),
+});
+
+export const CollectionIntegerFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("integer"),
+  references: RelationCollectionFieldSchema.optional(),
+});
+
+export const CollectionLongFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("long"),
+});
+
+export const CollectionStringFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("string"),
+  length: z.number(),
+});
+
+export const CollectionTextFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("text"),
+});
+
+export const CollectionTimeFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("time"),
+});
+
+// Union type if you want a single schema for all
+export const CollectionFieldSchema = z.union([
+  CollectionBoolFieldSchema,
+  CollectionDateFieldSchema,
+  CollectionDateTimeFieldSchema,
+  CollectionDecimalFieldSchema,
+  CollectionFloatFieldSchema,
+  CollectionIntegerFieldSchema,
+  CollectionLongFieldSchema,
+  CollectionStringFieldSchema,
+  CollectionTextFieldSchema,
+  CollectionTimeFieldSchema,
+]);
+
+export type CollectionField = z.infer<typeof CollectionFieldSchema>;

package/src/types/config/collectionsConfig.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import {
+  CollectionFieldSchema,
+  CollectionIntegerFieldSchema,
+} from "./collectionFields.ts";
+
+// CollectionIndexField
+export const CollectionIndexFieldSchema = z.object({
+  order: z.enum(["asc", "desc"]),
+});
+
+// CollectionIndexFields (Record<string, CollectionIndexField>)
+export const CollectionIndexFieldsSchema = z.record(CollectionIndexFieldSchema);
+
+// CollectionIndex
+export const CollectionIndexSchema = z.object({
+  unique: z.boolean(),
+  fields: CollectionIndexFieldsSchema,
+});
+
+// CollectionIndexes (Record<string, CollectionIndex>)
+export const CollectionIndexesSchema = z.record(CollectionIndexSchema);
+
+// CollectionFields (Record<string, CollectionField>)
+export const CollectionFieldsSchema = z.intersection(
+  z.object({
+    id: CollectionIntegerFieldSchema,
+  }),
+  z.record(CollectionFieldSchema),
+);
+
+// CollectionConfig
+export const CollectionConfigSchema = z.object({
+  category: z.string().optional(),
+  singleton: z.boolean().optional(),
+  indexes: CollectionIndexesSchema,
+  fields: CollectionFieldsSchema,
+});
+
+export const CollectionsConfigSchema = z.record(CollectionConfigSchema);
+
+// Inferred Types
+export type CollectionIndexField = z.infer<typeof CollectionIndexFieldSchema>;
+export type CollectionIndexFields = z.infer<typeof CollectionIndexFieldsSchema>;
+export type CollectionIndex = z.infer<typeof CollectionIndexSchema>;
+export type CollectionIndexes = z.infer<typeof CollectionIndexesSchema>;
+export type CollectionFields = z.infer<typeof CollectionFieldsSchema>;
+export type CollectionFieldsWithoutId = Omit<CollectionFields, "id">;
+export type CollectionConfig = z.infer<typeof CollectionConfigSchema>;
+export type CollectionsConfig = z.infer<typeof CollectionsConfigSchema>;