@maykonpaulo/maestro-core 0.3.0-next.0 → 0.3.0-next.1

package/dist/index.js

@@ -70,6 +70,52 @@ var ConsoleLogger = class {
   }
 };
 
+// src/logging/ConsoleStructuredLogger.ts
+var ConsoleStructuredLogger = class {
+  constructor(minLevel = "info") {
+    this.minLevel = minLevel;
+  }
+  minLevel;
+  debug(entry) {
+    this.log("debug", entry);
+  }
+  info(entry) {
+    this.log("info", entry);
+  }
+  warn(entry) {
+    this.log("warn", entry);
+  }
+  error(entry) {
+    this.log("error", entry);
+  }
+  log(level, entry) {
+    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.minLevel]) return;
+    const output = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level
+    };
+    if (entry.correlationId !== void 0) output["correlationId"] = entry.correlationId;
+    if (entry.operation !== void 0) output["operation"] = entry.operation;
+    if (entry.entity !== void 0) output["entity"] = entry.entity;
+    if (entry.entityId !== void 0) output["entityId"] = entry.entityId;
+    if (entry.actor !== void 0) output["actor"] = entry.actor;
+    if (entry.durationMs !== void 0) output["durationMs"] = entry.durationMs;
+    if (entry.status !== void 0) output["status"] = entry.status;
+    if (entry.severity !== void 0) output["severity"] = entry.severity;
+    if (entry.message !== void 0) output["message"] = entry.message;
+    if (entry.metadata !== void 0) output["metadata"] = entry.metadata;
+    if (entry.error !== void 0) output["error"] = this.serializeError(entry.error);
+    const consoleFn = level === "error" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.info;
+    consoleFn(JSON.stringify(output));
+  }
+  serializeError(error) {
+    if (error instanceof Error) {
+      return { name: error.name, message: error.message };
+    }
+    return error;
+  }
+};
+
 // src/audit/InMemoryAuditRepository.ts
 var InMemoryAuditRepository = class {
   store = /* @__PURE__ */ new Map();
@@ -85,6 +131,12 @@ var InMemoryAuditRepository = class {
     if (filter.action !== void 0) {
       events = events.filter((e) => e.action === filter.action);
     }
+    if (filter.entity !== void 0) {
+      events = events.filter((e) => e.entity === filter.entity);
+    }
+    if (filter.entityId !== void 0) {
+      events = events.filter((e) => e.entityId === filter.entityId);
+    }
     if (filter.resourceType !== void 0) {
       events = events.filter((e) => e.resource?.type === filter.resourceType);
     }
@@ -107,6 +159,9 @@ var InMemoryAuditRepository = class {
     }
     return events;
   }
+  async query(filter) {
+    return this.list(filter);
+  }
 };
 
 // src/audit/AuditRecorder.ts
@@ -124,6 +179,8 @@ var AuditRecorder = class {
       actor: input.actor,
       level: input.level ?? "info",
       resource: input.resource,
+      entity: input.entity,
+      entityId: input.entityId,
       before: input.before,
       after: input.after,
       metadata: input.metadata,
@@ -2303,25 +2360,297 @@ var IntrospectionRuntime = class {
     return engine.compare(previous.result, current);
   }
 };
+
+// src/correlation/CorrelationId.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function generateCorrelationId() {
+  return randomUUID4();
+}
+
+// src/risk/MetadataRiskClassifier.ts
+var MetadataRiskClassifier = class {
+  constructor(operationRiskMap = {}, defaultRisk = "LOW") {
+    this.operationRiskMap = operationRiskMap;
+    this.defaultRisk = defaultRisk;
+  }
+  operationRiskMap;
+  defaultRisk;
+  classify(input) {
+    const fromMetadata = input.metadata?.["riskLevel"];
+    if (isOperationalRisk(fromMetadata)) return fromMetadata;
+    return this.operationRiskMap[input.operation] ?? this.defaultRisk;
+  }
+};
+var RISK_LEVELS = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
+function isOperationalRisk(value) {
+  return typeof value === "string" && RISK_LEVELS.includes(value);
+}
+
+// src/authorization/ContextualAuthorizationEngine.ts
+var ContextualAuthorizationEngine = class {
+  constructor(policy, criticalOperations = /* @__PURE__ */ new Set()) {
+    this.criticalOperations = criticalOperations;
+    this.rbac = new RbacEngine(policy);
+  }
+  criticalOperations;
+  rbac;
+  async evaluate(context) {
+    if (!this.rbac.can(context.actor, context.operation)) {
+      return { decision: "DENY", reason: `Actor lacks permission for operation: ${context.operation}` };
+    }
+    const risk = context.riskLevel ?? "LOW";
+    if (risk === "CRITICAL" || this.criticalOperations.has(context.operation)) {
+      return { decision: "REQUIRES_CONFIRMATION", reason: `Operation requires confirmation due to risk level: ${risk}` };
+    }
+    return { decision: "ALLOW" };
+  }
+};
+
+// src/policy/PolicyEngine.ts
+var DECISION_PRIORITY = {
+  ALLOW: 0,
+  REQUIRES_CONFIRMATION: 1,
+  DENY: 2
+};
+var PolicyEngine = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  provider;
+  evaluate(context) {
+    const violations = [];
+    let decision = "ALLOW";
+    let reason;
+    for (const rule of this.provider.rules()) {
+      const result = rule.evaluate(context);
+      if (result === null) continue;
+      if (DECISION_PRIORITY[result.decision] > DECISION_PRIORITY[decision]) {
+        decision = result.decision;
+        reason = result.reason;
+      }
+      if (result.decision === "DENY" || result.decision === "REQUIRES_CONFIRMATION") {
+        violations.push({
+          ruleId: rule.id,
+          reason: result.reason,
+          context,
+          occurredAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return { decision, violations, reason };
+  }
+};
+
+// src/policy/InMemoryPolicyProvider.ts
+var InMemoryPolicyProvider = class {
+  _rules;
+  constructor(rules = []) {
+    this._rules = rules;
+  }
+  rules() {
+    return this._rules;
+  }
+};
+
+// src/confirmation/ConfirmationEngine.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var ConfirmationEngine = class {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  repository;
+  async request(input) {
+    const requiredApprovals = input.requiredApprovals ?? 1;
+    const request = {
+      id: randomUUID5(),
+      operation: input.operation,
+      actor: input.actor,
+      resource: input.resource,
+      status: requiredApprovals > 1 ? "AWAITING_CONFIRMATION" : "REQUESTED",
+      requiredApprovals,
+      approvals: [],
+      rejections: [],
+      requestedAt: /* @__PURE__ */ new Date(),
+      expiresAt: input.expiresAt,
+      metadata: input.metadata,
+      correlationId: input.correlationId
+    };
+    await this.repository.save(request);
+    return request;
+  }
+  async approve(requestId, approver, comment) {
+    const request = await this.findOrThrow(requestId);
+    this.assertActive(request);
+    const updated = {
+      ...request,
+      approvals: [...request.approvals, { approver, approvedAt: /* @__PURE__ */ new Date(), comment }]
+    };
+    const fullyApproved = updated.approvals.length >= updated.requiredApprovals;
+    updated.status = fullyApproved ? "APPROVED" : "AWAITING_CONFIRMATION";
+    await this.repository.save(updated);
+    return updated;
+  }
+  async reject(requestId, approver, comment) {
+    const request = await this.findOrThrow(requestId);
+    this.assertActive(request);
+    const updated = {
+      ...request,
+      status: "REJECTED",
+      rejections: [...request.rejections, { approver, approvedAt: /* @__PURE__ */ new Date(), comment }]
+    };
+    await this.repository.save(updated);
+    return updated;
+  }
+  async execute(requestId) {
+    const request = await this.findOrThrow(requestId);
+    if (request.status !== "APPROVED") {
+      throw new MaestroError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Cannot execute confirmation request in status: ${request.status}`
+      );
+    }
+    const updated = {
+      ...request,
+      status: "EXECUTED",
+      executedAt: /* @__PURE__ */ new Date()
+    };
+    await this.repository.save(updated);
+    return updated;
+  }
+  async getPending() {
+    return this.repository.listPending();
+  }
+  async findOrThrow(requestId) {
+    const request = await this.repository.findById(requestId);
+    if (!request) {
+      throw new MaestroError(
+        "NOT_FOUND" /* NOT_FOUND */,
+        `Confirmation request not found: ${requestId}`
+      );
+    }
+    return request;
+  }
+  assertActive(request) {
+    const terminal = ["APPROVED", "REJECTED", "EXECUTED", "EXPIRED"];
+    if (terminal.includes(request.status)) {
+      throw new MaestroError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Confirmation request is already in terminal status: ${request.status}`
+      );
+    }
+  }
+};
+
+// src/confirmation/InMemoryConfirmationRepository.ts
+var InMemoryConfirmationRepository = class {
+  store = /* @__PURE__ */ new Map();
+  async save(request) {
+    this.store.set(request.id, request);
+  }
+  async findById(id) {
+    return this.store.get(id);
+  }
+  async listPending() {
+    return Array.from(this.store.values()).filter(
+      (r) => r.status === "REQUESTED" || r.status === "AWAITING_CONFIRMATION"
+    );
+  }
+};
+
+// src/governance/GovernanceEventType.ts
+var GOVERNANCE_EVENT_TYPES = {
+  OPERATION_EXECUTED: "governance.operation.executed",
+  AUTHORIZATION_DENIED: "governance.authorization.denied",
+  POLICY_TRIGGERED: "governance.policy.triggered",
+  CONFIRMATION_REQUESTED: "governance.confirmation.requested",
+  CONFIRMATION_APPROVED: "governance.confirmation.approved",
+  CONFIRMATION_REJECTED: "governance.confirmation.rejected",
+  AUDIT_RECORDED: "governance.audit.recorded"
+};
+
+// src/governance/InMemoryGovernanceEventBus.ts
+import { randomUUID as randomUUID6 } from "crypto";
+var InMemoryGovernanceEventBus = class extends InMemoryEventBus {
+  async publishGovernance(type, payload, correlationId) {
+    const event = {
+      id: randomUUID6(),
+      type,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload,
+      correlationId
+    };
+    await this.publish(event);
+    return event;
+  }
+};
+
+// src/governance/DefaultGovernanceApi.ts
+var DefaultGovernanceApi = class {
+  constructor(auditRepository, confirmationRepository, violationLog = []) {
+    this.auditRepository = auditRepository;
+    this.confirmationRepository = confirmationRepository;
+    this.violationLog = violationLog;
+  }
+  auditRepository;
+  confirmationRepository;
+  violationLog;
+  async getAuditTimeline(filter) {
+    return this.auditRepository.list(filter);
+  }
+  async getCorrelationTrace(correlationId) {
+    return this.auditRepository.list({ correlationId });
+  }
+  async getPendingConfirmations() {
+    return this.confirmationRepository.listPending();
+  }
+  async getPolicyViolations(filter) {
+    let violations = [...this.violationLog];
+    if (filter?.ruleId !== void 0) {
+      violations = violations.filter((v) => v.ruleId === filter.ruleId);
+    }
+    if (filter?.correlationId !== void 0) {
+      violations = violations.filter((v) => v.context.correlationId === filter.correlationId);
+    }
+    if (filter?.from !== void 0) {
+      const from = filter.from;
+      violations = violations.filter((v) => v.occurredAt >= from);
+    }
+    if (filter?.to !== void 0) {
+      const to = filter.to;
+      violations = violations.filter((v) => v.occurredAt <= to);
+    }
+    return violations;
+  }
+};
 export {
   AuditRecorder,
+  ConfirmationEngine,
   ConsoleLogger,
+  ConsoleStructuredLogger,
+  ContextualAuthorizationEngine,
   CsvExportProvider,
   DEFAULT_CAPABILITIES,
   DatasourceRegistry,
+  DefaultGovernanceApi,
   DiffEngine,
   ErrorCode,
+  GOVERNANCE_EVENT_TYPES,
   InMemoryAuditRepository,
   InMemoryConfigProvider,
+  InMemoryConfirmationRepository,
   InMemoryDatasourceProvider,
   InMemoryEventBus,
   InMemoryFeatureFlagProvider,
+  InMemoryGovernanceEventBus,
+  InMemoryPolicyProvider,
   InMemorySnapshotRepository,
   IntrospectionRuntime,
   MaestroEngine,
   MaestroError,
   MetadataEngine,
+  MetadataRiskClassifier,
   OperationRegistry,
+  PolicyEngine,
   RbacEngine,
   ReportGenerator,
   createMaestro,
@@ -2329,6 +2658,7 @@ export {
   createMaestroHttpHandlers,
   detectDisplayField,
   generateAllConfigs,
+  generateCorrelationId,
   generateEntityConfig,
   generateRelationConfig,
   humanizeFieldName,