@lobb-js/core 0.27.0 → 0.29.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lobb-js/core",
   "license": "UNLICENSED",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -37,6 +37,7 @@
     "zod-to-ts": "^1.2.0"
   },
   "devDependencies": {
+    "lucide-svelte": "latest",
     "@types/lodash": "^4.17.0",
     "@types/nunjucks": "^3.2.6",
     "@types/pg": "^8.11.0",

package/src/api/collections/CollectionService.ts

@@ -59,6 +59,8 @@ export class CollectionService {
       }
     }
 
+    await Lobb.instance.eventSystem.emit("core.service.preCreateOne", props);
+
     return Lobb.instance.collectionStore.createOne(props as unknown as P<"createOne">) as Promise<T["output"]>;
   }
 
@@ -73,6 +75,8 @@ export class CollectionService {
       }
     }
 
+    await Lobb.instance.eventSystem.emit("core.service.preUpdateOne", props);
+
     return Lobb.instance.collectionStore.updateOne(props as unknown as P<"updateOne">) as Promise<T["output"]>;
   }
 
@@ -87,6 +91,8 @@ export class CollectionService {
       }
     }
 
+    await Lobb.instance.eventSystem.emit("core.service.preDeleteOne", props);
+
     return Lobb.instance.collectionStore.deleteOne(props as unknown as P<"deleteOne">) as Promise<T["output"]>;
   }
 
@@ -129,6 +135,8 @@ export class CollectionService {
       }
     }
 
+    await Lobb.instance.eventSystem.emit("core.service.preDeleteMany", props);
+
     return Lobb.instance.collectionStore.deleteMany(props as unknown as P<"deleteMany">) as Promise<T["output"]>;
   }
 

package/src/api/collections/collectionStore.ts

@@ -41,6 +41,16 @@ export class CollectionStore {
     context?: HonoContext;
     client?: PoolClient;
   }): Promise<ExposedManyServiceOutput> {
+    // Resolve children_of + parent_id into a regular filter before proceeding.
+    // This allows fetching related records (fk, m2m, polymorphic) without the caller
+    // needing to know the relation type or junction details.
+    if ((params as any)?.children_of !== undefined) {
+      const { children_of, parent_id, ...rest } = params as any;
+      const childFilter = await this.resolveChildrenOf(collectionName, children_of, parent_id);
+      if (childFilter === null) return { data: [], meta: { totalCount: 0 } };
+      params = { ...rest, filter: { ...rest.filter, ...childFilter } };
+    }
+
     return await beginTransaction(
       async (client) => {
         const eventResult = await Lobb.instance.eventSystem.emit(
@@ -1222,6 +1232,62 @@ export class CollectionStore {
     }
   }
 
+  private async resolveChildrenOf(
+    collectionName: string,
+    childrenOf: string,
+    parentId: any,
+  ): Promise<Record<string, any> | null> {
+    const children = Lobb.instance.configManager.getCollectionChildren(childrenOf);
+    const child = children.find((c) => c.collection === collectionName);
+
+    if (!child) {
+      throw new LobbError({
+        code: "BAD_REQUEST",
+        message: `"${collectionName}" is not a child of "${childrenOf}"`,
+      });
+    }
+
+    if (child.type === "fk") {
+      return { [child.field!]: parentId };
+    }
+
+    if (child.type === "m2m") {
+      const junction = await this.findAll({
+        collectionName: child.junction!,
+        params: { filter: { [child.junction_field!]: parentId } },
+      });
+      const ids = junction.data.map((r: any) => r[child.target_field!]);
+      if (ids.length === 0) return null;
+      return { id: { $in: ids } };
+    }
+
+    if (child.type === "polymorphic") {
+      const relations = Lobb.instance.configManager.config.relations ?? [];
+      const polyRelation = relations.find(
+        (r: any) =>
+          r.type === "polymorphic" &&
+          r.from.collection === collectionName &&
+          Array.isArray(r.to) &&
+          r.to.includes(childrenOf),
+      ) as any;
+      if (!polyRelation) {
+        throw new LobbError({
+          code: "BAD_REQUEST",
+          message: `No polymorphic relation found between "${collectionName}" and "${childrenOf}"`,
+        });
+      }
+      return {
+        [polyRelation.from.collection_field]: childrenOf,
+        [polyRelation.from.id_field]: parentId,
+      };
+    }
+
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message: `Unknown relation type: ${child.type}`,
+    });
+  }
+
   private async handleSingletonCollection(
     collectionName: string,
     context?: HonoContext,

package/src/config/ConfigManager.ts

@@ -425,10 +425,10 @@ export class ConfigManager {
     return [];
   }
 
-  public getCollectionChildren(collectionName: string): { type: string; collection: string; field?: string }[] {
+  public getCollectionChildren(collectionName: string): { type: string; collection: string; field?: string; junction?: string; junction_field?: string; target_field?: string }[] {
     const allRelations = this.config.relations ?? [];
     const allCollections = this.config.collections;
-    const children: { type: string; collection: string; field?: string }[] = [];
+    const children: { type: string; collection: string; field?: string; junction?: string; junction_field?: string; target_field?: string }[] = [];
     const seenJunctions = new Set<string>();
 
     for (const relation of allRelations) {
@@ -446,7 +446,13 @@ export class ConfigManager {
           (r as RegularRelation).from.field !== reg.from.field,
         ) as RegularRelation | undefined;
         if (otherSide) {
-          children.push({ type: "m2m", collection: otherSide.to.collection });
+          children.push({
+            type: "m2m",
+            collection: otherSide.to.collection,
+            junction: childCollection,
+            junction_field: reg.from.field,
+            target_field: otherSide.from.field,
+          });
         }
       } else {
         children.push({ type: "fk", collection: childCollection, field: reg.from.field });

package/src/events/coreEvents/index.ts

@@ -123,6 +123,29 @@ export function getCoreEvents(): Event[] {
     inputSchema: z.object({}),
     outputSchema: z.object({}),
   });
+  // service pre-events
+  events.push({
+    name: "core.service.preCreateOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.preUpdateOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.preDeleteOne",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+  events.push({
+    name: "core.service.preDeleteMany",
+    inputSchema: z.object({}),
+    outputSchema: z.object({}),
+  });
+
+  // service override events
   events.push({
     name: "core.service.findAll.override",
     inputSchema: z.object({}),

package/src/extension/ExtensionSystem.ts

@@ -95,6 +95,7 @@ export class ExtensionSystem {
         ? await extension.meta(Lobb.instance)
         : {};
       extensionMeta.version = extension.version;
+      extensionMeta.icon = extension.icon;
       return extensionMeta;
     }
   }

package/src/types/Extension.ts

@@ -5,6 +5,7 @@ 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";
+import * as Icons from "lucide-svelte";
 
 interface OpenApiProperty {
   paths: OpenAPIV3_1.Document["paths"];
@@ -17,6 +18,7 @@ export interface Dashboard {
 
 interface ExtensionBase {
   name: string;
+  icon?: keyof typeof Icons;
   workflows?: Workflow[];
   migrations?: Migrations;
   init?: (lobb: Lobb) => Promise<void>;