@astrale-domains/services 0.2.1 → 0.2.3

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/index.d.ts

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

package/dist/schema/service/index.js

@@ -1,4 +1,5 @@
-export { CloudflareWorker } from './class.js';
-export { serviceMethods } from './methods.js';
+export { CloudflareWorker } from './cloudflare-worker-class.js';
+export { deleteService, deleteServiceSecret, deployCloudflareWorker, listServiceLogs, listServiceSchedules, listServiceSecretNames, replaceServiceSchedules, setServiceSecret, } from './methods/index.js';
 export { ObserveService, TraverseOwnedService } from './policies.js';
-export { service_owned_by } from './relationships.js';
+export { Service, serviceLifecycle } from './service-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 provider resources and the Service record without uninstalling consumers.',
+    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,81 @@
+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;
+        application?: {
+            issuer: string;
+            origin: string;
+            revision: string;
+            publicationEtag: string;
+            functions: {
+                path: string;
+                ref: string;
+            }[];
+        } | undefined;
+    } | {
+        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 admit its optional Publication.',
+    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.js

@@ -1,5 +1,5 @@
 import { policy } from '@astrale-os/sdk/schema';
-import { service_owned_by } from './relationships.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.',