@lobb-js/core 0.15.1 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobb-js/core",
-  "version": "0.15.1",
+  "version": "0.17.0",
   "license": "AGPL-3.0-only",
   "type": "module",
   "publishConfig": {

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/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/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(),
@@ -33,8 +44,9 @@ const FieldHooksSchema = z.object({
   afterUpdate: z.custom<FieldHookFn>((val) => typeof val === "function").optional(),
 }).optional();
 
-// Base field schema
+// Base field schema (no default — each specialized schema adds it with the correct type)
 export const CollectionFieldBaseSchema = z.object({
+  required: z.boolean().optional(),
   hooks: FieldHooksSchema,
   validator: z.custom<FieldValidatorFn>((val) => typeof val === "function").optional(),
   pre_processors: z.record(z.any()).optional(),
@@ -48,44 +60,63 @@ export type CollectionFieldBase = z.infer<typeof CollectionFieldBaseSchema>;
 // Specialized field schemas
 export const CollectionBoolFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("bool"),
+  default: z.boolean().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(),
 });
 
 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 CollectionDecimalFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("decimal"),
+  default: z.number().optional(),
+  enum: z.array(z.number()).optional(),
 });
 
 export const CollectionFloatFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("float"),
+  default: z.number().optional(),
+  enum: z.array(z.number()).optional(),
 });
 
 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 CollectionLongFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("long"),
+  default: z.number().optional(),
+  enum: z.array(z.number()).optional(),
 });
 
 export const CollectionStringFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("string"),
   length: z.number(),
+  default: z.string().optional(),
+  enum: StringEnumSchema.optional(),
 });
 
 export const CollectionTextFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("text"),
+  default: z.string().optional(),
+  enum: StringEnumSchema.optional(),
 });
 
 export const CollectionTimeFieldSchema = CollectionFieldBaseSchema.extend({
   type: z.literal("time"),
+  default: z.string().optional(),
+  enum: StringEnumSchema.optional(),
 });
 
 // Union type if you want a single schema for all

package/src/workflows/coreWorkflows/index.ts

@@ -5,12 +5,18 @@ import { postOperationsWorkflows } from "./processors/postOperationsWorkflows.ts
 import { preOperationsWorkflows } from "./processors/preOperationsWorkflows.ts";
 import { hooksWorkflows } from "./processors/hooksWorkflows.ts";
 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 { coreWorkflowsCollectionWorkflows } from "./workflowsCollection/workflowsCollectionWorkflows.ts";
 import { getQueryCoreWorkflows } from "./queryCoreWorkflows.ts";
 
 export function getCoreWorkflows(): Array<Workflow> {
   return [
     ...hooksWorkflows.filter((w) => w.name.startsWith("core_hooksBefore")),
+    ...defaultWorkflows,
+    ...requiredWorkflows,
+    ...enumWorkflows,
     ...validatorWorkflows,
     ...preOperationsWorkflows,
     ...postOperationsWorkflows,

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

@@ -0,0 +1,26 @@
+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;
+  const data = input.data;
+
+  for (const [fieldName, fieldConfig] of Object.entries(fields) as [string, any][]) {
+    if (fieldConfig.default === undefined) continue;
+    if (data[fieldName] === undefined) {
+      data[fieldName] = typeof fieldConfig.default === "function"
+        ? fieldConfig.default()
+        : fieldConfig.default;
+    }
+  }
+
+  return input;
+}
+
+export const defaultWorkflows: Workflow[] = [
+  {
+    name: "core_defaultOnCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => applyDefaults(input),
+  },
+];

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

@@ -0,0 +1,49 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+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;
+  const data = input.data;
+  const errors: Record<string, string[]> = {};
+
+  const fieldNames = processAllFields ? Object.keys(fields) : Object.keys(data);
+
+  for (const fieldName of fieldNames) {
+    const fieldConfig = fields[fieldName] as any;
+    if (!fieldConfig?.enum) continue;
+
+    const value = data[fieldName];
+    if (value === undefined || value === null) continue;
+
+    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(", ")}`];
+    }
+  }
+
+  if (Object.keys(errors).length) {
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message: "Validation failed. Please check your inputs and try again.",
+      details: errors,
+    });
+  }
+
+  return input;
+}
+
+export const enumWorkflows: Workflow[] = [
+  {
+    name: "core_enumOnCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => runEnumCheck(input, true),
+  },
+  {
+    name: "core_enumOnUpdate",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => runEnumCheck(input, false),
+  },
+];

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

@@ -0,0 +1,44 @@
+import type { Workflow } from "../../WorkflowSystem.ts";
+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;
+  const data = input.data;
+  const errors: Record<string, string[]> = {};
+
+  const fieldNames = processAllFields ? Object.keys(fields) : Object.keys(data);
+
+  for (const fieldName of fieldNames) {
+    const fieldConfig = fields[fieldName];
+    if (!fieldConfig?.required) continue;
+
+    const value = data[fieldName];
+    if (value === undefined || value === null || value === "") {
+      errors[fieldName] = [`${fieldName} is required`];
+    }
+  }
+
+  if (Object.keys(errors).length) {
+    throw new LobbError({
+      code: "BAD_REQUEST",
+      message: "Validation failed. Please check your inputs and try again.",
+      details: errors,
+    });
+  }
+
+  return input;
+}
+
+export const requiredWorkflows: Workflow[] = [
+  {
+    name: "core_requiredOnCreate",
+    eventName: "core.store.preCreateOne",
+    handler: async (input) => runRequiredCheck(input, true),
+  },
+  {
+    name: "core_requiredOnUpdate",
+    eventName: "core.store.preUpdateOne",
+    handler: async (input) => runRequiredCheck(input, false),
+  },
+];