@marinoscar/platform-contract 0.1.0-next.3 → 0.1.0-next.4

package/dist/esm/db-backup/restore.d.ts

@@ -0,0 +1,405 @@
+import { z } from 'zod';
+import { type DbBackupEnum } from './constants.js';
+/**
+ * A restore gate id on the wire: any id matching {@link RESTORE_GATE_ID_PATTERN}
+ * (the eight built-ins and the ids an app registered with `registerRestoreGate`).
+ * An open vocabulary: it was a closed enum of the eight.
+ *
+ * @extensionPoint schema
+ * @stability experimental
+ */
+export declare const restoreGateIdSchema: z.ZodString;
+/**
+ * `POST /api/admin/db-backup/runs/:id/restore` body.
+ *
+ * @stability stable
+ */
+export declare const startRestoreRequestSchema: z.ZodObject<{
+    confirmation: z.ZodLiteral<"RESTORE">;
+    overrideSchemaCheck: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * The parsed body, after the global pipe has applied the default.
+ *
+ * @stability stable
+ */
+export type StartRestoreRequest = z.output<typeof startRestoreRequestSchema>;
+/**
+ * `POST /api/admin/db-backup/runs/:id/rollback` body.
+ *
+ * @stability stable
+ */
+export declare const rollbackRestoreRequestSchema: z.ZodObject<{
+    confirmation: z.ZodLiteral<"ROLLBACK">;
+}, z.core.$strip>;
+/**
+ * The parsed {@link rollbackRestoreRequestSchema}.
+ *
+ * @stability stable
+ */
+export type RollbackRestoreRequest = z.output<typeof rollbackRestoreRequestSchema>;
+/**
+ * One gate's finding.
+ *
+ * ⚠ EVERY GATE APPEARS, INCLUDING THE ONES THAT PASSED. An operator about to
+ * replace their production database is entitled to see WHAT WAS CHECKED, not
+ * only what failed — a list containing only failures gives no way to tell
+ * "checked, fine" from "never ran". #287's dialog renders the whole list.
+ *
+ * @stability stable
+ */
+export declare const restoreGateSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+    verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+    title: z.ZodString;
+    detail: z.ZodString;
+    action: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * What the restore's rollback story will be, after pre-flight has had its say.
+ *
+ * @stability stable
+ */
+export declare const restoreRollbackPlanSchema: z.ZodObject<{
+    configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+    effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+    downgraded: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The pre-flight verdict, minus its outcome-specific member.
+ *
+ * `guidance` and `block` are NOT repeated in here: they are hoisted to the top
+ * level of the response next to the `mode` that selects them, so a client
+ * narrows once rather than twice and a multi-line command block is never sent
+ * twice in one body.
+ *
+ * @stability stable
+ */
+export declare const restorePreflightSchema: z.ZodObject<{
+    outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+    runId: z.ZodUUID;
+    targetDatabase: z.ZodString;
+    scratchDatabase: z.ZodString;
+    oldDatabase: z.ZodString;
+    gates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+        verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+        title: z.ZodString;
+        detail: z.ZodString;
+        action: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    rollback: z.ZodObject<{
+        configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+        effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+        downgraded: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    archiveMigration: z.ZodNullable<z.ZodString>;
+    liveMigration: z.ZodNullable<z.ZodString>;
+    databaseSizeBytes: z.ZodNullable<z.ZodString>;
+    freeDiskBytes: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The parsed {@link restorePreflightSchema}.
+ *
+ * @stability stable
+ */
+export type RestorePreflightView = z.infer<typeof restorePreflightSchema>;
+/**
+ * `mode: "running"`: the gates passed and the restore is under way.
+ *
+ * @stability stable
+ */
+export declare const startRestoreRunningSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"running">;
+    runId: z.ZodUUID;
+    scratchDatabase: z.ZodString;
+    oldDatabase: z.ZodString;
+    preflight: z.ZodObject<{
+        outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+        runId: z.ZodUUID;
+        targetDatabase: z.ZodString;
+        scratchDatabase: z.ZodString;
+        oldDatabase: z.ZodString;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+            verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+            title: z.ZodString;
+            detail: z.ZodString;
+            action: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        rollback: z.ZodObject<{
+            configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+            effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+            downgraded: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        archiveMigration: z.ZodNullable<z.ZodString>;
+        liveMigration: z.ZodNullable<z.ZodString>;
+        databaseSizeBytes: z.ZodNullable<z.ZodString>;
+        freeDiskBytes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * `mode: "guided"`: this deployment cannot restore automatically; here is how a human can.
+ *
+ * @stability stable
+ */
+export declare const startRestoreGuidedSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"guided">;
+    runId: z.ZodUUID;
+    guidance: z.ZodObject<{
+        reason: z.ZodString;
+        commands: z.ZodString;
+        runbook: z.ZodString;
+    }, z.core.$strip>;
+    preflight: z.ZodObject<{
+        outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+        runId: z.ZodUUID;
+        targetDatabase: z.ZodString;
+        scratchDatabase: z.ZodString;
+        oldDatabase: z.ZodString;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+            verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+            title: z.ZodString;
+            detail: z.ZodString;
+            action: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        rollback: z.ZodObject<{
+            configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+            effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+            downgraded: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        archiveMigration: z.ZodNullable<z.ZodString>;
+        liveMigration: z.ZodNullable<z.ZodString>;
+        databaseSizeBytes: z.ZodNullable<z.ZodString>;
+        freeDiskBytes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * `mode: "blocked"`: a gate refused the restore.
+ *
+ * @stability stable
+ */
+export declare const startRestoreBlockedSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"blocked">;
+    runId: z.ZodUUID;
+    block: z.ZodObject<{
+        gateId: z.ZodString;
+        message: z.ZodString;
+        overridable: z.ZodBoolean;
+        overrideParameter: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    preflight: z.ZodObject<{
+        outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+        runId: z.ZodUUID;
+        targetDatabase: z.ZodString;
+        scratchDatabase: z.ZodString;
+        oldDatabase: z.ZodString;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+            verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+            title: z.ZodString;
+            detail: z.ZodString;
+            action: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        rollback: z.ZodObject<{
+            configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+            effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+            downgraded: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        archiveMigration: z.ZodNullable<z.ZodString>;
+        liveMigration: z.ZodNullable<z.ZodString>;
+        databaseSizeBytes: z.ZodNullable<z.ZodString>;
+        freeDiskBytes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * The three variants as one discriminated union — the RUNTIME contract and the
+ * TypeScript type.
+ *
+ * ⚠ `createZodDto` IS APPLIED TO EACH VARIANT, NOT TO THIS UNION, and it is not
+ * a stylistic choice: `createZodDto` builds a CLASS whose instance type is the
+ * schema's output, and a class cannot have a union instance type — TypeScript
+ * rejects it outright ("Base constructor return type is not an object type").
+ * So the union stays a schema and a type, and the OpenAPI document composes the
+ * three variant classes with `oneOf`. `openapi/data-envelope.ts` still wraps the
+ * result correctly because `ApiDataResponse` emits the `{ data: … }` envelope
+ * itself rather than relying on the later pass to recognise a composed schema.
+ *
+ * @stability stable
+ */
+export declare const startRestoreResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"running">;
+    runId: z.ZodUUID;
+    scratchDatabase: z.ZodString;
+    oldDatabase: z.ZodString;
+    preflight: z.ZodObject<{
+        outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+        runId: z.ZodUUID;
+        targetDatabase: z.ZodString;
+        scratchDatabase: z.ZodString;
+        oldDatabase: z.ZodString;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+            verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+            title: z.ZodString;
+            detail: z.ZodString;
+            action: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        rollback: z.ZodObject<{
+            configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+            effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+            downgraded: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        archiveMigration: z.ZodNullable<z.ZodString>;
+        liveMigration: z.ZodNullable<z.ZodString>;
+        databaseSizeBytes: z.ZodNullable<z.ZodString>;
+        freeDiskBytes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"guided">;
+    runId: z.ZodUUID;
+    guidance: z.ZodObject<{
+        reason: z.ZodString;
+        commands: z.ZodString;
+        runbook: z.ZodString;
+    }, z.core.$strip>;
+    preflight: z.ZodObject<{
+        outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+        runId: z.ZodUUID;
+        targetDatabase: z.ZodString;
+        scratchDatabase: z.ZodString;
+        oldDatabase: z.ZodString;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+            verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+            title: z.ZodString;
+            detail: z.ZodString;
+            action: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        rollback: z.ZodObject<{
+            configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+            effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+            downgraded: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        archiveMigration: z.ZodNullable<z.ZodString>;
+        liveMigration: z.ZodNullable<z.ZodString>;
+        databaseSizeBytes: z.ZodNullable<z.ZodString>;
+        freeDiskBytes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"blocked">;
+    runId: z.ZodUUID;
+    block: z.ZodObject<{
+        gateId: z.ZodString;
+        message: z.ZodString;
+        overridable: z.ZodBoolean;
+        overrideParameter: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    preflight: z.ZodObject<{
+        outcome: z.ZodEnum<DbBackupEnum<["ok", "guided", "blocked"]>>;
+        runId: z.ZodUUID;
+        targetDatabase: z.ZodString;
+        scratchDatabase: z.ZodString;
+        oldDatabase: z.ZodString;
+        gates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<DbBackupEnum<["capability", "disk", "replicas", "overridable", "app"]>>;
+            verdict: z.ZodEnum<DbBackupEnum<["pass", "warning", "block"]>>;
+            title: z.ZodString;
+            detail: z.ZodString;
+            action: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        rollback: z.ZodObject<{
+            configured: z.ZodEnum<DbBackupEnum<["retain_database", "drop_database"]>>;
+            effective: z.ZodEnum<DbBackupEnum<["retain_database", "pre_restore_dump"]>>;
+            downgraded: z.ZodBoolean;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        archiveMigration: z.ZodNullable<z.ZodString>;
+        liveMigration: z.ZodNullable<z.ZodString>;
+        databaseSizeBytes: z.ZodNullable<z.ZodString>;
+        freeDiskBytes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "mode">;
+/**
+ * The parsed {@link startRestoreResponseSchema}.
+ *
+ * @stability stable
+ */
+export type StartRestoreResponse = z.infer<typeof startRestoreResponseSchema>;
+/**
+ * `mode: "renamed"`: the displaced database was renamed back into place.
+ *
+ * @stability stable
+ */
+export declare const rollbackRenamedSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"renamed">;
+    runId: z.ZodUUID;
+    promoted: z.ZodString;
+    parked: z.ZodString;
+    detail: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `mode: "restore_started"`: the pre-restore safety dump is being restored instead.
+ *
+ * @stability stable
+ */
+export declare const rollbackRestoreStartedSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"restore_started">;
+    runId: z.ZodUUID;
+    preRestoreRunId: z.ZodUUID;
+    detail: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `mode: "unavailable"`: there is nothing to roll back to.
+ *
+ * @stability stable
+ */
+export declare const rollbackUnavailableSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"unavailable">;
+    runId: z.ZodUUID;
+    detail: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The three variants as one discriminated union. Split into classes for the same reason.
+ *
+ * @stability stable
+ */
+export declare const rollbackRestoreResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"renamed">;
+    runId: z.ZodUUID;
+    promoted: z.ZodString;
+    parked: z.ZodString;
+    detail: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"restore_started">;
+    runId: z.ZodUUID;
+    preRestoreRunId: z.ZodUUID;
+    detail: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"unavailable">;
+    runId: z.ZodUUID;
+    detail: z.ZodString;
+}, z.core.$strip>], "mode">;
+/**
+ * The parsed {@link rollbackRestoreResponseSchema}.
+ *
+ * @stability stable
+ */
+export type RollbackRestoreResponse = z.infer<typeof rollbackRestoreResponseSchema>;
+//# sourceMappingURL=restore.d.ts.map

package/dist/esm/db-backup/restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restore.d.ts","sourceRoot":"","sources":["../../../src/db-backup/restore.ts"],"names":[],"mappings":"AAgGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAwE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEzH;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,aAA4C,CAAC;AAO7E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;iBAsBpC,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;iBAUvC,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAMnF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBA6B5B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;iBAoBpC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;iBAqDjC,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAM1E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCnC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCpC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIrC,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;iBA0BhC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;iBA0BvC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;iBAqBpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;2BAIxC,CAAC;AAEH;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}