@serve.zone/interfaces 32.25.0 → 32.27.0

package/dist_ts/platform/objectstorageenvironment.d.ts

@@ -1,5 +1,6 @@
 import type { IPlatformBinding } from './types.js';
 import type { IPlatformObjectStorageEndpoint, TObjectStorageEndpointEnvironment, TObjectStorageEndpointEnvironmentKey } from './objectstorage.js';
+import type { TServiceRuntimeRefusal, TServiceRuntimeWaitingReason } from '../data/serviceruntime.js';
 import type { TObjectStorageRetentionEnvironment, TObjectStorageRetentionEnvironmentKey } from './objectstorageretention.js';
 /**
  * Every non-secret environment name an object-storage binding can give a workload: the nine
@@ -32,6 +33,9 @@ export type TObjectStorageBindingEnvironment = TObjectStorageEndpointEnvironment
  * The evidence's reconciliation generation and binding-request digest are read from its own
  * authority: they are what Cloudly checked when it admitted the evidence, and the binding document
  * does not repeat them. Everything the binding does state is checked again here.
+ *
+ * `composeObjectStorageServiceEnvironment()` answers the same questions with a service runtime
+ * reason instead of an error.
  */
 export declare const createObjectStorageBindingEnvironment: (bindingArg: IPlatformBinding, endpointArg: IPlatformObjectStorageEndpoint) => Promise<TObjectStorageBindingEnvironment>;
 /**
@@ -47,3 +51,58 @@ export declare const validateObjectStorageBindingEnvironment: (environmentArg: u
  * would otherwise have one value silently replace the other. The inputs are not changed.
  */
 export declare const mergeObjectStorageBindingEnvironment: (environmentArg: Readonly<Record<string, string>>, bindingEnvironmentArg: TObjectStorageBindingEnvironment) => Record<string, string>;
+/** One enabled object-storage binding of a service and the endpoint of the node it is placed on. */
+export interface IObjectStorageBindingEnvironmentSource {
+    binding: IPlatformBinding;
+    /**
+     * The `IClusterNode.data.corestoreObjectStorage` of the node the binding is placed on, `null`
+     * when that node states none. A binding placed on no node is not a source: its service waits as
+     * `bindings-pending`.
+     */
+    endpoint: IPlatformObjectStorageEndpoint | null;
+}
+/**
+ * The service runtime waiting reason an object-storage environment reports:
+ * `objectstorage-retention-pending`, a binding that declares compliance retention whose evidence
+ * has not arrived.
+ */
+export type TObjectStorageEnvironmentWaitingReason = Extract<TServiceRuntimeWaitingReason, 'objectstorage-retention-pending'>;
+/**
+ * The service runtime refusals an object-storage environment reports.
+ * `objectstorage-endpoint-missing` is a binding whose node states no valid
+ * `corestoreObjectStorage`; `objectstorage-binding-invalid` a binding
+ * `createObjectStorageBindingEnvironment()` refuses (not `objectstorage`, no canonical bucket, no
+ * canonical retention intent, or evidence that does not prove this binding);
+ * `objectstorage-environment-conflict` a name the service's own environment or another binding
+ * already sets.
+ */
+export type TObjectStorageEnvironmentRefusal = Extract<TServiceRuntimeRefusal, 'objectstorage-endpoint-missing' | 'objectstorage-binding-invalid' | 'objectstorage-environment-conflict'>;
+/** A service's environment with every object-storage binding added, or the one reason it is not. */
+export type TObjectStorageServiceEnvironmentComposition = {
+    status: 'composed';
+    environment: Record<string, string>;
+} | {
+    status: 'waiting';
+    reason: TObjectStorageEnvironmentWaitingReason;
+    bindingId: string;
+    message: string;
+} | {
+    status: 'refused';
+    reason: TObjectStorageEnvironmentRefusal;
+    bindingId: string;
+    message: string;
+};
+/**
+ * The service's own environment with the environment of every enabled object-storage binding
+ * added, or the service runtime reason it cannot be — so a producer reports the contract's
+ * verdict instead of classifying its errors.
+ *
+ * Each binding's names are `createObjectStorageBindingEnvironment()`'s from its node's endpoint,
+ * added as `mergeObjectStorageBindingEnvironment()` adds them. Bindings are taken in id order, so
+ * the verdict does not depend on the order of `sourcesArg`. A refusal outranks a wait, because a
+ * wait resolves on its own and a refusal never does: a binding waiting for retention evidence
+ * already claims all twenty of its names, so a collision with it is refused now, not once its
+ * evidence arrives. The first refusal is answered, otherwise the first wait, otherwise the
+ * composed environment. The inputs are not changed.
+ */
+export declare const composeObjectStorageServiceEnvironment: (serviceEnvironmentArg: Readonly<Record<string, string>>, sourcesArg: readonly IObjectStorageBindingEnvironmentSource[]) => Promise<TObjectStorageServiceEnvironmentComposition>;

package/dist_ts/platform/objectstorageenvironment.js

@@ -1,5 +1,5 @@
-import { createObjectStorageEndpointEnvironment, objectStorageEndpointEnvironmentKeys, validateObjectStorageEndpointEnvironment, validatePlatformObjectStorageBucketName, } from './objectstorage.js';
-import { createObjectStorageRetentionEnvironment, objectStorageRetentionEnvironmentKeys, validateObjectStorageRetentionEnvironment, validateObjectStorageRetentionIntent, } from './objectstorageretention.js';
+import { createObjectStorageEndpointEnvironment, objectStorageEndpointEnvironmentKeys, validateObjectStorageEndpointEnvironment, validatePlatformObjectStorageBucketName, validatePlatformObjectStorageEndpoint, } from './objectstorage.js';
+import { createObjectStorageRetentionEnvironment, objectStorageRetentionEnvironmentKeys, validateObjectStorageRetentionEnvironment, validateObjectStorageRetentionEvidence, validateObjectStorageRetentionIntent, } from './objectstorageretention.js';
 import { isPlainRecord, readDataProperties } from '../private/dataproperties.js';
 /**
  * Every non-secret environment name an object-storage binding can give a workload: the nine
@@ -10,65 +10,98 @@ export const objectStorageBindingEnvironmentKeys = Object.freeze([
     ...objectStorageRetentionEnvironmentKeys,
 ]);
 /**
- * The environment Cloudly composes into a workload's runtime configuration for one binding.
- *
- * `bindingArg` is the Cloudly binding document and `endpointArg` the
- * `IClusterNode.data.corestoreObjectStorage` of the node the binding is placed on. Refused by
- * name, never guessed:
- *
- * - a binding that is not `objectstorage` or carries no canonical `objectstorageBucketName`;
- * - an endpoint that `validatePlatformObjectStorageEndpoint()` refuses;
- * - a binding that declares `objectstorageRetention` without `evidence`. Its bucket's retention is
- *   not proven yet, so the workload is not given an environment that would let it run as if its
- *   bucket were ordinary storage; the caller waits for the evidence.
- * - evidence that does not prove the binding's own service, binding id, bucket and intent.
- *
- * A binding without `objectstorageRetention` gets the endpoint names alone: it promised no
- * retention, so there is nothing to state.
- *
- * The evidence's reconciliation generation and binding-request digest are read from its own
- * authority: they are what Cloudly checked when it admitted the evidence, and the binding document
- * does not repeat them. Everything the binding does state is checked again here.
+ * The one place a binding's environment is decided. `createObjectStorageBindingEnvironment()`
+ * throws its message, `composeObjectStorageServiceEnvironment()` reports its reason.
  */
-export const createObjectStorageBindingEnvironment = async (bindingArg, endpointArg) => {
+const resolveBindingEnvironment = async (bindingArg, endpointArg) => {
     const binding = readDataProperties(bindingArg);
     if (binding === null || binding.capability !== 'objectstorage') {
-        throw new Error('objectstorage binding environment requires an objectstorage binding');
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: 'objectstorage binding environment requires an objectstorage binding' };
     }
     const bindingName = typeof binding.id === 'string' ? binding.id : '(unnamed)';
     if (validatePlatformObjectStorageBucketName(binding.objectstorageBucketName).length > 0) {
-        throw new Error(`objectstorage binding ${bindingName} carries no canonical bucket name; Cloudly owns it and `
-            + 'no environment invents one');
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: `objectstorage binding ${bindingName} carries no canonical bucket name; Cloudly owns `
+                + 'it and no environment invents one' };
+    }
+    if (endpointArg === null) {
+        return { status: 'refused', reason: 'objectstorage-endpoint-missing',
+            message: `objectstorage binding ${bindingName} is placed on a node that states no `
+                + 'corestoreObjectStorage endpoint' };
+    }
+    const endpointErrors = validatePlatformObjectStorageEndpoint(endpointArg);
+    if (endpointErrors.length > 0) {
+        return { status: 'refused', reason: 'objectstorage-endpoint-missing', message: endpointErrors[0] };
     }
     const bucketName = binding.objectstorageBucketName;
     const endpointEnvironment = createObjectStorageEndpointEnvironment(endpointArg, bucketName);
     const retention = binding.objectstorageRetention;
     if (retention === undefined) {
-        return endpointEnvironment;
+        return { status: 'composed', environment: endpointEnvironment };
     }
     const retentionBinding = readDataProperties(retention);
     if (retentionBinding === null
         || validateObjectStorageRetentionIntent(retentionBinding.intent).length > 0) {
-        throw new Error(`objectstorage binding ${bindingName} must declare canonical compliance-retention intent`);
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: `objectstorage binding ${bindingName} must declare canonical compliance-retention `
+                + 'intent' };
     }
     const evidence = retentionBinding.evidence;
     if (evidence === undefined) {
-        throw new Error(`objectstorage binding ${bindingName} declares compliance retention without verified `
-            + 'evidence; its workload environment waits for the evidence');
+        return { status: 'waiting', reason: 'objectstorage-retention-pending',
+            message: `objectstorage binding ${bindingName} declares compliance retention without `
+                + 'verified evidence; its workload environment waits for the evidence' };
     }
     const authority = isPlainRecord(evidence) ? readDataProperties(evidence.authority) : null;
     if (authority === null) {
-        throw new Error('objectstorage retention evidence must use its exact schema');
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: 'objectstorage retention evidence must use its exact schema' };
     }
-    const retentionEnvironment = await createObjectStorageRetentionEnvironment(evidence, {
+    const expectation = {
         serviceId: binding.serviceId,
         bindingId: binding.id,
         reconciliationGeneration: authority.reconciliationGeneration,
         bindingRequestDigest: authority.bindingRequestDigest,
         bucketName,
         intent: retentionBinding.intent,
-    });
-    return { ...endpointEnvironment, ...retentionEnvironment };
+    };
+    const evidenceErrors = await validateObjectStorageRetentionEvidence(evidence, expectation);
+    if (evidenceErrors.length > 0) {
+        return { status: 'refused', reason: 'objectstorage-binding-invalid', message: evidenceErrors[0] };
+    }
+    const retentionEnvironment = await createObjectStorageRetentionEnvironment(evidence, expectation);
+    return { status: 'composed', environment: { ...endpointEnvironment, ...retentionEnvironment } };
+};
+/**
+ * The environment Cloudly composes into a workload's runtime configuration for one binding.
+ *
+ * `bindingArg` is the Cloudly binding document and `endpointArg` the
+ * `IClusterNode.data.corestoreObjectStorage` of the node the binding is placed on. Refused by
+ * name, never guessed:
+ *
+ * - a binding that is not `objectstorage` or carries no canonical `objectstorageBucketName`;
+ * - an endpoint that `validatePlatformObjectStorageEndpoint()` refuses;
+ * - a binding that declares `objectstorageRetention` without `evidence`. Its bucket's retention is
+ *   not proven yet, so the workload is not given an environment that would let it run as if its
+ *   bucket were ordinary storage; the caller waits for the evidence.
+ * - evidence that does not prove the binding's own service, binding id, bucket and intent.
+ *
+ * A binding without `objectstorageRetention` gets the endpoint names alone: it promised no
+ * retention, so there is nothing to state.
+ *
+ * The evidence's reconciliation generation and binding-request digest are read from its own
+ * authority: they are what Cloudly checked when it admitted the evidence, and the binding document
+ * does not repeat them. Everything the binding does state is checked again here.
+ *
+ * `composeObjectStorageServiceEnvironment()` answers the same questions with a service runtime
+ * reason instead of an error.
+ */
+export const createObjectStorageBindingEnvironment = async (bindingArg, endpointArg) => {
+    const resolution = await resolveBindingEnvironment(bindingArg, endpointArg);
+    if (resolution.status !== 'composed')
+        throw new Error(resolution.message);
+    return resolution.environment;
 };
 /**
  * Validates one binding's environment: the nine endpoint names, the eleven retention names all or
@@ -99,6 +132,9 @@ export const validateObjectStorageBindingEnvironment = async (environmentArg, pa
     }
     return errors;
 };
+const findEnvironmentCollisions = (claimedKeysArg, keysArg) => keysArg.filter((keyArg) => claimedKeysArg.has(keyArg)).sort();
+const describeEnvironmentCollisions = (collisionsArg) => (`objectstorage binding environment collides with ${collisionsArg.join(', ')} already set on the `
+    + 'workload');
 /**
  * A workload environment with one binding's environment added.
  *
@@ -107,13 +143,52 @@ export const validateObjectStorageBindingEnvironment = async (environmentArg, pa
  * would otherwise have one value silently replace the other. The inputs are not changed.
  */
 export const mergeObjectStorageBindingEnvironment = (environmentArg, bindingEnvironmentArg) => {
-    const collisions = Object.keys(bindingEnvironmentArg)
-        .filter((keyArg) => Object.hasOwn(environmentArg, keyArg))
-        .sort();
-    if (collisions.length > 0) {
-        throw new Error(`objectstorage binding environment collides with ${collisions.join(', ')} already set on the `
-            + 'workload');
-    }
+    const collisions = findEnvironmentCollisions(new Set(Object.keys(environmentArg)), Object.keys(bindingEnvironmentArg));
+    if (collisions.length > 0)
+        throw new Error(describeEnvironmentCollisions(collisions));
     return { ...environmentArg, ...bindingEnvironmentArg };
 };
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * The service's own environment with the environment of every enabled object-storage binding
+ * added, or the service runtime reason it cannot be — so a producer reports the contract's
+ * verdict instead of classifying its errors.
+ *
+ * Each binding's names are `createObjectStorageBindingEnvironment()`'s from its node's endpoint,
+ * added as `mergeObjectStorageBindingEnvironment()` adds them. Bindings are taken in id order, so
+ * the verdict does not depend on the order of `sourcesArg`. A refusal outranks a wait, because a
+ * wait resolves on its own and a refusal never does: a binding waiting for retention evidence
+ * already claims all twenty of its names, so a collision with it is refused now, not once its
+ * evidence arrives. The first refusal is answered, otherwise the first wait, otherwise the
+ * composed environment. The inputs are not changed.
+ */
+export const composeObjectStorageServiceEnvironment = async (serviceEnvironmentArg, sourcesArg) => {
+    const sources = [...sourcesArg].sort((leftArg, rightArg) => (leftArg.binding.id < rightArg.binding.id ? -1 : leftArg.binding.id > rightArg.binding.id ? 1 : 0));
+    let environment = { ...serviceEnvironmentArg };
+    const claimedKeys = new Set(Object.keys(environment));
+    let wait = null;
+    for (const source of sources) {
+        const bindingId = source.binding.id;
+        const resolution = await resolveBindingEnvironment(source.binding, source.endpoint);
+        if (resolution.status === 'refused') {
+            return { status: 'refused', reason: resolution.reason, bindingId, message: resolution.message };
+        }
+        const keys = resolution.status === 'composed'
+            ? Object.keys(resolution.environment)
+            : objectStorageBindingEnvironmentKeys;
+        const collisions = findEnvironmentCollisions(claimedKeys, keys);
+        if (collisions.length > 0) {
+            return { status: 'refused', reason: 'objectstorage-environment-conflict', bindingId,
+                message: describeEnvironmentCollisions(collisions) };
+        }
+        for (const key of keys)
+            claimedKeys.add(key);
+        if (resolution.status === 'composed') {
+            environment = { ...environment, ...resolution.environment };
+        }
+        else {
+            wait ??= { status: 'waiting', reason: resolution.reason, bindingId, message: resolution.message };
+        }
+    }
+    return wait ?? { status: 'composed', environment };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"objectstorageenvironment.js","sourceRoot":"","sources":["../../ts/platform/objectstorageenvironment.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/node.d.ts

@@ -5,6 +5,7 @@ import type { IClusterNode, INodeAction, INodeMetricsSample, TNodeActionName } f
 import type { IDeployment } from '../data/deployment.js';
 import type { IIdentity } from '../data/user.js';
 import type { IPlatformObjectStorageEndpoint } from '../platform/objectstorage.js';
+import type { IPlatformDatabaseEndpoint } from '../platform/database.js';
 import type { INodeCredentialMetadata, INodeCredentialMutationPreconditions, INodeCredentialMutationResult, TNodeCredentialPurpose } from '../data/nodecredential.js';
 import type { INodeRuntimeRetirement } from '../data/noderetirement.js';
 import type { INodeRuntimeBindingRead, INodeRuntimeBindingRequest } from '../data/noderuntimebinding.js';
@@ -246,6 +247,34 @@ export interface IReq_Any_Cloudly_SetClusterNodeCorestoreObjectStorageEndpoint e
         node: IClusterNode;
     };
 }
+/**
+ * An administrator states where a workload on one node reaches the node's Corestore database:
+ * `IClusterNode.data.corestoreDatabase`.
+ *
+ * A request of its own, separate from `setClusterNodeCorestoreEndpoint` and
+ * `setClusterNodeCorestoreObjectStorageEndpoint`: each sets one fact and never touches the others.
+ *
+ * Cloudly validates it with `validatePlatformDatabaseEndpoint` before it writes and takes the
+ * node's own real-write fence inside the writing transaction, as for the other two endpoints.
+ * `database: null` clears it, which is the same fact as never having set one: no database
+ * credential can be published for a binding on this node. A changed endpoint changes the binding
+ * request of every database binding placed on the node, so each is granted and published again,
+ * addressed to the new endpoint. The endpoint says where, never with what — no credential travels
+ * in this request or in the node document.
+ */
+export interface IReq_Any_Cloudly_SetClusterNodeCorestoreDatabaseEndpoint extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_SetClusterNodeCorestoreDatabaseEndpoint> {
+    method: 'setClusterNodeCorestoreDatabaseEndpoint';
+    request: {
+        identity: IIdentity;
+        nodeId: string;
+        /** The node's database endpoint, or `null` to state that it has none. */
+        database: IPlatformDatabaseEndpoint | null;
+    };
+    response: {
+        /** The node as it now stands, so a caller needs no second read to see what it set. */
+        node: IClusterNode;
+    };
+}
 export interface IReq_Any_Cloudly_CreateNodeAction extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_CreateNodeAction> {
     method: 'createNodeAction';
     request: {

package/dist_ts/runtime.corestore.d.ts

@@ -2,6 +2,7 @@ import * as plugins from './plugins.js';
 import type { IActiveSecretRecipientMetadata, ICorestoreDatabaseAllocationReference, IIdentityCredential, ISecretVersionReference } from './data/index.js';
 import type { ISecretEnvelopeAdmissionBinding } from './runtime.js';
 import type { IObjectStorageRetentionIntent, IObjectStorageRetentionEvidenceExpectation, IObjectStorageRetentionEvidence } from './platform/objectstorageretention.js';
+import type { IPlatformDatabaseEndpoint } from './platform/database.js';
 export type TCorestoreCredentialCapability = 'database' | 'objectstorage';
 export declare const corestoreProviderConfigIds: Readonly<{
     readonly database: "cloudly-corestore-database";
@@ -93,6 +94,14 @@ interface ICorestoreCredentialBindingRequestBase {
 }
 export type TCorestoreCredentialBindingRequest = ICorestoreCredentialBindingRequestBase & {
     capability: 'database';
+    /**
+     * Where a workload reaches the database: the `corestoreDatabase` of the node the binding is
+     * placed on. Corestore addresses the binding's connection values to it, and it is part of
+     * the request digest, so a changed endpoint is a changed request that is granted and
+     * published again. A request without it names no address a workload can reach; whether one
+     * is admitted is the provider's decision, never a default this contract supplies.
+     */
+    endpoint?: IPlatformDatabaseEndpoint;
 } | ICorestoreCredentialBindingRequestBase & {
     capability: 'objectstorage';
     bucketName: string;
@@ -129,6 +138,33 @@ export interface ICorestoreObjectStorageCredentialPlaintextMaterial {
 }
 export type TCorestoreCredentialPlaintextMaterial = ICorestoreDatabaseCredentialPlaintextMaterial | ICorestoreObjectStorageCredentialPlaintextMaterial;
 export declare const validateCorestoreDatabaseCredentialMaterial: (materialArg: unknown) => string[];
+/** What a database binding's connection values are made of, besides where the database is. */
+export interface ICorestoreDatabaseCredentialIdentity {
+    databaseName: string;
+    username: string;
+    password: string;
+}
+/**
+ * The connection URI of one database binding, addressed to `endpointArg`:
+ * `mongodb://<username>:<password>@<host>:<port>/<databaseName>?authSource=<databaseName>&directConnection=true`,
+ * the username, password and database name URI-component encoded, an IPv6 host in brackets.
+ * This is the one form Corestore writes and Cloudly checks, so the two can never disagree.
+ */
+export declare const createCorestoreDatabaseUri: (endpointArg: IPlatformDatabaseEndpoint, identityArg: ICorestoreDatabaseCredentialIdentity) => string;
+/**
+ * The eleven connection values of one database binding, addressed to `endpointArg`: the three URI
+ * aliases from `createCorestoreDatabaseUri()`, `MONGODB_HOST` the endpoint host without brackets,
+ * `MONGODB_PORT` its port in decimal, and the database, username and password under both alias
+ * families. Throws the first reason the result would not be valid material; nothing is defaulted.
+ */
+export declare const createCorestoreDatabaseCredentialValues: (endpointArg: IPlatformDatabaseEndpoint, identityArg: ICorestoreDatabaseCredentialIdentity) => TCorestoreDatabaseCredentialValues;
+/**
+ * Validates database material and that it is addressed to `endpointArg`: every value is the one
+ * `createCorestoreDatabaseCredentialValues()` derives from the endpoint and the material's own
+ * database name, username and password. Material a provider addressed to any other host or port —
+ * its own public host above all — is refused by name.
+ */
+export declare const validateCorestoreDatabaseCredentialMaterialEndpoint: (materialArg: unknown, endpointArg: IPlatformDatabaseEndpoint) => string[];
 export declare const validateCorestoreObjectStorageCredentialMaterial: (materialArg: unknown, retentionExpectationArg?: IObjectStorageRetentionEvidenceExpectation) => Promise<string[]>;
 export declare const validateCorestoreCredentialPlaintextMaterial: (materialArg: unknown, retentionExpectationArg?: IObjectStorageRetentionEvidenceExpectation) => Promise<string[]>;
 export interface ICorestoreCredentialSecretValue {