@lobb-js/core 0.19.0 → 0.21.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lobb-js/core",
   "license": "UNLICENSED",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/config/ConfigManager.ts

@@ -58,7 +58,7 @@ export class ConfigManager {
           if (!this.config.collections[fieldValue.references.collection]) {
             throw new LobbError({
               code: "INTERNAL_SERVER_ERROR",
-              message: `Field (${collectionName}.${fieldName}) references collection (${fieldValue.references.collection}) which does not exist`,
+              message: `"${collectionName}.${fieldName}" references "${fieldValue.references.collection}" which is not defined in your collections.`,
             });
           }
           if (!this.config.relations) {

package/src/database/DatabaseSyncManager.ts

@@ -1,11 +1,23 @@
-import * as _ from "lodash";
-
-import { diff } from "just-diff";
 import { runCoreDbSetup } from "../coreDbSetup/index.ts";
 import { MigrationsManager } from "./MigrationsManager.ts";
 import { LobbError } from "../LobbError.ts";
 import { Lobb } from "../Lobb.ts";
-import type { CollectionConfig, CollectionField, CollectionIndex } from "../types/index.ts";
+import type { CollectionConfig, CollectionField, CollectionIndex, CollectionsConfig } from "../types/index.ts";
+import type { NormalCollectionConfig } from "../types/config/collectionsConfig.ts";
+
+// ── Semantic diff types ────────────────────────────────────────────────────
+
+type SchemaDiffOp =
+  | { op: "add-collection"; collection: string; config: CollectionConfig }
+  | { op: "remove-collection"; collection: string }
+  | { op: "add-field"; collection: string; field: string; config: CollectionField }
+  | { op: "remove-field"; collection: string; field: string }
+  | { op: "alter-field"; collection: string; field: string; config: CollectionField }
+  | { op: "add-index"; collection: string; index: string; config: CollectionIndex }
+  | { op: "remove-index"; collection: string; index: string }
+  | { op: "replace-index"; collection: string; index: string; config: CollectionIndex };
+
+// ── DatabaseSyncManager ────────────────────────────────────────────────────
 
 export class DatabaseSyncManager {
   private dbDriver = Lobb.instance.databaseService.getDriver();
@@ -30,149 +42,169 @@ export class DatabaseSyncManager {
     await this.applyDbSchemaDiff(dbSchemaDiff, forceSync);
   }
 
-  private async applyDbSchemaDiff(
-    dbSchemaDiff: Array<{ op: string; path: (string | number)[]; value: unknown }>,
-    forceSync: boolean,
-  ) {
-    if (!dbSchemaDiff.length) return;
-
-    if (!forceSync) {
-      console.error(
-        "These are the differences between the config schema and the database schema",
-      );
-      console.error(
-        "You should add migrations to match the collection schema with the database schema",
-      );
-      console.error(dbSchemaDiff);
-      throw new LobbError({
-        code: "INTERNAL_SERVER_ERROR",
-        message:
-          "The schema of the configuration collection does not align with the actual schema of the connected database.",
-      });
-    }
+  private async applyDbSchemaDiff(ops: SchemaDiffOp[], forceSync: boolean) {
+    if (!ops.length) return;
 
-    // just-diff may produce deep paths (length > 3) for sub-field changes within
-    // an existing index (e.g. renaming a column the index covers). Convert those
-    // into explicit drop+recreate (replace) ops, deduplicating by index name.
-    const syntheticReplaces = new Map<string, (string | number)[]>();
-    const normalizedDiff = dbSchemaDiff.filter((change) => {
-      if (change.path[1] === "indexes" && change.path.length > 3) {
-        const key = `${change.path[0]}:${change.path[2]}`;
-        if (!syntheticReplaces.has(key)) {
-          syntheticReplaces.set(key, [change.path[0], "indexes", change.path[2]]);
-        }
-        return false;
+    await this.assertNoDataLoss(ops, forceSync);
+
+    // Apply in safe dependency order:
+    // 1. remove collections  2. remove indexes  3. remove fields
+    // 4. add collections     5. add/alter fields  6. add/replace indexes
+    const order: Record<SchemaDiffOp["op"], number> = {
+      "remove-collection": 0,
+      "remove-index": 1,
+      "remove-field": 2,
+      "add-collection": 3,
+      "add-field": 4,
+      "alter-field": 4,
+      "add-index": 5,
+      "replace-index": 5,
+    };
+    ops.sort((a, b) => order[a.op] - order[b.op]);
+
+    for (const op of ops) {
+      if (op.op === "add-collection") {
+        await this.dbDriver.createCollection(op.collection, op.config);
+      } else if (op.op === "remove-collection") {
+        await this.dbDriver.dropCollection(op.collection);
+      } else if (op.op === "add-field") {
+        await this.dbDriver.addField(op.collection, op.field, op.config);
+      } else if (op.op === "remove-field") {
+        await this.dbDriver.removeField(op.collection, op.field);
+      } else if (op.op === "alter-field") {
+        await this.dbDriver.alterField(op.collection, op.field, op.config);
+      } else if (op.op === "add-index") {
+        await this.dbDriver.createIndex(op.collection, op.index, op.config);
+      } else if (op.op === "remove-index") {
+        await this.dbDriver.dropIndex(op.collection, op.index);
+      } else if (op.op === "replace-index") {
+        await this.dbDriver.dropIndex(op.collection, op.index);
+        await this.dbDriver.createIndex(op.collection, op.index, op.config);
       }
-      return true;
-    });
-    for (const path of syntheticReplaces.values()) {
-      normalizedDiff.push({ op: "replace", path, value: undefined });
     }
+  }
 
-    // Apply changes in safe dependency order:
-    // 1. Drop collections, 2. Drop indexes, 3. Remove fields,
-    // 4. Add collections, 5. Add fields, 6. Add/replace indexes
-    const opOrder = (change: { op: string; path: (string | number)[] }) => {
-      if (change.path.length === 1 && change.op === "remove") return 0; // drop collection
-      if (change.path[1] === "indexes" && change.op === "remove") return 1; // drop index
-      if (change.path[1] === "indexes" && change.op === "replace") return 2; // replace index (drop+create)
-      if (change.path[1] === "fields" && change.op === "remove") return 3; // remove field
-      if (change.path.length === 1 && change.op === "add") return 4; // add collection
-      if (change.path[1] === "fields" && change.op === "add") return 5; // add field
-      if (change.path[1] === "indexes" && change.op === "add") return 6; // add index
-      return 7;
-    };
-    normalizedDiff.sort((a, b) => opOrder(a) - opOrder(b));
-
-    for (let index = 0; index < normalizedDiff.length; index++) {
-      const change = normalizedDiff[index];
-      if (change.path.length === 1 && change.op === "add") {
-        const addedCollectionName = change.path[0] as string;
-        await this.dbDriver.createCollection(
-          addedCollectionName,
-          change.value as CollectionConfig,
-        );
-      } else if (change.path.length === 1 && change.op === "remove") {
-        const removedCollectionName = change.path[0] as string;
-        await this.dbDriver.dropCollection(removedCollectionName);
-      } else if (
-        change.path.length === 3 &&
-        change.path[1] === "fields" &&
-        change.op === "add"
-      ) {
-        const collectionName = change.path[0] as string;
-        const fieldName = change.path[2] as string;
-        await this.dbDriver.addField(
-          collectionName,
-          fieldName,
-          change.value as CollectionField,
-        );
-      } else if (change.path[1] === "fields" && change.op === "remove") {
-        const collectionName = change.path[0] as string;
-        const fieldName = change.path[2] as string;
-        await this.dbDriver.removeField(collectionName, fieldName);
-      } else if (change.path[1] === "fields" && change.op === "replace") {
-        const collectionName = change.path[0] as string;
-        const fieldName = change.path[2] as string;
-        const fieldConfig = Lobb.instance.configManager.getNormalCollection(collectionName).fields[fieldName];
-        await this.dbDriver.alterField(collectionName, fieldName, fieldConfig);
-      } else if (change.path[1] === "indexes" && change.op === "add") {
-        const collectionName = change.path[0] as string;
-        const indexName = change.path[2] as string;
-        await this.dbDriver.createIndex(
-          collectionName,
-          indexName,
-          change.value as CollectionIndex,
-        );
-      } else if (change.path[1] === "indexes" && change.op === "remove") {
-        const collectionName = change.path[0] as string;
-        const indexName = change.path[2] as string;
-        await this.dbDriver.dropIndex(collectionName, indexName);
-      } else if (change.path[1] === "indexes" && change.op === "replace") {
-        const collectionName = change.path[0] as string;
-        const indexName = change.path[2] as string;
-        const collectionConfig = Lobb.instance.configManager.getNormalCollection(
-          collectionName,
-        );
-        const indexes = collectionConfig.indexes ?? {};
-        const index = indexes[indexName];
-        await this.dbDriver.dropIndex(collectionName, indexName);
-        await this.dbDriver.createIndex(
-          collectionName,
-          indexName,
-          index,
-        );
-      } else {
-        console.error(change);
-        throw new LobbError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: "the database change above is not handled",
+  private async assertNoDataLoss(ops: SchemaDiffOp[], forceSync: boolean) {
+    if (forceSync) return;
+
+    const destructiveOps = ops.filter(
+      (op) => op.op === "remove-collection" || op.op === "remove-field",
+    );
+    if (destructiveOps.length === 0) return;
+
+    const blocked: string[] = [];
+
+    for (const op of destructiveOps) {
+      if (op.op === "remove-collection") {
+        const { meta } = await this.dbDriver.findAll(op.collection, { limit: 1, offset: 0, fields: "id" });
+        if (meta.totalCount > 0) {
+          blocked.push(
+            `Table "${op.collection}" has ${meta.totalCount} row(s) and cannot be dropped automatically. Write a migration to handle the data first.`,
+          );
+        }
+      } else if (op.op === "remove-field") {
+        const { meta } = await this.dbDriver.findAll(op.collection, {
+          limit: 1,
+          offset: 0,
+          fields: "id",
+          filter: { [op.field]: { $ne: null } },
         });
+        if (meta.totalCount > 0) {
+          blocked.push(
+            `Column "${op.collection}.${op.field}" has ${meta.totalCount} non-null row(s) and cannot be dropped automatically. Write a migration to handle the data first.`,
+          );
+        }
       }
     }
+
+    if (blocked.length > 0) {
+      console.error("Blocked destructive schema changes detected:");
+      for (const msg of blocked) console.error(` • ${msg}`);
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message:
+          "Refusing to apply destructive schema changes on tables/columns that contain data. " +
+          "Write explicit migrations to handle the data, then re-run.",
+      });
+    }
   }
 
-  private async getDbDifferences(specificColleciton?: string) {
+  private async getDbDifferences(specificCollection?: string): Promise<SchemaDiffOp[]> {
     let dbSchema = await this.dbDriver.getDbSchema();
-    let configDbSchema = Lobb.instance.configManager.getDbSchema();
-
-    if (specificColleciton) {
-      if (dbSchema[specificColleciton]) {
-        dbSchema = {
-          [specificColleciton]: dbSchema[specificColleciton],
-        };
-      } else {
-        dbSchema = {};
+    let configSchema = Lobb.instance.configManager.getDbSchema();
+
+    if (specificCollection) {
+      dbSchema = dbSchema[specificCollection] ? { [specificCollection]: dbSchema[specificCollection] } : {};
+      configSchema = configSchema[specificCollection] ? { [specificCollection]: configSchema[specificCollection] } : {};
+    }
+
+    return this.computeSemanticDiff(dbSchema, configSchema);
+  }
+
+  private computeSemanticDiff(dbSchema: CollectionsConfig, configSchema: CollectionsConfig): SchemaDiffOp[] {
+    const ops: SchemaDiffOp[] = [];
+    const allCollections = new Set([...Object.keys(dbSchema), ...Object.keys(configSchema)]);
+
+    for (const collection of allCollections) {
+      const inDb = dbSchema[collection];
+      const inConfig = configSchema[collection];
+
+      if (!inDb && inConfig) {
+        ops.push({ op: "add-collection", collection, config: inConfig });
+        continue;
       }
-      if (configDbSchema[specificColleciton]) {
-        configDbSchema = {
-          [specificColleciton]: configDbSchema[specificColleciton],
-        };
-      } else {
-        configDbSchema = {};
+
+      if (inDb && !inConfig) {
+        ops.push({ op: "remove-collection", collection });
+        continue;
+      }
+
+      // Collection exists in both — diff fields and indexes
+      // Skip virtual collections — they have no DB columns
+      if ("virtual" in inConfig && inConfig.virtual) continue;
+
+      const normalInDb = inDb as NormalCollectionConfig;
+      const normalInConfig = inConfig as NormalCollectionConfig;
+      const allFields = new Set([...Object.keys(normalInDb.fields), ...Object.keys(normalInConfig.fields)]);
+      for (const field of allFields) {
+        const dbField = normalInDb.fields[field];
+        const configField = normalInConfig.fields[field];
+
+        if (!dbField && configField) {
+          ops.push({ op: "add-field", collection, field, config: configField as CollectionField });
+        } else if (dbField && !configField) {
+          ops.push({ op: "remove-field", collection, field });
+        } else if (dbField && configField && !this.fieldsEqual(dbField, configField)) {
+          ops.push({ op: "alter-field", collection, field, config: configField as CollectionField });
+        }
+      }
+
+      const dbIndexes = normalInDb.indexes ?? {};
+      const configIndexes = normalInConfig.indexes ?? {};
+      const allIndexes = new Set([...Object.keys(dbIndexes), ...Object.keys(configIndexes)]);
+      for (const index of allIndexes) {
+        const dbIndex = dbIndexes[index];
+        const configIndex = configIndexes[index];
+
+        if (!dbIndex && configIndex) {
+          ops.push({ op: "add-index", collection, index, config: configIndex });
+        } else if (dbIndex && !configIndex) {
+          ops.push({ op: "remove-index", collection, index });
+        } else if (dbIndex && configIndex && !this.indexesEqual(dbIndex, configIndex)) {
+          ops.push({ op: "replace-index", collection, index, config: configIndex });
+        }
       }
     }
 
-    return diff(dbSchema, configDbSchema);
+    return ops;
+  }
+
+  private fieldsEqual(a: any, b: any): boolean {
+    // Compare only DB-relevant properties: type and length
+    return a.type === b.type && (a.length ?? null) === (b.length ?? null);
+  }
+
+  private indexesEqual(a: CollectionIndex, b: CollectionIndex): boolean {
+    return JSON.stringify(a) === JSON.stringify(b);
   }
 }

package/src/index.ts

@@ -29,7 +29,7 @@ export type {
   CollectionField,
   CollectionFieldBase,
   EnumOption,
-  EnumLevel,
+  EnumColor,
 } from "./types/config/collectionFields.ts";
 export type { Dashboard, Extension } from "./types/Extension.ts";
 export { Field } from "./types/Field.ts";

package/src/types/config/collectionFields.ts

@@ -2,11 +2,17 @@ import { RelationCollectionFieldSchema } from "./relations.ts";
 
 import { z } from "zod";
 
-export type EnumLevel = "success" | "warning" | "danger" | "info" | "neutral" | "muted";
+export type EnumColor =
+  | "red" | "rose" | "pink" | "fuchsia" | "purple"
+  | "violet" | "indigo" | "blue" | "sky" | "cyan"
+  | "teal" | "emerald" | "green" | "lime" | "yellow"
+  | "amber" | "orange" | "slate" | "zinc" | "gray"
+  | "stone" | "neutral";
 
 export const EnumOptionSchema = z.object({
-  value: z.string(),
-  level: z.enum(["success", "warning", "danger", "info", "neutral", "muted"]),
+  value: z.union([z.string(), z.number()]),
+  color: z.enum(["red", "rose", "pink", "fuchsia", "purple", "violet", "indigo", "blue", "sky", "cyan", "teal", "emerald", "green", "lime", "yellow", "amber", "orange", "slate", "zinc", "gray", "stone", "neutral"]).optional(),
+  description: z.string().optional(),
 });
 
 export type EnumOption = z.infer<typeof EnumOptionSchema>;
@@ -114,7 +120,7 @@ export const CollectionIntegerFieldSchema = z.union([
   CollectionFieldBaseSchema.extend({
     type: z.literal("integer"),
     default: z.number().int().optional(),
-    enum: z.array(z.number().int()).optional(),
+    enum: z.union([z.array(z.number().int()), z.array(EnumOptionSchema)]).optional(),
     references: RelationCollectionFieldSchema.optional(),
   }),
   VirtualFieldSchema.extend({ type: z.literal("integer") }),