@spacefast/common 0.0.10 → 0.0.12

package/dist/contracts/publishes.js

@@ -1,162 +0,0 @@
-import { z } from "zod";
-import { registeredIdSchema } from "./ids.js";
-export const publishStates = [
-    "awaiting_upload",
-    "uploaded",
-    "parked",
-    "materializing",
-    "succeeded",
-    "failed",
-    "cancelled",
-    "expired",
-];
-export const publishStateSchema = z.enum(publishStates);
-export const publishIdSchema = registeredIdSchema("pub");
-const spaceIdSchema = registeredIdSchema("spc");
-const versionIdSchema = registeredIdSchema("ver");
-export const publishAdmissionSchema = z.object({
-    id: publishIdSchema,
-    idempotencyKey: z.string().min(1),
-    requestFingerprint: z.string().min(1),
-});
-const cancellableActionSchema = z.object({
-    kind: z.literal("cancel_publish"),
-    publishId: publishIdSchema,
-});
-export const publishSchema = z.discriminatedUnion("state", [
-    z
-        .object({
-        id: publishIdSchema,
-        state: z.literal("awaiting_upload"),
-        target: z
-            .object({
-            spaceId: spaceIdSchema,
-            baseVersionId: versionIdSchema.nullable(),
-        })
-            .optional(),
-        counts: z
-            .object({
-            received: z.number().int().nonnegative(),
-            missing: z.number().int().positive(),
-        })
-            .optional(),
-        expiresAt: z.string().datetime().optional(),
-        upload: z
-            .object({
-            missing: z
-                .array(z.object({
-                path: z.string(),
-                sha256: z
-                    .string()
-                    .regex(/^[0-9a-f]{64}$/)
-                    .nullable(),
-                size: z.number().int().nonnegative(),
-                url: z.string().url(),
-                headers: z.record(z.string(), z.string()),
-                expiresAt: z.string().datetime(),
-            }))
-                .min(1),
-        })
-            .optional(),
-    })
-        .refine((publish) => publish.counts === undefined ||
-        publish.upload === undefined ||
-        publish.counts.missing === publish.upload.missing.length, {
-        message: "Upload instructions must match the missing upload count.",
-        path: ["upload", "missing"],
-    })
-        .refine((publish) => publish.counts !== undefined || publish.upload !== undefined, {
-        message: "An awaiting_upload publish must carry counts or upload instructions.",
-        path: ["counts"],
-    }),
-    z.object({ id: publishIdSchema, state: z.literal("uploaded") }),
-    z
-        .object({
-        id: publishIdSchema,
-        state: z.literal("parked"),
-        reason: z.literal("capacity"),
-        queuePosition: z.number().int().positive().optional(),
-        nextCheckAfterSeconds: z.number().int().positive(),
-        actions: z.tuple([cancellableActionSchema]),
-    })
-        .refine((publish) => publish.actions.every((action) => action.publishId === publish.id), {
-        message: "Cancel actions must reference the enclosing publish.",
-        path: ["actions"],
-    }),
-    z.object({
-        id: publishIdSchema,
-        state: z.literal("materializing"),
-        operation: z.object({
-            id: registeredIdSchema("op"),
-            kind: z.literal("publish.finalize"),
-            status: z.enum(["queued", "running"]),
-        }),
-    }),
-    z.object({
-        id: publishIdSchema,
-        state: z.literal("succeeded"),
-        outcome: z.enum(["created", "updated", "unchanged"]),
-        capturedBaseVersionId: versionIdSchema.nullable().optional(),
-        claim: z
-            .object({
-            token: z.string().min(1),
-            url: z.string().url(),
-            expiresAt: z.string().datetime(),
-        })
-            .optional(),
-        result: z.object({
-            space: z.object({ id: spaceIdSchema, liveUrl: z.string().url() }),
-            version: z.object({ id: versionIdSchema, immutableUrl: z.string().url() }),
-            live: z.object({
-                previousVersionId: versionIdSchema.nullable(),
-                versionId: versionIdSchema,
-            }),
-        }),
-    }),
-    z.object({ id: publishIdSchema, state: z.literal("failed"), errorCode: z.string().min(1) }),
-    z.object({ id: publishIdSchema, state: z.literal("cancelled") }),
-    z.object({ id: publishIdSchema, state: z.literal("expired") }),
-]);
-// Cancellation may win during materialization only before the Version exists;
-// afterwards it is not cancelable and the outcome is unchanged.
-const allowedTransitions = {
-    awaiting_upload: ["uploaded", "cancelled", "expired"],
-    uploaded: ["parked", "materializing", "cancelled", "expired"],
-    parked: ["materializing", "cancelled", "expired"],
-    materializing: ["succeeded", "failed", "cancelled", "expired"],
-    succeeded: [],
-    failed: [],
-    cancelled: [],
-    expired: [],
-};
-export function canTransitionPublish(from, to) {
-    return allowedTransitions[from].some((candidate) => candidate === to);
-}
-export function transitionPublish(publish, next) {
-    if (publish.id !== next.id ||
-        publish.idempotencyKey !== next.idempotencyKey ||
-        publish.requestFingerprint !== next.requestFingerprint) {
-        throw new Error("A publish transition cannot change the durable publish identity.");
-    }
-    if (!canTransitionPublish(publish.state, next.state)) {
-        throw new Error(`Invalid publish transition: ${publish.state} -> ${next.state}`);
-    }
-    // Project through the wire schema so fields from the previous variant (e.g. a
-    // parked `reason` spread into a materializing publish) never leak downstream.
-    return {
-        ...publishSchema.parse(next),
-        idempotencyKey: next.idempotencyKey,
-        requestFingerprint: next.requestFingerprint,
-    };
-}
-export function convergePublishAdmission(existing, attempted) {
-    if (existing === undefined)
-        return { outcome: "created", publish: attempted };
-    if (existing.idempotencyKey !== attempted.idempotencyKey) {
-        throw new Error("Admission convergence requires one idempotency key.");
-    }
-    if (existing.requestFingerprint !== attempted.requestFingerprint) {
-        return { outcome: "conflict", publish: existing };
-    }
-    return { outcome: "replayed", publish: existing };
-}