@stndrds/schema 0.1.0-alpha.15 → 0.1.0-alpha.16

package/dist/runtime.js

@@ -121,6 +121,7 @@ __export(runtime_exports, {
   AuditService: () => AuditService,
   DEFAULT_LABEL_FALLBACK: () => DEFAULT_LABEL_FALLBACK,
   FileService: () => FileService,
+  FlowService: () => FlowService,
   GeocodingService: () => GeocodingService,
   GlobalSearchService: () => GlobalSearchService,
   NoopGeocodingAdapter: () => NoopGeocodingAdapter,
@@ -1533,6 +1534,273 @@ var FileService = class {
   }
 };
 
+// src/runtime/services/flow.service.ts
+var FlowService = class {
+  constructor(adapter, systemFlows = []) {
+    this.adapter = adapter;
+    this.systemFlows = new Map(systemFlows.map((f) => [f.name, f]));
+  }
+  /**
+   * Get all flows for a tenant (system + custom)
+   */
+  async getAllFlows(tenantId) {
+    const systemFlowsList = Array.from(this.systemFlows.values());
+    if (!this.adapter.flows) {
+      return systemFlowsList;
+    }
+    const dbFlows = await this.adapter.flows.findAllForTenant(tenantId);
+    const customFlows = dbFlows.filter((f) => !f.system).map(this.convertDBFlowToDefinition);
+    return [...systemFlowsList, ...customFlows];
+  }
+  /**
+   * Get published flows only
+   */
+  async getPublishedFlows(tenantId) {
+    const allFlows = await this.getAllFlows(tenantId);
+    return allFlows.filter((f) => f.status === "published");
+  }
+  /**
+   * Get a specific flow by name
+   */
+  async getFlow(name, tenantId) {
+    const systemFlow = this.systemFlows.get(name);
+    if (systemFlow) {
+      return systemFlow;
+    }
+    if (!this.adapter.flows) {
+      return null;
+    }
+    const dbFlow = await this.adapter.flows.findByName(tenantId, name);
+    if (dbFlow) {
+      return this.convertDBFlowToDefinition(dbFlow);
+    }
+    return null;
+  }
+  /**
+   * Get a flow by ID
+   */
+  async getFlowById(flowId) {
+    if (!this.adapter.flows) {
+      return null;
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (dbFlow) {
+      return this.convertDBFlowToDefinition(dbFlow);
+    }
+    return null;
+  }
+  /**
+   * Create a new custom flow (as draft)
+   */
+  async createFlow(input, tenantId) {
+    if (!this.adapter.flows) {
+      throw new Error("Flows feature is not enabled. Database adapter does not support flows.");
+    }
+    this.validateFlowName(input.name);
+    const existing = await this.adapter.flows.findByName(tenantId, input.name);
+    if (existing) {
+      throw new Error(`Flow "${input.name}" already exists`);
+    }
+    if (this.systemFlows.has(input.name)) {
+      throw new Error(
+        `Cannot create flow "${input.name}": a system flow with this name already exists`
+      );
+    }
+    this.validateFlowStructure(input);
+    const dbFlow = await this.adapter.flows.create({
+      tenantId,
+      name: input.name,
+      label: input.label,
+      description: input.description,
+      icon: input.icon,
+      status: "draft",
+      version: 1,
+      slots: input.slots,
+      pages: input.pages,
+      relations: input.relations,
+      system: false,
+      metadata: input.metadata
+    });
+    return this.convertDBFlowToDefinition(dbFlow);
+  }
+  /**
+   * Update a custom flow
+   */
+  async updateFlow(flowId, input) {
+    if (!this.adapter.flows) {
+      throw new Error("Flows feature is not enabled.");
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new Error(`Flow with id "${flowId}" not found`);
+    }
+    if (dbFlow.system) {
+      throw new Error("Cannot modify system flows. System flows are protected.");
+    }
+    if (input.slots || input.pages || input.relations) {
+      this.validateFlowStructure({
+        name: dbFlow.name,
+        label: input.label ?? dbFlow.label,
+        slots: input.slots ?? dbFlow.slots,
+        pages: input.pages ?? dbFlow.pages,
+        relations: input.relations ?? dbFlow.relations
+      });
+    }
+    const updated = await this.adapter.flows.update(flowId, {
+      label: input.label,
+      description: input.description,
+      icon: input.icon,
+      slots: input.slots,
+      pages: input.pages,
+      relations: input.relations,
+      metadata: input.metadata
+    });
+    return this.convertDBFlowToDefinition(updated);
+  }
+  /**
+   * Publish a flow
+   */
+  async publishFlow(flowId) {
+    if (!this.adapter.flows) {
+      throw new Error("Flows feature is not enabled.");
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new Error(`Flow with id "${flowId}" not found`);
+    }
+    if (dbFlow.system) {
+      throw new Error("Cannot publish system flows. They are always published.");
+    }
+    if (dbFlow.status === "published") {
+      return this.convertDBFlowToDefinition(dbFlow);
+    }
+    this.validateFlowStructure({
+      name: dbFlow.name,
+      label: dbFlow.label,
+      slots: dbFlow.slots,
+      pages: dbFlow.pages,
+      relations: dbFlow.relations
+    });
+    const updated = await this.adapter.flows.update(flowId, {
+      status: "published",
+      version: dbFlow.version + 1
+    });
+    return this.convertDBFlowToDefinition(updated);
+  }
+  /**
+   * Archive a flow
+   */
+  async archiveFlow(flowId) {
+    if (!this.adapter.flows) {
+      throw new Error("Flows feature is not enabled.");
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new Error(`Flow with id "${flowId}" not found`);
+    }
+    if (dbFlow.system) {
+      throw new Error("Cannot archive system flows.");
+    }
+    const updated = await this.adapter.flows.update(flowId, {
+      status: "archived"
+    });
+    return this.convertDBFlowToDefinition(updated);
+  }
+  /**
+   * Delete a custom flow
+   */
+  async deleteFlow(flowId) {
+    if (!this.adapter.flows) {
+      throw new Error("Flows feature is not enabled.");
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new Error(`Flow with id "${flowId}" not found`);
+    }
+    if (dbFlow.system) {
+      throw new Error("Cannot delete system flows. System flows are protected.");
+    }
+    await this.adapter.flows.delete(flowId);
+  }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
+  /**
+   * Validate flow name format (kebab-case)
+   */
+  validateFlowName(name) {
+    if (!name || name.length === 0) {
+      throw new Error("Flow name cannot be empty");
+    }
+    if (name.length > 63) {
+      throw new Error("Flow name is too long (max 63 characters)");
+    }
+    const kebabCaseRegex = /^[a-z][a-z0-9-]*$/;
+    if (!kebabCaseRegex.test(name)) {
+      throw new Error(
+        "Invalid flow name format. Name must be in kebab-case (e.g., 'couple-creation', 'new-contact')"
+      );
+    }
+  }
+  /**
+   * Validate flow structure (slots, pages, relations)
+   */
+  validateFlowStructure(input) {
+    if (!input.slots || input.slots.length === 0) {
+      throw new Error("Flow must have at least one slot");
+    }
+    if (!input.pages || input.pages.length === 0) {
+      throw new Error("Flow must have at least one page");
+    }
+    const slotIds = new Set(input.slots.map((s) => s.id));
+    if (slotIds.size !== input.slots.length) {
+      throw new Error("Duplicate slot IDs detected");
+    }
+    for (const page of input.pages) {
+      for (const row of page.rows) {
+        for (const field of row.fields) {
+          if (!slotIds.has(field.slotId)) {
+            throw new Error(`Field "${field.id}" references unknown slot "${field.slotId}"`);
+          }
+        }
+      }
+    }
+    for (const relation of input.relations) {
+      if (!slotIds.has(relation.sourceSlotId)) {
+        throw new Error(`Relation references unknown source slot "${relation.sourceSlotId}"`);
+      }
+      if (!slotIds.has(relation.targetSlotId)) {
+        throw new Error(`Relation references unknown target slot "${relation.targetSlotId}"`);
+      }
+      if (relation.sourceSlotId === relation.targetSlotId) {
+        throw new Error(`Relation cannot link a slot to itself: "${relation.sourceSlotId}"`);
+      }
+    }
+  }
+  /**
+   * Convert database flow to FlowDefinition
+   */
+  convertDBFlowToDefinition(dbFlow) {
+    return {
+      id: dbFlow.id,
+      name: dbFlow.name,
+      label: dbFlow.label,
+      description: dbFlow.description,
+      icon: dbFlow.icon,
+      status: dbFlow.status,
+      version: dbFlow.version,
+      slots: dbFlow.slots,
+      pages: dbFlow.pages,
+      relations: dbFlow.relations,
+      system: dbFlow.system,
+      tenantId: dbFlow.tenantId,
+      metadata: dbFlow.metadata,
+      createdAt: dbFlow.createdAt,
+      updatedAt: dbFlow.updatedAt
+    };
+  }
+};
+
 // src/runtime/services/geocoding.service.ts
 var GeocodingService = class {
   constructor(adapter) {
@@ -1652,8 +1920,11 @@ var GlobalSearchService = class {
 var import_constants = require("@stndrds/constants");
 var VALID_ICONS = new Set(import_constants.ICONS);
 
+// src/builders/flow-builder.ts
+var import_zod = require("zod");
+
 // src/builders/object-builder.ts
-var import_zod = __toESM(require("zod"));
+var import_zod2 = __toESM(require("zod"));
 var ObjectBuilder = class {
   constructor(config) {
     this.validateName(config.name);
@@ -1786,14 +2057,14 @@ The labelExpression defines how records are displayed in lists and relations.
     if (name === void 0) {
       return;
     }
-    const objectNameSchema = import_zod.default.string().min(1, "Object name cannot be empty").max(63, "Object name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+    const objectNameSchema = import_zod2.default.string().min(1, "Object name cannot be empty").max(63, "Object name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
       message: "Invalid object name format.\nName must be in kebab-case (slug format):\n  \u2705 Valid: 'products', 'user-profiles', 'order-items'\n  \u274C Invalid: 'Products', 'userProfiles', 'user_profiles'"
     });
     try {
       objectNameSchema.parse(name);
     } catch (error) {
-      if (error instanceof import_zod.default.ZodError) {
-        throw new Error(`[ObjectBuilder] ${error.errors[0].message}`);
+      if (error instanceof import_zod2.default.ZodError) {
+        throw new Error(`[ObjectBuilder] ${error.issues[0].message}`);
       }
       throw error;
     }
@@ -1804,7 +2075,7 @@ function object(config) {
 }
 
 // src/builders/view-builder.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/types/errors.ts
 var RecordReferencedError = class extends Error {
@@ -1839,35 +2110,35 @@ var ObjectReferencedError = class extends Error {
 };
 
 // src/validation/validators.ts
-var import_zod3 = require("zod");
-var baseConfigSchema = import_zod3.z.object({
-  disabled: import_zod3.z.boolean().optional(),
-  placeholder: import_zod3.z.string().optional(),
-  description: import_zod3.z.string().optional(),
-  defaultValue: import_zod3.z.unknown().optional(),
-  icon: import_zod3.z.string().optional(),
-  order: import_zod3.z.number().int().optional(),
-  hidden: import_zod3.z.boolean().optional(),
-  archived: import_zod3.z.boolean().optional(),
-  deprecated: import_zod3.z.boolean().optional(),
-  metadata: import_zod3.z.record(import_zod3.z.unknown()).optional()
+var import_zod4 = require("zod");
+var baseConfigSchema = import_zod4.z.object({
+  disabled: import_zod4.z.boolean().optional(),
+  placeholder: import_zod4.z.string().optional(),
+  description: import_zod4.z.string().optional(),
+  defaultValue: import_zod4.z.unknown().optional(),
+  icon: import_zod4.z.string().optional(),
+  order: import_zod4.z.number().int().optional(),
+  hidden: import_zod4.z.boolean().optional(),
+  archived: import_zod4.z.boolean().optional(),
+  deprecated: import_zod4.z.boolean().optional(),
+  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
 });
-var optionSchema = import_zod3.z.object({
-  id: import_zod3.z.string().min(1),
-  label: import_zod3.z.string().min(1),
-  value: import_zod3.z.string().min(1),
-  color: import_zod3.z.string().optional(),
-  icon: import_zod3.z.string().optional(),
-  description: import_zod3.z.string().optional(),
-  group: import_zod3.z.enum(["idle", "in_progress", "finished"]).optional()
+var optionSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1),
+  label: import_zod4.z.string().min(1),
+  value: import_zod4.z.string().min(1),
+  color: import_zod4.z.string().optional(),
+  icon: import_zod4.z.string().optional(),
+  description: import_zod4.z.string().optional(),
+  group: import_zod4.z.enum(["idle", "in_progress", "finished"]).optional()
 });
-var relationTargetSchema = import_zod3.z.object({
-  object: import_zod3.z.string().min(1),
-  displayTemplate: import_zod3.z.string().optional(),
-  filter: import_zod3.z.record(import_zod3.z.unknown()).optional()
+var relationTargetSchema = import_zod4.z.object({
+  object: import_zod4.z.string().min(1),
+  displayTemplate: import_zod4.z.string().optional(),
+  filter: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
 });
-var documentTypeConfigSchema = import_zod3.z.object({
-  type: import_zod3.z.enum([
+var documentTypeConfigSchema = import_zod4.z.object({
+  type: import_zod4.z.enum([
     "id_card",
     "passport",
     "incorporation_certificate",
@@ -1878,86 +2149,86 @@ var documentTypeConfigSchema = import_zod3.z.object({
     "proof_of_address",
     "custom"
   ]),
-  label: import_zod3.z.string(),
-  faces: import_zod3.z.array(import_zod3.z.enum(["front", "back", "single"])),
-  attributeMapping: import_zod3.z.array(
-    import_zod3.z.object({
-      attributeId: import_zod3.z.string(),
-      extractedKey: import_zod3.z.string(),
-      face: import_zod3.z.enum(["front", "back", "single"]).optional(),
-      required: import_zod3.z.boolean().optional()
+  label: import_zod4.z.string(),
+  faces: import_zod4.z.array(import_zod4.z.enum(["front", "back", "single"])),
+  attributeMapping: import_zod4.z.array(
+    import_zod4.z.object({
+      attributeId: import_zod4.z.string(),
+      extractedKey: import_zod4.z.string(),
+      face: import_zod4.z.enum(["front", "back", "single"]).optional(),
+      required: import_zod4.z.boolean().optional()
     })
   ).optional()
 });
-var fileVerificationConfigSchema = import_zod3.z.object({
-  enabled: import_zod3.z.boolean(),
-  documentTypes: import_zod3.z.array(documentTypeConfigSchema),
-  autoExtract: import_zod3.z.boolean().optional(),
-  autoValidate: import_zod3.z.boolean().optional()
+var fileVerificationConfigSchema = import_zod4.z.object({
+  enabled: import_zod4.z.boolean(),
+  documentTypes: import_zod4.z.array(documentTypeConfigSchema),
+  autoExtract: import_zod4.z.boolean().optional(),
+  autoValidate: import_zod4.z.boolean().optional()
 });
 var textConfigSchema = baseConfigSchema.extend({
-  minLength: import_zod3.z.number().int().min(0).optional(),
-  maxLength: import_zod3.z.number().int().min(1).optional(),
-  pattern: import_zod3.z.string().optional()
+  minLength: import_zod4.z.number().int().min(0).optional(),
+  maxLength: import_zod4.z.number().int().min(1).optional(),
+  pattern: import_zod4.z.string().optional()
 });
 var textareaConfigSchema = baseConfigSchema;
 var numberConfigSchema = baseConfigSchema.extend({
-  min: import_zod3.z.number().optional(),
-  max: import_zod3.z.number().optional(),
-  unit: import_zod3.z.enum(["integer", "decimal", "percentage"]).optional(),
-  decimals: import_zod3.z.number().int().min(0).optional()
+  min: import_zod4.z.number().optional(),
+  max: import_zod4.z.number().optional(),
+  unit: import_zod4.z.enum(["integer", "decimal", "percentage"]).optional(),
+  decimals: import_zod4.z.number().int().min(0).optional()
 });
 var checkboxConfigSchema = baseConfigSchema;
 var dateConfigSchema = baseConfigSchema.extend({
-  dateFormat: import_zod3.z.enum(["short", "long", "full", "relative"]).optional(),
-  minDate: import_zod3.z.string().optional(),
-  maxDate: import_zod3.z.string().optional()
+  dateFormat: import_zod4.z.enum(["short", "long", "full", "relative"]).optional(),
+  minDate: import_zod4.z.string().optional(),
+  maxDate: import_zod4.z.string().optional()
 });
 var phoneConfigSchema = baseConfigSchema.extend({
-  defaultCountryCode: import_zod3.z.string().length(3).optional()
+  defaultCountryCode: import_zod4.z.string().length(3).optional()
 });
 var currencyConfigSchema = baseConfigSchema.extend({
-  defaultCurrency: import_zod3.z.string().length(3).optional(),
-  allowedCurrencies: import_zod3.z.array(import_zod3.z.string().length(3)).optional()
+  defaultCurrency: import_zod4.z.string().length(3).optional(),
+  allowedCurrencies: import_zod4.z.array(import_zod4.z.string().length(3)).optional()
 });
 var statusConfigSchema = baseConfigSchema.extend({
-  options: import_zod3.z.array(optionSchema).min(1)
+  options: import_zod4.z.array(optionSchema).min(1)
 });
 var locationConfigSchema = baseConfigSchema.extend({
-  granularity: import_zod3.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
-  enableAutocomplete: import_zod3.z.boolean().optional(),
-  enableMap: import_zod3.z.boolean().optional(),
-  defaultCountry: import_zod3.z.string().length(3).optional(),
-  allowedCountries: import_zod3.z.array(import_zod3.z.string().length(3)).optional(),
-  displayFormat: import_zod3.z.enum(["single_line", "multi_line", "compact"]).optional()
+  granularity: import_zod4.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
+  enableAutocomplete: import_zod4.z.boolean().optional(),
+  enableMap: import_zod4.z.boolean().optional(),
+  defaultCountry: import_zod4.z.string().length(3).optional(),
+  allowedCountries: import_zod4.z.array(import_zod4.z.string().length(3)).optional(),
+  displayFormat: import_zod4.z.enum(["single_line", "multi_line", "compact"]).optional()
 });
 var timestampConfigSchema = baseConfigSchema.extend({
-  autoUpdate: import_zod3.z.boolean().optional()
+  autoUpdate: import_zod4.z.boolean().optional()
 });
 var selectConfigSchema = baseConfigSchema.extend({
-  options: import_zod3.z.array(optionSchema).min(1)
+  options: import_zod4.z.array(optionSchema).min(1)
 });
 var multiselectConfigSchema = baseConfigSchema.extend({
-  options: import_zod3.z.array(optionSchema).min(1)
+  options: import_zod4.z.array(optionSchema).min(1)
 });
 var fileConfigSchema = baseConfigSchema.extend({
-  maxFiles: import_zod3.z.number().int().min(1).optional(),
-  maxSize: import_zod3.z.number().int().min(1).optional(),
-  allowedTypes: import_zod3.z.array(import_zod3.z.string()).optional(),
+  maxFiles: import_zod4.z.number().int().min(1).optional(),
+  maxSize: import_zod4.z.number().int().min(1).optional(),
+  allowedTypes: import_zod4.z.array(import_zod4.z.string()).optional(),
   verification: fileVerificationConfigSchema.optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: import_zod3.z.array(import_zod3.z.string()).optional()
+  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional()
 });
 var relationConfigSchema = baseConfigSchema.extend({
-  targets: import_zod3.z.array(relationTargetSchema).min(1),
-  cardinality: import_zod3.z.enum(["one", "many"]),
-  minItems: import_zod3.z.number().int().min(0).optional(),
-  maxItems: import_zod3.z.number().int().min(1).optional()
+  targets: import_zod4.z.array(relationTargetSchema).min(1),
+  cardinality: import_zod4.z.enum(["one", "many"]),
+  minItems: import_zod4.z.number().int().min(0).optional(),
+  maxItems: import_zod4.z.number().int().min(1).optional()
 });
 var ratingConfigSchema = baseConfigSchema.extend({
-  max: import_zod3.z.number().int().min(1).optional(),
-  iconType: import_zod3.z.enum(["star", "heart", "thumbs", "number"]).optional()
+  max: import_zod4.z.number().int().min(1).optional(),
+  iconType: import_zod4.z.enum(["star", "heart", "thumbs", "number"]).optional()
 });
 var attributeConfigSchemas = {
   text: textConfigSchema,
@@ -1985,7 +2256,7 @@ function parseAttributeConfig(type, config) {
   return schema.strip().parse(config);
 }
 function createTextValidator(attr) {
-  let schema = import_zod3.z.string();
+  let schema = import_zod4.z.string();
   if (attr.minLength !== void 0) {
     schema = schema.min(
       attr.minLength,
@@ -2004,7 +2275,7 @@ function createTextValidator(attr) {
   return schema;
 }
 function createNumberValidator(attr) {
-  let schema = import_zod3.z.number();
+  let schema = import_zod4.z.number();
   if (attr.min !== void 0) {
     schema = schema.min(attr.min, `${attr.label} must be at least ${attr.min}`);
   }
@@ -2017,81 +2288,75 @@ function createNumberValidator(attr) {
   return schema;
 }
 function createCheckboxValidator(_attr) {
-  return import_zod3.z.boolean();
+  return import_zod4.z.boolean();
 }
 function createDateValidator(attr) {
-  return import_zod3.z.string().datetime({ message: `${attr.label} must be a valid ISO date` });
+  return import_zod4.z.string().datetime({ message: `${attr.label} must be a valid ISO date` });
 }
 function createPhoneValidator(_attr) {
-  return import_zod3.z.object({
-    countryCode: import_zod3.z.string().length(3),
-    phoneNumber: import_zod3.z.string().min(1)
+  return import_zod4.z.object({
+    countryCode: import_zod4.z.string().length(3),
+    phoneNumber: import_zod4.z.string().min(1)
   });
 }
 function createCurrencyValidator(_attr) {
-  return import_zod3.z.object({
-    code: import_zod3.z.string().length(3),
-    value: import_zod3.z.number().min(0)
+  return import_zod4.z.object({
+    code: import_zod4.z.string().length(3),
+    value: import_zod4.z.number().min(0)
   });
 }
 function createStatusValidator(attr) {
   const validValues = attr.options.map((opt) => opt.value);
-  return import_zod3.z.enum(validValues, {
-    errorMap: () => ({
-      message: `${attr.label} must be one of: ${validValues.join(", ")}`
-    })
+  return import_zod4.z.enum(validValues, {
+    error: `${attr.label} must be one of: ${validValues.join(", ")}`
   });
 }
 function createSelectValidator(attr) {
   const validValues = attr.options.map((opt) => opt.value);
-  return import_zod3.z.enum(validValues, {
-    errorMap: () => ({
-      message: `${attr.label} must be one of: ${validValues.join(", ")}`
-    })
+  return import_zod4.z.enum(validValues, {
+    error: `${attr.label} must be one of: ${validValues.join(", ")}`
   });
 }
 function createMultiselectValidator(attr) {
   const validValues = attr.options.map((opt) => opt.value);
-  return import_zod3.z.array(
-    import_zod3.z.enum(validValues, {
-      errorMap: () => ({
-        message: `Each value must be one of: ${validValues.join(", ")}`
-      })
+  return import_zod4.z.array(
+    import_zod4.z.enum(validValues, {
+      error: `Each value must be one of: ${validValues.join(", ")}`
     })
   );
 }
 function createLocationValidator(_attr) {
-  return import_zod3.z.object({
-    address: import_zod3.z.string().optional(),
-    address2: import_zod3.z.string().optional(),
-    city: import_zod3.z.string().optional(),
-    state: import_zod3.z.string().optional(),
-    postalCode: import_zod3.z.string().optional(),
-    country: import_zod3.z.string().length(3).optional(),
-    latitude: import_zod3.z.number().optional(),
-    longitude: import_zod3.z.number().optional()
+  return import_zod4.z.object({
+    address: import_zod4.z.string().optional(),
+    address2: import_zod4.z.string().optional(),
+    city: import_zod4.z.string().optional(),
+    state: import_zod4.z.string().optional(),
+    postalCode: import_zod4.z.string().optional(),
+    country: import_zod4.z.string().length(3).optional(),
+    latitude: import_zod4.z.number().optional(),
+    longitude: import_zod4.z.number().optional()
   });
 }
 function createTimestampValidator(_attr) {
-  return import_zod3.z.number().int().positive();
+  return import_zod4.z.number().int().positive();
 }
 function createFileValidator(_attr) {
-  return import_zod3.z.string().uuid();
+  return import_zod4.z.string().uuid();
 }
 function createUserValidator(_attr) {
-  return import_zod3.z.string().uuid();
+  return import_zod4.z.string().uuid();
 }
 function createSingleRelationValidator(attr) {
-  const uuidSchema = import_zod3.z.string().uuid({
+  const uuidSchema = import_zod4.z.string().uuid({
     message: `${attr.label} must be a valid record ID`
   });
-  return import_zod3.z.union([uuidSchema, import_zod3.z.null()]);
+  return import_zod4.z.union([uuidSchema, import_zod4.z.null()]);
 }
 function createMultiRelationValidator(attr) {
-  const uuidSchema = import_zod3.z.string().uuid({
+  const uuidSchema = import_zod4.z.string().uuid({
     message: `Each ${attr.label} item must be a valid record ID`
   });
-  let arraySchema = import_zod3.z.array(uuidSchema);
+  let arraySchema = import_zod4.z.array(uuidSchema);
   if (attr.minItems !== void 0) {
     arraySchema = arraySchema.min(
       attr.minItems,
@@ -2113,7 +2378,7 @@ function createRelationValidator(attr) {
   return createSingleRelationValidator(attr);
 }
 function createRatingValidator(attr) {
-  let schema = import_zod3.z.number().int().min(0);
+  let schema = import_zod4.z.number().int().min(0);
   if (attr.max !== void 0) {
     schema = schema.max(attr.max, `${attr.label} must be at most ${attr.max}`);
   }
@@ -2152,7 +2417,7 @@ function createAttributeValidator(attr) {
     case "rating":
       return createRatingValidator(attr);
     default:
-      return import_zod3.z.unknown();
+      return import_zod4.z.unknown();
   }
 }
 function createObjectValidator(objectDef) {
@@ -2164,7 +2429,7 @@ function createObjectValidator(objectDef) {
     }
     shape[attr.name] = validator;
   }
-  return import_zod3.z.object(shape);
+  return import_zod4.z.object(shape);
 }
 function validateObject(objectDef, data) {
   const validator = createObjectValidator(objectDef);
@@ -2177,7 +2442,7 @@ function validateObject(objectDef, data) {
   }
   return {
     success: false,
-    errors: result.error.errors.map((err) => ({
+    errors: result.error.issues.map((err) => ({
       path: err.path.map(String),
       message: err.message
     }))
@@ -2198,7 +2463,7 @@ function createDraftValidator(objectDef) {
     const validator = createAttributeValidator(attr).optional();
     shape[attr.name] = validator;
   }
-  return import_zod3.z.object(shape);
+  return import_zod4.z.object(shape);
 }
 function validateDraft(objectDef, data) {
   const validator = createDraftValidator(objectDef);
@@ -2211,7 +2476,7 @@ function validateDraft(objectDef, data) {
   }
   return {
     success: false,
-    errors: result.error.errors.map((err) => ({
+    errors: result.error.issues.map((err) => ({
       path: err.path.map(String),
       message: err.message
     }))
@@ -4683,9 +4948,6 @@ var ViewService = class {
         `Cannot create view "${input.name}": a system view with this name already exists`
       );
     }
-    if (!input.tabs || input.tabs.length === 0) {
-      throw new Error("View must have at least one tab");
-    }
     const dbView = await this.adapter.views.create({
       tenantId,
       objectName: input.objectName,
@@ -4693,7 +4955,7 @@ var ViewService = class {
       label: input.label,
       description: input.description,
       icon: input.icon,
-      tabs: input.tabs,
+      tabs: input.tabs ?? [],
       default: input.default ?? false,
       system: false,
       // Custom views are never system
@@ -4716,9 +4978,6 @@ var ViewService = class {
     if (dbView.system) {
       throw new Error("Cannot modify system views. System views are protected.");
     }
-    if (input.tabs && input.tabs.length === 0) {
-      throw new Error("View must have at least one tab");
-    }
     const updated = await this.adapter.views.update(viewId, {
       label: input.label,
       description: input.description,
@@ -5149,6 +5408,7 @@ var NoopGeocodingAdapter = class {
   AuditService,
   DEFAULT_LABEL_FALLBACK,
   FileService,
+  FlowService,
   GeocodingService,
   GlobalSearchService,
   NoopGeocodingAdapter,