@lobb-js/core 0.25.0 → 0.26.1

package/package.json

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

package/src/api/meta/service.ts

@@ -76,6 +76,7 @@ export class MetaService {
 
       // filling the collection ui
       collections[collectionName].ui = collection.ui;
+      collections[collectionName].children = Lobb.instance.configManager.getCollectionChildren(collectionName);
     }
 
     return collections;

package/src/config/ConfigManager.ts

@@ -425,6 +425,45 @@ export class ConfigManager {
     return [];
   }
 
+  public getCollectionChildren(collectionName: string): { type: string; collection: string; field?: string }[] {
+    const allRelations = this.config.relations ?? [];
+    const allCollections = this.config.collections;
+    const children: { type: string; collection: string; field?: string }[] = [];
+    const seenJunctions = new Set<string>();
+
+    for (const relation of allRelations) {
+      if ((relation as any).type === "polymorphic") continue;
+      const reg = relation as RegularRelation;
+      if (reg.to.collection !== collectionName) continue;
+
+      const childCollection = reg.from.collection;
+      if ((allCollections[childCollection] as any)?.junction) {
+        if (seenJunctions.has(childCollection)) continue;
+        seenJunctions.add(childCollection);
+        const otherSide = allRelations.find((r) =>
+          !("type" in r && r.type === "polymorphic") &&
+          (r as RegularRelation).from.collection === childCollection &&
+          (r as RegularRelation).from.field !== reg.from.field,
+        ) as RegularRelation | undefined;
+        if (otherSide) {
+          children.push({ type: "m2m", collection: otherSide.to.collection });
+        }
+      } else {
+        children.push({ type: "fk", collection: childCollection, field: reg.from.field });
+      }
+    }
+
+    for (const relation of allRelations) {
+      if (!("type" in relation) || relation.type !== "polymorphic") continue;
+      const poly = relation as any;
+      if (Array.isArray(poly.to) && poly.to.includes(collectionName)) {
+        children.push({ type: "polymorphic", collection: poly.from.collection });
+      }
+    }
+
+    return children;
+  }
+
   public isCollectionSingleton(collectionName: string): boolean {
     const collection = this.config.collections[collectionName];
     if (!collection || collection.virtual) return false;

package/src/database/DatabaseSyncManager.ts

@@ -35,11 +35,27 @@ export class DatabaseSyncManager {
     // Startup tasks run first — applies any idempotent DB fixes before schema reading begins.
     await runCoreDbSetup();
 
+    const dbSchemaDiff = await this.getDbDifferences(specificColleciton);
+
+    // Pass 1: additive ops only (add-collection, add-field) — always safe, no data loss possible.
+    // Running these before migrations means any new collection defined in config already exists
+    // when migration code tries to seed it.
+    const additiveOps = dbSchemaDiff.filter(
+      (op) => op.op === "add-collection" || op.op === "add-field",
+    );
+    await this.applyDbSchemaDiff(additiveOps, forceSync);
+
+    // Migrations run after additive schema changes so they can safely insert into new collections.
     const migrationsManager = new MigrationsManager();
     await migrationsManager.init();
 
-    const dbSchemaDiff = await this.getDbDifferences(specificColleciton);
-    await this.applyDbSchemaDiff(dbSchemaDiff, forceSync);
+    // Pass 2: everything else (remove-collection, remove-field, alter-field, indexes).
+    // Destructive ops run after migrations so a migration can clear data before applyDbSchemaDiff
+    // would otherwise refuse to drop a column/table that still has rows.
+    const remainingOps = dbSchemaDiff.filter(
+      (op) => op.op !== "add-collection" && op.op !== "add-field",
+    );
+    await this.applyDbSchemaDiff(remainingOps, forceSync);
   }
 
   private async applyDbSchemaDiff(ops: SchemaDiffOp[], forceSync: boolean) {