@astrale-domains/services 0.4.6 → 0.4.7

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

@@ -2,7 +2,8 @@ import { z } from 'zod';
 /**
  * One immutable deployment of a release: one build in one environment with its frozen
  * configuration, served by one script at its own URL. It never changes code; a new release is a
- * new deployment on the same line.
+ * new deployment on the same line. Its secrets alone rotate in place, on this deployment only,
+ * and only under the names its configuration declares: a name added or removed is a new release.
  */
 export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly abstract: true;
@@ -29,6 +30,7 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
             };
             readonly failed: {
                 readonly retry: "deploying";
+                readonly retire: "retiring";
             };
         }, "deploying">, {
             required?: boolean;
@@ -57,9 +59,75 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
         }, z.core.$strict>;
+        /** The configuration frozen into this deployment; its digest is `record.configuration`. */
+        configuration: z.ZodObject<{
+            format: z.ZodLiteral<"astrale.deployment.configuration">;
+            version: z.ZodLiteral<1>;
+            vars: z.ZodRecord<z.ZodString, z.ZodString>;
+            settings: z.ZodObject<{
+                maximumRequestBytes: z.ZodNumber;
+                invocationTimeoutMs: z.ZodNumber;
+                tokenExchange: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+                    maximumLifetimeSeconds: z.ZodNumber;
+                }, z.core.$strict>]>;
+                durableOptions: z.ZodOptional<z.ZodObject<{
+                    retentionMs: z.ZodOptional<z.ZodNumber>;
+                    retry: z.ZodOptional<z.ZodObject<{
+                        initialIntervalMs: z.ZodOptional<z.ZodNumber>;
+                        maxAttempts: z.ZodOptional<z.ZodNumber>;
+                        maxIntervalMs: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                    stepTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                compatibilityDate: z.ZodString;
+                compatibilityFlags: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            bindings: z.ZodObject<{
+                services: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    service: z.ZodString;
+                }, z.core.$strict>>;
+                dispatchNamespaces: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    namespace: z.ZodString;
+                }, z.core.$strict>>;
+                secrets: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            router: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+                service: z.ZodString;
+                hostSuffix: z.ZodString;
+                minLabels: z.ZodNumber;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        /** The keyed digest of each secret bound to this deployment, never a value. */
+        secretDigests: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>, {
+            readonly required: false;
+        }>;
+        /**
+         * The provider's code hash of the script. With the artifact tag and the configuration digest it
+         * identifies the deployment; a secret rewritten in place keeps it, unlike a provider version.
+         */
+        scriptEtag: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
+            readonly required: false;
+        }>;
         signingKeyId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
             readonly required: false;
         }>;
+        /**
+         * The last time this deployment became active: its creation, or its revival after it expired.
+         * A preview's 30 days run from it or from its last call, whichever is later.
+         */
+        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';
@@ -84,7 +152,10 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
         }>, {
             readonly required: false;
         }>;
-        /** The graph lease of the provider operation in flight on this deployment. */
+        /**
+         * The graph lease of the provider operation in flight on this deployment: its creation, or an
+         * in-place rewrite of its secrets once it serves.
+         */
         operationReceipt: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
             readonly required: false;
         }>;
@@ -95,4 +166,24 @@ export declare const Deployment: import("@astrale-os/sdk/schema").AuthoredNodeCl
             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>>;
+    };
 }>;

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

@@ -1,12 +1,15 @@
 import { classIcon, K, nodeClass, property, schema as valueSchema, stateProperty, } from '@astrale-os/sdk/schema';
 import { Rocket } from '@astrale-os/sdk/schema/icons';
 import { z } from 'zod';
+import { listDeploymentSecretNames } from '../functions/list-deployment-secret-names.js';
+import { setDeploymentSecret } from '../functions/set-deployment-secret.js';
 import { deploymentLifecycle } from '../states/index.js';
-import { deploymentRecord, deploymentRetention, deploymentRetirement } from '../types/index.js';
+import { deploymentRecord, deploymentRetention, deploymentRetirement, deploymentSecretDigests, frozenConfiguration, } from '../types/index.js';
 /**
  * One immutable deployment of a release: one build in one environment with its frozen
  * configuration, served by one script at its own URL. It never changes code; a new release is a
- * new deployment on the same line.
+ * new deployment on the same line. Its secrets alone rotate in place, on this deployment only,
+ * and only under the names its configuration declares: a name added or removed is a new release.
  */
 export const Deployment = nodeClass({
     abstract: true,
@@ -20,13 +23,34 @@ export const Deployment = nodeClass({
         state: stateProperty(deploymentLifecycle),
         retention: deploymentRetention,
         record: deploymentRecord,
+        /** The configuration frozen into this deployment; its digest is `record.configuration`. */
+        configuration: frozenConfiguration,
+        /** The keyed digest of each secret bound to this deployment, never a value. */
+        secretDigests: property(deploymentSecretDigests, { required: false }),
+        /**
+         * The provider's code hash of the script. With the artifact tag and the configuration digest it
+         * identifies the deployment; a secret rewritten in place keeps it, unlike a provider version.
+         */
+        scriptEtag: property(z.string().min(1).max(128), { required: false }),
         signingKeyId: property(z.string().min(1).max(128), { required: false }),
+        /**
+         * The last time this deployment became active: its creation, or its revival after it expired.
+         * A preview's 30 days run from it or from its last call, whichever is later.
+         */
+        activatedAt: property(valueSchema.values.instant, { required: false }),
         lastCallAt: property(valueSchema.values.instant, { required: false }),
         expiresAt: property(valueSchema.values.instant, { required: false }),
         retiredAt: property(valueSchema.values.instant, { required: false }),
         retirement: property(deploymentRetirement, { required: false }),
-        /** The graph lease of the provider operation in flight on this deployment. */
+        /**
+         * The graph lease of the provider operation in flight on this deployment: its creation, or an
+         * in-place rewrite of its secrets once it serves.
+         */
         operationReceipt: property(z.string().min(1).max(128), { required: false }),
         operationExpiresAt: property(valueSchema.values.instant, { required: false }),
     },
+    methods: {
+        setSecret: setDeploymentSecret,
+        secrets: listDeploymentSecretNames,
+    },
 });

package/dist/schema/modules/deployment/errors/deployment-hosting-unavailable.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** Asked of a Services runtime that hosts no deployments: only Admin's Services host them. */
+export declare const deploymentHostingUnavailable: Readonly<{
+    readonly family: "UNSUPPORTED";
+    readonly message: "This Services runtime does not host deployments.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-hosting-unavailable.js

@@ -0,0 +1,8 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/** Asked of a Services runtime that hosts no deployments: only Admin's Services host them. */
+export const deploymentHostingUnavailable = error({
+    family: 'UNSUPPORTED',
+    message: 'This Services runtime does not host deployments.',
+    details: z.strictObject({}),
+});

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/**
+ * A label that names no deployment the caller may read: an unknown label and another
+ * organisation's deployment answer alike, so the answer never tells one from the other.
+ */
+export declare const deploymentLabelNotFound: Readonly<{
+    readonly family: "NOT_FOUND";
+    readonly message: "No deployment of yours has this label.";
+    readonly details: z.ZodObject<{
+        label: z.ZodString;
+    }, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-label-not-found.js

@@ -0,0 +1,11 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/**
+ * A label that names no deployment the caller may read: an unknown label and another
+ * organisation's deployment answer alike, so the answer never tells one from the other.
+ */
+export const deploymentLabelNotFound = error({
+    family: 'NOT_FOUND',
+    message: 'No deployment of yours has this label.',
+    details: z.strictObject({ label: z.string().min(1).max(63) }),
+});

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/**
+ * Asked about a deployment the caller does not hold: a deployment of a line held by another
+ * organisation is invisible to the caller, as its read Policy keeps it.
+ */
+export declare const deploymentNotFound: Readonly<{
+    readonly family: "NOT_FOUND";
+    readonly message: "No deployment of a line the caller holds has this id.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

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

@@ -0,0 +1,11 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/**
+ * Asked about a deployment the caller does not hold: a deployment of a line held by another
+ * organisation is invisible to the caller, as its read Policy keeps it.
+ */
+export const deploymentNotFound = error({
+    family: 'NOT_FOUND',
+    message: 'No deployment of a line the caller holds has this id.',
+    details: z.strictObject({}),
+});

package/dist/schema/modules/deployment/errors/deployment-registry-only.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/**
+ * Asked of retention by anyone but the registry Domain (`SERVICES_REGISTRY_ORIGIN`). Only the
+ * registry knows which releases are published, so a line holder cannot keep its own preview by
+ * marking it, and only the registry runs the expiry of every organisation's previews.
+ */
+export declare const deploymentRegistryOnly: Readonly<{
+    readonly family: "UNSUPPORTED";
+    readonly message: "Only the registry Domain marks deployments published and expires previews.";
+    readonly details: z.ZodObject<{}, z.core.$strict>;
+}>;

package/dist/schema/modules/deployment/errors/deployment-registry-only.js

@@ -0,0 +1,12 @@
+import { error } from '@astrale-os/sdk/schema/errors';
+import { z } from 'zod';
+/**
+ * Asked of retention by anyone but the registry Domain (`SERVICES_REGISTRY_ORIGIN`). Only the
+ * registry knows which releases are published, so a line holder cannot keep its own preview by
+ * marking it, and only the registry runs the expiry of every organisation's previews.
+ */
+export const deploymentRegistryOnly = error({
+    family: 'UNSUPPORTED',
+    message: 'Only the registry Domain marks deployments published and expires previews.',
+    details: z.strictObject({}),
+});

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

@@ -0,0 +1,4 @@
+export { deploymentHostingUnavailable } from './deployment-hosting-unavailable.js';
+export { deploymentLabelNotFound } from './deployment-label-not-found.js';
+export { deploymentNotFound } from './deployment-not-found.js';
+export { deploymentRegistryOnly } from './deployment-registry-only.js';

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

@@ -0,0 +1,4 @@
+export { deploymentHostingUnavailable } from './deployment-hosting-unavailable.js';
+export { deploymentLabelNotFound } from './deployment-label-not-found.js';
+export { deploymentNotFound } from './deployment-not-found.js';
+export { deploymentRegistryOnly } from './deployment-registry-only.js';

package/dist/schema/modules/deployment/functions/deploy-cloudflare-deployment.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Host one release as an immutable deployment on its publisher's line. Any authenticated identity
+ * may ask; the handler proves that it acts for the organisation it names before any write.
+ */
+export declare const deployCloudflareDeployment: 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: "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;
+            };
+        };
+    } | {
+        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", true, false, undefined>>;

package/dist/schema/modules/deployment/functions/deploy-cloudflare-deployment.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { deploymentRequest } from '../types/deployment-request.js';
+import { deploymentResponse } from '../types/deployment-response.js';
+/**
+ * Host one release as an immutable deployment on its publisher's line. Any authenticated identity
+ * may ask; the handler proves that it acts for the organisation it names before any write.
+ */
+export const deployCloudflareDeployment = method({
+    description: 'Host one release as an immutable deployment on its publisher line.',
+    auth: 'authenticated',
+    static: true,
+    input: deploymentRequest,
+    output: deploymentResponse,
+});

package/dist/schema/modules/deployment/functions/describe-deployment-hosting.d.ts

@@ -0,0 +1,8 @@
+/** Where this Services runtime addresses the deployments it hosts. */
+export declare const describeDeploymentHosting: 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>>;

package/dist/schema/modules/deployment/functions/describe-deployment-hosting.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { deploymentHosting } from '../types/deployment-hosting.js';
+/** Where this Services runtime addresses the deployments it hosts. */
+export const describeDeploymentHosting = method({
+    description: 'Describe the routing domain and line addressing of hosted deployments.',
+    auth: 'authenticated',
+    static: true,
+    input: z.strictObject({}),
+    output: deploymentHosting,
+});

package/dist/schema/modules/deployment/functions/expire-deployment-previews.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One pass of preview expiry over every line: a preview expires 30 days after its last call or
+ * its activation, whichever is later, and a published deployment never does. The pass is a plan
+ * unless the runtime enforces expiry. Only the registry Domain runs it.
+ */
+export declare const expireDeploymentPreviews: 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>>;

package/dist/schema/modules/deployment/functions/expire-deployment-previews.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { expirePreviewsInput, expirePreviewsOutput } from '../types/deployment-retention.js';
+/**
+ * One pass of preview expiry over every line: a preview expires 30 days after its last call or
+ * its activation, whichever is later, and a published deployment never does. The pass is a plan
+ * unless the runtime enforces expiry. Only the registry Domain runs it.
+ */
+export const expireDeploymentPreviews = method({
+    description: 'Plan, or where enforced apply, the expiry of previews uncalled for 30 days.',
+    auth: 'authenticated',
+    static: true,
+    input: expirePreviewsInput,
+    output: expirePreviewsOutput,
+});

package/dist/schema/modules/deployment/functions/index.d.ts

@@ -0,0 +1,11 @@
+export { deployCloudflareDeployment } from './deploy-cloudflare-deployment.js';
+export { describeDeploymentHosting } from './describe-deployment-hosting.js';
+export { expireDeploymentPreviews } from './expire-deployment-previews.js';
+export { listCloudflareDeployments } from './list-cloudflare-deployments.js';
+export { listCloudflareDeploymentSecretNames } from './list-cloudflare-deployment-secret-names.js';
+export { listDeploymentSecretNames } from './list-deployment-secret-names.js';
+export { readDeploymentLastCalls } from './read-deployment-last-calls.js';
+export { retainDeployment } from './retain-deployment.js';
+export { retireDeployment } from './retire-deployment.js';
+export { setCloudflareDeploymentSecret } from './set-cloudflare-deployment-secret.js';
+export { setDeploymentSecret } from './set-deployment-secret.js';

package/dist/schema/modules/deployment/functions/index.js

@@ -0,0 +1,11 @@
+export { deployCloudflareDeployment } from './deploy-cloudflare-deployment.js';
+export { describeDeploymentHosting } from './describe-deployment-hosting.js';
+export { expireDeploymentPreviews } from './expire-deployment-previews.js';
+export { listCloudflareDeployments } from './list-cloudflare-deployments.js';
+export { listCloudflareDeploymentSecretNames } from './list-cloudflare-deployment-secret-names.js';
+export { listDeploymentSecretNames } from './list-deployment-secret-names.js';
+export { readDeploymentLastCalls } from './read-deployment-last-calls.js';
+export { retainDeployment } from './retain-deployment.js';
+export { retireDeployment } from './retire-deployment.js';
+export { setCloudflareDeploymentSecret } from './set-cloudflare-deployment-secret.js';
+export { setDeploymentSecret } from './set-deployment-secret.js';

package/dist/schema/modules/deployment/functions/list-cloudflare-deployment-secret-names.d.ts

@@ -0,0 +1,5 @@
+/** Decided as `setSecret`: `OwnDeployment` for the caller, before the deployment is read. */
+export declare const listCloudflareDeploymentSecretNames: 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>>;

package/dist/schema/modules/deployment/functions/list-cloudflare-deployment-secret-names.js

@@ -0,0 +1,4 @@
+import { method } from '@astrale-os/sdk/schema';
+import { listDeploymentSecretNamesContract } from '../types/deployment-secret.js';
+/** Decided as `setSecret`: `OwnDeployment` for the caller, before the deployment is read. */
+export const listCloudflareDeploymentSecretNames = method(listDeploymentSecretNamesContract);

package/dist/schema/modules/deployment/functions/list-cloudflare-deployments.d.ts

@@ -0,0 +1,58 @@
+/** The deployments of the lines the caller holds, or acts for through `extends_with`. */
+export declare const listCloudflareDeployments: 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>>;

package/dist/schema/modules/deployment/functions/list-cloudflare-deployments.js

@@ -0,0 +1,10 @@
+import { method } from '@astrale-os/sdk/schema';
+import { listDeploymentsInput, listDeploymentsOutput } from '../types/deployment-hosting.js';
+/** The deployments of the lines the caller holds, or acts for through `extends_with`. */
+export const listCloudflareDeployments = method({
+    description: 'List the deployments of the lines the caller holds.',
+    auth: 'authenticated',
+    static: true,
+    input: listDeploymentsInput,
+    output: listDeploymentsOutput,
+});

package/dist/schema/modules/deployment/functions/list-deployment-secret-names.d.ts

@@ -0,0 +1,4 @@
+export declare const listDeploymentSecretNames: 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>>;