@astrale-os/sdk 0.6.0-beta.22 → 0.6.0-beta.23

package/dist/deployment/worker/response.js

@@ -0,0 +1,213 @@
+import { parseDeploymentLabel } from '../address/label.js';
+import { serviceName } from './address.js';
+import { decodeWorkerRecord } from './record.js';
+export const WORKER_DEPLOYMENT_REJECTIONS = Object.freeze([
+    'invalid-deployment',
+    'address-mismatch',
+    'build-mismatch',
+    'service-owned-elsewhere',
+    'deployment-conflict',
+    'deployment-retired',
+    'hosting-unavailable',
+    'service-unavailable',
+]);
+const STATES = Object.freeze([
+    'deploying',
+    'active',
+    'retiring',
+    'retired',
+    'failed',
+]);
+/** Which secret states each deployment state reports. */
+const SECRETS_BY_STATE = Object.freeze({
+    created: Object.freeze(['bound']),
+    reused: Object.freeze(['updated', 'unchanged']),
+});
+/**
+ * Admit the answer of a host's `hosting`: its routing domain. The `addressing: 'opaque'` an older
+ * Services answers beside it is admitted and dropped: every Service name is opaque.
+ */
+export function decodeWorkerHosting(input) {
+    const value = exact(input, ['routingDomain'], ['addressing'], 'hosting');
+    if (typeof value.routingDomain !== 'string' || !isDnsName(value.routingDomain)) {
+        invalid('hosting', 'routingDomain');
+    }
+    if (value.addressing !== undefined && value.addressing !== 'opaque') {
+        invalid('hosting', 'addressing');
+    }
+    return Object.freeze({ routingDomain: value.routingDomain });
+}
+/**
+ * Admit the answer of a deploy exactly: a deployment whose state reports the secret state it
+ * pairs with, or a refusal a host can give.
+ */
+export function decodeWorkerDeploymentResponse(input) {
+    const value = exact(input, ['kind'], ['state', 'secrets', 'deployment', 'reason', 'message', 'retryAfter'], 'deploy');
+    if (value.kind === 'rejected') {
+        exact(value, ['kind', 'reason', 'message'], ['retryAfter'], 'refusal');
+        if (!WORKER_DEPLOYMENT_REJECTIONS.includes(value.reason)) {
+            invalid('refusal', 'reason');
+        }
+        if (typeof value.message !== 'string' ||
+            value.message.length < 1 ||
+            value.message.length > 500) {
+            invalid('refusal', 'message');
+        }
+        if (value.retryAfter !== undefined && !isInstant(value.retryAfter)) {
+            invalid('refusal', 'retryAfter');
+        }
+        return Object.freeze({
+            kind: 'rejected',
+            reason: value.reason,
+            message: value.message,
+            ...(value.retryAfter === undefined ? {} : { retryAfter: value.retryAfter }),
+        });
+    }
+    exact(value, ['kind', 'state', 'secrets', 'deployment'], [], 'deploy');
+    if (value.kind !== 'deployed')
+        invalid('deploy', 'kind');
+    if (value.state !== 'created' && value.state !== 'reused')
+        invalid('deploy', 'state');
+    const secrets = exact(value.secrets, ['state'], [], 'secrets');
+    const allowed = SECRETS_BY_STATE[value.state];
+    if (typeof secrets.state !== 'string' || !allowed.includes(secrets.state)) {
+        invalid('deploy', 'secrets.state');
+    }
+    return Object.freeze({
+        kind: 'deployed',
+        state: value.state,
+        secrets: Object.freeze({ state: secrets.state }),
+        deployment: decodeWorkerDeploymentSummary(value.deployment),
+    });
+}
+/** Admit the answer of a host's `list`: the summaries of the caller's deployments, in its order. */
+export function decodeWorkerDeploymentList(input) {
+    const value = exact(input, ['deployments'], [], 'list');
+    if (!Array.isArray(value.deployments))
+        invalid('list', 'deployments');
+    return Object.freeze(value.deployments.map((deployment) => decodeWorkerDeploymentSummary(deployment)));
+}
+/**
+ * Admit one summary exactly: node ids and names a person can read, a label whose first part is
+ * the Service's name, the URL of that label, a known state, instants, digests, and a record that
+ * decodes.
+ */
+export function decodeWorkerDeploymentSummary(input) {
+    const value = exact(input, [
+        'id',
+        'url',
+        'label',
+        'serviceId',
+        'service',
+        'project',
+        'environment',
+        'owner',
+        'state',
+        'current',
+        'createdAt',
+        'buildDigest',
+        'configuration',
+    ], ['retiredAt', 'signingKeyId', 'record'], 'deployment');
+    for (const key of [
+        'id',
+        'url',
+        'label',
+        'serviceId',
+        'service',
+        'project',
+        'environment',
+        'owner',
+    ]) {
+        if (typeof value[key] !== 'string' || !isPrintable(value[key]))
+            invalid('deployment', key);
+    }
+    if (value.signingKeyId !== undefined) {
+        if (typeof value.signingKeyId !== 'string' || !isPrintable(value.signingKeyId)) {
+            invalid('deployment', 'signingKeyId');
+        }
+    }
+    let line;
+    try {
+        line = parseDeploymentLabel(value.label).line;
+    }
+    catch {
+        invalid('deployment', 'label');
+    }
+    if (value.service !== line)
+        invalid('deployment', 'service');
+    let named;
+    try {
+        named = serviceName(value.project, value.environment);
+    }
+    catch {
+        invalid('deployment', 'project');
+    }
+    if (named !== line)
+        invalid('deployment', 'service');
+    if (!isDeploymentUrl(value.url, value.label))
+        invalid('deployment', 'url');
+    if (!STATES.includes(value.state))
+        invalid('deployment', 'state');
+    if (typeof value.current !== 'boolean')
+        invalid('deployment', 'current');
+    if (!isInstant(value.createdAt))
+        invalid('deployment', 'createdAt');
+    if (value.retiredAt !== undefined && !isInstant(value.retiredAt))
+        invalid('deployment', 'retiredAt');
+    for (const key of ['buildDigest', 'configuration']) {
+        if (typeof value[key] !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(value[key])) {
+            invalid('deployment', key);
+        }
+    }
+    let record;
+    if (value.record !== undefined) {
+        try {
+            record = decodeWorkerRecord(value.record);
+        }
+        catch {
+            invalid('deployment', 'record');
+        }
+    }
+    const summary = { ...value };
+    delete summary.record;
+    return Object.freeze({
+        ...summary,
+        ...(record === undefined ? {} : { record }),
+    });
+}
+/** `https://<label>.<routing domain>`, nothing more. */
+function isDeploymentUrl(url, label) {
+    const prefix = `https://${label}.`;
+    return url.startsWith(prefix) && isDnsName(url.slice(prefix.length));
+}
+/** Text a person can read in a listing: at most 512 characters, none of them a control character. */
+function isPrintable(value) {
+    return value.length > 0 && value.length <= 512 && !/[\p{Cc}]/u.test(value);
+}
+function isInstant(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= 64 &&
+        !Number.isNaN(Date.parse(value)));
+}
+function isDnsName(value) {
+    return (value.length <= 253 &&
+        value.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u.test(label)));
+}
+function exact(input, required, optional, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label);
+    const value = input;
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== 'string' || (!required.includes(key) && !optional.includes(key))) {
+            invalid(label, String(key));
+        }
+    }
+    for (const key of required)
+        if (!Object.hasOwn(value, key))
+            invalid(label, key);
+    return value;
+}
+function invalid(label, member) {
+    throw new TypeError(`The Worker host returned an invalid ${label} answer${member === undefined ? '' : ` (${member})`}.`);
+}

package/dist/tooling/cli/immutable-deployment.d.ts

@@ -1,4 +1,4 @@
-import type { DeploymentCommitV1, FrozenConfigurationV1 } from '../../deployment/address/index.js';
+import type { DeploymentCommitV1, DeploymentConfiguration } from '../../deployment/address/index.js';
 import type { Adapter, Build, Bundle, LegacyAdapter, Placement, Release, ResolvedRuntimeReference } from '../../deployment/index.js';
 import type { DeployResultV1 } from './deploy-result.js';
 /**
@@ -15,7 +15,7 @@ export interface ImmutableDeploymentPlan {
     readonly identity?: string;
     readonly bundle: Bundle;
     readonly secrets: Readonly<Record<string, string>>;
-    readonly configuration: FrozenConfigurationV1;
+    readonly configuration: DeploymentConfiguration;
     readonly placement: Placement;
     /** `<line>-<content>`: the deployment's DNS label and provider script. */
     readonly label: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.6.0-beta.22",
+  "version": "0.6.0-beta.23",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",
@@ -167,6 +167,10 @@
       "types": "./dist/deployment/address/vectors.d.ts",
       "import": "./dist/deployment/address/vectors.js"
     },
+    "./deployment/worker": {
+      "types": "./dist/deployment/worker/index.d.ts",
+      "import": "./dist/deployment/worker/index.js"
+    },
     "./deployment/release": {
       "types": "./dist/deployment/release/index.d.ts",
       "import": "./dist/deployment/release/index.js"