@astrale-domains/services 0.4.8 → 0.5.0

package/dist/schema/modules/service/types/service-management.d.ts

@@ -1,48 +1,84 @@
 import { z } from 'zod';
-export declare const setServiceSecretContract: {
-    readonly description: 'Set one write-only Service secret.';
-    readonly auth: 'authorized';
+export declare const promoteServiceContract: {
+    readonly description: 'Make one active deployment of this Service the one its URL serves.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{
-        name: z.ZodString;
-        value: z.ZodString;
+        label: z.ZodString;
     }, z.core.$strict>;
     readonly output: z.ZodUnion<readonly [z.ZodObject<{
-        name: z.ZodString;
+        current: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"rejected">;
         reason: z.ZodEnum<{
-            "binding-unavailable": "binding-unavailable";
-            "invalid-secret-name": "invalid-secret-name";
+            "address-mismatch": "address-mismatch";
+            "build-mismatch": "build-mismatch";
+            "deployment-conflict": "deployment-conflict";
+            "deployment-retired": "deployment-retired";
+            "hosting-unavailable": "hosting-unavailable";
+            "invalid-deployment": "invalid-deployment";
+            "service-owned-elsewhere": "service-owned-elsewhere";
             "service-unavailable": "service-unavailable";
         }>;
+        message: z.ZodString;
+        retryAfter: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>]>;
 };
-export declare const deleteServiceSecretContract: {
-    readonly description: 'Delete one write-only Service secret.';
-    readonly auth: 'authorized';
+export declare const transferServiceContract: {
+    readonly description: 'Give this Service to another Identity the caller is or acts as.';
+    readonly auth: 'authenticated';
+    readonly input: z.ZodObject<{
+        owner: z.ZodString;
+    }, z.core.$strict>;
+    readonly output: z.ZodUnion<readonly [z.ZodObject<{
+        owner: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rejected">;
+        reason: z.ZodEnum<{
+            "address-mismatch": "address-mismatch";
+            "build-mismatch": "build-mismatch";
+            "deployment-conflict": "deployment-conflict";
+            "deployment-retired": "deployment-retired";
+            "hosting-unavailable": "hosting-unavailable";
+            "invalid-deployment": "invalid-deployment";
+            "service-owned-elsewhere": "service-owned-elsewhere";
+            "service-unavailable": "service-unavailable";
+        }>;
+        message: z.ZodString;
+        retryAfter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+};
+/**
+ * Rewrite one secret of the current deployment in place. The next deploy binds the values it
+ * carries itself: Services never keeps a secret value.
+ */
+export declare const setServiceSecretContract: {
+    readonly description: 'Rewrite one declared secret of the current deployment in place.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{
         name: z.ZodString;
+        value: z.ZodString;
     }, z.core.$strict>;
     readonly output: z.ZodUnion<readonly [z.ZodObject<{
-        ok: z.ZodLiteral<true>;
+        name: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"rejected">;
         reason: z.ZodEnum<{
-            "binding-unavailable": "binding-unavailable";
-            "invalid-secret-name": "invalid-secret-name";
+            "secret-undeclared": "secret-undeclared";
             "service-unavailable": "service-unavailable";
         }>;
+        message: z.ZodString;
+        retryAfter: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>]>;
 };
 export declare const listServiceSecretNamesContract: {
-    readonly description: 'List write-only Service secret names without exposing values.';
-    readonly auth: 'authorized';
+    readonly description: 'List the names of the secrets the current deployment binds, never their values.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{}, z.core.$strict>;
     readonly output: z.ZodArray<z.ZodString>;
 };
 export declare const replaceServiceSchedulesContract: {
-    readonly description: 'Replace the complete Service cron set.';
-    readonly auth: 'authorized';
+    readonly description: 'Replace the complete UTC cron set of this Service; it runs on the current deployment.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{
         crons: z.ZodArray<z.ZodString>;
     }, z.core.$strict>;
@@ -57,15 +93,16 @@ export declare const replaceServiceSchedulesContract: {
     }, z.core.$strict>]>;
 };
 export declare const listServiceSchedulesContract: {
-    readonly description: 'List active Service cron expressions.';
-    readonly auth: 'authorized';
+    readonly description: 'List the UTC cron expressions of this Service.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{}, z.core.$strict>;
     readonly output: z.ZodArray<z.ZodString>;
 };
 export declare const listServiceLogsContract: {
-    readonly description: 'Read recent Service runtime logs.';
-    readonly auth: 'authorized';
+    readonly description: 'Read recent runtime logs of the current deployment, or of one named deployment.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
         tail: z.ZodOptional<z.ZodNumber>;
         since: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>;
@@ -76,9 +113,13 @@ export declare const listServiceLogsContract: {
         line: z.ZodString;
     }, z.core.$strict>>;
 };
+/**
+ * Retire every deployment of this Service, then delete it and free its name. Retirement is two
+ * phases per deployment: `deleting` answers when a retry may finish.
+ */
 export declare const deleteServiceContract: {
-    readonly description: 'Convergently delete provider resources and the owned Service without uninstalling consumers.';
-    readonly auth: 'authorized';
+    readonly description: 'Retire every deployment of this Service, then delete it and free its name.';
+    readonly auth: 'authenticated';
     readonly input: z.ZodObject<{}, z.core.$strict>;
     readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"deleted">;

package/dist/schema/modules/service/types/service-management.js

@@ -1,9 +1,35 @@
 import { z } from 'zod';
+import { deploymentRejection, deploymentSecretRejection } from '../../deployment/index.js';
 import { secretName } from './service-secret-name.js';
-import { secretOperationRejection } from './service-secret-operation-rejection.js';
+/**
+ * Every Service Method is `authenticated`: a deployer's identities on the Admin instance hold no
+ * `can_use` on Services' Functions, which an `authorized` Method requires of every non-Root
+ * caller. Each handler asks the Kernel `OwnService` for the caller on its own session before it
+ * reads anything, and a caller who does not own the Service finds none (`SERVICE_NOT_FOUND`). The
+ * day the Admin instance grants deployers `can_use` on these Methods, they become `authorized` with
+ * the `OwnService` Policy and the handler checks go.
+ */
+/** One deployment of this Service, named by its label. */
+const deploymentLabel = z.string().min(33).max(57);
+export const promoteServiceContract = {
+    description: 'Make one active deployment of this Service the one its URL serves.',
+    auth: 'authenticated',
+    input: z.strictObject({ label: deploymentLabel }),
+    output: z.union([z.strictObject({ current: deploymentLabel }), deploymentRejection]),
+};
+export const transferServiceContract = {
+    description: 'Give this Service to another Identity the caller is or acts as.',
+    auth: 'authenticated',
+    input: z.strictObject({ owner: z.string().min(1).max(256) }),
+    output: z.union([z.strictObject({ owner: z.string().min(1) }), deploymentRejection]),
+};
+/**
+ * Rewrite one secret of the current deployment in place. The next deploy binds the values it
+ * carries itself: Services never keeps a secret value.
+ */
 export const setServiceSecretContract = {
-    description: 'Set one write-only Service secret.',
-    auth: 'authorized',
+    description: 'Rewrite one declared secret of the current deployment in place.',
+    auth: 'authenticated',
     input: z.strictObject({
         name: secretName,
         value: z
@@ -11,23 +37,17 @@ export const setServiceSecretContract = {
             .min(1)
             .max(64 * 1024),
     }),
-    output: z.union([z.strictObject({ name: secretName }), secretOperationRejection]),
-};
-export const deleteServiceSecretContract = {
-    description: 'Delete one write-only Service secret.',
-    auth: 'authorized',
-    input: z.strictObject({ name: secretName }),
-    output: z.union([z.strictObject({ ok: z.literal(true) }), secretOperationRejection]),
+    output: z.union([z.strictObject({ name: secretName }), deploymentSecretRejection]),
 };
 export const listServiceSecretNamesContract = {
-    description: 'List write-only Service secret names without exposing values.',
-    auth: 'authorized',
+    description: 'List the names of the secrets the current deployment binds, never their values.',
+    auth: 'authenticated',
     input: z.strictObject({}),
     output: z.array(secretName),
 };
 export const replaceServiceSchedulesContract = {
-    description: 'Replace the complete Service cron set.',
-    auth: 'authorized',
+    description: 'Replace the complete UTC cron set of this Service; it runs on the current deployment.',
+    auth: 'authenticated',
     input: z.strictObject({ crons: z.array(z.string()).max(24) }),
     output: z.union([
         z.strictObject({ crons: z.array(z.string()) }),
@@ -38,29 +58,34 @@ export const replaceServiceSchedulesContract = {
     ]),
 };
 export const listServiceSchedulesContract = {
-    description: 'List active Service cron expressions.',
-    auth: 'authorized',
+    description: 'List the UTC cron expressions of this Service.',
+    auth: 'authenticated',
     input: z.strictObject({}),
     output: z.array(z.string()),
 };
 export const listServiceLogsContract = {
-    description: 'Read recent Service runtime logs.',
-    auth: 'authorized',
+    description: 'Read recent runtime logs of the current deployment, or of one named deployment.',
+    auth: 'authenticated',
     input: z.strictObject({
+        label: deploymentLabel.optional(),
         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() })),
 };
+/**
+ * Retire every deployment of this Service, then delete it and free its name. Retirement is two
+ * phases per deployment: `deleting` answers when a retry may finish.
+ */
 export const deleteServiceContract = {
-    description: 'Convergently delete provider resources and the owned Service without uninstalling consumers.',
-    auth: 'authorized',
+    description: 'Retire every deployment of this Service, then delete it and free its name.',
+    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),
+            retryAfterMs: z.number().int().min(0).max(3_600_000),
         }),
     ]),
 };