@cat-factory/app 0.36.0 → 0.37.1

package/app/composables/api/providerConnections.ts

@@ -1,61 +1,103 @@
+import {
+  describeEnvironmentProviderContract,
+  describeRunnerPoolProviderContract,
+  getEnvironmentConnectionContract,
+  getRunnerPoolConnectionContract,
+  registerEnvironmentProviderContract,
+  registerRunnerPoolContract,
+  testEnvironmentConnectionContract,
+  testRunnerPoolConnectionContract,
+  unregisterEnvironmentProviderContract,
+  unregisterRunnerPoolContract,
+  updateEnvironmentSecretsContract,
+  updateRunnerPoolSecretsContract,
+} from '@cat-factory/contracts'
+import type {
+  RegisterEnvironmentProviderInput,
+  RegisterRunnerPoolInput,
+  TestEnvironmentConnectionInput,
+  TestRunnerPoolConnectionInput,
+} from '@cat-factory/contracts'
 import type {
-  ConnectionTestResult,
-  ProviderConnection,
   ProviderConnectionKind,
-  ProviderDescriptor,
   RegisterProviderInput,
   TestProviderInput,
 } from '~/types/providerConnections'
 import type { ApiContext } from './context'
 
 // The two infrastructure providers share an identical REST surface, differing only in the
-// path segment (`environments` vs `runner-pool`). One factory serves both so a single
-// generic store + connect form drives either.
-const SEGMENT: Record<ProviderConnectionKind, string> = {
-  environment: 'environments',
-  'runner-pool': 'runner-pool',
-}
+// path segment (`environments` vs `runner-pool`). The contracts split into per-kind names,
+// so a small lookup table maps each kind to its four contracts; one factory then serves both
+// so a single generic store + connect form drives either.
+const CONTRACTS = {
+  environment: {
+    describe: describeEnvironmentProviderContract,
+    get: getEnvironmentConnectionContract,
+    register: registerEnvironmentProviderContract,
+    updateSecrets: updateEnvironmentSecretsContract,
+    test: testEnvironmentConnectionContract,
+    unregister: unregisterEnvironmentProviderContract,
+  },
+  'runner-pool': {
+    describe: describeRunnerPoolProviderContract,
+    get: getRunnerPoolConnectionContract,
+    register: registerRunnerPoolContract,
+    updateSecrets: updateRunnerPoolSecretsContract,
+    test: testRunnerPoolConnectionContract,
+    unregister: unregisterRunnerPoolContract,
+  },
+} satisfies Record<ProviderConnectionKind, unknown>
 
 /** Environment-provider + runner-pool connection endpoints (self-describe + register/test). */
-export function providerConnectionsApi({ http, ws }: ApiContext) {
-  const base = (workspaceId: string, kind: ProviderConnectionKind) =>
-    `${ws(workspaceId)}/${SEGMENT[kind]}`
-
+export function providerConnectionsApi({ send, ws }: ApiContext) {
   return {
     describeProvider: (workspaceId: string, kind: ProviderConnectionKind) =>
-      http<ProviderDescriptor>(`${base(workspaceId, kind)}/provider`),
+      send(CONTRACTS[kind].describe, { pathPrefix: ws(workspaceId) }),
 
     getProviderConnection: (workspaceId: string, kind: ProviderConnectionKind) =>
-      http<{ connection: ProviderConnection | null }>(`${base(workspaceId, kind)}/connection`),
+      send(CONTRACTS[kind].get, { pathPrefix: ws(workspaceId) }),
 
+    // The connect form builds the manifest dynamically from a server-provided scaffold, so
+    // the FE input keeps `manifest` opaque (`Record<string, unknown>`); narrow on the kind
+    // and cast to the matching per-kind contract input at this single boundary (the backend
+    // re-validates the manifest against the precise contract on receipt).
     registerProviderConnection: (
       workspaceId: string,
       kind: ProviderConnectionKind,
       body: RegisterProviderInput,
     ) =>
-      http<ProviderConnection>(`${base(workspaceId, kind)}/connection`, { method: 'POST', body }),
+      kind === 'environment'
+        ? send(CONTRACTS.environment.register, {
+            pathPrefix: ws(workspaceId),
+            body: body as RegisterEnvironmentProviderInput,
+          })
+        : send(CONTRACTS['runner-pool'].register, {
+            pathPrefix: ws(workspaceId),
+            body: body as RegisterRunnerPoolInput,
+          }),
 
     updateProviderSecrets: (
       workspaceId: string,
       kind: ProviderConnectionKind,
       secrets: Record<string, string>,
-    ) =>
-      http<ProviderConnection>(`${base(workspaceId, kind)}/connection/secrets`, {
-        method: 'PUT',
-        body: { secrets },
-      }),
+    ) => send(CONTRACTS[kind].updateSecrets, { pathPrefix: ws(workspaceId), body: { secrets } }),
 
     testProviderConnection: (
       workspaceId: string,
       kind: ProviderConnectionKind,
       body: TestProviderInput,
     ) =>
-      http<ConnectionTestResult>(`${base(workspaceId, kind)}/connection/test`, {
-        method: 'POST',
-        body,
-      }),
+      kind === 'environment'
+        ? send(CONTRACTS.environment.test, {
+            pathPrefix: ws(workspaceId),
+            body: body as TestEnvironmentConnectionInput,
+          })
+        : send(CONTRACTS['runner-pool'].test, {
+            pathPrefix: ws(workspaceId),
+            body: body as TestRunnerPoolConnectionInput,
+          }),
 
     deleteProviderConnection: (workspaceId: string, kind: ProviderConnectionKind) =>
-      http(`${base(workspaceId, kind)}/connection`, { method: 'DELETE' }),
+      send(CONTRACTS[kind].unregister, { pathPrefix: ws(workspaceId) }),
   }
 }

package/app/composables/api/recurring.ts

@@ -1,67 +1,77 @@
-import type { Service, WorkspaceMount } from '~/types/domain'
-import type {
-  CreateScheduleInput,
-  PipelineSchedule,
-  ScheduleRun,
-  UpdateScheduleInput,
-} from '~/types/recurring'
+import {
+  createScheduleContract,
+  deleteScheduleContract,
+  listSchedulesContract,
+  listScheduleRunsContract,
+  listServiceCatalogContract,
+  listServiceMountsContract,
+  mountServiceContract,
+  runScheduleNowContract,
+  unmountServiceContract,
+  updateScheduleContract,
+  updateServiceMountLayoutContract,
+} from '@cat-factory/contracts'
+import type { UpdateScheduleInput } from '~/types/recurring'
+import type { SendParams } from './client'
 import type { ApiContext, Position } from './context'
 
+// The create-schedule body is typed from the contract's INPUT shape so the
+// valibot-defaulted `enabled` stays optional for callers (the exported
+// `CreateScheduleInput` is the post-default OUTPUT shape).
+type CreateScheduleBody = NonNullable<SendParams<typeof createScheduleContract>['body']>
+
 /** Recurring (scheduled) pipelines + the in-org shared-service mount catalog. */
-export function recurringApi({ http, ws }: ApiContext) {
+export function recurringApi({ send, ws }: ApiContext) {
   return {
     // ---- recurring pipelines (scheduled runs against a service) -----------
     listRecurringPipelines: (workspaceId: string) =>
-      http<PipelineSchedule[]>(`${ws(workspaceId)}/recurring-pipelines`),
+      send(listSchedulesContract, { pathPrefix: ws(workspaceId) }),
 
-    createRecurringPipeline: (workspaceId: string, body: CreateScheduleInput) =>
-      http<PipelineSchedule>(`${ws(workspaceId)}/recurring-pipelines`, { method: 'POST', body }),
+    createRecurringPipeline: (workspaceId: string, body: CreateScheduleBody) =>
+      send(createScheduleContract, { pathPrefix: ws(workspaceId), body }),
 
     updateRecurringPipeline: (workspaceId: string, id: string, body: UpdateScheduleInput) =>
-      http<PipelineSchedule>(`${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}`, {
-        method: 'PATCH',
+      send(updateScheduleContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { scheduleId: id },
         body,
       }),
 
     deleteRecurringPipeline: (workspaceId: string, id: string) =>
-      http(`${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}`, {
-        method: 'DELETE',
-      }),
+      send(deleteScheduleContract, { pathPrefix: ws(workspaceId), pathParams: { scheduleId: id } }),
 
     listScheduleRuns: (workspaceId: string, id: string) =>
-      http<ScheduleRun[]>(`${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}/runs`),
+      send(listScheduleRunsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { scheduleId: id },
+      }),
 
     runScheduleNow: (workspaceId: string, id: string) =>
-      http<PipelineSchedule>(
-        `${ws(workspaceId)}/recurring-pipelines/${encodeURIComponent(id)}/run-now`,
-        { method: 'POST' },
-      ),
+      send(runScheduleNowContract, { pathPrefix: ws(workspaceId), pathParams: { scheduleId: id } }),
 
     // ---- in-org shared services (mount/unmount + org catalog) -------------
     // The services this workspace mounts, and the org catalog it can mount from. A 503
     // means the feature isn't wired (the store hides its UI on any error here).
     listServiceMounts: (workspaceId: string) =>
-      http<WorkspaceMount[]>(`${ws(workspaceId)}/services`),
+      send(listServiceMountsContract, { pathPrefix: ws(workspaceId) }),
 
     listServiceCatalog: (workspaceId: string) =>
-      http<Service[]>(`${ws(workspaceId)}/services/catalog`),
+      send(listServiceCatalogContract, { pathPrefix: ws(workspaceId) }),
 
     mountService: (workspaceId: string, serviceId: string, body: { position?: Position } = {}) =>
-      http<WorkspaceMount>(`${ws(workspaceId)}/services/${encodeURIComponent(serviceId)}`, {
-        method: 'POST',
-        body,
-      }),
+      send(mountServiceContract, { pathPrefix: ws(workspaceId), pathParams: { serviceId }, body }),
 
     unmountService: (workspaceId: string, serviceId: string) =>
-      http(`${ws(workspaceId)}/services/${encodeURIComponent(serviceId)}`, { method: 'DELETE' }),
+      send(unmountServiceContract, { pathPrefix: ws(workspaceId), pathParams: { serviceId } }),
 
     updateMountLayout: (
       workspaceId: string,
       serviceId: string,
       body: { position?: Position; size?: { w: number; h: number } | null },
     ) =>
-      http<WorkspaceMount>(`${ws(workspaceId)}/services/${encodeURIComponent(serviceId)}/layout`, {
-        method: 'PATCH',
+      send(updateServiceMountLayoutContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { serviceId },
         body,
       }),
   }

package/app/composables/api/releaseHealth.ts

@@ -1,61 +1,63 @@
+import {
+  deleteIncidentEnrichmentContract,
+  deleteObservabilityConnectionContract,
+  deleteReleaseHealthConfigContract,
+  getIncidentEnrichmentContract,
+  getObservabilityConnectionContract,
+  listReleaseHealthConfigsContract,
+  setIncidentEnrichmentContract,
+  setObservabilityConnectionContract,
+  upsertReleaseHealthConfigContract,
+} from '@cat-factory/contracts'
 import type {
-  ObservabilityConnectionView,
-  ReleaseHealthConfig,
   UpsertObservabilityConnectionInput,
   UpsertReleaseHealthConfigInput,
 } from '~/types/releaseHealth'
-import type {
-  IncidentEnrichmentView,
-  UpsertIncidentEnrichmentInput,
-} from '~/types/incidentEnrichment'
+import type { UpsertIncidentEnrichmentInput } from '~/types/incidentEnrichment'
 import type { ApiContext } from './context'
 
 /** Post-release-health: the observability connection + per-block monitor/SLO mapping. */
-export function releaseHealthApi({ http, ws }: ApiContext) {
+export function releaseHealthApi({ send, ws }: ApiContext) {
   return {
     // ---- Observability connection ------------------------------------------
     getObservabilityConnection: (workspaceId: string) =>
-      http<ObservabilityConnectionView>(`${ws(workspaceId)}/observability/connection`),
+      send(getObservabilityConnectionContract, { pathPrefix: ws(workspaceId) }),
 
     setObservabilityConnection: (workspaceId: string, body: UpsertObservabilityConnectionInput) =>
-      http<ObservabilityConnectionView>(`${ws(workspaceId)}/observability/connection`, {
-        method: 'PUT',
-        body,
-      }),
+      send(setObservabilityConnectionContract, { pathPrefix: ws(workspaceId), body }),
 
     deleteObservabilityConnection: (workspaceId: string) =>
-      http(`${ws(workspaceId)}/observability/connection`, { method: 'DELETE' }),
+      send(deleteObservabilityConnectionContract, { pathPrefix: ws(workspaceId) }),
 
     // ---- Per-block monitor/SLO config --------------------------------------
     listReleaseHealthConfigs: (workspaceId: string) =>
-      http<ReleaseHealthConfig[]>(`${ws(workspaceId)}/release-health-configs`),
+      send(listReleaseHealthConfigsContract, { pathPrefix: ws(workspaceId) }),
 
     upsertReleaseHealthConfig: (
       workspaceId: string,
       blockId: string,
       body: UpsertReleaseHealthConfigInput,
     ) =>
-      http<ReleaseHealthConfig>(
-        `${ws(workspaceId)}/release-health-configs/${encodeURIComponent(blockId)}`,
-        { method: 'PUT', body },
-      ),
+      send(upsertReleaseHealthConfigContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
+        body,
+      }),
 
     deleteReleaseHealthConfig: (workspaceId: string, blockId: string) =>
-      http(`${ws(workspaceId)}/release-health-configs/${encodeURIComponent(blockId)}`, {
-        method: 'DELETE',
+      send(deleteReleaseHealthConfigContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { blockId },
       }),
 
     // ---- Incident enrichment (PagerDuty + incident.io, write-only secrets) --
     getIncidentEnrichment: (workspaceId: string) =>
-      http<IncidentEnrichmentView>(`${ws(workspaceId)}/incident-enrichment`),
+      send(getIncidentEnrichmentContract, { pathPrefix: ws(workspaceId) }),
 
     setIncidentEnrichment: (workspaceId: string, body: UpsertIncidentEnrichmentInput) =>
-      http<IncidentEnrichmentView>(`${ws(workspaceId)}/incident-enrichment`, {
-        method: 'PUT',
-        body,
-      }),
+      send(setIncidentEnrichmentContract, { pathPrefix: ws(workspaceId), body }),
 
     deleteIncidentEnrichment: (workspaceId: string) =>
-      http(`${ws(workspaceId)}/incident-enrichment`, { method: 'DELETE' }),
+      send(deleteIncidentEnrichmentContract, { pathPrefix: ws(workspaceId) }),
   }
 }