@serve.zone/interfaces 31.9.0 → 32.0.0

package/dist_ts/protocol.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The contract this build speaks: the installed `@serve.zone/interfaces` release.
+ *
+ * There is no protocol number beside it and no per-shape version anywhere in this package. One
+ * release of these interfaces is exactly one contract, so naming the release is the complete
+ * statement about what a peer sends and what it can read.
+ */
+export declare const protocolVersion: string;
+/**
+ * What one side of a session speaks, and the oldest peer it accepts.
+ *
+ * Frozen across majors together with `IProtocolRefusal`: a peer built against the next major must
+ * still be able to read this, or the mismatch it exists to name arrives as an unreadable body and
+ * degrades into a generic contract rejection.
+ */
+export interface IProtocolOffer {
+    /** `MAJOR.MINOR.PATCH` of the `@serve.zone/interfaces` release the sender was built against. */
+    interfacesVersion: string;
+    /**
+     * The oldest peer release this side accepts: in the same major as `interfacesVersion` and never
+     * above it. A deployable raises it in the commit that starts depending on a later minor, for the
+     * session kind that depends on it, which is what orders a rollout: peers first.
+     */
+    minimumPeerVersion: string;
+}
+/**
+ * Why two offers cannot serve one session, judged from the side that refuses.
+ *
+ * `peer-below-minimum` and `self-below-peer-minimum` are the same fact seen from the two sides,
+ * which is why both exist: a log line names who was too old without the reader having to know
+ * which side wrote it.
+ */
+declare const protocolIncompatibilities: readonly ["major-mismatch", "peer-below-minimum", "self-below-peer-minimum"];
+export type TProtocolIncompatibility = (typeof protocolIncompatibilities)[number];
+/**
+ * The named refusal, carried as `TypedResponseError.errorData` on a TypedRequest hop and as the
+ * response body on the Spark heartbeat's refusal status. Frozen across majors.
+ */
+export interface IProtocolRefusal {
+    code: 'protocol-incompatible';
+    /** Judged from the refusing side. */
+    reason: TProtocolIncompatibility;
+    /** The offer of the side that refused. */
+    refusing: IProtocolOffer;
+    /** The offer it refused. */
+    refused: IProtocolOffer;
+}
+export type TProtocolNegotiation = {
+    compatible: true;
+} | {
+    compatible: false;
+    refusal: IProtocolRefusal;
+};
+/**
+ * The cadence at which a refused client offers again.
+ *
+ * Shared so that no client invents its own: a refusal stands until one of the two sides is
+ * upgraded, which is an operator action, so offering faster only costs connections.
+ */
+export declare const refusedOfferRetryIntervalMs = 300000;
+/**
+ * The status a route that carries no typed error answers a refusal with, body `IProtocolRefusal`.
+ *
+ * The Spark routes are plain HTTPS POSTs, so the refusal needs a status of its own: 422 says the
+ * body was read and judged, which is exactly what happened, and separates a refused offer from the
+ * 401 an unknown node gets and the 400 a malformed body gets.
+ */
+export declare const protocolRefusalHttpStatus = 422;
+/**
+ * Validates one protocol offer and names every reason it is refused.
+ *
+ * Shape and self-consistency only, like every other validator in this package: whether the peer
+ * that sent it may open a session is the server's decision against its own records, and whether
+ * the two sides can serve one is `negotiateProtocol`.
+ */
+export declare const validateProtocolOffer: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * Every reason the `protocol` key of a body does not carry one offer.
+ *
+ * The naming twin of `readProtocolOffer`, for a validator that lists reasons instead of throwing:
+ * both read that key once as a data property, so a carrier never runs an accessor a peer put on a
+ * body, and both judge the copy that read produced rather than the peer's object.
+ */
+export declare const validateProtocolOfferOn: (bodyArg: unknown, pathArg?: string) => string[];
+/**
+ * This build's offer towards one kind of peer.
+ *
+ * The spoken version is never stated by the caller: it is the installed release, so an offer
+ * cannot claim a contract this build does not carry. A minimum above that release, or in another
+ * major, is refused here — at start-up of the deployable that declared it, rather than at its
+ * first registration in production.
+ */
+export declare const createProtocolOffer: (minimumPeerVersionArg: string) => IProtocolOffer;
+/**
+ * The offer on a request or response body, read before anything else on that body.
+ *
+ * This is where the one server order on every carrier is written down, so that each carrier can
+ * refer to it instead of restating it: read the raw body as a bounded record, `readProtocolOffer`
+ * on it, `negotiateProtocol` against this server's offer for that session kind, answer a refusal,
+ * and only then the carrier's exact-key validator, the bearer and any mutation. The offer comes
+ * before the validator because every validator in this package is exact-key: a peer of a later
+ * major sends keys this build cannot validate, so a server that shape-checked first would answer
+ * an incompatible peer with a generic malformed-body rejection instead of the named refusal it
+ * backs off from. A carrier whose validator also checks `protocol` checks it for self-consistency
+ * within one major; the negotiation has already happened by then.
+ *
+ * Reads `protocol` alone and touches no other key, for that same reason. The returned offer is
+ * detached, so validating the rest of the body afterwards cannot change what was negotiated.
+ */
+export declare const readProtocolOffer: (bodyArg: unknown) => IProtocolOffer;
+/**
+ * Whether the two sides can serve one session, judged from the local side.
+ *
+ * Pure, and the order of the three checks is part of the contract: a major mismatch is reported as
+ * a major mismatch even when a minimum would also fail, because that is the fact an operator acts
+ * on. The two minimum rules are mirror images — one of them holding means the other holds on the
+ * peer, and they can never hold at once, since that would need each version to be below the other.
+ * An offer whose versions are not release versions is refused by throwing, at the caller that
+ * passed it, rather than named as an incompatibility between two peers.
+ */
+export declare const negotiateProtocol: (localArg: IProtocolOffer, remoteArg: IProtocolOffer) => TProtocolNegotiation;
+/**
+ * The refusal inside an error payload or a response body, or `null` when the value is not one.
+ *
+ * Every transport hands it over as plain JSON, so this reads a value that survived serialization
+ * and answers `null` for everything else: that is how a client tells a protocol refusal, which it
+ * must not retry quickly, apart from every other error a server may return.
+ */
+export declare const readProtocolRefusal: (valueArg: unknown) => IProtocolRefusal | null;
+/**
+ * One line naming both sides, for the log a refusal is judged from.
+ *
+ * It opens with the code, which is the text prefix frozen across majors, so a refusal stays
+ * recognisable in a log written by a build nobody runs any more.
+ */
+export declare const describeProtocolRefusal: (refusalArg: IProtocolRefusal) => string;
+export {};

package/dist_ts/protocol.js

@@ -0,0 +1,255 @@
+import { commitinfo } from './00_commitinfo_data.js';
+import { isPlainRecord, readDataProperty, readExactDataRecord, } from './private/dataproperties.js';
+import { compareReleaseVersions, isReleaseVersion, maximumReleaseVersionLength, parseReleaseVersion, } from './private/releaseversion.js';
+/**
+ * The contract this build speaks: the installed `@serve.zone/interfaces` release.
+ *
+ * There is no protocol number beside it and no per-shape version anywhere in this package. One
+ * release of these interfaces is exactly one contract, so naming the release is the complete
+ * statement about what a peer sends and what it can read.
+ */
+export const protocolVersion = commitinfo.version;
+const protocolOfferKeys = ['interfacesVersion', 'minimumPeerVersion'];
+/**
+ * Why two offers cannot serve one session, judged from the side that refuses.
+ *
+ * `peer-below-minimum` and `self-below-peer-minimum` are the same fact seen from the two sides,
+ * which is why both exist: a log line names who was too old without the reader having to know
+ * which side wrote it.
+ */
+const protocolIncompatibilities = [
+    'major-mismatch',
+    'peer-below-minimum',
+    'self-below-peer-minimum',
+];
+const protocolRefusalKeys = ['code', 'reason', 'refusing', 'refused'];
+/**
+ * The cadence at which a refused client offers again.
+ *
+ * Shared so that no client invents its own: a refusal stands until one of the two sides is
+ * upgraded, which is an operator action, so offering faster only costs connections.
+ */
+export const refusedOfferRetryIntervalMs = 300_000;
+/**
+ * The status a route that carries no typed error answers a refusal with, body `IProtocolRefusal`.
+ *
+ * The Spark routes are plain HTTPS POSTs, so the refusal needs a status of its own: 422 says the
+ * body was read and judged, which is exactly what happened, and separates a refused offer from the
+ * 401 an unknown node gets and the 400 a malformed body gets.
+ */
+export const protocolRefusalHttpStatus = 422;
+const exactSchemaMessage = (pathArg) => `${pathArg} must use its exact schema`;
+const releaseVersionMessage = (pathArg) => (`${pathArg} must be a MAJOR.MINOR.PATCH release version of at most `
+    + `${maximumReleaseVersionLength} characters, without prerelease or build metadata`);
+const requireReleaseVersion = (valueArg, pathArg) => {
+    const version = parseReleaseVersion(valueArg);
+    if (version === null) {
+        throw new Error(releaseVersionMessage(pathArg));
+    }
+    return version;
+};
+/**
+ * The one place an offer is built: frozen, over two values that were read once and then judged.
+ *
+ * Every offer this module hands out comes from here, so what a caller holds shares nothing with
+ * the body it arrived on and cannot change under a session that was already negotiated.
+ */
+const buildProtocolOffer = (interfacesVersionArg, minimumPeerVersionArg) => Object.freeze({
+    interfacesVersion: interfacesVersionArg,
+    minimumPeerVersion: minimumPeerVersionArg,
+});
+/** Every reason two values are not one offer, in the order a reader fixes them. */
+const offerErrors = (interfacesVersionArg, minimumPeerVersionArg, pathArg) => {
+    const spoken = parseReleaseVersion(interfacesVersionArg);
+    const minimum = parseReleaseVersion(minimumPeerVersionArg);
+    if (spoken === null || minimum === null) {
+        return [
+            ...(spoken === null ? [releaseVersionMessage(`${pathArg} interfacesVersion`)] : []),
+            ...(minimum === null ? [releaseVersionMessage(`${pathArg} minimumPeerVersion`)] : []),
+        ];
+    }
+    return [
+        ...(spoken.major !== minimum.major
+            ? [`${pathArg} minimumPeerVersion must be in the same major as interfacesVersion`]
+            : []),
+        ...(compareReleaseVersions(minimum, spoken) > 0
+            ? [`${pathArg} minimumPeerVersion must not be above interfacesVersion`]
+            : []),
+    ];
+};
+/**
+ * Reads both fields once and judges those two values.
+ *
+ * The copy is built from what was judged rather than read again from the source: an offer arrives
+ * on a body a peer wrote, and the session must be served by the offer the validator saw. A field
+ * that is not plain data is refused by `readExactDataRecord` instead of run, so reading an offer
+ * never executes a peer's code and cannot observe two different values.
+ */
+const readOffer = (valueArg, pathArg = 'protocol offer') => {
+    const offer = readExactDataRecord(valueArg, protocolOfferKeys);
+    if (offer === null) {
+        return { offer: null, errors: [exactSchemaMessage(pathArg)] };
+    }
+    const interfacesVersion = offer.interfacesVersion;
+    const minimumPeerVersion = offer.minimumPeerVersion;
+    // The grammar is judged first because the rules below compare two releases, and a value that
+    // names none cannot be compared to one.
+    if (!isReleaseVersion(interfacesVersion) || !isReleaseVersion(minimumPeerVersion)) {
+        return { offer: null, errors: offerErrors(interfacesVersion, minimumPeerVersion, pathArg) };
+    }
+    const errors = offerErrors(interfacesVersion, minimumPeerVersion, pathArg);
+    return errors.length > 0
+        ? { offer: null, errors }
+        : { offer: buildProtocolOffer(interfacesVersion, minimumPeerVersion), errors };
+};
+/**
+ * Validates one protocol offer and names every reason it is refused.
+ *
+ * Shape and self-consistency only, like every other validator in this package: whether the peer
+ * that sent it may open a session is the server's decision against its own records, and whether
+ * the two sides can serve one is `negotiateProtocol`.
+ */
+export const validateProtocolOffer = (valueArg, pathArg = 'protocol offer') => readOffer(valueArg, pathArg).errors;
+/**
+ * Every reason the `protocol` key of a body does not carry one offer.
+ *
+ * The naming twin of `readProtocolOffer`, for a validator that lists reasons instead of throwing:
+ * both read that key once as a data property, so a carrier never runs an accessor a peer put on a
+ * body, and both judge the copy that read produced rather than the peer's object.
+ */
+export const validateProtocolOfferOn = (bodyArg, pathArg = 'protocol offer') => validateProtocolOffer(readDataProperty(bodyArg, 'protocol')?.value, pathArg);
+/** One valid offer, detached and inert, or the first reason the value is not one. */
+const requireProtocolOffer = (valueArg, pathArg) => {
+    const read = readOffer(valueArg, pathArg);
+    if (read.offer === null) {
+        throw new Error(read.errors[0]);
+    }
+    return read.offer;
+};
+/**
+ * This build's offer towards one kind of peer.
+ *
+ * The spoken version is never stated by the caller: it is the installed release, so an offer
+ * cannot claim a contract this build does not carry. A minimum above that release, or in another
+ * major, is refused here — at start-up of the deployable that declared it, rather than at its
+ * first registration in production.
+ */
+export const createProtocolOffer = (minimumPeerVersionArg) => (requireProtocolOffer({
+    interfacesVersion: protocolVersion,
+    minimumPeerVersion: minimumPeerVersionArg,
+}, 'protocol offer'));
+/**
+ * The offer on a request or response body, read before anything else on that body.
+ *
+ * This is where the one server order on every carrier is written down, so that each carrier can
+ * refer to it instead of restating it: read the raw body as a bounded record, `readProtocolOffer`
+ * on it, `negotiateProtocol` against this server's offer for that session kind, answer a refusal,
+ * and only then the carrier's exact-key validator, the bearer and any mutation. The offer comes
+ * before the validator because every validator in this package is exact-key: a peer of a later
+ * major sends keys this build cannot validate, so a server that shape-checked first would answer
+ * an incompatible peer with a generic malformed-body rejection instead of the named refusal it
+ * backs off from. A carrier whose validator also checks `protocol` checks it for self-consistency
+ * within one major; the negotiation has already happened by then.
+ *
+ * Reads `protocol` alone and touches no other key, for that same reason. The returned offer is
+ * detached, so validating the rest of the body afterwards cannot change what was negotiated.
+ */
+export const readProtocolOffer = (bodyArg) => {
+    if (!isPlainRecord(bodyArg)) {
+        throw new Error('protocol offer must be carried as the protocol key of a body record');
+    }
+    // One data property, read once: a `protocol` key that is an accessor carries no offer this
+    // module will serve a session from, exactly like a key that is missing or malformed.
+    return requireProtocolOffer(readDataProperty(bodyArg, 'protocol')?.value, 'protocol offer');
+};
+/**
+ * The one place an `IProtocolRefusal` is built: frozen, over two offers this module already
+ * detached, so a refusal states what was judged and nothing a caller can change afterwards.
+ */
+const buildProtocolRefusal = (reasonArg, refusingArg, refusedArg) => Object.freeze({
+    code: 'protocol-incompatible',
+    reason: reasonArg,
+    refusing: refusingArg,
+    refused: refusedArg,
+});
+/**
+ * One side, read exactly once.
+ *
+ * Only the grammar is judged here: whether two offers can serve one session is the decision this
+ * feeds, and a side whose own two versions disagree still has to get a named answer rather than a
+ * different error. Reading once is what lets the refusal state what was judged while each caller
+ * goes on holding, and changing, its own offer object.
+ */
+const readNegotiatingSide = (offerArg, pathArg) => {
+    const { interfacesVersion, minimumPeerVersion } = offerArg;
+    const spoken = requireReleaseVersion(interfacesVersion, `${pathArg} interfacesVersion`);
+    const minimum = requireReleaseVersion(minimumPeerVersion, `${pathArg} minimumPeerVersion`);
+    return { offer: buildProtocolOffer(interfacesVersion, minimumPeerVersion), spoken, minimum };
+};
+/**
+ * Whether the two sides can serve one session, judged from the local side.
+ *
+ * Pure, and the order of the three checks is part of the contract: a major mismatch is reported as
+ * a major mismatch even when a minimum would also fail, because that is the fact an operator acts
+ * on. The two minimum rules are mirror images — one of them holding means the other holds on the
+ * peer, and they can never hold at once, since that would need each version to be below the other.
+ * An offer whose versions are not release versions is refused by throwing, at the caller that
+ * passed it, rather than named as an incompatibility between two peers.
+ */
+export const negotiateProtocol = (localArg, remoteArg) => {
+    const local = readNegotiatingSide(localArg, 'local protocol offer');
+    const remote = readNegotiatingSide(remoteArg, 'remote protocol offer');
+    const refuse = (reasonArg) => ({
+        compatible: false,
+        refusal: buildProtocolRefusal(reasonArg, local.offer, remote.offer),
+    });
+    if (local.spoken.major !== remote.spoken.major) {
+        return refuse('major-mismatch');
+    }
+    if (compareReleaseVersions(remote.spoken, local.minimum) < 0) {
+        return refuse('peer-below-minimum');
+    }
+    if (compareReleaseVersions(local.spoken, remote.minimum) < 0) {
+        return refuse('self-below-peer-minimum');
+    }
+    return { compatible: true };
+};
+const isProtocolIncompatibility = (valueArg) => (protocolIncompatibilities.some((reasonArg) => reasonArg === valueArg));
+/**
+ * The refusal inside an error payload or a response body, or `null` when the value is not one.
+ *
+ * Every transport hands it over as plain JSON, so this reads a value that survived serialization
+ * and answers `null` for everything else: that is how a client tells a protocol refusal, which it
+ * must not retry quickly, apart from every other error a server may return.
+ */
+export const readProtocolRefusal = (valueArg) => {
+    const refusal = readExactDataRecord(valueArg, protocolRefusalKeys);
+    if (refusal === null) {
+        return null;
+    }
+    // Every field is read once and both offers are judged as copies, so what a client waits on is
+    // what its own check answered `null` or a refusal for.
+    const code = refusal.code;
+    const reason = refusal.reason;
+    if (code !== 'protocol-incompatible' || !isProtocolIncompatibility(reason)) {
+        return null;
+    }
+    const refusing = readOffer(refusal.refusing).offer;
+    const refused = readOffer(refusal.refused).offer;
+    if (refusing === null || refused === null) {
+        return null;
+    }
+    return buildProtocolRefusal(reason, refusing, refused);
+};
+/**
+ * One line naming both sides, for the log a refusal is judged from.
+ *
+ * It opens with the code, which is the text prefix frozen across majors, so a refusal stays
+ * recognisable in a log written by a build nobody runs any more.
+ */
+export const describeProtocolRefusal = (refusalArg) => (`${refusalArg.code} (${refusalArg.reason}): `
+    + `refusing side speaks ${refusalArg.refusing.interfacesVersion} `
+    + `and accepts from ${refusalArg.refusing.minimumPeerVersion}; `
+    + `refused side speaks ${refusalArg.refused.interfacesVersion} `
+    + `and accepts from ${refusalArg.refused.minimumPeerVersion}`);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../ts/protocol.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/admin.d.ts

@@ -1,15 +1,15 @@
 import * as plugins from '../plugins.js';
 import type { IIdentity, IIdentityCredential, IServiceDeploymentGrant } from '../data/user.js';
-import type { IServiceMachineCredentialMetadataV1, IServiceMachineCredentialMutationResultV1, TServiceMachineCredentialMutationV1 } from '../data/servicecredential.js';
-export interface IReq_Admin_GetServiceMachineCredentialV1 extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_GetServiceMachineCredentialV1> {
-    method: 'getServiceMachineCredentialV1';
+import type { IServiceMachineCredentialMetadata, IServiceMachineCredentialMutationResult, TServiceMachineCredentialMutation } from '../data/servicecredential.js';
+export interface IReq_Admin_GetServiceMachineCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_GetServiceMachineCredential> {
+    method: 'getServiceMachineCredential';
     request: {
         identity: IIdentityCredential;
         organizationId: string;
         serviceId: string;
     };
     response: {
-        credential: IServiceMachineCredentialMetadataV1 | null;
+        credential: IServiceMachineCredentialMetadata | null;
     };
 }
 /**
@@ -17,13 +17,13 @@ export interface IReq_Admin_GetServiceMachineCredentialV1 extends plugins.typedr
  * encrypted SecretSet delivery and the replay receipt in one fenced transaction.
  * No bearer is returned. Existing legacy deployment/cluster credentials are separate.
  */
-export interface IReq_Admin_MutateServiceMachineCredentialV1 extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_MutateServiceMachineCredentialV1> {
-    method: 'mutateServiceMachineCredentialV1';
+export interface IReq_Admin_MutateServiceMachineCredential extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Admin_MutateServiceMachineCredential> {
+    method: 'mutateServiceMachineCredential';
     request: {
         identity: IIdentityCredential;
-        mutation: TServiceMachineCredentialMutationV1;
+        mutation: TServiceMachineCredentialMutation;
     };
-    response: IServiceMachineCredentialMutationResultV1;
+    response: IServiceMachineCredentialMutationResult;
 }
 /** Backend-owned human credential metadata; never includes a password verifier. */
 export interface IHumanCredentialMetadata {