@lobb-js/core 0.17.0 → 0.19.0

package/package.json

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

package/src/api/collections/collectionStore.ts

@@ -226,11 +226,15 @@ export class CollectionStore {
             transaction: client,
           },
         );
-        data = await this.dbDriver.createOne(
-          collectionName,
-          this.filterPayload(collectionName, result.data),
-          client,
-        );
+
+        if (!Lobb.instance.configManager.isCollectionVirtual(collectionName)) {
+          data = await this.dbDriver.createOne(
+            collectionName,
+            this.filterPayload(collectionName, result.data),
+            client,
+          );
+        }
+
         data = (await Lobb.instance.eventSystem.emit(
           `core.store.createOne`,
           {

package/src/api/collections/utils.ts

@@ -8,6 +8,7 @@ export function getCollectionDocumentSchema(
     const collection = Lobb.instance.configManager.getCollection(
       collectionName,
     );
+    if (collection.virtual) return z.object({}).passthrough();
     const fieldNames = Object.keys(collection.fields);
 
     const properties: Record<string, any> = {};
@@ -64,7 +65,7 @@ export function getColFieldPropSchema(
     );
   }
 
-  const requiredField = Boolean(field.validators?.required);
+  const requiredField = Boolean("validators" in field && field.validators?.required);
   if (!requiredField) {
     fieldSchema = fieldSchema.optional();
   }

package/src/api/meta/service.ts

@@ -40,6 +40,10 @@ export class MetaService {
       collections[collectionName].singleton = Lobb.instance.configManager
         .isCollectionSingleton(collectionName);
 
+      // is collection virtual
+      collections[collectionName].virtual = Lobb.instance.configManager
+        .isCollectionVirtual(collectionName);
+
       // filling the extension property
       collections[collectionName].category = collection.category;
       collections[collectionName].owner = Lobb.instance.utils
@@ -64,12 +68,15 @@ export class MetaService {
         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.validators = "validators" in fieldConfig ? fieldConfig.validators : undefined;
+        field.pre_processors = "pre_processors" in fieldConfig ? fieldConfig.pre_processors : undefined;
         field.ui = fieldConfig.ui;
 
         collections[collectionName].fields[fieldName] = field;
       }
+
+      // filling the collection ui
+      collections[collectionName].ui = collection.ui;
     }
 
     return collections;

package/src/config/ConfigManager.ts

@@ -3,6 +3,7 @@ import {
   type CollectionConfig,
   CollectionConfigSchema,
   type CollectionsConfig,
+  type NormalCollectionConfig,
 } from "../types/index.ts";
 import type { CollectionField } from "../types/index.ts";
 import type { Extension } from "../types/index.ts";
@@ -47,9 +48,10 @@ export class ConfigManager {
         this.config.collections,
       )
     ) {
+      if (collectionValue.virtual) continue;
       for (
         const [fieldName, fieldValue] of Object.entries(
-          this.config.collections[collectionName].fields,
+          (this.config.collections[collectionName] as any).fields,
         )
       ) {
         if (fieldValue.type === "integer" && fieldValue.references) {
@@ -82,6 +84,12 @@ export class ConfigManager {
 
     // Iterate over the collections and map each field to only include the 'type' property
     for (const collectionName in collections) {
+      // Virtual collections have no DB table — skip them entirely
+      if (collections[collectionName].virtual) {
+        delete collections[collectionName];
+        continue;
+      }
+
       // Keep only the 'indexes' and 'fields' properties in a collection
       collections[collectionName] = {
         indexes: collections[collectionName].indexes,
@@ -89,6 +97,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;
@@ -125,19 +139,30 @@ export class ConfigManager {
     return collection;
   }
 
+  public getNormalCollection(collectionName: string): NormalCollectionConfig {
+    const collection = this.getCollection(collectionName);
+    if (collection.virtual) {
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message: `The (${collectionName}) collection is virtual and has no fields`,
+      });
+    }
+    return collection;
+  }
+
   public getFieldNames(collectionName: string) {
-    return Object.keys(
-      this.getCollection(collectionName).fields,
-    );
+    const collection = this.getCollection(collectionName);
+    if (collection.virtual) return [];
+    return Object.keys(collection.fields);
   }
 
   public fieldExists(
     fieldName: string,
     collectionName: string,
   ): boolean {
-    return Boolean(
-      this.getCollection(collectionName).fields[fieldName],
-    );
+    const collection = this.getCollection(collectionName);
+    if (collection.virtual) return false;
+    return Boolean(collection.fields[fieldName]);
   }
 
   public collectionExists(collectionName: string): boolean {
@@ -148,7 +173,8 @@ export class ConfigManager {
     fieldName: string,
     collectionName: string,
   ): CollectionField {
-    const field = this.getCollection(collectionName).fields[fieldName];
+    const collection = this.getCollection(collectionName);
+    const field = collection.virtual ? undefined : collection.fields[fieldName];
     if (!field) {
       throw new LobbError({
         code: "BAD_REQUEST",
@@ -199,7 +225,11 @@ export class ConfigManager {
     const virtualCollections: CollectionsConfig = {};
     const collections = this.getCollections();
     for (const [collectionName, collection] of Object.entries(collections)) {
-      const collectionFieldsNames = Object.keys(collection.fields);
+      if (collection.virtual) {
+        virtualCollections[collectionName] = collection;
+        continue;
+      }
+      const collectionFieldsNames = Object.keys(collection.fields ?? {});
       if (collectionFieldsNames.length <= 1) {
         virtualCollections[collectionName] = collection;
       }
@@ -247,6 +277,12 @@ export class ConfigManager {
   }
 
   public isCollectionSingleton(collectionName: string): boolean {
-    return Boolean(this.config.collections[collectionName]?.singleton);
+    const collection = this.config.collections[collectionName];
+    if (!collection || collection.virtual) return false;
+    return Boolean(collection.singleton);
+  }
+
+  public isCollectionVirtual(collectionName: string): boolean {
+    return Boolean(this.config.collections[collectionName]?.virtual);
   }
 }

package/src/config/validations.ts

@@ -37,7 +37,7 @@ function validateDBNamesAreSnakeCase(
       );
     }
     for (
-      const [fieldName, _] of Object.entries(collectionValue.fields)
+      const [fieldName, _] of Object.entries(collectionValue.virtual ? {} : collectionValue.fields)
     ) {
       if (!isSnakeCase(fieldName)) {
         throw new Error(

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.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;
@@ -126,10 +131,10 @@ export class DatabaseSyncManager {
       } 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.getCollection(
+        const collectionConfig = Lobb.instance.configManager.getNormalCollection(
           collectionName,
         );
-        const indexes = collectionConfig.indexes;
+        const indexes = collectionConfig.indexes ?? {};
         const index = indexes[indexName];
         await this.dbDriver.dropIndex(collectionName, indexName);
         await this.dbDriver.createIndex(

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

@@ -1,7 +1,7 @@
 import format from "pg-format";
 import type { FindAllParamsOutput } from "../../../types/index.ts";
 import type {
-  CollectionConfig,
+  NormalCollectionConfig,
   CollectionIndex,
   CollectionIndexes,
   CollectionsConfig,
@@ -109,7 +109,7 @@ export class PGDriver extends DatabaseDriver {
 
   public async createCollection(
     collectionName: string,
-    collectionConfig: CollectionConfig,
+    collectionConfig: NormalCollectionConfig,
   ) {
     const collectionEntries = Object.entries(collectionConfig.fields);
     const createTableBodySql: string = collectionEntries.map(
@@ -127,7 +127,7 @@ export class PGDriver extends DatabaseDriver {
     await this.runQuery(client, query);
 
     // creating the indexes
-    const indexes = collectionConfig.indexes;
+    const indexes = collectionConfig.indexes ?? {};
     for (
       const [indexName, value] of Object.entries(indexes)
     ) {
@@ -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,24 @@ export class PGDriver extends DatabaseDriver {
     return result.rows[0] as any;
   }
 
+  private stripVirtualFields(collectionName: string, data: any): any {
+    const collection = Lobb.instance.configManager.getCollection(collectionName);
+    if (collection.virtual) return data;
+    const fields = collection.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.getNormalCollection(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.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(
-              ${nestedFields.map((f) => `'${f}', ${alias}.${f}`).join(", ")}
+              ${nonVirtualNestedFields.map((f) => `'${f}', ${alias}.${f}`).join(", ")}
             )
           END AS ${foreignField}
         `;

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

@@ -46,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(),
@@ -57,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: StringEnumSchema.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: StringEnumSchema.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: StringEnumSchema.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/types/config/collectionsConfig.ts

@@ -41,15 +41,40 @@ export const CollectionFieldsSchema = z.intersection(
   z.record(CollectionFieldSchema),
 );
 
-// CollectionConfig
-export const CollectionConfigSchema = z.object({
+const CollectionTabSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  filter: z.record(z.unknown()).optional(),
+  default: z.boolean().optional(),
+});
+
+const CollectionUiSchema = z.object({
+  tabs: z.array(CollectionTabSchema).optional(),
+}).optional();
+
+// Virtual collection — no DB table, no fields, just an API endpoint for workflows to intercept
+export const VirtualCollectionConfigSchema = z.object({
+  virtual: z.literal(true),
+  category: z.string().optional(),
+  ui: CollectionUiSchema,
+});
+
+// Normal collection — has fields (required) and optional indexes
+export const NormalCollectionConfigSchema = z.object({
+  virtual: z.literal(false).optional(),
   category: z.string().optional(),
   singleton: z.boolean().optional(),
   hooks: CollectionHooksSchema,
-  indexes: CollectionIndexesSchema,
+  indexes: CollectionIndexesSchema.optional(),
   fields: CollectionFieldsSchema,
+  ui: CollectionUiSchema,
 });
 
+export const CollectionConfigSchema = z.union([
+  VirtualCollectionConfigSchema,
+  NormalCollectionConfigSchema,
+]);
+
 export const CollectionsConfigSchema = z.record(CollectionConfigSchema);
 
 // Inferred Types
@@ -59,5 +84,7 @@ export type CollectionIndex = z.infer<typeof CollectionIndexSchema>;
 export type CollectionIndexes = z.infer<typeof CollectionIndexesSchema>;
 export type CollectionFields = z.infer<typeof CollectionFieldsSchema>;
 export type CollectionFieldsWithoutId = Omit<CollectionFields, "id">;
+export type VirtualCollectionConfig = z.infer<typeof VirtualCollectionConfigSchema>;
+export type NormalCollectionConfig = z.infer<typeof NormalCollectionConfigSchema>;
 export type CollectionConfig = z.infer<typeof CollectionConfigSchema>;
 export type CollectionsConfig = z.infer<typeof CollectionsConfigSchema>;

package/src/types/index.ts

@@ -5,6 +5,7 @@ export type { Config, WebConfig } from "./config/config.ts";
 export type { RelationsConfig } from "./config/relations.ts";
 export type {
   CollectionConfig,
+  NormalCollectionConfig,
   CollectionIndex,
   CollectionIndexes,
   CollectionsConfig,

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

@@ -2,7 +2,8 @@ import type { Workflow } from "../../WorkflowSystem.ts";
 import { Lobb } from "../../../Lobb.ts";
 
 async function applyDefaults(input: any) {
-  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+  const fields = Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
   const data = input.data;
 
   for (const [fieldName, fieldConfig] of Object.entries(fields) as [string, any][]) {

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

@@ -3,7 +3,8 @@ import { Lobb } from "../../../Lobb.ts";
 import { LobbError } from "../../../LobbError.ts";
 
 async function runEnumCheck(input: any, processAllFields: boolean) {
-  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+  const fields = Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
   const data = input.data;
   const errors: Record<string, string[]> = {};
 

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

@@ -5,9 +5,10 @@ async function runFieldHooks(
   hookName: "beforeCreate" | "beforeUpdate" | "afterCreate" | "afterUpdate",
   input: any,
 ) {
-  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return;
+  const fields = Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
   for (const [fieldName, fieldConfig] of Object.entries(fields)) {
-    const hook = fieldConfig.hooks?.[hookName];
+    const hook = "hooks" in fieldConfig ? fieldConfig.hooks?.[hookName] : undefined;
     if (!hook) continue;
     const result = await hook({ data: input.data, context: input.context });
     if (result !== undefined) {
@@ -21,7 +22,8 @@ export const hooksWorkflows: Workflow[] = [
     name: "core_hooksBeforeCreate",
     eventName: "core.store.preCreateOne",
     handler: async (input) => {
-      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+      const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
       await hooks?.beforeCreate?.({ data: input.data, context: input.context });
       await runFieldHooks("beforeCreate", input);
       return input;
@@ -31,7 +33,8 @@ export const hooksWorkflows: Workflow[] = [
     name: "core_hooksBeforeUpdate",
     eventName: "core.store.preUpdateOne",
     handler: async (input) => {
-      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+      const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
       await hooks?.beforeUpdate?.({ data: input.data, context: input.context });
       await runFieldHooks("beforeUpdate", input);
       return input;
@@ -41,7 +44,8 @@ export const hooksWorkflows: Workflow[] = [
     name: "core_hooksAfterCreate",
     eventName: "core.store.createOne",
     handler: async (input) => {
-      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+      const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
       await hooks?.afterCreate?.({ data: input.data, context: input.context });
       await runFieldHooks("afterCreate", input);
       return input;
@@ -51,7 +55,8 @@ export const hooksWorkflows: Workflow[] = [
     name: "core_hooksAfterUpdate",
     eventName: "core.store.updateOne",
     handler: async (input) => {
-      const hooks = Lobb.instance.configManager.getCollection(input.collectionName).hooks;
+      if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+      const hooks = Lobb.instance.configManager.getNormalCollection(input.collectionName).hooks;
       await hooks?.afterUpdate?.({ data: input.data, context: input.context });
       await runFieldHooks("afterUpdate", input);
       return input;

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

@@ -9,7 +9,7 @@ export async function processor(
   processAllFields: boolean,
 ) {
   const fieldsSchema =
-    Lobb.instance.configManager.getCollection(input.collectionName).fields;
+    Lobb.instance.configManager.isCollectionVirtual(input.collectionName) ? {} as any : Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
 
   input.data = await processPayloadWithSchema(
     type,

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

@@ -3,7 +3,8 @@ import { Lobb } from "../../../Lobb.ts";
 import { LobbError } from "../../../LobbError.ts";
 
 async function runRequiredCheck(input: any, processAllFields: boolean) {
-  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+  const fields = Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
   const data = input.data;
   const errors: Record<string, string[]> = {};
 
@@ -11,7 +12,7 @@ async function runRequiredCheck(input: any, processAllFields: boolean) {
 
   for (const fieldName of fieldNames) {
     const fieldConfig = fields[fieldName];
-    if (!fieldConfig?.required) continue;
+    if (!fieldConfig || !("required" in fieldConfig) || !fieldConfig.required) continue;
 
     const value = data[fieldName];
     if (value === undefined || value === null || value === "") {

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

@@ -6,7 +6,7 @@ export async function validator(
   processAllFields: boolean = false,
 ) {
   const fieldsSchema =
-    Lobb.instance.configManager.getCollection(input.collectionName).fields;
+    Lobb.instance.configManager.isCollectionVirtual(input.collectionName) ? {} as any : Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
 
   await validatePayloadWithSchema(
     input.data,

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

@@ -3,7 +3,8 @@ import { Lobb } from "../../../Lobb.ts";
 import { LobbError } from "../../../LobbError.ts";
 
 async function runFieldValidators(input: any, processAllFields: boolean) {
-  const fields = Lobb.instance.configManager.getCollection(input.collectionName).fields;
+  if (Lobb.instance.configManager.isCollectionVirtual(input.collectionName)) return input;
+  const fields = Lobb.instance.configManager.getNormalCollection(input.collectionName).fields;
   const data = input.data;
   const errors: Record<string, string[]> = {};
 
@@ -11,7 +12,7 @@ async function runFieldValidators(input: any, processAllFields: boolean) {
 
   for (const fieldName of fieldNames) {
     const fieldConfig = fields[fieldName];
-    if (!fieldConfig?.validator) continue;
+    if (!fieldConfig || !("validator" in fieldConfig) || !fieldConfig.validator) continue;
 
     const error = await fieldConfig.validator({
       value: data[fieldName],