@maykonpaulo/maestro-core 0.3.0-next.2 → 0.3.0-next.3

package/dist/index.js

@@ -521,7 +521,10 @@ function validateMaestroConfig(config) {
     errors.push({ path: "datasources", message: "At least one datasource is required." });
   }
   if (!config.entities || config.entities.length === 0) {
-    errors.push({ path: "entities", message: "At least one entity is required." });
+    errors.push({
+      path: "entities",
+      message: "At least one entity is required. Provide entities directly or via declarations.entities."
+    });
   }
   const entityIds = /* @__PURE__ */ new Set();
   for (const entity of config.entities ?? []) {
@@ -718,7 +721,7 @@ function buildBulkOperations(entity, operations) {
 var MetadataEngine = class {
   normalize(config) {
     const operations = config.operations ?? [];
-    const entities = config.entities.map((e) => this.normalizeEntity(e, operations));
+    const entities = (config.entities ?? []).map((e) => this.normalizeEntity(e, operations));
     const relations = config.relations ?? [];
     const entityRelationMap = /* @__PURE__ */ new Map();
     for (const rel of relations) {
@@ -890,21 +893,54 @@ var CsvExportProvider = class {
 
 // src/engine/MaestroEngine.ts
 var MaestroEngine = class {
-  constructor(metadata, datasources, operations, audit) {
+  constructor(metadata, datasources, operations, audit, consumers = []) {
     this.metadata = metadata;
     this.datasources = datasources;
     this.operations = operations;
     this.audit = audit;
     this.rbac = new RbacEngine(metadata.policies);
+    this.consumerMap = new Map(consumers.map((c) => [c.consumer, c]));
   }
   metadata;
   datasources;
   operations;
   audit;
   rbac;
+  consumerMap;
   getMetadata() {
     return this.metadata;
   }
+  /**
+   * Returns the resolved consumer projection for the given consumer ID, or undefined if not found.
+   * Each call returns an independent copy — mutations to the returned object do not affect internal state.
+   * Consumer projections are only available when declarations.consumers were provided to createMaestro().
+   */
+  getConsumer(consumerId) {
+    const p = this.consumerMap.get(consumerId);
+    if (!p) return void 0;
+    return {
+      consumer: p.consumer,
+      entity: p.entity,
+      fields: {
+        list: [...p.fields.list],
+        detail: [...p.fields.detail],
+        create: [...p.fields.create],
+        update: [...p.fields.update],
+        clone: [...p.fields.clone]
+      },
+      operations: {
+        row: [...p.operations.row],
+        bulk: [...p.operations.bulk],
+        global: [...p.operations.global]
+      }
+    };
+  }
+  /**
+   * Returns the IDs of all registered consumer projections.
+   */
+  listConsumers() {
+    return [...this.consumerMap.keys()];
+  }
   async list(entityId, query, actor) {
     const entity = this.requireEntity(entityId);
     this.requireCapability(entity, "list", actor, `entity.${entityId}.list`);
@@ -1131,25 +1167,451 @@ var MaestroEngine = class {
   }
 };
 
+// src/declarative/DeclarativeValidator.ts
+var SUPPORTED_FIELD_TYPES = [
+  "string",
+  "text",
+  "number",
+  "integer",
+  "decimal",
+  "currency",
+  "boolean",
+  "date",
+  "datetime",
+  "time",
+  "email",
+  "phone",
+  "url",
+  "document",
+  "uuid",
+  "enum",
+  "json",
+  "relation",
+  "array"
+];
+var SUPPORTED_OPERATIONAL_RISKS = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
+var SUPPORTED_OPERATION_SCOPES = ["global", "entity", "record", "bulk"];
+function validateEntityDeclaration(input) {
+  const errors = [];
+  if (!input || typeof input !== "object") {
+    return { valid: false, errors: [{ path: "", message: "Entity declaration must be an object." }] };
+  }
+  const decl = input;
+  if (!decl["entity"] || typeof decl["entity"] !== "string" || decl["entity"].trim() === "") {
+    errors.push({ path: "entity", message: "Entity name is required." });
+  }
+  const fields = decl["fields"];
+  if (!fields || typeof fields !== "object" || Array.isArray(fields)) {
+    errors.push({ path: "fields", message: "Entity must declare at least one field." });
+  } else {
+    const fieldMap = fields;
+    if (Object.keys(fieldMap).length === 0) {
+      errors.push({ path: "fields", message: "Entity must declare at least one field." });
+    } else {
+      for (const [name, rawField] of Object.entries(fieldMap)) {
+        validateFieldDeclaration(name, rawField, errors);
+      }
+    }
+  }
+  const operations = decl["operations"];
+  if (operations !== void 0) {
+    if (typeof operations !== "object" || Array.isArray(operations)) {
+      errors.push({ path: "operations", message: "Operations must be an object." });
+    } else {
+      const opMap = operations;
+      for (const [id, rawOp] of Object.entries(opMap)) {
+        validateOperationDeclaration(id, rawOp, errors);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateFieldDeclaration(name, rawField, errors) {
+  const prefix = `fields[${name}]`;
+  if (!rawField || typeof rawField !== "object") {
+    errors.push({ path: prefix, message: `Field '${name}' must be an object.` });
+    return;
+  }
+  const field = rawField;
+  if (!field.type) {
+    errors.push({ path: `${prefix}.type`, message: "Field type is required." });
+  } else if (!SUPPORTED_FIELD_TYPES.includes(field.type)) {
+    errors.push({
+      path: `${prefix}.type`,
+      message: `Field type '${field.type}' is not supported. Supported types: ${SUPPORTED_FIELD_TYPES.join(", ")}.`
+    });
+  }
+  if (field.sensitive === true && field.exportable === true) {
+    errors.push({
+      path: prefix,
+      message: `Field '${name}' cannot be both sensitive and exportable.`
+    });
+  }
+}
+function validateOperationDeclaration(id, rawOp, errors) {
+  const prefix = `operations[${id}]`;
+  if (!rawOp || typeof rawOp !== "object") {
+    errors.push({ path: prefix, message: `Operation '${id}' must be an object.` });
+    return;
+  }
+  const op = rawOp;
+  if (!op.label || typeof op.label !== "string" || op.label.trim() === "") {
+    errors.push({ path: `${prefix}.label`, message: "Operation label is required." });
+  }
+  if (op.risk !== void 0 && !SUPPORTED_OPERATIONAL_RISKS.includes(op.risk)) {
+    errors.push({
+      path: `${prefix}.risk`,
+      message: `Operation risk '${op.risk}' is not valid. Valid values: ${SUPPORTED_OPERATIONAL_RISKS.join(", ")}.`
+    });
+  }
+  if (op.scope !== void 0 && !SUPPORTED_OPERATION_SCOPES.includes(op.scope)) {
+    errors.push({
+      path: `${prefix}.scope`,
+      message: `Operation scope '${op.scope}' is not valid. Valid values: ${SUPPORTED_OPERATION_SCOPES.join(", ")}.`
+    });
+  }
+  if (op.confirmation !== void 0) {
+    const conf = op.confirmation;
+    if (conf.approvers !== void 0 && (typeof conf.approvers !== "number" || conf.approvers < 1)) {
+      errors.push({
+        path: `${prefix}.confirmation.approvers`,
+        message: "Confirmation approvers must be at least 1."
+      });
+    }
+  }
+}
+function validateConsumerDeclaration(input, entity) {
+  const errors = [];
+  if (!input || typeof input !== "object") {
+    return { valid: false, errors: [{ path: "", message: "Consumer declaration must be an object." }] };
+  }
+  const decl = input;
+  if (!decl["consumer"] || typeof decl["consumer"] !== "string" || decl["consumer"].trim() === "") {
+    errors.push({ path: "consumer", message: "Consumer name is required." });
+  }
+  if (!decl["entity"] || typeof decl["entity"] !== "string" || decl["entity"].trim() === "") {
+    errors.push({ path: "entity", message: "Entity name is required." });
+  }
+  if (entity) {
+    const knownFields = new Set(Object.keys(entity.fields));
+    const knownOps = new Set(Object.keys(entity.operations ?? {}));
+    const entityName = entity.entity;
+    validateFieldRefs("list.fields", decl["list"], knownFields, entityName, errors);
+    validateFieldRefs("detail.fields", decl["detail"], knownFields, entityName, errors);
+    const forms = decl["forms"];
+    if (forms && typeof forms === "object") {
+      validateFieldRefs("forms.create.fields", forms["create"], knownFields, entityName, errors);
+      validateFieldRefs("forms.update.fields", forms["update"], knownFields, entityName, errors);
+      validateFieldRefs("forms.clone.fields", forms["clone"], knownFields, entityName, errors);
+    }
+    const actions = decl["actions"];
+    if (actions && typeof actions === "object") {
+      validateOperationRefs("actions.row", actions["row"], knownOps, entityName, errors);
+      validateOperationRefs("actions.bulk", actions["bulk"], knownOps, entityName, errors);
+      validateOperationRefs("actions.global", actions["global"], knownOps, entityName, errors);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateFieldRefs(path, container, knownFields, entityName, errors) {
+  if (!container || typeof container !== "object") return;
+  const obj = container;
+  const fields = obj["fields"];
+  if (!Array.isArray(fields)) return;
+  for (let i = 0; i < fields.length; i++) {
+    const name = fields[i];
+    if (!knownFields.has(name)) {
+      errors.push({
+        path: `${path}[${i}]`,
+        message: `Field '${name}' does not exist in entity '${entityName}'.`
+      });
+    }
+  }
+}
+function validateOperationRefs(path, refs, knownOps, entityName, errors) {
+  if (!Array.isArray(refs)) return;
+  for (let i = 0; i < refs.length; i++) {
+    const id = refs[i];
+    if (!knownOps.has(id)) {
+      errors.push({
+        path: `${path}[${i}]`,
+        message: `Operation '${id}' does not exist in entity '${entityName}'.`
+      });
+    }
+  }
+}
+
+// src/declarative/DeclarativeMetadataCompiler.ts
+function capitalizeFirst(name) {
+  if (!name) return name;
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function fieldDeclToFieldSchema(name, field) {
+  return {
+    name,
+    label: field.label ?? capitalizeFirst(name),
+    type: field.type,
+    required: field.required,
+    readonly: field.readonly,
+    // FieldDeclaration uses visible (default true); FieldSchema uses hidden (default false)
+    hidden: field.visible === false ? true : void 0,
+    sensitive: field.sensitive,
+    searchable: field.searchable,
+    sortable: field.sortable,
+    filterable: field.filterable,
+    exportable: field.exportable,
+    description: field.description
+  };
+}
+function opDeclToStubOperationDef(entityId, opKey, op) {
+  const id = `${entityId}.${opKey}`;
+  return {
+    id,
+    label: op.label,
+    description: op.description,
+    entity: entityId,
+    scope: op.scope ?? "record",
+    requiredPermission: op.permission,
+    requiresConfirmation: op.confirmation?.required,
+    execute: async () => {
+      throw new MaestroError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        `Operation '${id}' declared but has no registered implementation. Provide an OperationDef with id '${id}' in config.operations.`
+      );
+    }
+  };
+}
+function entityDeclToEntitySchema(decl, datasource) {
+  const primaryKeyEntry = Object.entries(decl.fields).find(([, f]) => f.primary);
+  const primaryKey = primaryKeyEntry ? primaryKeyEntry[0] : "id";
+  const singularLabel = decl.label ?? capitalizeFirst(decl.entity);
+  const pluralLabel = decl.pluralLabel ?? decl.label ?? capitalizeFirst(decl.entity);
+  const fields = Object.entries(decl.fields).map(
+    ([name, field]) => fieldDeclToFieldSchema(name, field)
+  );
+  return {
+    id: decl.entity,
+    label: { singular: singularLabel, plural: pluralLabel },
+    description: decl.description,
+    source: {
+      datasource,
+      table: decl.entity,
+      primaryKey
+    },
+    fields
+  };
+}
+function compileDeclarations(config, options) {
+  const errors = [];
+  const datasource = options.defaultDatasource ?? (options.datasourceIds.length === 1 ? options.datasourceIds[0] : void 0);
+  if (options.datasourceIds.length > 1 && !datasource) {
+    errors.push({
+      path: "declarations.defaultDatasource",
+      message: "Multiple datasources are configured. Set declarations.defaultDatasource to specify which one to use for declared entities."
+    });
+  }
+  const entityDeclarationMap = /* @__PURE__ */ new Map();
+  const compiledEntities = [];
+  const compiledOperations = [];
+  for (const decl of config.entities) {
+    const entityId = typeof decl?.entity === "string" ? decl.entity : "?";
+    const prefix = `declarations.entities[${entityId}]`;
+    const validation = validateEntityDeclaration(decl);
+    if (!validation.valid) {
+      for (const err of validation.errors) {
+        errors.push({ path: `${prefix}.${err.path}`.replace(/\.$/, ""), message: err.message });
+      }
+      continue;
+    }
+    if (entityDeclarationMap.has(decl.entity)) {
+      errors.push({
+        path: prefix,
+        message: `Duplicate entity '${decl.entity}' in declarations.entities.`
+      });
+      continue;
+    }
+    entityDeclarationMap.set(decl.entity, decl);
+    if (datasource) {
+      compiledEntities.push(entityDeclToEntitySchema(decl, datasource));
+      for (const [opKey, opDecl] of Object.entries(decl.operations ?? {})) {
+        compiledOperations.push(opDeclToStubOperationDef(decl.entity, opKey, opDecl));
+      }
+    }
+  }
+  const consumerNames = /* @__PURE__ */ new Set();
+  const validConsumers = [];
+  for (const consumer of config.consumers ?? []) {
+    const consumerId = typeof consumer?.consumer === "string" ? consumer.consumer : "?";
+    const prefix = `declarations.consumers[${consumerId}]`;
+    const entityDecl = entityDeclarationMap.get(consumer?.entity ?? "");
+    if (consumer?.entity && !entityDecl) {
+      errors.push({
+        path: `${prefix}.entity`,
+        message: `Entity '${consumer.entity}' referenced by consumer '${consumerId}' is not declared in declarations.entities.`
+      });
+      continue;
+    }
+    const validation = validateConsumerDeclaration(consumer, entityDecl);
+    if (!validation.valid) {
+      for (const err of validation.errors) {
+        errors.push({ path: `${prefix}.${err.path}`.replace(/\.$/, ""), message: err.message });
+      }
+      continue;
+    }
+    if (consumerNames.has(consumer.consumer)) {
+      errors.push({
+        path: prefix,
+        message: `Duplicate consumer '${consumer.consumer}' in declarations.consumers.`
+      });
+      continue;
+    }
+    consumerNames.add(consumer.consumer);
+    validConsumers.push(consumer);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    entities: compiledEntities,
+    operations: compiledOperations,
+    consumers: validConsumers
+  };
+}
+function resolveConsumerProjections(consumers, metadata) {
+  const results = [];
+  for (const consumer of consumers) {
+    const entityMeta = metadata.entities.find((e) => e.id === consumer.entity);
+    if (!entityMeta) continue;
+    const allFields = entityMeta.fields;
+    const entityOps = metadata.operations.filter((o) => o.entity === consumer.entity);
+    const resolveFields = (names) => {
+      if (!names || names.length === 0) return [...allFields];
+      return names.map((name) => allFields.find((f) => f.name === name)).filter((f) => f !== void 0);
+    };
+    const resolveOps = (keys, defaultScope) => {
+      if (!keys || keys.length === 0) {
+        return defaultScope ? entityOps.filter((o) => o.scope === defaultScope) : [...entityOps];
+      }
+      return keys.map((key) => {
+        const fullId = `${consumer.entity}.${key}`;
+        return entityOps.find((o) => o.id === fullId);
+      }).filter((o) => o !== void 0);
+    };
+    results.push({
+      consumer: consumer.consumer,
+      entity: consumer.entity,
+      fields: {
+        list: resolveFields(consumer.list?.fields),
+        detail: resolveFields(consumer.detail?.fields),
+        create: resolveFields(consumer.forms?.create?.fields),
+        update: resolveFields(consumer.forms?.update?.fields),
+        clone: resolveFields(consumer.forms?.clone?.fields)
+      },
+      operations: {
+        row: resolveOps(consumer.actions?.row, "record"),
+        bulk: resolveOps(consumer.actions?.bulk, "bulk"),
+        global: resolveOps(consumer.actions?.global, "global")
+      }
+    });
+  }
+  return results;
+}
+
 // src/engine/createMaestro.ts
+function bindAndValidateOperations(stubs, configOps) {
+  const errors = [];
+  const configOpMap = /* @__PURE__ */ new Map();
+  for (const op of configOps) {
+    if (configOpMap.has(op.id)) {
+      errors.push({
+        path: `operations[${op.id}]`,
+        message: `Duplicate operation id '${op.id}' in config.operations. Each operation must have a unique id.`
+      });
+    } else {
+      configOpMap.set(op.id, op);
+    }
+  }
+  const stubIds = new Set(stubs.map((s) => s.id));
+  const bound = [];
+  for (const stub of stubs) {
+    const impl = configOpMap.get(stub.id);
+    if (!impl) {
+      errors.push({
+        path: `declarations.entities[${stub.entity}].operations`,
+        message: `Declared operation '${stub.id}' has no implementation. Provide an OperationDef with id '${stub.id}' in config.operations.`
+      });
+      continue;
+    }
+    if (impl.entity !== void 0 && impl.entity !== stub.entity) {
+      errors.push({
+        path: `operations[${impl.id}].entity`,
+        message: `Operation '${impl.id}' is declared for entity '${stub.entity}' but config.operations specifies entity '${impl.entity}'.`
+      });
+      continue;
+    }
+    bound.push(impl);
+  }
+  for (const op of configOpMap.values()) {
+    if (!stubIds.has(op.id)) {
+      bound.push(op);
+    }
+  }
+  return { operations: bound, errors };
+}
 function createMaestro(config) {
-  const validation = validateMaestroConfig(config);
+  let extraEntities = [];
+  let declaredOperations = [];
+  let compiledConsumers = [];
+  if (config.declarations) {
+    const datasourceIds = Object.keys(config.datasources ?? {});
+    const defaultDatasource = config.declarations.defaultDatasource ?? (datasourceIds.length === 1 ? datasourceIds[0] : void 0);
+    const compilation = compileDeclarations(config.declarations, {
+      datasourceIds,
+      defaultDatasource
+    });
+    if (!compilation.valid) {
+      const messages = compilation.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+      throw new MaestroError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        `Invalid declarative configuration: ${messages}`
+      );
+    }
+    extraEntities = compilation.entities;
+    declaredOperations = compilation.operations;
+    compiledConsumers = compilation.consumers;
+  }
+  const mergedEntities = [
+    ...config.entities ?? [],
+    ...extraEntities
+  ];
+  const binding = bindAndValidateOperations(declaredOperations, config.operations ?? []);
+  if (binding.errors.length > 0) {
+    const messages = binding.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+    throw new MaestroError("CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */, `Invalid operation bindings: ${messages}`);
+  }
+  const mergedOperations = binding.operations;
+  const mergedConfig = {
+    ...config,
+    entities: mergedEntities,
+    operations: mergedOperations
+  };
+  const validation = validateMaestroConfig(mergedConfig);
   if (!validation.valid) {
     const messages = validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
     throw new MaestroError("CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */, `Invalid Maestro configuration: ${messages}`);
   }
   const metadataEngine = new MetadataEngine();
-  const metadata = metadataEngine.normalize(config);
+  const metadata = metadataEngine.normalize(mergedConfig);
+  const consumers = resolveConsumerProjections(compiledConsumers, metadata);
   const datasources = new DatasourceRegistry();
   for (const [id, provider] of Object.entries(config.datasources)) {
     datasources.register(id, provider);
   }
   const operations = new OperationRegistry();
-  for (const operation of config.operations ?? []) {
+  for (const operation of mergedOperations) {
     operations.register(operation);
   }
   const audit = config.audit ? new AuditRecorder(config.audit) : void 0;
-  return new MaestroEngine(metadata, datasources, operations, audit);
+  return new MaestroEngine(metadata, datasources, operations, audit, consumers);
 }
 
 // src/introspection/utils.ts
@@ -2557,180 +3019,6 @@ var InMemoryConfirmationRepository = class {
   }
 };
 
-// src/declarative/DeclarativeValidator.ts
-var SUPPORTED_FIELD_TYPES = [
-  "string",
-  "text",
-  "number",
-  "integer",
-  "decimal",
-  "currency",
-  "boolean",
-  "date",
-  "datetime",
-  "time",
-  "email",
-  "phone",
-  "url",
-  "document",
-  "uuid",
-  "enum",
-  "json",
-  "relation",
-  "array"
-];
-var SUPPORTED_OPERATIONAL_RISKS = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
-var SUPPORTED_OPERATION_SCOPES = ["global", "entity", "record", "bulk"];
-function validateEntityDeclaration(input) {
-  const errors = [];
-  if (!input || typeof input !== "object") {
-    return { valid: false, errors: [{ path: "", message: "Entity declaration must be an object." }] };
-  }
-  const decl = input;
-  if (!decl["entity"] || typeof decl["entity"] !== "string" || decl["entity"].trim() === "") {
-    errors.push({ path: "entity", message: "Entity name is required." });
-  }
-  const fields = decl["fields"];
-  if (!fields || typeof fields !== "object" || Array.isArray(fields)) {
-    errors.push({ path: "fields", message: "Entity must declare at least one field." });
-  } else {
-    const fieldMap = fields;
-    if (Object.keys(fieldMap).length === 0) {
-      errors.push({ path: "fields", message: "Entity must declare at least one field." });
-    } else {
-      for (const [name, rawField] of Object.entries(fieldMap)) {
-        validateFieldDeclaration(name, rawField, errors);
-      }
-    }
-  }
-  const operations = decl["operations"];
-  if (operations !== void 0) {
-    if (typeof operations !== "object" || Array.isArray(operations)) {
-      errors.push({ path: "operations", message: "Operations must be an object." });
-    } else {
-      const opMap = operations;
-      for (const [id, rawOp] of Object.entries(opMap)) {
-        validateOperationDeclaration(id, rawOp, errors);
-      }
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function validateFieldDeclaration(name, rawField, errors) {
-  const prefix = `fields[${name}]`;
-  if (!rawField || typeof rawField !== "object") {
-    errors.push({ path: prefix, message: `Field '${name}' must be an object.` });
-    return;
-  }
-  const field = rawField;
-  if (!field.type) {
-    errors.push({ path: `${prefix}.type`, message: "Field type is required." });
-  } else if (!SUPPORTED_FIELD_TYPES.includes(field.type)) {
-    errors.push({
-      path: `${prefix}.type`,
-      message: `Field type '${field.type}' is not supported. Supported types: ${SUPPORTED_FIELD_TYPES.join(", ")}.`
-    });
-  }
-  if (field.sensitive === true && field.exportable === true) {
-    errors.push({
-      path: prefix,
-      message: `Field '${name}' cannot be both sensitive and exportable.`
-    });
-  }
-}
-function validateOperationDeclaration(id, rawOp, errors) {
-  const prefix = `operations[${id}]`;
-  if (!rawOp || typeof rawOp !== "object") {
-    errors.push({ path: prefix, message: `Operation '${id}' must be an object.` });
-    return;
-  }
-  const op = rawOp;
-  if (!op.label || typeof op.label !== "string" || op.label.trim() === "") {
-    errors.push({ path: `${prefix}.label`, message: "Operation label is required." });
-  }
-  if (op.risk !== void 0 && !SUPPORTED_OPERATIONAL_RISKS.includes(op.risk)) {
-    errors.push({
-      path: `${prefix}.risk`,
-      message: `Operation risk '${op.risk}' is not valid. Valid values: ${SUPPORTED_OPERATIONAL_RISKS.join(", ")}.`
-    });
-  }
-  if (op.scope !== void 0 && !SUPPORTED_OPERATION_SCOPES.includes(op.scope)) {
-    errors.push({
-      path: `${prefix}.scope`,
-      message: `Operation scope '${op.scope}' is not valid. Valid values: ${SUPPORTED_OPERATION_SCOPES.join(", ")}.`
-    });
-  }
-  if (op.confirmation !== void 0) {
-    const conf = op.confirmation;
-    if (conf.approvers !== void 0 && (typeof conf.approvers !== "number" || conf.approvers < 1)) {
-      errors.push({
-        path: `${prefix}.confirmation.approvers`,
-        message: "Confirmation approvers must be at least 1."
-      });
-    }
-  }
-}
-function validateConsumerDeclaration(input, entity) {
-  const errors = [];
-  if (!input || typeof input !== "object") {
-    return { valid: false, errors: [{ path: "", message: "Consumer declaration must be an object." }] };
-  }
-  const decl = input;
-  if (!decl["consumer"] || typeof decl["consumer"] !== "string" || decl["consumer"].trim() === "") {
-    errors.push({ path: "consumer", message: "Consumer name is required." });
-  }
-  if (!decl["entity"] || typeof decl["entity"] !== "string" || decl["entity"].trim() === "") {
-    errors.push({ path: "entity", message: "Entity name is required." });
-  }
-  if (entity) {
-    const knownFields = new Set(Object.keys(entity.fields));
-    const knownOps = new Set(Object.keys(entity.operations ?? {}));
-    const entityName = entity.entity;
-    validateFieldRefs("list.fields", decl["list"], knownFields, entityName, errors);
-    validateFieldRefs("detail.fields", decl["detail"], knownFields, entityName, errors);
-    const forms = decl["forms"];
-    if (forms && typeof forms === "object") {
-      validateFieldRefs("forms.create.fields", forms["create"], knownFields, entityName, errors);
-      validateFieldRefs("forms.update.fields", forms["update"], knownFields, entityName, errors);
-      validateFieldRefs("forms.clone.fields", forms["clone"], knownFields, entityName, errors);
-    }
-    const actions = decl["actions"];
-    if (actions && typeof actions === "object") {
-      validateOperationRefs("actions.row", actions["row"], knownOps, entityName, errors);
-      validateOperationRefs("actions.bulk", actions["bulk"], knownOps, entityName, errors);
-      validateOperationRefs("actions.global", actions["global"], knownOps, entityName, errors);
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function validateFieldRefs(path, container, knownFields, entityName, errors) {
-  if (!container || typeof container !== "object") return;
-  const obj = container;
-  const fields = obj["fields"];
-  if (!Array.isArray(fields)) return;
-  for (let i = 0; i < fields.length; i++) {
-    const name = fields[i];
-    if (!knownFields.has(name)) {
-      errors.push({
-        path: `${path}[${i}]`,
-        message: `Field '${name}' does not exist in entity '${entityName}'.`
-      });
-    }
-  }
-}
-function validateOperationRefs(path, refs, knownOps, entityName, errors) {
-  if (!Array.isArray(refs)) return;
-  for (let i = 0; i < refs.length; i++) {
-    const id = refs[i];
-    if (!knownOps.has(id)) {
-      errors.push({
-        path: `${path}[${i}]`,
-        message: `Operation '${id}' does not exist in entity '${entityName}'.`
-      });
-    }
-  }
-}
-
 // src/governance/GovernanceEventType.ts
 var GOVERNANCE_EVENT_TYPES = {
   OPERATION_EXECUTED: "governance.operation.executed",
@@ -2827,6 +3115,7 @@ export {
   PolicyEngine,
   RbacEngine,
   ReportGenerator,
+  compileDeclarations,
   createMaestro,
   createMaestroFromIntrospection,
   createMaestroHttpHandlers,
@@ -2843,6 +3132,7 @@ export {
   loadMaestroConfig,
   mergeIntrospectionWithOverrides,
   parseQueryInput,
+  resolveConsumerProjections,
   tableNameToEntityId,
   tableNameToLabel,
   validateConsumerDeclaration,