@astrale-domains/services 0.2.1 → 0.2.2

package/dist/schema/service/cloudflare-worker-class.js

@@ -0,0 +1,18 @@
+import { nodeClass, property } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { deployCloudflareWorker } from './methods/index.js';
+import { Service } from './service-class.js';
+export const CloudflareWorker = nodeClass({
+    description: 'One Service placed in a Cloudflare Workers dispatch namespace.',
+    extends: [Service],
+    properties: {
+        deploymentMode: z.enum(['plain', 'revisioned']),
+        tenantDomainState: property(z.enum(['unresolved', 'absent', 'attached']), {
+            required: false,
+        }),
+        tenantDomainId: property(z.string().min(1).max(128), { required: false }),
+        tenantCertificatePackId: property(z.string().min(1).max(128), { required: false }),
+        tenantZoneId: property(z.string().min(1).max(128), { required: false }),
+    },
+    methods: { deploy: deployCloudflareWorker },
+});

package/dist/schema/service/hosted-by-service-edge-class.d.ts

@@ -0,0 +1,19 @@
+export declare const hosted_by_service: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: {
+        readonly callableRef: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "callableRef", "self">;
+        readonly callablePath: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "callablePath", "self">;
+    };
+    readonly source: {
+        readonly as: "function";
+        readonly outgoing: "0..1";
+    };
+    readonly target: {
+        readonly as: "service";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: Record<never, never>;
+    readonly effectiveProperties: import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "callablePath", "self"> | import("@astrale-os/sdk/schema").AuthoredPropertyProjection<string, string, true, "callableRef", "self">;
+}>;

package/dist/schema/service/hosted-by-service-edge-class.js

@@ -0,0 +1,14 @@
+import { K, edgeClass } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { TraverseHostedFunction } from './policies.js';
+import { Service } from './service-class.js';
+export const hosted_by_service = edgeClass.directed({
+    description: 'One installed Function declaration delivered by one Service.',
+    source: { as: 'function', accepts: [K.classes.Function], outgoing: '0..1' },
+    target: { as: 'service', accepts: [() => Service], incoming: '0..*' },
+    properties: {
+        callableRef: z.string().min(1).max(512),
+        callablePath: z.string().min(1).max(2_048),
+    },
+    policies: { traverse: () => TraverseHostedFunction },
+});

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

@@ -1,4 +1,7 @@
-export { CloudflareWorker } from './class.js';
-export { serviceMethods } from './methods.js';
-export { ObserveService, TraverseOwnedService } from './policies.js';
-export { service_owned_by } from './relationships.js';
+export { CloudflareWorker } from './cloudflare-worker-class.js';
+export { hosted_by_service } from './hosted-by-service-edge-class.js';
+export { deleteService, deleteServiceSecret, deployCloudflareWorker, listServiceLogs, listServiceSchedules, listServiceSecretNames, replaceServiceSchedules, setServiceSecret, } from './methods/index.js';
+export { ObserveService, TraverseHostedDomain, TraverseHostedFunction, TraverseOwnedService, } from './policies.js';
+export { Service, serviceLifecycle } from './service-class.js';
+export { service_hosts_domain } from './service-hosts-domain-edge-class.js';
+export { service_owned_by } from './service-owned-by-edge-class.js';

package/dist/schema/service/index.js

@@ -1,4 +1,7 @@
-export { CloudflareWorker } from './class.js';
-export { serviceMethods } from './methods.js';
-export { ObserveService, TraverseOwnedService } from './policies.js';
-export { service_owned_by } from './relationships.js';
+export { CloudflareWorker } from './cloudflare-worker-class.js';
+export { hosted_by_service } from './hosted-by-service-edge-class.js';
+export { deleteService, deleteServiceSecret, deployCloudflareWorker, listServiceLogs, listServiceSchedules, listServiceSecretNames, replaceServiceSchedules, setServiceSecret, } from './methods/index.js';
+export { ObserveService, TraverseHostedDomain, TraverseHostedFunction, TraverseOwnedService, } from './policies.js';
+export { Service, serviceLifecycle } from './service-class.js';
+export { service_hosts_domain } from './service-hosts-domain-edge-class.js';
+export { service_owned_by } from './service-owned-by-edge-class.js';

package/dist/schema/service/methods/delete-secret.d.ts

@@ -0,0 +1,11 @@
+export declare const deleteServiceSecret: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        ok: true;
+    } | {
+        kind: "rejected";
+        reason: "binding-unavailable" | "invalid-secret-name" | "service-unavailable";
+    };
+}, "authenticated", false, "default">>;

package/dist/schema/service/methods/delete-secret.js

@@ -0,0 +1,10 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { secretName } from './secret-name.js';
+import { secretOperationRejection } from './secret-operation-rejection.js';
+export const deleteServiceSecret = method({
+    description: 'Delete one write-only Service secret.',
+    auth: 'authenticated',
+    input: z.strictObject({ name: secretName }),
+    output: z.union([z.strictObject({ ok: z.literal(true) }), secretOperationRejection]),
+});

package/dist/schema/service/methods/delete-service.d.ts

@@ -0,0 +1,9 @@
+export declare const deleteService: 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, "default">>;

package/dist/schema/service/methods/delete-service.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+export const deleteService = method({
+    description: 'Convergently delete the hosted Domain, provider placement, and Service record.',
+    auth: 'authenticated',
+    input: z.strictObject({}),
+    output: z.discriminatedUnion('kind', [
+        z.strictObject({ kind: z.literal('deleted') }),
+        z.strictObject({
+            kind: z.literal('deleting'),
+            retryAfterMs: z.number().int().min(250).max(30_000),
+        }),
+    ]),
+});

package/dist/schema/service/methods/deploy-cloudflare-worker.d.ts

@@ -0,0 +1,82 @@
+export declare const deployCloudflareWorker: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    name?: string | undefined;
+    entry?: string | undefined;
+    modules?: ({
+        contentBase64: string;
+        name: string;
+        kind?: "data" | "esm" | "text" | "wasm" | undefined;
+    } | {
+        contentBase64Chunks: string[];
+        name: string;
+        kind?: "data" | "esm" | "text" | "wasm" | undefined;
+    })[] | undefined;
+    revisioned?: {
+        revision: string;
+        requiredSecrets: string[];
+        release: {
+            entry: string;
+            modules: ({
+                contentBase64: string;
+                name: string;
+                kind?: "data" | "esm" | "text" | "wasm" | undefined;
+            } | {
+                contentBase64Chunks: string[];
+                name: string;
+                kind?: "data" | "esm" | "text" | "wasm" | undefined;
+            })[];
+        };
+    } | undefined;
+    compatibilityDate?: string | undefined;
+    compatibilityFlags?: string[] | undefined;
+    serviceBindings?: {
+        name: string;
+        service: string;
+    }[] | undefined;
+    vars?: Record<string, string> | undefined;
+    secrets?: Record<string, string> | undefined;
+    assets?: {
+        files: ({
+            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;
+    limits?: {
+        cpuMs?: number | undefined;
+        subrequests?: number | undefined;
+    } | undefined;
+    serviceKey: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        serviceKey: string;
+        url: string;
+        digest: string;
+        revision?: string | undefined;
+        state: "deleting" | "deploying" | "failed" | "ready" | "reconciling";
+        error?: string | null | undefined;
+        domain?: {
+            issuer: string;
+            origin: string;
+            revision: string;
+            publicationEtag: string;
+        } | undefined;
+        functions: {
+            id: string;
+            path: string;
+            ref: string;
+        }[];
+    } | {
+        kind: "rejected";
+        reason: "artifact-mode-conflict" | "invalid-deployment" | "service-unavailable";
+        message: string;
+    };
+}, "authenticated", true, "default">>;

package/dist/schema/service/methods/deploy-cloudflare-worker.js

@@ -0,0 +1,9 @@
+import { method } from '@astrale-os/sdk/schema';
+import { deployServiceInput, deployServiceOutput } from '../../deployment/index.js';
+export const deployCloudflareWorker = method({
+    description: 'Create or converge one Cloudflare Worker Service and its hosted Domain.',
+    auth: 'authenticated',
+    static: true,
+    input: deployServiceInput,
+    output: deployServiceOutput,
+});

package/dist/schema/service/methods/index.d.ts

@@ -0,0 +1,8 @@
+export { deleteServiceSecret } from './delete-secret.js';
+export { deleteService } from './delete-service.js';
+export { deployCloudflareWorker } from './deploy-cloudflare-worker.js';
+export { listServiceLogs } from './list-service-logs.js';
+export { listServiceSchedules } from './list-service-schedules.js';
+export { listServiceSecretNames } from './list-service-secret-names.js';
+export { replaceServiceSchedules } from './replace-service-schedules.js';
+export { setServiceSecret } from './set-service-secret.js';

package/dist/schema/service/methods/index.js

@@ -0,0 +1,8 @@
+export { deleteServiceSecret } from './delete-secret.js';
+export { deleteService } from './delete-service.js';
+export { deployCloudflareWorker } from './deploy-cloudflare-worker.js';
+export { listServiceLogs } from './list-service-logs.js';
+export { listServiceSchedules } from './list-service-schedules.js';
+export { listServiceSecretNames } from './list-service-secret-names.js';
+export { replaceServiceSchedules } from './replace-service-schedules.js';
+export { setServiceSecret } from './set-service-secret.js';

package/dist/schema/service/methods/list-service-logs.d.ts

@@ -0,0 +1,12 @@
+export declare const listServiceLogs: 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;
+    }[];
+}, "authenticated", false, "default">>;

package/dist/schema/service/methods/list-service-logs.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+export const listServiceLogs = method({
+    description: 'Read recent Service runtime logs.',
+    auth: 'authenticated',
+    input: z.strictObject({
+        tail: z.number().int().min(1).max(1_000).optional(),
+        since: z.number().int().min(0).optional(),
+    }),
+    output: z.array(z.strictObject({ id: z.string(), ts: z.number(), level: z.string(), line: z.string() })),
+});

package/dist/schema/service/methods/list-service-schedules.d.ts

@@ -0,0 +1,4 @@
+export declare const listServiceSchedules: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: string[];
+}, "authenticated", false, "default">>;

package/dist/schema/service/methods/list-service-schedules.js

@@ -0,0 +1,8 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+export const listServiceSchedules = method({
+    description: 'List active Service cron expressions.',
+    auth: 'authenticated',
+    input: z.strictObject({}),
+    output: z.array(z.string()),
+});

package/dist/schema/service/methods/list-service-secret-names.d.ts

@@ -0,0 +1,4 @@
+export declare const listServiceSecretNames: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<Record<string, never>, {
+    readonly mode: 'value';
+    readonly value: string[];
+}, "authenticated", false, "default">>;

package/dist/schema/service/methods/list-service-secret-names.js

@@ -0,0 +1,9 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { secretName } from './secret-name.js';
+export const listServiceSecretNames = method({
+    description: 'List write-only Service secret names without exposing values.',
+    auth: 'authenticated',
+    input: z.strictObject({}),
+    output: z.array(secretName),
+});

package/dist/schema/service/methods/replace-service-schedules.d.ts

@@ -0,0 +1,11 @@
+export declare const replaceServiceSchedules: 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, "default">>;

package/dist/schema/service/methods/replace-service-schedules.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+export const replaceServiceSchedules = method({
+    description: 'Replace the complete Service cron set.',
+    auth: 'authenticated',
+    input: z.strictObject({ crons: z.array(z.string()).max(24) }),
+    output: z.union([
+        z.strictObject({ crons: z.array(z.string()) }),
+        z.strictObject({
+            kind: z.literal('rejected'),
+            reason: z.enum(['invalid-schedule', 'service-unavailable']),
+        }),
+    ]),
+});

package/dist/schema/service/methods/secret-name.js

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const secretName = z.string().min(1).max(256);

package/dist/schema/service/methods/secret-operation-rejection.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const secretOperationRejection = z.strictObject({
+    kind: z.literal('rejected'),
+    reason: z.enum(['invalid-secret-name', 'service-unavailable', 'binding-unavailable']),
+});

package/dist/schema/service/methods/set-service-secret.d.ts

@@ -0,0 +1,12 @@
+export declare const setServiceSecret: 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;
+    };
+}, "authenticated", false, "default">>;

package/dist/schema/service/methods/set-service-secret.js

@@ -0,0 +1,16 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { secretName } from './secret-name.js';
+import { secretOperationRejection } from './secret-operation-rejection.js';
+export const setServiceSecret = method({
+    description: 'Set one write-only Service secret.',
+    auth: 'authenticated',
+    input: z.strictObject({
+        name: secretName,
+        value: z
+            .string()
+            .min(1)
+            .max(64 * 1024),
+    }),
+    output: z.union([z.strictObject({ name: secretName }), secretOperationRejection]),
+});

package/dist/schema/service/policies.d.ts

@@ -2,3 +2,6 @@
 export declare const ObserveService: import("@astrale-os/sdk/schema").Policy;
 /** Ownership edges disclose only the subject's own Service relationship. */
 export declare const TraverseOwnedService: import("@astrale-os/sdk/schema").Policy;
+/** Hosted relationships disclose only resources attached to a caller-owned Service endpoint. */
+export declare const TraverseHostedDomain: import("@astrale-os/sdk/schema").Policy;
+export declare const TraverseHostedFunction: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/service/policies.js

@@ -1,5 +1,7 @@
 import { policy } from '@astrale-os/sdk/schema';
-import { service_owned_by } from './relationships.js';
+import { hosted_by_service } from './hosted-by-service-edge-class.js';
+import { service_hosts_domain } from './service-hosts-domain-edge-class.js';
+import { service_owned_by } from './service-owned-by-edge-class.js';
 /** A Service is visible only to the Identity that owns its provider effects. */
 export const ObserveService = policy({
     description: 'The subject owns this Service.',
@@ -10,3 +12,12 @@ export const TraverseOwnedService = policy({
     description: 'The subject owns the Service at the target of this relationship.',
     match: ({ allOf, edge, source, subject, target }) => allOf(edge({ source: subject, class: () => service_owned_by, target }), edge({ source, class: () => service_owned_by, target })),
 });
+/** Hosted relationships disclose only resources attached to a caller-owned Service endpoint. */
+export const TraverseHostedDomain = policy({
+    description: 'The subject owns the Service that hosts this Domain.',
+    match: ({ allOf, edge, source, subject, target }) => allOf(edge({ source, class: () => service_hosts_domain, target }), edge({ source: subject, class: () => service_owned_by, target: source })),
+});
+export const TraverseHostedFunction = policy({
+    description: 'The subject owns the Service that hosts this Function.',
+    match: ({ allOf, edge, source, subject, target }) => allOf(edge({ source, class: () => hosted_by_service, target }), edge({ source: subject, class: () => service_owned_by, target })),
+});