@lobb-js/core 0.16.0 → 0.18.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lobb-js/core",
-  "version": "0.16.0",
-  "license": "AGPL-3.0-only",
+  "license": "UNLICENSED",
+  "version": "0.18.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/api/meta/service.ts

@@ -63,6 +63,7 @@ export class MetaService {
         field.type = fieldConfig.type;
         field.label = fieldName;
         field.key = fieldName;
+        field.enum = "enum" in fieldConfig ? fieldConfig.enum : undefined;
         field.validators = fieldConfig.validators;
         field.pre_processors = fieldConfig.pre_processors;
         field.ui = fieldConfig.ui;

package/src/config/ConfigManager.ts

@@ -89,6 +89,12 @@ export class ConfigManager {
       };
       const fields = collections[collectionName].fields;
       for (const fieldName in fields) {
+        // virtual fields have no database column — skip them entirely
+        if (fields[fieldName].virtual) {
+          delete fields[fieldName];
+          continue;
+        }
+
         // including only the properties that are db related
         const field: any = {};
         field["type"] = fields[fieldName].type;

package/src/database/DatabaseSyncManager.ts

@@ -111,6 +111,11 @@ export class DatabaseSyncManager {
         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.getCollection(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;

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

@@ -169,6 +169,18 @@ export class PGDriver extends DatabaseDriver {
     await this.runQuery(client, sql);
   }
 
+  public async alterField(
+    collectionName: string,
+    fieldName: string,
+    field: CollectionField,
+  ): Promise<void> {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const pgType = this.generateFieldSignature(fieldName, field);
+    const sql = `ALTER TABLE ${collectionName} ALTER COLUMN ${fieldName} TYPE ${pgType} USING ${fieldName}::${pgType}`;
+    await this.runQuery(client, sql);
+  }
+
   public async getDbSchema(): Promise<CollectionsConfig> {
     const client = asDisposable(await this.pool.connect());
     using _ = client;
@@ -391,6 +403,7 @@ export class PGDriver extends DatabaseDriver {
     localClient?: PoolClient,
   ) {
     delete data.id;
+    data = this.stripVirtualFields(collectionName, data);
 
     const query = format(
       `INSERT INTO ${collectionName} (%I) VALUES (%L) RETURNING *`,
@@ -409,12 +422,22 @@ export class PGDriver extends DatabaseDriver {
     return result.rows[0] as any;
   }
 
+  private stripVirtualFields(collectionName: string, data: any): any {
+    const fields = Lobb.instance.configManager.getCollection(collectionName).fields;
+    const result = { ...data };
+    for (const key of Object.keys(result)) {
+      if (fields[key]?.virtual) delete result[key];
+    }
+    return result;
+  }
+
   public async updateOne(
     collectionName: string,
     id: string,
     data: any,
     localClient?: PoolClient,
   ) {
+    data = this.stripVirtualFields(collectionName, data);
     const setClause = Object.keys(data).map((key) =>
       format("%I = %L", key, data[key])
     ).join(", ");

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

@@ -82,9 +82,10 @@ export class QueryBuilder {
     const mainFields = fields.filter((f) => !f.includes("."));
     mainFields.forEach((field) => {
       if (field === "*") {
-        const currentCollectionFields = Object.keys(
-          Lobb.instance.configManager.getCollection(this.collectionName).fields,
-        );
+        const collectionFields = Lobb.instance.configManager.getCollection(this.collectionName).fields;
+        const currentCollectionFields = Object.entries(collectionFields)
+          .filter(([, fieldConfig]) => !fieldConfig.virtual)
+          .map(([fieldName]) => fieldName);
         currentCollectionFields.forEach((item) => {
           columns.add(`${this.collectionName}.${item}`);
         });
@@ -128,12 +129,16 @@ export class QueryBuilder {
           ? `${foreignFieldCollection}_self_${foreignField}`
           : foreignFieldCollection;
 
+        // Exclude virtual fields — they have no DB column in the related table
+        const foreignCollectionFields = Lobb.instance.configManager.getCollection(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(
-              ${nestedFields.map((f) => `'${f}', ${alias}.${f}`).join(", ")}
+              ${nonVirtualNestedFields.map((f) => `'${f}', ${alias}.${f}`).join(", ")}
             )
           END AS ${foreignField}
         `;

package/src/index.ts

@@ -28,6 +28,8 @@ export type { CollectionFieldsWithoutId } from "./types/config/collectionsConfig
 export type {
   CollectionField,
   CollectionFieldBase,
+  EnumOption,
+  EnumLevel,
 } from "./types/config/collectionFields.ts";
 export type { Dashboard, Extension } from "./types/Extension.ts";
 export { Field } from "./types/Field.ts";

package/src/types/DatabaseDriver.ts

@@ -50,6 +50,11 @@ export abstract class DatabaseDriver {
     collectionName: string,
     fieldName: string,
   ): Promise<void>;
+  public abstract alterField(
+    collectionName: string,
+    fieldName: string,
+    field: CollectionField,
+  ): Promise<void>;
   public abstract getDbSchema(): Promise<CollectionsConfig>;
   public abstract getIdsByFilter(
     collectionName: string,

package/src/types/config/collectionFields.ts

@@ -2,6 +2,17 @@ import { RelationCollectionFieldSchema } from "./relations.ts";
 
 import { z } from "zod";
 
+export type EnumLevel = "success" | "warning" | "danger" | "info" | "neutral" | "muted";
+
+export const EnumOptionSchema = z.object({
+  value: z.string(),
+  level: z.enum(["success", "warning", "danger", "info", "neutral", "muted"]),
+});
+
+export type EnumOption = z.infer<typeof EnumOptionSchema>;
+
+const StringEnumSchema = z.union([z.array(z.string()), z.array(EnumOptionSchema)]);
+
 // Define the UiInput schema
 const UiInputSchema = z.object({
   type: z.string(),
@@ -35,6 +46,7 @@ const FieldHooksSchema = z.object({
 
 // Base field schema (no default — each specialized schema adds it with the correct type)
 export const CollectionFieldBaseSchema = z.object({
+  virtual: z.never().optional(),
   required: z.boolean().optional(),
   hooks: FieldHooksSchema,
   validator: z.custom<FieldValidatorFn>((val) => typeof val === "function").optional(),
@@ -46,67 +58,107 @@ export const CollectionFieldBaseSchema = z.object({
 
 export type CollectionFieldBase = z.infer<typeof CollectionFieldBaseSchema>;
 
-// Specialized field schemas
-export const CollectionBoolFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("bool"),
-  default: z.boolean().optional(),
+// Virtual field schema — read-only, computed at runtime, no DB column.
+// Only type and ui are allowed; all write-side properties are excluded.
+const VirtualFieldSchema = z.object({
+  virtual: z.literal(true),
+  ui: UiSchema.optional(),
 });
 
-export const CollectionDateFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("date"),
-  default: z.union([z.string(), z.date()]).optional(),
-  enum: z.array(z.union([z.string(), z.date()])).optional(),
-});
+// Specialized field schemas
+export const CollectionBoolFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("bool"),
+    default: z.boolean().optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("bool") }),
+]);
 
-export const CollectionDateTimeFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("datetime"),
-  default: z.union([z.string(), z.date()]).optional(),
-  enum: z.array(z.union([z.string(), z.date()])).optional(),
-});
+export const CollectionDateFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("date"),
+    default: z.union([z.string(), z.date()]).optional(),
+    enum: z.array(z.union([z.string(), z.date()])).optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("date") }),
+]);
 
-export const CollectionDecimalFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("decimal"),
-  default: z.number().optional(),
-  enum: z.array(z.number()).optional(),
-});
+export const CollectionDateTimeFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("datetime"),
+    default: z.union([z.string(), z.date()]).optional(),
+    enum: z.array(z.union([z.string(), z.date()])).optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("datetime") }),
+]);
 
-export const CollectionFloatFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("float"),
-  default: z.number().optional(),
-  enum: z.array(z.number()).optional(),
-});
+export const CollectionDecimalFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("decimal"),
+    default: z.number().optional(),
+    enum: z.array(z.number()).optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("decimal") }),
+]);
 
-export const CollectionIntegerFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("integer"),
-  default: z.number().int().optional(),
-  enum: z.array(z.number().int()).optional(),
-  references: RelationCollectionFieldSchema.optional(),
-});
+export const CollectionFloatFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("float"),
+    default: z.number().optional(),
+    enum: z.array(z.number()).optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("float") }),
+]);
 
-export const CollectionLongFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("long"),
-  default: z.number().optional(),
-  enum: z.array(z.number()).optional(),
-});
+export const CollectionIntegerFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("integer"),
+    default: z.number().int().optional(),
+    enum: z.array(z.number().int()).optional(),
+    references: RelationCollectionFieldSchema.optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("integer") }),
+]);
 
-export const CollectionStringFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("string"),
-  length: z.number(),
-  default: z.string().optional(),
-  enum: z.array(z.string()).optional(),
-});
+export const CollectionLongFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("long"),
+    default: z.number().optional(),
+    enum: z.array(z.number()).optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("long") }),
+]);
 
-export const CollectionTextFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("text"),
-  default: z.string().optional(),
-  enum: z.array(z.string()).optional(),
-});
+export const CollectionStringFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("string"),
+    length: z.number(),
+    default: z.string().optional(),
+    enum: StringEnumSchema.optional(),
+  }),
+  VirtualFieldSchema.extend({
+    type: z.literal("string"),
+    length: z.number().optional(),
+  }),
+]);
 
-export const CollectionTimeFieldSchema = CollectionFieldBaseSchema.extend({
-  type: z.literal("time"),
-  default: z.string().optional(),
-  enum: z.array(z.string()).optional(),
-});
+export const CollectionTextFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("text"),
+    default: z.string().optional(),
+    enum: StringEnumSchema.optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("text") }),
+]);
+
+export const CollectionTimeFieldSchema = z.union([
+  CollectionFieldBaseSchema.extend({
+    type: z.literal("time"),
+    default: z.string().optional(),
+    enum: StringEnumSchema.optional(),
+  }),
+  VirtualFieldSchema.extend({ type: z.literal("time") }),
+]);
 
 // Union type if you want a single schema for all
 export const CollectionFieldSchema = z.union([

package/src/workflows/coreWorkflows/processors/enumWorkflows.ts

@@ -16,8 +16,11 @@ async function runEnumCheck(input: any, processAllFields: boolean) {
     const value = data[fieldName];
     if (value === undefined || value === null) continue;
 
-    if (!fieldConfig.enum.includes(value)) {
-      errors[fieldName] = [`${fieldName} must be one of: ${fieldConfig.enum.join(", ")}`];
+    const allowedValues = fieldConfig.enum.map((item: any) =>
+      typeof item === "object" ? item.value : item
+    );
+    if (!allowedValues.includes(value)) {
+      errors[fieldName] = [`${fieldName} must be one of: ${allowedValues.join(", ")}`];
     }
   }