@spacefast/common 0.0.13 → 0.0.18

package/dist/contracts/runtime-db.d.ts

@@ -0,0 +1,424 @@
+import { z } from "zod";
+/**
+ * The database surface, for whichever runtime a space is carrying.
+ *
+ * There is one database per space — the site's own MySQL — and at most one
+ * runtime with a claim on it, so these contracts are runtime-neutral by
+ * default. The two exceptions are stated explicitly: a migration plan is a
+ * capsule's declaration and no worker has one, and the console hand-off is a
+ * property of the wp.cloud site rather than of anything a version declared.
+ *
+ * The reads answer in the capsule's declaration shapes (`zeroTableSchema`,
+ * `zeroMigrationOperationSchema`) because a capsule's declared schema is the
+ * richest answer either runtime can give and a worker's is the same answer with
+ * the declaration-shaped fields empty. Those shapes stay Zero-named and stay in
+ * `./zero.js`: a declared table is the capsule's own statement about itself.
+ */
+export declare const runtimeDbInspectResponseSchema: z.ZodObject<{
+    versionId: z.ZodNullable<z.ZodString>;
+    artifactId: z.ZodNullable<z.ZodString>;
+    backend: z.ZodNullable<z.ZodLiteral<"wpcloud-mysql">>;
+    migrationMode: z.ZodNullable<z.ZodEnum<{
+        safe: "safe";
+        drop: "drop";
+        rename: "rename";
+    }>>;
+    schemaHash: z.ZodNullable<z.ZodString>;
+    tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                json: "json";
+            }>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>>;
+        indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    migrations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"create_table">;
+        table: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"add_column">;
+        table: z.ZodString;
+        column: z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                json: "json";
+            }>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"add_index">;
+        table: z.ZodString;
+        name: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"drop_index">;
+        table: z.ZodString;
+        name: z.ZodString;
+        explicit: z.ZodLiteral<"drop">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"drop_table">;
+        table: z.ZodString;
+        explicit: z.ZodLiteral<"drop">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"drop_column">;
+        table: z.ZodString;
+        column: z.ZodString;
+        explicit: z.ZodLiteral<"drop">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"rename_table">;
+        from: z.ZodString;
+        to: z.ZodString;
+        explicit: z.ZodLiteral<"rename">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"rename_column">;
+        table: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        explicit: z.ZodLiteral<"rename">;
+    }, z.core.$strict>], "op">>>;
+}, z.core.$strict>;
+export type RuntimeDbInspectResponse = z.infer<typeof runtimeDbInspectResponseSchema>;
+export declare const runtimeDbInspectPublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        versionId: z.ZodNullable<z.ZodString>;
+        artifactId: z.ZodNullable<z.ZodString>;
+        backend: z.ZodNullable<z.ZodLiteral<"wpcloud-mysql">>;
+        migrationMode: z.ZodNullable<z.ZodEnum<{
+            safe: "safe";
+            drop: "drop";
+            rename: "rename";
+        }>>;
+        schemaHash: z.ZodNullable<z.ZodString>;
+        tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    json: "json";
+                }>;
+                nullable: z.ZodDefault<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strict>>>;
+            indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                fields: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        migrations: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"create_table">;
+            table: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"add_column">;
+            table: z.ZodString;
+            column: z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    json: "json";
+                }>;
+                nullable: z.ZodDefault<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"add_index">;
+            table: z.ZodString;
+            name: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"drop_index">;
+            table: z.ZodString;
+            name: z.ZodString;
+            explicit: z.ZodLiteral<"drop">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"drop_table">;
+            table: z.ZodString;
+            explicit: z.ZodLiteral<"drop">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"drop_column">;
+            table: z.ZodString;
+            column: z.ZodString;
+            explicit: z.ZodLiteral<"drop">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"rename_table">;
+            from: z.ZodString;
+            to: z.ZodString;
+            explicit: z.ZodLiteral<"rename">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"rename_column">;
+            table: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            explicit: z.ZodLiteral<"rename">;
+        }, z.core.$strict>], "op">>>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const runtimeDbDumpQuerySchema: z.ZodObject<{
+    table: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const runtimeDbDumpTableSchema: z.ZodObject<{
+    name: z.ZodString;
+    rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+export declare const runtimeDbDumpResponseSchema: z.ZodObject<{
+    versionId: z.ZodNullable<z.ZodString>;
+    artifactId: z.ZodNullable<z.ZodString>;
+    schemaHash: z.ZodNullable<z.ZodString>;
+    tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RuntimeDbDumpResponse = z.infer<typeof runtimeDbDumpResponseSchema>;
+export declare const runtimeDbDumpPublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        versionId: z.ZodNullable<z.ZodString>;
+        artifactId: z.ZodNullable<z.ZodString>;
+        schemaHash: z.ZodNullable<z.ZodString>;
+        tables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            rows: z.ZodDefault<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const runtimeDbExportOrderingSchema: z.ZodObject<{
+    tables: z.ZodLiteral<"name_asc">;
+    rows: z.ZodLiteral<"created_at_id_asc">;
+}, z.core.$strict>;
+export declare const runtimeDbExportMetadataSchema: z.ZodObject<{
+    spaceId: z.ZodNullable<z.ZodString>;
+    versionId: z.ZodNullable<z.ZodString>;
+    schemaHash: z.ZodString;
+    consistency: z.ZodLiteral<"per_page">;
+    ordering: z.ZodObject<{
+        tables: z.ZodLiteral<"name_asc">;
+        rows: z.ZodLiteral<"created_at_id_asc">;
+    }, z.core.$strict>;
+    tables: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type RuntimeDbExportMetadata = z.infer<typeof runtimeDbExportMetadataSchema>;
+export declare const runtimeDbExportMetadataPublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        spaceId: z.ZodNullable<z.ZodString>;
+        versionId: z.ZodNullable<z.ZodString>;
+        schemaHash: z.ZodString;
+        consistency: z.ZodLiteral<"per_page">;
+        ordering: z.ZodObject<{
+            tables: z.ZodLiteral<"name_asc">;
+            rows: z.ZodLiteral<"created_at_id_asc">;
+        }, z.core.$strict>;
+        tables: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const runtimeDbExportPageQuerySchema: z.ZodObject<{
+    schemaHash: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const runtimeDbExportPageSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type RuntimeDbExportPage = z.infer<typeof runtimeDbExportPageSchema>;
+export declare const runtimeDbExportPagePublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        cursor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const runtimeDbMigrateResultSchema: z.ZodObject<{
+    versionId: z.ZodString;
+    runtimeKind: z.ZodLiteral<"zero">;
+    schemaHash: z.ZodNullable<z.ZodString>;
+    mode: z.ZodNullable<z.ZodEnum<{
+        safe: "safe";
+        drop: "drop";
+        rename: "rename";
+    }>>;
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"create_table">;
+        table: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"add_column">;
+        table: z.ZodString;
+        column: z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                json: "json";
+            }>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"add_index">;
+        table: z.ZodString;
+        name: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"drop_index">;
+        table: z.ZodString;
+        name: z.ZodString;
+        explicit: z.ZodLiteral<"drop">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"drop_table">;
+        table: z.ZodString;
+        explicit: z.ZodLiteral<"drop">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"drop_column">;
+        table: z.ZodString;
+        column: z.ZodString;
+        explicit: z.ZodLiteral<"drop">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"rename_table">;
+        from: z.ZodString;
+        to: z.ZodString;
+        explicit: z.ZodLiteral<"rename">;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"rename_column">;
+        table: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        explicit: z.ZodLiteral<"rename">;
+    }, z.core.$strict>], "op">>;
+    queued: z.ZodBoolean;
+}, z.core.$strict>;
+export type RuntimeDbMigrateResult = z.infer<typeof runtimeDbMigrateResultSchema>;
+export declare const runtimeDbMigrateResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        versionId: z.ZodString;
+        runtimeKind: z.ZodLiteral<"zero">;
+        schemaHash: z.ZodNullable<z.ZodString>;
+        mode: z.ZodNullable<z.ZodEnum<{
+            safe: "safe";
+            drop: "drop";
+            rename: "rename";
+        }>>;
+        operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"create_table">;
+            table: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"add_column">;
+            table: z.ZodString;
+            column: z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    json: "json";
+                }>;
+                nullable: z.ZodDefault<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"add_index">;
+            table: z.ZodString;
+            name: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"drop_index">;
+            table: z.ZodString;
+            name: z.ZodString;
+            explicit: z.ZodLiteral<"drop">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"drop_table">;
+            table: z.ZodString;
+            explicit: z.ZodLiteral<"drop">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"drop_column">;
+            table: z.ZodString;
+            column: z.ZodString;
+            explicit: z.ZodLiteral<"drop">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"rename_table">;
+            from: z.ZodString;
+            to: z.ZodString;
+            explicit: z.ZodLiteral<"rename">;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"rename_column">;
+            table: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            explicit: z.ZodLiteral<"rename">;
+        }, z.core.$strict>], "op">>;
+        queued: z.ZodBoolean;
+    }, z.core.$strict>;
+    operation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            canceled: "canceled";
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        progress: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            completed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strip>>;
+        diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                warning: "warning";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                registrar: "registrar";
+                wpcloud: "wpcloud";
+                dns: "dns";
+                runtime: "runtime";
+            }>>>;
+            details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const runtimeDbConsoleSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"wpcloud-phpmyadmin">;
+    url: z.ZodString;
+}, z.core.$strict>;
+export type RuntimeDbConsole = z.infer<typeof runtimeDbConsoleSchema>;
+export declare const runtimeDbConsoleResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        provider: z.ZodLiteral<"wpcloud-phpmyadmin">;
+        url: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;

package/dist/contracts/runtime-db.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { dataEnvelope, mutationEnvelope } from "./common.js";
+import { executionIdentifierSchema, executionSha256Schema } from "./execution.js";
+import { ZERO_RUNTIME_KIND, zeroMigrationOperationSchema, zeroTableSchema } from "./zero.js";
+/**
+ * The database surface, for whichever runtime a space is carrying.
+ *
+ * There is one database per space — the site's own MySQL — and at most one
+ * runtime with a claim on it, so these contracts are runtime-neutral by
+ * default. The two exceptions are stated explicitly: a migration plan is a
+ * capsule's declaration and no worker has one, and the console hand-off is a
+ * property of the wp.cloud site rather than of anything a version declared.
+ *
+ * The reads answer in the capsule's declaration shapes (`zeroTableSchema`,
+ * `zeroMigrationOperationSchema`) because a capsule's declared schema is the
+ * richest answer either runtime can give and a worker's is the same answer with
+ * the declaration-shaped fields empty. Those shapes stay Zero-named and stay in
+ * `./zero.js`: a declared table is the capsule's own statement about itself.
+ */
+export const runtimeDbInspectResponseSchema = z
+    .object({
+    versionId: z.string().min(1).nullable(),
+    artifactId: z.string().min(1).nullable(),
+    backend: z.literal("wpcloud-mysql").nullable(),
+    migrationMode: z.enum(["safe", "drop", "rename"]).nullable(),
+    schemaHash: executionSha256Schema.nullable(),
+    tables: z.array(zeroTableSchema).default([]),
+    migrations: z.array(zeroMigrationOperationSchema).default([]),
+})
+    .strict();
+export const runtimeDbInspectPublicResponseSchema = dataEnvelope(runtimeDbInspectResponseSchema);
+export const runtimeDbDumpQuerySchema = z
+    .object({
+    table: executionIdentifierSchema.optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(25),
+})
+    .strict();
+export const runtimeDbDumpTableSchema = z
+    .object({
+    name: executionIdentifierSchema,
+    rows: z.array(z.record(z.string(), z.unknown())).default([]),
+})
+    .strict();
+export const runtimeDbDumpResponseSchema = z
+    .object({
+    versionId: z.string().min(1).nullable(),
+    artifactId: z.string().min(1).nullable(),
+    schemaHash: executionSha256Schema.nullable(),
+    tables: z.array(runtimeDbDumpTableSchema).default([]),
+})
+    .strict();
+export const runtimeDbDumpPublicResponseSchema = dataEnvelope(runtimeDbDumpResponseSchema);
+export const runtimeDbExportOrderingSchema = z
+    .object({
+    tables: z.literal("name_asc"),
+    rows: z.literal("created_at_id_asc"),
+})
+    .strict();
+export const runtimeDbExportMetadataSchema = z
+    .object({
+    spaceId: z.string().min(1).nullable(),
+    versionId: z.string().min(1).nullable(),
+    schemaHash: executionSha256Schema,
+    consistency: z.literal("per_page"),
+    ordering: runtimeDbExportOrderingSchema,
+    tables: z.array(executionIdentifierSchema),
+})
+    .strict();
+export const runtimeDbExportMetadataPublicResponseSchema = dataEnvelope(runtimeDbExportMetadataSchema);
+export const runtimeDbExportPageQuerySchema = z
+    .object({
+    schemaHash: executionSha256Schema,
+    cursor: z.string().min(1).max(4_096).optional(),
+    limit: z.coerce.number().int().min(1).max(1_000).default(500),
+})
+    .strict();
+export const runtimeDbExportPageSchema = z
+    .object({
+    rows: z.array(z.record(z.string(), z.unknown())),
+    cursor: z.string().nullable(),
+})
+    .strict();
+export const runtimeDbExportPagePublicResponseSchema = dataEnvelope(runtimeDbExportPageSchema);
+export const runtimeDbMigrateResultSchema = z
+    .object({
+    versionId: z.string().min(1).describe("Live version whose migration plan this is."),
+    runtimeKind: z.literal(ZERO_RUNTIME_KIND),
+    schemaHash: executionSha256Schema.nullable(),
+    mode: z.enum(["safe", "drop", "rename"]).nullable(),
+    operations: z
+        .array(zeroMigrationOperationSchema)
+        .describe("The plan the live capsule declared, in the order it applies."),
+    queued: z
+        .boolean()
+        .describe("Whether runtime finalize was queued to apply the plan. `false` when the plan is empty because there is nothing to run."),
+})
+    .strict();
+export const runtimeDbMigrateResponseSchema = mutationEnvelope(runtimeDbMigrateResultSchema);
+export const runtimeDbConsoleSchema = z
+    .object({
+    provider: z.literal("wpcloud-phpmyadmin"),
+    url: z
+        .string()
+        .url()
+        .describe("Short-lived, single-use phpMyAdmin sign-in URL for the space MySQL. Treat it as a credential."),
+})
+    .strict();
+export const runtimeDbConsoleResponseSchema = dataEnvelope(runtimeDbConsoleSchema);

package/dist/contracts/runtime-storage.d.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+export declare const runtimeStorageVisibilitySchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+}>;
+export type RuntimeStorageVisibility = z.infer<typeof runtimeStorageVisibilitySchema>;
+export declare const runtimeStorageObjectIdSchema: z.ZodString;
+export declare const runtimeStorageObjectKeySchema: z.ZodString;
+export declare const runtimeStorageListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+}, z.core.$strict>;
+export declare const runtimeStorageObjectSchema: z.ZodObject<{
+    key: z.ZodString;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>;
+    contentType: z.ZodString;
+    createdAt: z.ZodString;
+    size: z.ZodNumber;
+    uploaderId: z.ZodString;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export type RuntimeStorageObject = z.infer<typeof runtimeStorageObjectSchema>;
+export declare const runtimeStorageListResponseSchema: z.ZodObject<{
+    objects: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        visibility: z.ZodEnum<{
+            public: "public";
+            private: "private";
+        }>;
+        contentType: z.ZodString;
+        createdAt: z.ZodString;
+        size: z.ZodNumber;
+        uploaderId: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+    cursor: z.ZodNullable<z.ZodString>;
+    hasMore: z.ZodBoolean;
+    usedBytes: z.ZodNumber;
+    quotaBytes: z.ZodNumber;
+}, z.core.$strict>;
+export type RuntimeStorageListResponse = z.infer<typeof runtimeStorageListResponseSchema>;
+export declare const runtimeStorageListPublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        objects: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            visibility: z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>;
+            contentType: z.ZodString;
+            createdAt: z.ZodString;
+            size: z.ZodNumber;
+            uploaderId: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>>;
+        cursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+        usedBytes: z.ZodNumber;
+        quotaBytes: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const runtimeStorageDeleteResponseSchema: z.ZodObject<{
+    key: z.ZodString;
+    deleted: z.ZodBoolean;
+}, z.core.$strict>;
+export type RuntimeStorageDeleteResponse = z.infer<typeof runtimeStorageDeleteResponseSchema>;
+export declare const runtimeStorageDeletePublicResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        key: z.ZodString;
+        deleted: z.ZodBoolean;
+    }, z.core.$strict>;
+    operation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            canceled: "canceled";
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        progress: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            completed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strip>>;
+        diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                warning: "warning";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                registrar: "registrar";
+                wpcloud: "wpcloud";
+                dns: "dns";
+                runtime: "runtime";
+            }>>>;
+            details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/contracts/runtime-storage.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { dataEnvelope, mutationEnvelope } from "./common.js";
+export const runtimeStorageVisibilitySchema = z.enum(["public", "private"]);
+export const runtimeStorageObjectIdSchema = z.string().regex(/^[a-f0-9]{32}$/);
+export const runtimeStorageObjectKeySchema = z.string().regex(/^(public|private)\/[a-f0-9]{32}$/);
+export const runtimeStorageListQuerySchema = z
+    .object({
+    cursor: z.string().min(1).max(2_048).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    visibility: runtimeStorageVisibilitySchema.optional(),
+})
+    .strict();
+export const runtimeStorageObjectSchema = z
+    .object({
+    key: runtimeStorageObjectKeySchema,
+    visibility: runtimeStorageVisibilitySchema,
+    contentType: z.string().min(1).max(255),
+    createdAt: z.string().datetime(),
+    size: z.number().int().nonnegative(),
+    uploaderId: z.string().min(1).max(255),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .strict();
+export const runtimeStorageListResponseSchema = z
+    .object({
+    objects: z.array(runtimeStorageObjectSchema),
+    cursor: z.string().nullable(),
+    hasMore: z.boolean(),
+    usedBytes: z.number().int().nonnegative(),
+    quotaBytes: z.number().int().positive(),
+})
+    .strict();
+export const runtimeStorageListPublicResponseSchema = dataEnvelope(runtimeStorageListResponseSchema);
+export const runtimeStorageDeleteResponseSchema = z
+    .object({
+    key: runtimeStorageObjectKeySchema,
+    deleted: z.boolean(),
+})
+    .strict();
+export const runtimeStorageDeletePublicResponseSchema = mutationEnvelope(runtimeStorageDeleteResponseSchema);