@lobb-js/core 0.22.1 → 0.24.0

package/src/api/meta/service.ts

@@ -40,6 +40,7 @@ export class MetaService {
       collections[collectionName].singleton = Lobb.instance.configManager
         .isCollectionSingleton(collectionName);
 
+      // filling the collection properties
       // is collection virtual
       collections[collectionName].virtual = Lobb.instance.configManager
         .isCollectionVirtual(collectionName);

package/src/config/ConfigManager.ts

@@ -7,7 +7,7 @@ import {
 } from "../types/index.ts";
 import type { CollectionField } from "../types/index.ts";
 import type { Extension } from "../types/index.ts";
-import type { RelationsConfig } from "../types/index.ts";
+import type { RelationsConfig, RegularRelation } from "../types/index.ts";
 
 import _ from "lodash";
 import { coreCollections } from "../coreCollections/index.ts";
@@ -42,6 +42,64 @@ export class ConfigManager {
     };
   }
 
+  public expandPolymorphicFields() {
+    for (const [collectionName, collection] of Object.entries(this.config.collections)) {
+      if (!collection.fields) continue;
+      for (const [fieldName, fieldValue] of Object.entries(collection.fields)) {
+        if (fieldValue.type !== "polymorphic") continue;
+
+        const { collection_field, id_field, references } = fieldValue as any;
+
+        // Create the two real DB columns (hidden in UI)
+        collection.fields[collection_field] = {
+          type: "string",
+          length: 50,
+          ui: { hidden: true },
+        } as any;
+        collection.fields[id_field] = {
+          type: "integer",
+          ui: { hidden: true },
+        } as any;
+
+        // Convert the original field to virtual (drives the UI picker)
+        collection.fields[fieldName] = { virtual: true, ui: { icon: "Shuffle" } } as any;
+
+        // Auto-register the polymorphic relation
+        if (!this.config.relations) this.config.relations = [];
+        this.config.relations.push({
+          type: "polymorphic",
+          from: { collection: collectionName, virtual_field: fieldName, collection_field, id_field },
+          to: references,
+        } as any);
+      }
+    }
+  }
+
+  public addUniqueIndexesFromFields() {
+    for (
+      const [collectionName, collectionValue] of Object.entries(
+        this.config.collections,
+      )
+    ) {
+      if (collectionValue.virtual) continue;
+      for (
+        const [fieldName, fieldValue] of Object.entries(
+          (collectionValue as any).fields,
+        )
+      ) {
+        if ((fieldValue as any).unique) {
+          const indexName = `${collectionName}_${fieldName}_unique_index`;
+          (collectionValue as any).indexes[indexName] = {
+            unique: true,
+            fields: {
+              [fieldName]: { order: "asc" },
+            },
+          };
+        }
+      }
+    }
+  }
+
   public addRelationsFromIntegerRefrences() {
     for (
       const [collectionName, collectionValue] of Object.entries(
@@ -265,12 +323,102 @@ export class ConfigManager {
     delete this.config.collections[collectionName];
   }
 
-  public getChildRelations(collectionName: string): RelationsConfig {
+  public getParentRelation(
+    collectionName: string,
+    fieldName: string,
+  ): RegularRelation | null {
+    return (
+      this.config.relations?.find((rel): rel is RegularRelation => {
+        if ("type" in rel && rel.type === "polymorphic") return false;
+        return (
+          (rel as RegularRelation).from.collection === collectionName &&
+          (rel as RegularRelation).from.field === fieldName
+        );
+      }) ?? null
+    );
+  }
+
+  public getPolymorphicRelationByVirtualField(
+    collectionName: string,
+    virtualField: string,
+  ): { collectionField: string; idField: string; allowedCollections: string[] } | null {
+    const rel = this.config.relations?.find((r) => {
+      if (!("type" in r) || r.type !== "polymorphic") return false;
+      return (r as any).from.collection === collectionName &&
+        (r as any).from.virtual_field === virtualField;
+    }) as any | undefined;
+
+    if (!rel) return null;
+    return {
+      collectionField: rel.from.collection_field,
+      idField: rel.from.id_field,
+      allowedCollections: rel.to,
+    };
+  }
+
+  public getPolymorphicChildRelation(
+    parentCollection: string,
+    childCollection: string,
+  ): { collectionField: string; idField: string } | null {
+    const rel = this.config.relations?.find((r) => {
+      if (!("type" in r) || r.type !== "polymorphic") return false;
+      return (r as any).from.collection === childCollection &&
+        (r as any).to.includes(parentCollection);
+    }) as any | undefined;
+
+    if (!rel) return null;
+    return {
+      collectionField: rel.from.collection_field,
+      idField: rel.from.id_field,
+    };
+  }
+
+  public getM2MJunction(
+    fromCollection: string,
+    toCollection: string,
+  ): { junctionCollection: string; parentFKField: string; targetFKField: string } | null {
+    const fromChildRelations = this.getChildRelations(fromCollection);
+
+    for (const fromRelation of fromChildRelations) {
+      const junctionName = fromRelation.from.collection;
+      if (!this.config.collections[junctionName]?.junction) continue;
+
+      const toRelation = this.config.relations?.find((rel): rel is RegularRelation => {
+        if ("type" in rel && rel.type === "polymorphic") return false;
+        return (
+          (rel as RegularRelation).from.collection === junctionName &&
+          (rel as RegularRelation).to.collection === toCollection
+        );
+      });
+
+      if (toRelation) {
+        return {
+          junctionCollection: junctionName,
+          parentFKField: fromRelation.from.field,
+          targetFKField: toRelation.from.field,
+        };
+      }
+    }
+
+    return null;
+  }
+
+  public getCollectionFKFields(collectionName: string): string[] {
+    if (!this.config.relations) return [];
+    return this.config.relations
+      .filter((rel): rel is RegularRelation => {
+        if ("type" in rel && rel.type === "polymorphic") return false;
+        return (rel as RegularRelation).from.collection === collectionName;
+      })
+      .map((rel) => rel.from.field);
+  }
+
+  public getChildRelations(collectionName: string): RegularRelation[] {
     if (this.config.relations) {
-      const childrenRelations = this.config.relations.filter((relation) =>
-        relation.to.collection === collectionName
-      );
-      return childrenRelations;
+      return this.config.relations.filter((relation): relation is RegularRelation => {
+        if ("type" in relation && relation.type === "polymorphic") return false;
+        return (relation as RegularRelation).to.collection === collectionName;
+      });
     }
 
     return [];

package/src/config/validations.ts

@@ -10,11 +10,19 @@ function validateRelations(config: Config, configManager: ConfigManager) {
   if (config.relations) {
     for (let index = 0; index < config.relations.length; index++) {
       const relation = config.relations[index];
-      configManager.getCollection(relation.from.collection);
-      configManager.getField(relation.from.field, relation.from.collection);
-      if (!Array.isArray(relation.to)) {
-        configManager.getCollection(relation.to.collection);
-        configManager.getField(relation.to.field, relation.to.collection);
+      if ("type" in relation && relation.type === "polymorphic") {
+        configManager.getCollection(relation.from.collection);
+        configManager.fieldExists(relation.from.collection_field, relation.from.collection);
+        configManager.fieldExists(relation.from.id_field, relation.from.collection);
+        for (const targetCollection of relation.to) {
+          configManager.getCollection(targetCollection);
+        }
+      } else {
+        configManager.getCollection(relation.from.collection);
+        configManager.getField((relation.from as any).field, relation.from.collection);
+        const to = relation.to as { collection: string; field: string };
+        configManager.getCollection(to.collection);
+        configManager.getField(to.field, to.collection);
       }
     }
   }

package/src/database/drivers/pgDriver/QueryBuilder.ts

@@ -1,5 +1,4 @@
 import type { FindAllParamsOutput } from "../../../types/index.ts";
-import { Lobb } from "../../../Lobb.ts";
 import format from "pg-format";
 import _ from "lodash";
 import { LobbError } from "../../../LobbError.ts";
@@ -74,128 +73,14 @@ export class QueryBuilder {
   }
 
   private getSelectFields(): string {
-    // TODO: SANITIZE ALL THE FIELDS IN HERE THAT COMES FROM THE USER USING THE FORMAT LIBRARY
     const columns: Set<string> = new Set([`${this.collectionName}.id`]);
-    const fields = this.params.fields.split(",").map((f) => f.trim());
-
-    // Separate main fields (no dot) from foreign fields
-    const mainFields = fields.filter((f) => !f.includes("."));
-    mainFields.forEach((field) => {
-      if (field === "*") {
-        const collectionFields = Lobb.instance.configManager.getNormalCollection(this.collectionName).fields;
-        const currentCollectionFields = Object.entries(collectionFields)
-          .filter(([, fieldConfig]) => !fieldConfig.virtual)
-          .map(([fieldName]) => fieldName);
-        currentCollectionFields.forEach((item) => {
-          columns.add(`${this.collectionName}.${item}`);
-        });
-      } else {
-        columns.add(`${this.collectionName}.${field}`);
-      }
-    });
-
-    // Process foreign fields (nested relations)
-    if (fields.some((f) => f.includes("."))) {
-      const foreignFields: Record<string, string[]> = {};
-
-      // Group foreign fields by their parent
-      for (const field of fields) {
-        if (field.includes(".")) {
-          const foreignField = field.split(".")[0];
-          if (!foreignFields[foreignField]) foreignFields[foreignField] = [];
-        }
-      }
-
-      for (const foreignField of Object.keys(foreignFields)) {
-        foreignFields[foreignField] = fields
-          .filter((f) => f.startsWith(`${foreignField}.`))
-          .map((f) => f.slice(foreignField.length + 1));
-      }
-
-      // Add JSON build objects for each foreign field
-      for (
-        const [foreignField, nestedFields] of Object.entries(foreignFields)
-      ) {
-        const foreignFieldCollection = this.getForeignFieldCollection(
-          this.collectionName,
-          foreignField,
-        );
-
-        // Remove raw foreign key column
-        columns.delete(`${this.collectionName}.${foreignField}`);
-
-        // Determine alias (handle self-reference)
-        const alias = foreignFieldCollection === this.collectionName
-          ? `${foreignFieldCollection}_self_${foreignField}`
-          : foreignFieldCollection;
-
-        // Exclude virtual fields — they have no DB column in the related table
-        const foreignCollectionFields = Lobb.instance.configManager.getNormalCollection(foreignFieldCollection).fields;
-        const nonVirtualNestedFields = nestedFields.filter((f) => !foreignCollectionFields[f]?.virtual);
-
-        // Build JSON safely: only if related row exists
-        const jsonField = `
-          CASE
-            WHEN ${alias}.id IS NULL THEN NULL
-            ELSE json_build_object(
-              ${nonVirtualNestedFields.map((f) => `'${f}', ${alias}.${f}`).join(", ")}
-            )
-          END AS ${foreignField}
-        `;
-
-        columns.add(jsonField.trim());
-      }
-    }
-
+    const fields = this.params.fields.split(",").map((f) => f.trim()).filter(Boolean);
+    fields.forEach((field) => columns.add(`${this.collectionName}.${field}`));
     return Array.from(columns).join(", ");
   }
 
-  private getJsonBuildObject(
-    collectionName: string,
-    fieldName: string,
-    columns: string[],
-  ): string {
-    return `json_build_object(
-      ${
-      columns.map((column) => `'${column}', ${collectionName}.${column}`)
-        .join(",")
-    }
-    ) AS ${fieldName}`;
-  }
-
   private getJoins(): string {
-    const joins: string[] = [];
-    const fields = this.params.fields.split(",").map((field) => field.trim());
-    const foreignFields: Set<string> = new Set();
-
-    // Collect all foreign fields from the selected fields
-    for (const field of fields) {
-      if (field.includes(".")) {
-        const foreignKeyField = field.split(".")[0];
-        foreignFields.add(foreignKeyField);
-      }
-    }
-
-    const collectionName = this.collectionName;
-
-    // Build LEFT JOIN statements
-    for (const foreignField of Array.from(foreignFields)) {
-      const foreignKeyCollection = this.getForeignFieldCollection(
-        collectionName,
-        foreignField,
-      );
-
-      // If self-referencing, generate a unique alias
-      const alias = foreignKeyCollection === collectionName
-        ? `${foreignKeyCollection}_self_${foreignField}`
-        : foreignKeyCollection;
-
-      joins.push(
-        `LEFT JOIN ${foreignKeyCollection} AS ${alias} ON ${alias}.id = ${collectionName}.${foreignField}`,
-      );
-    }
-
-    return joins.join(" ");
+    return "";
   }
 
   private getGroupBy(): string {
@@ -453,27 +338,4 @@ export class QueryBuilder {
     return whereClause.trim();
   }
 
-  getForeignFieldCollection(collection: string, foreignField: string) {
-    const relations = Lobb.instance.configManager.config.relations;
-    if (!relations) {
-      throw new LobbError({
-        code: "BAD_REQUEST",
-        message:
-          `Can't use dot (".") operator in (fields) findAll property because there is not relations`,
-      });
-    }
-    const foreignFieldRelation = relations.find((relation) =>
-      relation.from.collection === collection &&
-      relation.from.field === foreignField
-    );
-    if (!foreignFieldRelation) {
-      throw new LobbError({
-        code: "BAD_REQUEST",
-        message:
-          `Couldn't find the relation object of the (${this.collectionName}.${foreignField}) field`,
-      });
-    }
-
-    return foreignFieldRelation.to.collection;
-  }
 }

package/src/index.ts

@@ -40,7 +40,7 @@ export {
   filterSchema,
 } from "./types/filterSchema.ts";
 export type {
-  FindAllParamsInput,
+  FindAllParams,
   FindAllParamsOutput,
 } from "./types/collectionServiceSchema.ts";
 export { findAllParamsSchema } from "./types/collectionServiceSchema.ts";

package/src/types/collectionServiceSchema.ts

@@ -1,18 +1,65 @@
 import { z } from "zod";
 
-export const findAllParamsSchema = z
-  .object({
+export type ChildParams = {
+  fields?: string | string[];
+  sort?: string;
+  limit?: number;
+  offset?: number;
+  page?: number;
+  filter?: any;
+  children?: Record<string, ChildParams>;
+};
+
+export const childParamsSchema: z.ZodType<ChildParams> = z.lazy(() =>
+  z.object({
+    fields: z.union([z.string(), z.array(z.string())]).optional(),
     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("*"),
+    limit: z.number().optional(),
+    offset: z.number().optional(),
+    page: z.number().optional(),
     filter: z.any(),
-  }).strict()
-  .default({
-    fields: "*",
-    limit: 100,
-    offset: 0,
-  });
-export type FindAllParamsInput = z.input<typeof findAllParamsSchema>;
-export type FindAllParamsOutput = z.output<typeof findAllParamsSchema>;
+    children: z.record(childParamsSchema).optional(),
+  })
+);
+
+const baseParamsSchema = z.object({
+  fields: z.union([z.string(), z.array(z.string())]).optional(),
+  children: z.record(childParamsSchema).optional(),
+});
+
+export const findOneParamsSchema = baseParamsSchema;
+export type FindOneParams = z.infer<typeof findOneParamsSchema>;
+
+export const findAllParamsSchema = baseParamsSchema
+  .extend({
+    sort: z.string().optional(),
+    limit: z.number().optional(),
+    offset: z.number().optional(),
+    page: z.number().optional(),
+    filter: z.any(),
+  })
+  .strict();
+export type FindAllParams = z.infer<typeof findAllParamsSchema>;
+
+export type CreateChildren = Record<string, {
+  create?: Array<Record<string, any> & { children?: CreateChildren }>;
+  link?: (string | number)[];
+}>;
+
+export type UpdateChildren = Record<string, {
+  create?: Array<Record<string, any> & { children?: UpdateChildren }>;
+  link?: (string | number)[];
+  unlink?: (string | number)[];
+  delete?: (string | number)[];
+  set?: (string | number)[];
+  update?: Array<{ id: string | number } & Record<string, any>>;
+}>;
+
+export type FindAllParamsOutput = {
+  sort?: string;
+  limit: number;
+  offset: number;
+  page?: number;
+  fields: string;
+  filter?: any;
+};

package/src/types/config/collectionFields.ts

@@ -1,6 +1,9 @@
 import { RelationCollectionFieldSchema } from "./relations.ts";
 
 import { z } from "zod";
+import type { icons } from "lucide-svelte";
+
+type LucideIconName = keyof typeof icons;
 
 export type EnumColor =
   | "red" | "rose" | "pink" | "fuchsia" | "purple"
@@ -28,8 +31,10 @@ const UiInputSchema = z.object({
 // Defining the ui property schema
 const UiSchema = z.object({
   disabled: z.boolean().optional(),
+  hidden: z.boolean().optional(),
   placeholder: z.string().optional(),
   input: UiInputSchema.optional(),
+  icon: z.custom<LucideIconName>((val) => typeof val === "string").optional(),
 });
 
 export type FieldHookFn = (ctx: {
@@ -54,6 +59,7 @@ const FieldHooksSchema = z.object({
 export const CollectionFieldBaseSchema = z.object({
   virtual: z.never().optional(),
   required: z.boolean().optional(),
+  unique: z.boolean().optional(),
   hooks: FieldHooksSchema,
   validator: z.custom<FieldValidatorFn>((val) => typeof val === "function").optional(),
   ui: UiSchema.optional(),
@@ -163,6 +169,18 @@ export const CollectionTimeFieldSchema = z.union([
   VirtualFieldSchema.extend({ type: z.literal("time") }),
 ]);
 
+// Polymorphic field — expands during config init into:
+//   - {collection_field}: real string column (hidden in UI)
+//   - {id_field}: real integer column (hidden in UI)
+//   - the field itself becomes virtual (drives the compound picker widget)
+// A polymorphic relation is also auto-registered into config.relations.
+export const CollectionPolymorphicFieldSchema = CollectionFieldBaseSchema.extend({
+  type: z.literal("polymorphic"),
+  collection_field: z.string(),
+  id_field: z.string(),
+  references: z.array(z.string()),
+});
+
 // Union type if you want a single schema for all
 export const CollectionFieldSchema = z.union([
   CollectionBoolFieldSchema,
@@ -175,6 +193,7 @@ export const CollectionFieldSchema = z.union([
   CollectionStringFieldSchema,
   CollectionTextFieldSchema,
   CollectionTimeFieldSchema,
+  CollectionPolymorphicFieldSchema,
 ]);
 
 export type CollectionField = z.infer<typeof CollectionFieldSchema>;

package/src/types/config/collectionsConfig.ts

@@ -3,6 +3,9 @@ import {
   CollectionFieldSchema,
   CollectionIntegerFieldSchema,
 } from "./collectionFields.ts";
+import type { icons } from "lucide-svelte";
+
+type LucideIconName = keyof typeof icons;
 
 export type CollectionHookFn = (ctx: {
   data: Record<string, any>;
@@ -49,6 +52,7 @@ const CollectionTabSchema = z.object({
 });
 
 const CollectionUiSchema = z.object({
+  icon: z.custom<LucideIconName>((val) => typeof val === "string").optional(),
   tabs: z.array(CollectionTabSchema).optional(),
 }).optional();
 
@@ -64,6 +68,7 @@ export const NormalCollectionConfigSchema = z.object({
   virtual: z.literal(false).optional(),
   category: z.string().optional(),
   singleton: z.boolean().optional(),
+  junction: z.boolean().optional(),
   hooks: CollectionHooksSchema,
   indexes: CollectionIndexesSchema.optional(),
   fields: CollectionFieldsSchema,

package/src/types/config/relations.ts

@@ -6,12 +6,31 @@ export const RelationCollectionFieldSchema = z.object({
   field: z.string(),
 });
 
-// Regular relation schema
-const RelationSchema = z.object({
+// Regular (FK) relation schema
+export const RegularRelationSchema = z.object({
   from: RelationCollectionFieldSchema,
   to: RelationCollectionFieldSchema,
 });
 
+export type RegularRelation = z.infer<typeof RegularRelationSchema>;
+
+// Polymorphic relation schema
+// from.collection_field holds the target collection name per row
+// from.id_field holds the target record id per row
+// to lists the allowed target collections
+const PolymorphicRelationSchema = z.object({
+  type: z.literal("polymorphic"),
+  from: z.object({
+    collection: z.string(),
+    virtual_field: z.string(),
+    collection_field: z.string(),
+    id_field: z.string(),
+  }),
+  to: z.array(z.string()),
+});
+
 // Union of all relation types
-export const RelationsConfigSchema = z.array(RelationSchema);
+export const RelationsConfigSchema = z.array(
+  z.union([RegularRelationSchema, PolymorphicRelationSchema]),
+);
 export type RelationsConfig = z.infer<typeof RelationsConfigSchema>;

package/src/types/index.ts

@@ -2,7 +2,7 @@ export { DatabaseDriver } from "./DatabaseDriver.ts";
 export type { FindAllResult, MassReturn } from "./DatabaseDriver.ts";
 export type { ApiCollectionAction } from "./apiSchema.ts";
 export type { Config, WebConfig } from "./config/config.ts";
-export type { RelationsConfig } from "./config/relations.ts";
+export type { RelationsConfig, RegularRelation } from "./config/relations.ts";
 export type {
   CollectionConfig,
   NormalCollectionConfig,
@@ -24,10 +24,14 @@ export {
   filterSchema,
 } from "./filterSchema.ts";
 export type {
-  FindAllParamsInput,
+  FindAllParams,
   FindAllParamsOutput,
+  FindOneParams,
+  ChildParams,
+  CreateChildren,
+  UpdateChildren,
 } from "./collectionServiceSchema.ts";
-export { findAllParamsSchema } from "./collectionServiceSchema.ts";
+export { findAllParamsSchema, findOneParamsSchema, childParamsSchema } from "./collectionServiceSchema.ts";
 export { CollectionConfigSchema } from "./config/collectionsConfig.ts";
 export type { CollectionControllers } from "./CollectionControllers.ts";
 export type {

package/src/workflows/coreWorkflows/index.ts

@@ -6,11 +6,13 @@ import { validatorWorkflows } from "./processors/validatorWorkflows.ts";
 import { requiredWorkflows } from "./processors/requiredWorkflows.ts";
 import { defaultWorkflows } from "./processors/defaultWorkflows.ts";
 import { enumWorkflows } from "./processors/enumWorkflows.ts";
+import { coerceAndValidateWorkflows } from "./processors/coerceAndValidateWorkflows.ts";
 import { coreWorkflowsCollectionWorkflows } from "./workflowsCollection/workflowsCollectionWorkflows.ts";
 import { getQueryCoreWorkflows } from "./queryCoreWorkflows.ts";
 
 export function getCoreWorkflows(): Array<Workflow> {
   return [
+    ...coerceAndValidateWorkflows,
     ...hooksWorkflows.filter((w) => w.name.startsWith("core_hooksBefore")),
     ...defaultWorkflows,
     ...requiredWorkflows,