@astrale-domains/services 0.4.5 → 0.4.7

package/dist/schema/modules/deployment/classes/cloudflare-deployment.d.ts

@@ -0,0 +1,463 @@
+export declare const CloudflareDeployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly description: "One Deployment uploaded as the Workers for Platforms script its label names.";
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+        readonly abstract: true;
+        readonly description: "One immutable deployment of a release on a publisher line.";
+        readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+        readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+        readonly properties: {
+            label: import("zod").ZodString;
+            url: import("zod").ZodString;
+            state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
+                readonly deploying: {
+                    readonly activate: "active";
+                    readonly fail: "failed";
+                };
+                readonly active: {
+                    readonly retire: "retiring";
+                };
+                readonly retiring: {
+                    readonly completeRetirement: "retired";
+                };
+                readonly retired: {
+                    readonly revive: "deploying";
+                };
+                readonly failed: {
+                    readonly retry: "deploying";
+                    readonly retire: "retiring";
+                };
+            }, "deploying">, {
+                required?: boolean;
+                description?: string;
+            }>;
+            retention: import("zod").ZodEnum<{
+                preview: "preview";
+                published: "published";
+            }>;
+            record: import("zod").ZodObject<{
+                format: import("zod").ZodLiteral<"astrale.deployment-record">;
+                version: import("zod").ZodLiteral<1>;
+                origin: import("zod").ZodString;
+                environment: import("zod").ZodString;
+                releaseDigest: import("zod").ZodString;
+                buildDigest: import("zod").ZodString;
+                schemaRevision: import("zod").ZodString;
+                configuration: import("zod").ZodString;
+                providerScript: import("zod").ZodString;
+                commit: import("zod").ZodNullable<import("zod").ZodObject<{
+                    sha: import("zod").ZodString;
+                    dirty: import("zod").ZodBoolean;
+                    base: import("zod").ZodOptional<import("zod").ZodObject<{
+                        version: import("zod").ZodString;
+                        distance: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>;
+            configuration: import("zod").ZodObject<{
+                format: import("zod").ZodLiteral<"astrale.deployment.configuration">;
+                version: import("zod").ZodLiteral<1>;
+                vars: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                settings: import("zod").ZodObject<{
+                    maximumRequestBytes: import("zod").ZodNumber;
+                    invocationTimeoutMs: import("zod").ZodNumber;
+                    tokenExchange: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                        maximumLifetimeSeconds: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strict>]>;
+                    durableOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                        retentionMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                            initialIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            maxAttempts: import("zod").ZodOptional<import("zod").ZodNumber>;
+                            maxIntervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strict>>;
+                        stepTimeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>;
+                runtime: import("zod").ZodObject<{
+                    compatibilityDate: import("zod").ZodString;
+                    compatibilityFlags: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>;
+                bindings: import("zod").ZodObject<{
+                    services: import("zod").ZodArray<import("zod").ZodObject<{
+                        name: import("zod").ZodString;
+                        service: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                    dispatchNamespaces: import("zod").ZodArray<import("zod").ZodObject<{
+                        name: import("zod").ZodString;
+                        namespace: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>>;
+                    secrets: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>;
+                router: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<false>, import("zod").ZodObject<{
+                    service: import("zod").ZodString;
+                    hostSuffix: import("zod").ZodString;
+                    minLabels: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strict>]>;
+            }, import("zod/v4/core").$strict>;
+            secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                digest: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>, {
+                readonly required: false;
+            }>;
+            scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                readonly required: false;
+            }>;
+            signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                readonly required: false;
+            }>;
+            activatedAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                readonly type: 'string';
+                readonly 'x-astrale-value-kind': 'instant';
+            }>, {
+                readonly required: false;
+            }>;
+            lastCallAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                readonly type: 'string';
+                readonly 'x-astrale-value-kind': 'instant';
+            }>, {
+                readonly required: false;
+            }>;
+            expiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                readonly type: 'string';
+                readonly 'x-astrale-value-kind': 'instant';
+            }>, {
+                readonly required: false;
+            }>;
+            retiredAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                readonly type: 'string';
+                readonly 'x-astrale-value-kind': 'instant';
+            }>, {
+                readonly required: false;
+            }>;
+            retirement: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodEnum<{
+                expired: "expired";
+                withdrawn: "withdrawn";
+            }>, {
+                readonly required: false;
+            }>;
+            operationReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
+                readonly required: false;
+            }>;
+            operationExpiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
+                readonly type: 'string';
+                readonly 'x-astrale-value-kind': 'instant';
+            }>, {
+                readonly required: false;
+            }>;
+        };
+        readonly methods: {
+            setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                name: string;
+                value: string;
+            }, {
+                readonly mode: 'value';
+                readonly value: {
+                    name: string;
+                } | {
+                    kind: "rejected";
+                    reason: "secret-undeclared" | "service-unavailable";
+                    message: string;
+                    retryAfter?: string | undefined;
+                };
+            }, "authenticated", false, true, undefined>>;
+            secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+                readonly mode: 'value';
+                readonly value: string[];
+            }, "authenticated", false, true, undefined>>;
+        };
+    }>];
+    readonly methods: {
+        deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            format: "astrale.services.deployment-request";
+            version: 1;
+            organization?: string | undefined;
+            origin: string;
+            environment: string;
+            addressing: "opaque" | "readable";
+            label: string;
+            buildDigest: string;
+            configuration: {
+                format: "astrale.deployment.configuration";
+                version: 1;
+                vars: Record<string, string>;
+                settings: {
+                    maximumRequestBytes: number;
+                    invocationTimeoutMs: number;
+                    tokenExchange: false | {
+                        maximumLifetimeSeconds: number;
+                    };
+                    durableOptions?: {
+                        retentionMs?: number | undefined;
+                        retry?: {
+                            initialIntervalMs?: number | undefined;
+                            maxAttempts?: number | undefined;
+                            maxIntervalMs?: number | undefined;
+                        } | undefined;
+                        stepTimeoutMs?: number | undefined;
+                    } | undefined;
+                };
+                runtime: {
+                    compatibilityDate: string;
+                    compatibilityFlags: string[];
+                };
+                bindings: {
+                    services: {
+                        name: string;
+                        service: string;
+                    }[];
+                    dispatchNamespaces: {
+                        name: string;
+                        namespace: string;
+                    }[];
+                    secrets: string[];
+                };
+                router: false | {
+                    service: string;
+                    hostSuffix: string;
+                    minLabels: number;
+                };
+            };
+            record: {
+                releaseDigest: string;
+                schemaRevision: string;
+                schemaBundle: string;
+                commit: {
+                    sha: string;
+                    dirty: boolean;
+                    base?: {
+                        version: string;
+                        distance: number;
+                    } | undefined;
+                } | null;
+            };
+            bundle: {
+                entrypoint: string;
+                modules: ({
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                    content: {
+                        encoding: "gzip" | "identity";
+                        decodedSize: number;
+                        contentBase64: string;
+                    } | {
+                        encoding: "gzip" | "identity";
+                        decodedSize: number;
+                        contentBase64Chunks: string[];
+                    };
+                } | {
+                    contentBase64: string;
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                } | {
+                    contentBase64Chunks: string[];
+                    name: string;
+                    kind?: "data" | "esm" | "text" | "wasm" | undefined;
+                })[];
+                assets?: {
+                    files: ({
+                        path: string;
+                        contentType?: string | undefined;
+                        content: {
+                            encoding: "gzip" | "identity";
+                            decodedSize: number;
+                            contentBase64: string;
+                        } | {
+                            encoding: "gzip" | "identity";
+                            decodedSize: number;
+                            contentBase64Chunks: string[];
+                        };
+                    } | {
+                        contentBase64: string;
+                        path: string;
+                        contentType?: string | undefined;
+                    } | {
+                        contentBase64Chunks: string[];
+                        path: string;
+                        contentType?: string | undefined;
+                    })[];
+                    notFound?: "404-page" | "none" | "single-page-application" | undefined;
+                    runWorkerFirst?: boolean | undefined;
+                    htmlHandling?: "none" | undefined;
+                } | undefined;
+            };
+            secrets: Record<string, string>;
+            readiness?: {
+                paths: string[];
+            } | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "rejected";
+                reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "line-owned-elsewhere" | "service-unavailable";
+                message: string;
+                retryAfter?: string | undefined;
+            } | {
+                kind: "deployed";
+                state: "created" | "reused";
+                secrets: {
+                    state: "bound" | "unchanged" | "updated";
+                };
+                deployment: {
+                    id: string;
+                    url: string;
+                    label: string;
+                    line: string;
+                    owner: string;
+                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                    retention: "preview" | "published";
+                    createdAt: string;
+                    lastCallAt?: string | undefined;
+                    expiresAt?: string | undefined;
+                    retiredAt?: string | undefined;
+                    retirement?: "expired" | "withdrawn" | undefined;
+                    signingKeyId: string;
+                    record: {
+                        format: "astrale.deployment-record";
+                        version: 1;
+                        origin: string;
+                        environment: string;
+                        releaseDigest: string;
+                        buildDigest: string;
+                        schemaRevision: string;
+                        configuration: string;
+                        providerScript: string;
+                        commit: {
+                            sha: string;
+                            dirty: boolean;
+                            base?: {
+                                version: string;
+                                distance: number;
+                            } | undefined;
+                        } | null;
+                    };
+                };
+            };
+        }, "authenticated", true, false, undefined>>;
+        hosting: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                routingDomain: string;
+                addressing: "opaque" | "readable";
+            };
+        }, "authenticated", true, false, undefined>>;
+        list: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            origin?: string | undefined;
+            environment?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                deployments: ({
+                    id: string;
+                    url: string;
+                    label: string;
+                    line: string;
+                    owner: string;
+                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                    retention: "preview" | "published";
+                    createdAt: string;
+                    lastCallAt?: string | undefined;
+                    expiresAt?: string | undefined;
+                    retiredAt?: string | undefined;
+                    retirement?: "expired" | "withdrawn" | undefined;
+                    signingKeyId: string;
+                    record: {
+                        format: "astrale.deployment-record";
+                        version: 1;
+                        origin: string;
+                        environment: string;
+                        releaseDigest: string;
+                        buildDigest: string;
+                        schemaRevision: string;
+                        configuration: string;
+                        providerScript: string;
+                        commit: {
+                            sha: string;
+                            dirty: boolean;
+                            base?: {
+                                version: string;
+                                distance: number;
+                            } | undefined;
+                        } | null;
+                    };
+                } | {
+                    id: string;
+                    url: string;
+                    label: string;
+                    line: string;
+                    owner: string;
+                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                    retention: "preview" | "published";
+                    createdAt: string;
+                    lastCallAt?: string | undefined;
+                    expiresAt?: string | undefined;
+                    retiredAt?: string | undefined;
+                    retirement?: "expired" | "withdrawn" | undefined;
+                    signingKeyId: string;
+                    record: unknown;
+                })[];
+            };
+        }, "authenticated", true, false, undefined>>;
+        setSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            name: string;
+            value: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                name: string;
+            } | {
+                kind: "rejected";
+                reason: "secret-undeclared" | "service-unavailable";
+                message: string;
+                retryAfter?: string | undefined;
+            };
+        }, "authenticated", false, false, undefined>>;
+        secrets: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: string[];
+        }, "authenticated", false, false, undefined>>;
+        lastCalls: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            labels: string[];
+        }, {
+            readonly mode: 'value';
+            readonly value: Record<string, string | null>;
+        }, "authenticated", true, false, undefined>>;
+        expirePreviews: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            limit?: number | undefined;
+            apply?: boolean | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                planned: string[];
+                retired: string[];
+                pending: string[];
+            };
+        }, "authenticated", true, false, undefined>>;
+        retain: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            label: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                retention: "published";
+            };
+        }, "authenticated", true, false, undefined>>;
+        retire: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "retired";
+            } | {
+                kind: "retiring";
+                retryAfterMs: number;
+            } | {
+                kind: "rejected";
+                reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "line-owned-elsewhere" | "service-unavailable";
+                message: string;
+                retryAfter?: string | undefined;
+            };
+        }, "authenticated", false, false, undefined>>;
+    };
+    readonly policies: {
+        read: () => import("@astrale-os/sdk/schema").Policy;
+    };
+}>;

package/dist/schema/modules/deployment/classes/cloudflare-deployment.js

@@ -0,0 +1,30 @@
+import { classIcon, nodeClass } from '@astrale-os/sdk/schema';
+import { CloudUpload } from '@astrale-os/sdk/schema/icons';
+import { deployCloudflareDeployment } from '../functions/deploy-cloudflare-deployment.js';
+import { describeDeploymentHosting } from '../functions/describe-deployment-hosting.js';
+import { expireDeploymentPreviews } from '../functions/expire-deployment-previews.js';
+import { listCloudflareDeploymentSecretNames } from '../functions/list-cloudflare-deployment-secret-names.js';
+import { listCloudflareDeployments } from '../functions/list-cloudflare-deployments.js';
+import { readDeploymentLastCalls } from '../functions/read-deployment-last-calls.js';
+import { retainDeployment } from '../functions/retain-deployment.js';
+import { retireDeployment } from '../functions/retire-deployment.js';
+import { setCloudflareDeploymentSecret } from '../functions/set-cloudflare-deployment-secret.js';
+import { OwnDeployment } from '../policies/own-deployment.js';
+import { Deployment } from './deployment.js';
+export const CloudflareDeployment = nodeClass({
+    description: 'One Deployment uploaded as the Workers for Platforms script its label names.',
+    icon: classIcon.lucide(CloudUpload),
+    extends: [Deployment],
+    methods: {
+        deploy: deployCloudflareDeployment,
+        hosting: describeDeploymentHosting,
+        list: listCloudflareDeployments,
+        setSecret: setCloudflareDeploymentSecret,
+        secrets: listCloudflareDeploymentSecretNames,
+        lastCalls: readDeploymentLastCalls,
+        expirePreviews: expireDeploymentPreviews,
+        retain: retainDeployment,
+        retire: retireDeployment,
+    },
+    policies: { read: () => OwnDeployment },
+});

package/dist/schema/modules/deployment/classes/deployment-line.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * The line every deployment of one origin in one environment shares. The first organisation that
+ * deploys on it holds it, and only an operator transfer gives it to another: it stays registered
+ * and refused to every other organisation after its organisation, that organisation's Services or
+ * every deployment on it are deleted.
+ */
+export declare const DeploymentLine: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly description: "The deployment line of one origin in one environment, held by one organisation.";
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+    readonly properties: {
+        origin: z.ZodString;
+        environment: z.ZodString;
+        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the line. */
+        fingerprint: z.ZodString;
+        /** How the line reads in its deployments' labels: readable, or the fingerprint alone. */
+        line: z.ZodString;
+    };
+    readonly policies: {
+        read: () => import("@astrale-os/sdk/schema").Policy;
+    };
+}>;

package/dist/schema/modules/deployment/classes/deployment-line.js

@@ -0,0 +1,24 @@
+import { classIcon, fullMatch, K, nodeClass } from '@astrale-os/sdk/schema';
+import { GitBranch } from '@astrale-os/sdk/schema/icons';
+import { z } from 'zod';
+import { OwnLine } from '../policies/own-line.js';
+/**
+ * The line every deployment of one origin in one environment shares. The first organisation that
+ * deploys on it holds it, and only an operator transfer gives it to another: it stays registered
+ * and refused to every other organisation after its organisation, that organisation's Services or
+ * every deployment on it are deleted.
+ */
+export const DeploymentLine = nodeClass({
+    description: 'The deployment line of one origin in one environment, held by one organisation.',
+    icon: classIcon.lucide(GitBranch),
+    extends: [K.classes.Timestamped],
+    properties: {
+        origin: z.string().min(1).max(253),
+        environment: z.string().min(1).max(63),
+        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the line. */
+        fingerprint: z.string().check(fullMatch('[a-z2-7]{16}')),
+        /** How the line reads in its deployments' labels: readable, or the fingerprint alone. */
+        line: z.string().min(16).max(40),
+    },
+    policies: { read: () => OwnLine },
+});

package/dist/schema/modules/deployment/classes/deployment-on-line.d.ts

@@ -0,0 +1,17 @@
+/** The line one deployment was made on; a deployment never moves to another line. */
+export declare const deployment_on_line: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "deployment";
+        readonly outgoing: "1";
+    };
+    readonly target: {
+        readonly as: "line";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/deployment/classes/deployment-on-line.js

@@ -0,0 +1,11 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseOwnedLineDeployment } from '../policies/traverse-owned-line-deployment.js';
+import { DeploymentLine } from './deployment-line.js';
+import { Deployment } from './deployment.js';
+/** The line one deployment was made on; a deployment never moves to another line. */
+export const deployment_on_line = edgeClass.directed({
+    description: 'The deployment line one Deployment belongs to.',
+    source: { as: 'deployment', accepts: [() => Deployment], outgoing: '1' },
+    target: { as: 'line', accepts: [() => DeploymentLine], incoming: '0..*' },
+    policies: { traverse: () => TraverseOwnedLineDeployment },
+});