@aifabrix/builder 2.49.1 → 2.50.0

package/lib/programmatic/openapi-request-schemas.js

@@ -0,0 +1,155 @@
+/**
+ * Frozen OpenAPI request body schemas for builder-api routes.
+ *
+ * @fileoverview Typed POST/DELETE bodies (additionalProperties: false)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { frozenObject, schemaRef, stringArraySchema } = require('./openapi-schema-helpers');
+
+/** @type {Record<string, Object>} */
+const OPENAPI_REQUEST_SCHEMAS = {
+  SystemKey: {
+    type: 'string',
+    pattern: '^[a-z0-9-_]+$',
+    description: 'External integration system key (lowercase alphanumeric, hyphen, underscore).',
+    example: 'hubspot-demo'
+  },
+  CertifyPillar: {
+    type: 'string',
+    enum: ['operations', 'trust', 'governance', 'lifecycle-run']
+  },
+  TestRunType: {
+    type: 'string',
+    enum: ['unit', 'integration', 'e2e']
+  },
+  RepositorySyncDirection: {
+    type: 'string',
+    enum: ['pull', 'push']
+  },
+  WizardSourceType: {
+    type: 'string',
+    enum: ['openapiFile', 'openapiUrl', 'mcpServer', 'knownPlatform']
+  },
+  WizardSourceConfig: frozenObject(
+    {
+      type: schemaRef('WizardSourceType'),
+      path: { type: 'string' },
+      url: { type: 'string', format: 'uri' },
+      platform: { type: 'string' }
+    },
+    ['type']
+  ),
+  WizardCredentialOptions: frozenObject({
+    method: { type: 'string', description: 'Auth method hint for wizard (e.g. apikey, oauth2).' },
+    credentialKey: { type: 'string', description: 'Existing credential key in Dataplane.' }
+  }),
+  WizardPreferences: frozenObject({
+    expose: { type: 'boolean' },
+    rbac: { type: 'boolean' },
+    sync: { type: 'boolean' }
+  }),
+  CreateSystemRequest: frozenObject({ systemKey: schemaRef('SystemKey') }, ['systemKey']),
+  WizardConfigRequest: frozenObject(
+    {
+      appName: { type: 'string' },
+      mode: { type: 'string' },
+      systemIdOrKey: { type: 'string' },
+      systemDisplayName: { type: 'string' },
+      source: schemaRef('WizardSourceConfig'),
+      credential: schemaRef('WizardCredentialOptions'),
+      preferences: schemaRef('WizardPreferences'),
+      debug: { type: 'boolean' }
+    },
+    ['appName', 'source']
+  ),
+  RepairRequest: frozenObject({
+    dryRun: { type: 'boolean' },
+    auth: { type: 'string' },
+    rbac: { type: 'boolean' },
+    expose: { type: 'boolean' },
+    sync: { type: 'boolean' },
+    test: { type: 'boolean' },
+    api: { type: 'boolean' },
+    operations: {
+      type: 'boolean',
+      description:
+        'When true, sync capabilities[] → openapi.operations → execution.cip.operations for operationId-shaped keys.'
+    },
+    rbacPreset: {
+      type: 'string',
+      enum: ['platform'],
+      description:
+        'When platform, use dataplane platform roles (aifabrix-platform-admin, …) instead of per-system admin/reader.'
+    }
+  }),
+  ValidateRequest: frozenObject({
+    pipelineValidate: { type: 'boolean' }
+  }),
+  PreviewUploadRequest: frozenObject({
+    force: { type: 'boolean' }
+  }),
+  UploadRequest: frozenObject({
+    force: { type: 'boolean' },
+    probe: { type: 'boolean' }
+  }),
+  TestRequest: frozenObject({
+    runType: schemaRef('TestRunType'),
+    noPublish: { type: 'boolean' }
+  }),
+  CertifyRequest: frozenObject({
+    noPublish: { type: 'boolean' },
+    pack: { type: 'string' },
+    lifecycleBody: schemaRef('LifecycleRunRequest')
+  }),
+  LifecycleRunRequest: frozenObject({
+    subjectEmail: { type: 'string', format: 'email' },
+    dryRun: { type: 'boolean' }
+  }),
+  TemplateMaterializeRequest: frozenObject({
+    templateKey: { type: 'string' },
+    params: schemaRef('TemplateMaterializeParams')
+  }),
+  TemplateMaterializeParams: frozenObject({
+    branch: { type: 'string' },
+    paths: stringArraySchema()
+  }),
+  WorkspaceDiffRequest: frozenObject({
+    baseline: { type: 'string' },
+    paths: stringArraySchema()
+  }),
+  WorkspaceResetRequest: frozenObject({
+    templateKey: { type: 'string' },
+    confirm: { type: 'boolean' }
+  }),
+  RepositorySyncRequest: frozenObject({
+    direction: schemaRef('RepositorySyncDirection'),
+    branch: { type: 'string' },
+    paths: stringArraySchema(),
+    commitMessage: { type: 'string' }
+  }),
+  RepositoryCreateReviewRequest: frozenObject({
+    title: { type: 'string' },
+    body: { type: 'string' },
+    sourceBranch: { type: 'string' },
+    targetBranch: { type: 'string' },
+    draft: { type: 'boolean' }
+  }),
+  RepositoryDispatchPipelineRequest: frozenObject({
+    workflow: { type: 'string' },
+    ref: { type: 'string' },
+    inputs: schemaRef('RepositoryPipelineInputs')
+  }),
+  RepositoryPipelineInputs: frozenObject({
+    environment: { type: 'string' },
+    ref: { type: 'string' }
+  }),
+  EmptyRequestBody: frozenObject({})
+};
+
+module.exports = {
+  OPENAPI_REQUEST_SCHEMAS
+};

package/lib/programmatic/openapi-result-schemas.js

@@ -0,0 +1,476 @@
+/**
+ * Frozen OpenAPI response data schemas for builder-api routes.
+ *
+ * @fileoverview Typed handler result models (additionalProperties: false)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { frozenObject, schemaRef, stringArraySchema } = require('./openapi-schema-helpers');
+
+/** @type {Record<string, Object>} */
+const OPENAPI_RESULT_SCHEMAS = {
+  ProblemDetails: frozenObject(
+    {
+      type: { type: 'string', format: 'uri-reference' },
+      title: { type: 'string' },
+      status: { type: 'integer', minimum: 100, maximum: 599 },
+      detail: { type: 'string' },
+      instance: { type: 'string' },
+      correlationId: { type: 'string' },
+      errors: { type: 'array', items: schemaRef('ProblemValidationError') }
+    },
+    ['type', 'title', 'status', 'detail']
+  ),
+  ProblemValidationError: frozenObject(
+    {
+      field: { type: 'string' },
+      message: { type: 'string' },
+      value: { type: 'string' }
+    },
+    ['message']
+  ),
+  LifecycleVerdict: {
+    type: 'string',
+    enum: ['VERIFIED', 'FAILED', 'NOT_VERIFIED']
+  },
+  CertificationLevel: {
+    type: 'string',
+    enum: ['BRONZE', 'SILVER', 'GOLD', 'PLATINUM', 'NONE']
+  },
+  CertificationStatus: {
+    type: 'string',
+    enum: [
+      'TECHNICALLY_READY',
+      'AI_READY',
+      'ENTERPRISE_AI_READY',
+      'REGULATED_ENTERPRISE_READY',
+      'NOT_CERTIFIED'
+    ]
+  },
+  WorkspaceMeta: frozenObject(
+    {
+      ownerUserId: { type: 'string' },
+      systemKey: schemaRef('SystemKey'),
+      createdAt: { type: 'string', format: 'date-time' },
+      lastModifiedAt: { type: 'string', format: 'date-time' },
+      lastOperation: { type: 'string' },
+      lastUploadId: { type: ['string', 'null'] }
+    },
+    ['ownerUserId', 'systemKey', 'createdAt', 'lastModifiedAt', 'lastOperation']
+  ),
+  WorkspaceSystemSummary: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      meta: {
+        oneOf: [schemaRef('WorkspaceMeta'), { type: 'null' }]
+      }
+    },
+    ['systemKey']
+  ),
+  WorkspaceManifestFileEntry: frozenObject(
+    {
+      path: { type: 'string' },
+      isDirectory: { type: 'boolean' },
+      sizeBytes: { type: 'integer', minimum: 0 },
+      redacted: { type: 'boolean' }
+    },
+    ['path']
+  ),
+  ListSystemsData: frozenObject(
+    {
+      systems: { type: 'array', items: schemaRef('WorkspaceSystemSummary') }
+    },
+    ['systems']
+  ),
+  CreateSystemData: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      meta: schemaRef('WorkspaceMeta')
+    },
+    ['systemKey', 'meta']
+  ),
+  SystemManifestData: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      meta: { oneOf: [schemaRef('WorkspaceMeta'), { type: 'null' }] },
+      files: { type: 'array', items: schemaRef('WorkspaceManifestFileEntry') }
+    },
+    ['systemKey', 'files']
+  ),
+  DeleteSystemData: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      deleted: { type: 'boolean', enum: [true] }
+    },
+    ['systemKey', 'deleted']
+  ),
+  WizardRunData: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      status: { type: 'string', enum: ['completed'] }
+    },
+    ['systemKey', 'status']
+  ),
+  RepairResultData: frozenObject(
+    {
+      updated: { type: 'boolean' },
+      actionsPerformed: { type: 'boolean' },
+      changes: stringArraySchema(),
+      warnings: stringArraySchema(),
+      changedFiles: stringArraySchema(),
+      systemFiles: stringArraySchema(),
+      datasourceFiles: stringArraySchema(),
+      backupPaths: stringArraySchema(),
+      appKeyFixed: { type: 'boolean' },
+      datasourceKeysFixed: { type: 'boolean' },
+      rbacFileCreated: { type: 'boolean' },
+      envTemplateRepaired: { type: 'boolean' },
+      manifestRegenerated: { type: 'boolean' },
+      readmeRegenerated: { type: 'boolean' }
+    },
+    ['updated', 'changes', 'warnings', 'changedFiles']
+  ),
+  ValidationStepResult: frozenObject(
+    {
+      valid: { type: 'boolean' },
+      errors: stringArraySchema(),
+      warnings: stringArraySchema(),
+      files: stringArraySchema(),
+      skipped: { type: 'boolean' }
+    },
+    ['valid', 'errors', 'warnings']
+  ),
+  ValidationSteps: frozenObject(
+    {
+      application: schemaRef('ValidationStepResult'),
+      components: schemaRef('ValidationStepResult'),
+      manifest: schemaRef('ValidationStepResult')
+    },
+    ['application', 'components', 'manifest']
+  ),
+  ValidationResultCore: frozenObject(
+    {
+      valid: { type: 'boolean' },
+      errors: stringArraySchema(),
+      warnings: stringArraySchema(),
+      steps: schemaRef('ValidationSteps'),
+      appPath: { type: 'string' }
+    },
+    ['valid', 'errors', 'warnings']
+  ),
+  PipelineValidationResult: frozenObject(
+    {
+      valid: { type: 'boolean' },
+      isValid: { type: 'boolean' },
+      errors: stringArraySchema(),
+      warnings: stringArraySchema()
+    },
+    ['errors', 'warnings']
+  ),
+  ValidateResultData: frozenObject(
+    {
+      validationResult: schemaRef('ValidationResultCore'),
+      pipelineValidation: {
+        oneOf: [schemaRef('PipelineValidationResult'), { type: 'null' }]
+      }
+    },
+    ['validationResult']
+  ),
+  UploadApplicationPreview: frozenObject({
+    key: { type: 'string' },
+    displayName: { type: 'string' },
+    type: { type: 'string' }
+  }),
+  UploadDatasourcePreview: frozenObject({ key: { type: 'string' } }, ['key']),
+  UploadManifestPreview: frozenObject(
+    {
+      key: { type: 'string' },
+      version: { type: 'string' },
+      type: { type: 'string' }
+    },
+    ['key']
+  ),
+  UploadPayloadPreview: frozenObject(
+    {
+      version: { type: 'string' },
+      application: schemaRef('UploadApplicationPreview'),
+      dataSources: { type: 'array', items: schemaRef('UploadDatasourcePreview') }
+    },
+    ['version', 'application', 'dataSources']
+  ),
+  PreviewUploadData: frozenObject(
+    {
+      manifest: schemaRef('UploadManifestPreview'),
+      payload: schemaRef('UploadPayloadPreview')
+    },
+    ['manifest', 'payload']
+  ),
+  UploadResultData: frozenObject(
+    {
+      dataplaneUrl: { type: 'string', format: 'uri' },
+      environment: { type: 'string' },
+      uploadSkipped: { type: 'boolean' }
+    },
+    ['dataplaneUrl', 'environment', 'uploadSkipped']
+  ),
+  TestSystemFileResult: frozenObject(
+    {
+      file: { type: 'string' },
+      valid: { type: 'boolean' },
+      errors: stringArraySchema()
+    },
+    ['file', 'valid', 'errors']
+  ),
+  TestDatasourceResult: frozenObject(
+    {
+      key: { type: 'string' },
+      file: { type: 'string' },
+      valid: { type: 'boolean' },
+      errors: stringArraySchema(),
+      warnings: stringArraySchema(),
+      structuralValid: { type: 'boolean' },
+      payloadTestsRan: { type: 'boolean' },
+      payloadTestsOk: { type: 'boolean' }
+    },
+    ['key', 'valid', 'errors', 'warnings']
+  ),
+  IntegrationDatasourceResult: frozenObject(
+    {
+      key: { type: 'string' },
+      success: { type: 'boolean' },
+      skipped: { type: 'boolean' },
+      error: { type: 'string' }
+    },
+    ['key', 'success']
+  ),
+  E2ETestRunItem: frozenObject(
+    {
+      key: { type: 'string' },
+      success: { type: 'boolean' },
+      error: { type: 'string' },
+      datasourceTestRun: schemaRef('DatasourceTestRunSummary')
+    },
+    ['key', 'success']
+  ),
+  DatasourceTestRunSummary: frozenObject({
+    id: { type: 'string' },
+    status: { type: 'string' },
+    datasourceKey: { type: 'string' }
+  }),
+  UnitTestResultData: frozenObject(
+    {
+      runType: { type: 'string', enum: ['unit'] },
+      valid: { type: 'boolean' },
+      errors: stringArraySchema(),
+      warnings: stringArraySchema(),
+      systemResults: { type: 'array', items: schemaRef('TestSystemFileResult') },
+      datasourceResults: { type: 'array', items: schemaRef('TestDatasourceResult') },
+      systemKey: schemaRef('SystemKey'),
+      appName: { type: 'string' }
+    },
+    ['runType', 'valid', 'errors', 'warnings', 'systemResults', 'datasourceResults']
+  ),
+  IntegrationTestResultData: frozenObject(
+    {
+      runType: { type: 'string', enum: ['integration'] },
+      success: { type: 'boolean' },
+      datasourceResults: { type: 'array', items: schemaRef('IntegrationDatasourceResult') },
+      systemKey: schemaRef('SystemKey'),
+      appName: { type: 'string' }
+    },
+    ['runType', 'success', 'datasourceResults']
+  ),
+  E2ETestResultData: frozenObject(
+    {
+      runType: { type: 'string', enum: ['e2e'] },
+      success: { type: 'boolean' },
+      results: { type: 'array', items: schemaRef('E2ETestRunItem') }
+    },
+    ['runType', 'success', 'results']
+  ),
+  TestResultData: {
+    oneOf: [
+      schemaRef('UnitTestResultData'),
+      schemaRef('IntegrationTestResultData'),
+      schemaRef('E2ETestResultData')
+    ]
+  },
+  CertificationSummary: frozenObject(
+    {
+      level: schemaRef('CertificationLevel'),
+      status: schemaRef('CertificationStatus')
+    },
+    ['level', 'status']
+  ),
+  OperationsCheckDetail: frozenObject({
+    key: { type: 'string' },
+    passed: { type: 'boolean' },
+    message: { type: 'string' }
+  }),
+  OperationsStepResult: frozenObject({
+    step: { type: 'string' },
+    success: { type: 'boolean' },
+    error: { type: 'string' }
+  }),
+  CertifyOperationsResultData: frozenObject(
+    {
+      command: { type: 'string', enum: ['verify-operations'] },
+      systemKey: schemaRef('SystemKey'),
+      verdict: schemaRef('LifecycleVerdict'),
+      operationalReadinessPercent: { type: 'number', minimum: 0, maximum: 100 },
+      certification: schemaRef('CertificationSummary'),
+      warnings: stringArraySchema(),
+      details: { type: 'array', items: schemaRef('OperationsCheckDetail') },
+      stepResults: { type: 'array', items: schemaRef('OperationsStepResult') }
+    },
+    ['command', 'systemKey', 'verdict', 'operationalReadinessPercent', 'certification']
+  ),
+  TrustDatasourceRow: frozenObject(
+    {
+      datasourceKey: { type: 'string' },
+      verdict: schemaRef('LifecycleVerdict'),
+      trustDecision: { type: 'string' },
+      validationStatus: { type: 'string' },
+      error: { type: 'string' }
+    },
+    ['datasourceKey', 'verdict']
+  ),
+  CertifyTrustResultData: frozenObject(
+    {
+      command: { type: 'string', enum: ['verify-trust'] },
+      systemKey: schemaRef('SystemKey'),
+      verdict: schemaRef('LifecycleVerdict'),
+      aiTrustPercent: { type: ['number', 'null'] },
+      accessConfidencePercent: { type: ['number', 'null'] },
+      businessConfidencePercent: { type: ['number', 'null'] },
+      findings: stringArraySchema(),
+      datasourceRows: { type: 'array', items: schemaRef('TrustDatasourceRow') }
+    },
+    ['command', 'systemKey', 'verdict', 'datasourceRows']
+  ),
+  GovernanceScenarioCount: frozenObject(
+    {
+      passed: { type: 'integer', minimum: 0 },
+      total: { type: 'integer', minimum: 0 }
+    },
+    ['passed', 'total']
+  ),
+  GovernanceDatasourceRow: frozenObject(
+    {
+      datasourceKey: { type: 'string' },
+      verdict: schemaRef('LifecycleVerdict'),
+      policyCoveragePercent: { type: ['number', 'null'] },
+      dimensionCoveragePercent: { type: ['number', 'null'] },
+      scenarios: schemaRef('GovernanceScenarioCount')
+    },
+    ['datasourceKey', 'verdict']
+  ),
+  CertifyGovernanceResultData: frozenObject(
+    {
+      command: { type: 'string', enum: ['verify-governance'] },
+      systemKey: schemaRef('SystemKey'),
+      verdict: schemaRef('LifecycleVerdict'),
+      policyCoveragePercent: { type: 'number' },
+      dimensionCoveragePercent: { type: 'number' },
+      enforcementScenarios: schemaRef('GovernanceScenarioCount'),
+      datasourceRows: { type: 'array', items: schemaRef('GovernanceDatasourceRow') }
+    },
+    ['command', 'systemKey', 'verdict', 'enforcementScenarios', 'datasourceRows']
+  ),
+  LifecycleRunStep: frozenObject(
+    {
+      pillar: { type: 'string' },
+      success: { type: 'boolean' },
+      error: { type: 'string' }
+    },
+    ['pillar', 'success']
+  ),
+  LifecycleRunReport: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      certification: schemaRef('CertificationSummary')
+    },
+    ['systemKey']
+  ),
+  CertifyLifecycleRunResultData: frozenObject(
+    {
+      report: schemaRef('LifecycleRunReport'),
+      stepsRun: { type: 'array', items: schemaRef('LifecycleRunStep') }
+    },
+    ['report']
+  ),
+  CertifyResultData: {
+    oneOf: [
+      schemaRef('CertifyOperationsResultData'),
+      schemaRef('CertifyTrustResultData'),
+      schemaRef('CertifyGovernanceResultData'),
+      schemaRef('CertifyLifecycleRunResultData')
+    ]
+  },
+  LifecycleReportData: frozenObject(
+    {
+      systemKey: schemaRef('SystemKey'),
+      certification: schemaRef('CertificationSummary'),
+      operationalReadinessPercent: { type: 'number' },
+      summary: { type: 'boolean' },
+      details: { type: 'boolean' }
+    },
+    ['systemKey']
+  ),
+  EnterpriseMcpToolOutput: frozenObject({
+    success: { type: 'boolean' },
+    status: { type: 'string' },
+    message: { type: 'string' },
+    branch: { type: 'string' },
+    pullRequestUrl: { type: 'string', format: 'uri' },
+    syncDirection: schemaRef('RepositorySyncDirection'),
+    commitSha: { type: 'string' },
+    workflowRunId: { type: 'string' }
+  }),
+  WorkspaceRemoteUnavailable: frozenObject(
+    {
+      unavailable: { type: 'boolean', enum: [true] },
+      message: { type: 'string' }
+    },
+    ['unavailable', 'message']
+  ),
+  WorkspaceRemoteStatus: {
+    oneOf: [schemaRef('EnterpriseMcpToolOutput'), schemaRef('WorkspaceRemoteUnavailable'), { type: 'null' }]
+  },
+  EnterpriseMcpInvocationData: frozenObject(
+    {
+      capabilityKey: { type: 'string' },
+      result: schemaRef('EnterpriseMcpToolOutput')
+    },
+    ['capabilityKey', 'result']
+  ),
+  WorkspaceStatusData: frozenObject(
+    {
+      local: schemaRef('SystemManifestData'),
+      remote: schemaRef('WorkspaceRemoteStatus')
+    },
+    ['local', 'remote']
+  ),
+  RepositoryStatusData: frozenObject(
+    {
+      capabilityKey: { type: 'string', enum: ['repository.status'] },
+      result: schemaRef('EnterpriseMcpToolOutput')
+    },
+    ['capabilityKey', 'result']
+  ),
+  HealthData: frozenObject({ status: { type: 'string', enum: ['ok'] } }, ['status']),
+  ReadyData: frozenObject(
+    {
+      status: { type: 'string', enum: ['ready'] },
+      dataplaneUrl: { type: ['string', 'null'], format: 'uri' }
+    },
+    ['status']
+  )
+};
+
+module.exports = {
+  OPENAPI_RESULT_SCHEMAS
+};