@astrale-domains/services 0.4.8 → 0.5.0

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

@@ -0,0 +1,321 @@
+/** One Service whose deployments are Workers for Platforms scripts. */
+export declare const CloudflareService: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+    readonly description: "One Service whose deployments are Cloudflare Workers for Platforms scripts.";
+    readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+    readonly extends: readonly [import("@astrale-os/sdk/schema").AuthoredNodeClass<{
+        readonly abstract: true;
+        readonly description: "One deployed Service: a stable name and URL serving its current deployment.";
+        readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
+        readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+        readonly properties: {
+            origin: import("zod").ZodString;
+            environment: import("zod").ZodString;
+            fingerprint: import("zod").ZodString;
+            url: import("zod").ZodString;
+            state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
+                readonly active: {
+                    readonly delete: "deleting";
+                };
+                readonly deleting: {};
+            }, "active">, {
+                required?: boolean;
+                description?: string;
+            }>;
+        };
+    }>];
+    readonly methods: {
+        deploy: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            format: "astrale.services.deployment-request";
+            version: 1;
+            owner?: string | undefined;
+            origin: string;
+            environment: string;
+            addressing: "opaque";
+            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[];
+                    };
+                }[];
+                assets?: {
+                    files: {
+                        path: string;
+                        contentType?: string | undefined;
+                        content: {
+                            encoding: "gzip" | "identity";
+                            decodedSize: number;
+                            contentBase64: string;
+                        } | {
+                            encoding: "gzip" | "identity";
+                            decodedSize: number;
+                            contentBase64Chunks: string[];
+                        };
+                    }[];
+                    notFound?: "404-page" | "none" | "single-page-application" | undefined;
+                    runWorkerFirst?: boolean | undefined;
+                    htmlHandling?: "none" | undefined;
+                } | undefined;
+            };
+            secrets: Record<string, string>;
+            promote?: boolean | undefined;
+            readiness?: {
+                paths: string[];
+            } | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "rejected";
+                reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "service-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;
+                    serviceId: string;
+                    service: string;
+                    owner: string;
+                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                    current: boolean;
+                    createdAt: string;
+                    retiredAt?: string | 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";
+            };
+        }, "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;
+                    serviceId: string;
+                    service: string;
+                    owner: string;
+                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                    current: boolean;
+                    createdAt: string;
+                    retiredAt?: string | 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;
+                    serviceId: string;
+                    service: string;
+                    owner: string;
+                    state: "active" | "deploying" | "failed" | "retired" | "retiring";
+                    current: boolean;
+                    createdAt: string;
+                    retiredAt?: string | undefined;
+                    signingKeyId: string;
+                    record: unknown;
+                })[];
+            };
+        }, "authenticated", true, false, undefined>>;
+        promote: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            label: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "rejected";
+                reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "service-owned-elsewhere" | "service-unavailable";
+                message: string;
+                retryAfter?: string | undefined;
+            } | {
+                current: string;
+            };
+        }, "authenticated", false, false, undefined>>;
+        transfer: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            owner: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "rejected";
+                reason: "address-mismatch" | "build-mismatch" | "deployment-conflict" | "deployment-retired" | "hosting-unavailable" | "invalid-deployment" | "service-owned-elsewhere" | "service-unavailable";
+                message: string;
+                retryAfter?: string | undefined;
+            } | {
+                owner: string;
+            };
+        }, "authenticated", false, 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>>;
+        setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            crons: string[];
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                crons: string[];
+            } | {
+                kind: "rejected";
+                reason: "invalid-schedule" | "service-unavailable";
+            };
+        }, "authenticated", false, false, undefined>>;
+        schedules: 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>>;
+        logs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            label?: string | undefined;
+            tail?: number | undefined;
+            since?: number | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                ts: number;
+                level: string;
+                line: string;
+            }[];
+        }, "authenticated", false, false, undefined>>;
+        delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+            readonly mode: 'value';
+            readonly value: {
+                kind: "deleted";
+            } | {
+                kind: "deleting";
+                retryAfterMs: number;
+            };
+        }, "authenticated", false, false, undefined>>;
+    };
+    readonly policies: {
+        read: () => import("@astrale-os/sdk/schema").Policy;
+    };
+}>;

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

@@ -0,0 +1,35 @@
+import { classIcon, nodeClass } from '@astrale-os/sdk/schema';
+import { CloudCog } from '@astrale-os/sdk/schema/icons';
+import { deleteService } from '../functions/delete-service.js';
+import { deployService } from '../functions/deploy-service.js';
+import { describeHosting } from '../functions/describe-hosting.js';
+import { listServiceDeployments } from '../functions/list-service-deployments.js';
+import { listServiceLogs } from '../functions/list-service-logs.js';
+import { listServiceSchedules } from '../functions/list-service-schedules.js';
+import { listServiceSecretNames } from '../functions/list-service-secret-names.js';
+import { promoteService } from '../functions/promote-service.js';
+import { replaceServiceSchedules } from '../functions/replace-service-schedules.js';
+import { setServiceSecret } from '../functions/set-service-secret.js';
+import { transferService } from '../functions/transfer-service.js';
+import { OwnService } from '../policies/own-service.js';
+import { Service } from './service.js';
+/** One Service whose deployments are Workers for Platforms scripts. */
+export const CloudflareService = nodeClass({
+    description: 'One Service whose deployments are Cloudflare Workers for Platforms scripts.',
+    icon: classIcon.lucide(CloudCog),
+    extends: [Service],
+    methods: {
+        deploy: deployService,
+        hosting: describeHosting,
+        list: listServiceDeployments,
+        promote: promoteService,
+        transfer: transferService,
+        setSecret: setServiceSecret,
+        secrets: listServiceSecretNames,
+        setSchedule: replaceServiceSchedules,
+        schedules: listServiceSchedules,
+        logs: listServiceLogs,
+        delete: deleteService,
+    },
+    policies: { read: () => OwnService },
+});

package/dist/schema/modules/service/classes/index.d.ts

@@ -1,3 +1,3 @@
-export { CloudflareWorker } from './cloudflare-worker.js';
+export { CloudflareService } from './cloudflare-service.js';
 export { Service } from './service.js';
 export { service_owned_by } from './service-owned-by.js';

package/dist/schema/modules/service/classes/index.js

@@ -1,3 +1,3 @@
-export { CloudflareWorker } from './cloudflare-worker.js';
+export { CloudflareService } from './cloudflare-service.js';
 export { Service } from './service.js';
 export { service_owned_by } from './service-owned-by.js';

package/dist/schema/modules/service/classes/service.d.ts

@@ -1,120 +1,31 @@
 import { z } from 'zod';
-/** Provider-neutral deployed resource. Provider implementation versions are deliberately external. */
+/**
+ * One deployed Service: the stable identity of one origin in one environment, owned by one
+ * Identity. Every deploy adds an immutable Deployment of it, and its URL serves the one it
+ * currently points at. Its `name` derives from the origin and the environment: it is the DNS label
+ * of the Service and the prefix of each deployment's label, unique among Services, and free again
+ * once the Service is deleted.
+ */
 export declare const Service: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly abstract: true;
-    readonly description: "One caller-owned provider-neutral deployed Service.";
+    readonly description: "One deployed Service: a stable name and URL serving its current deployment.";
     readonly icon: import("@astrale-os/sdk/schema").ClassIcon;
-    readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
+    readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
-        providerName: z.ZodString;
-        serviceKey: z.ZodString;
-        url: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
+        origin: z.ZodString;
+        environment: z.ZodString;
+        /** The 16-character fingerprint of `(origin, environment)`; it alone identifies the Service. */
+        fingerprint: z.ZodString;
+        /** `https://<name>.<routing domain>`: always serves the current deployment. */
+        url: z.ZodString;
         state: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
-            readonly deploying: {
-                readonly recordProviderDeployment: "reconciling";
-                readonly failDeployment: "failed";
-                readonly rejectDeployment: "ready";
-                readonly deleteService: "deleting";
-            };
-            readonly reconciling: {
-                readonly retryDeployment: "deploying";
-                readonly completeDeployment: "ready";
-                readonly deleteService: "deleting";
-            };
-            readonly ready: {
-                readonly redeploy: "deploying";
-                readonly deleteService: "deleting";
-            };
-            readonly failed: {
-                readonly retryDeployment: "deploying";
-                readonly deleteService: "deleting";
+            readonly active: {
+                readonly delete: "deleting";
             };
             readonly deleting: {};
-        }, "deploying">, {
+        }, "active">, {
             required?: boolean;
             description?: string;
         }>;
-        digest: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
-        deploymentReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            readonly required: false;
-        }>;
-        operationExpiresAt: import("@astrale-os/sdk/schema").AuthoredProperty<Readonly<{
-            readonly type: 'string';
-            readonly 'x-astrale-value-kind': 'instant';
-        }>, {
-            readonly required: false;
-        }>;
-        error: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
-            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: {
-                kind: "rejected";
-                reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-            } | {
-                name: string;
-            };
-        }, "authorized", false, true, undefined>>;
-        deleteSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-            name: string;
-        }, {
-            readonly mode: 'value';
-            readonly value: {
-                kind: "rejected";
-                reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
-            } | {
-                ok: true;
-            };
-        }, "authorized", 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[];
-        }, "authorized", false, true, undefined>>;
-        setSchedule: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-            crons: string[];
-        }, {
-            readonly mode: 'value';
-            readonly value: {
-                crons: string[];
-            } | {
-                kind: "rejected";
-                reason: "invalid-schedule" | "service-unavailable";
-            };
-        }, "authorized", false, true, undefined>>;
-        schedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-            readonly mode: 'value';
-            readonly value: string[];
-        }, "authorized", false, true, undefined>>;
-        logs: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
-            tail?: number | undefined;
-            since?: number | undefined;
-        }, {
-            readonly mode: 'value';
-            readonly value: {
-                id: string;
-                ts: number;
-                level: string;
-                line: string;
-            }[];
-        }, "authorized", false, true, undefined>>;
-        delete: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
-            readonly mode: 'value';
-            readonly value: {
-                kind: "deleted";
-            } | {
-                kind: "deleting";
-                retryAfterMs: number;
-            };
-        }, "authorized", false, true, undefined>>;
     };
 }>;

package/dist/schema/modules/service/classes/service.js

@@ -1,37 +1,26 @@
-import { classIcon, K, nodeClass, property, schema as valueSchema, stateProperty, } from '@astrale-os/sdk/schema';
+import { classIcon, fullMatch, K, nodeClass, stateProperty } from '@astrale-os/sdk/schema';
 import { Server } from '@astrale-os/sdk/schema/icons';
 import { z } from 'zod';
-import { deleteServiceSecret } from '../functions/delete-service-secret.js';
-import { deleteService } from '../functions/delete-service.js';
-import { listServiceLogs } from '../functions/list-service-logs.js';
-import { listServiceSchedules } from '../functions/list-service-schedules.js';
-import { listServiceSecretNames } from '../functions/list-service-secret-names.js';
-import { replaceServiceSchedules } from '../functions/replace-service-schedules.js';
-import { setServiceSecret } from '../functions/set-service-secret.js';
 import { serviceLifecycle } from '../states/index.js';
-/** Provider-neutral deployed resource. Provider implementation versions are deliberately external. */
+/**
+ * One deployed Service: the stable identity of one origin in one environment, owned by one
+ * Identity. Every deploy adds an immutable Deployment of it, and its URL serves the one it
+ * currently points at. Its `name` derives from the origin and the environment: it is the DNS label
+ * of the Service and the prefix of each deployment's label, unique among Services, and free again
+ * once the Service is deleted.
+ */
 export const Service = nodeClass({
     abstract: true,
-    description: 'One caller-owned provider-neutral deployed Service.',
+    description: 'One deployed Service: a stable name and URL serving its current deployment.',
     icon: classIcon.lucide(Server),
-    extends: [K.classes.Named, K.classes.Descriptable, K.classes.Timestamped],
+    extends: [K.classes.Named, K.classes.Timestamped],
     properties: {
-        providerName: z.string().min(1).max(120),
-        serviceKey: z.string().min(1).max(63),
-        url: property(z.string().min(1).max(2_048), { required: false }),
+        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 Service. */
+        fingerprint: z.string().check(fullMatch('[a-z2-7]{16}')),
+        /** `https://<name>.<routing domain>`: always serves the current deployment. */
+        url: z.string().min(1).max(2_048),
         state: stateProperty(serviceLifecycle),
-        digest: property(z.string().min(1).max(256), { required: false }),
-        deploymentReceipt: property(z.string().min(1).max(128), { required: false }),
-        operationExpiresAt: property(valueSchema.values.instant, { required: false }),
-        error: property(z.string().max(5_000), { required: false }),
-    },
-    methods: {
-        setSecret: setServiceSecret,
-        deleteSecret: deleteServiceSecret,
-        secrets: listServiceSecretNames,
-        setSchedule: replaceServiceSchedules,
-        schedules: listServiceSchedules,
-        logs: listServiceLogs,
-        delete: deleteService,
     },
 });

package/dist/schema/modules/service/errors/index.d.ts

@@ -0,0 +1 @@
+export { serviceNotFound } from './service-not-found.js';

package/dist/schema/modules/service/errors/index.js

@@ -0,0 +1 @@
+export { serviceNotFound } from './service-not-found.js';

package/dist/schema/modules/service/errors/service-not-found.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** Asked about a Service the caller does not own: another owner's Service is invisible to it. */
+export declare const serviceNotFound: Readonly<{
+    readonly family: "NOT_FOUND";
+    readonly message: "No Service the caller owns has this id.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

package/dist/schema/modules/service/errors/service-not-found.js

@@ -0,0 +1,8 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/** Asked about a Service the caller does not own: another owner's Service is invisible to it. */
+export const serviceNotFound = error({
+    family: 'NOT_FOUND',
+    message: 'No Service the caller owns has this id.',
+    details: z.strictObject({}),
+});

package/dist/schema/modules/service/functions/delete-service.d.ts

@@ -6,4 +6,4 @@ export declare const deleteService: import("@astrale-os/sdk/schema").Method<impo
         kind: "deleting";
         retryAfterMs: number;
     };
-}, "authorized", false, true, undefined>>;
+}, "authenticated", false, false, undefined>>;

package/dist/schema/modules/service/functions/delete-service.js

@@ -1,3 +1,3 @@
 import { method } from '@astrale-os/sdk/schema';
 import { deleteServiceContract } from '../types/service-management.js';
-export const deleteService = method({ ...deleteServiceContract, abstract: true });
+export const deleteService = method(deleteServiceContract);