@serve.zone/interfaces 32.64.0 → 32.66.0

package/ts/data/networkdnscomposition.ts

@@ -0,0 +1,113 @@
+import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
+import type { IRuntimeNetworkDnsRecordSet, IRuntimeNetworkDnsRecordSets, IRuntimeNetworkDnsView, IRuntimeNetworkEndpoint,
+  IRuntimeNetworkProjection } from './networkprojection.js';
+import type { IPrivateNetwork, IServicePrivateNetworks } from './privatenetwork.js';
+import { buildPrivateNetworkFqdn, composeServicePrivateNetworkDnsPolicy } from './privatenetwork.js';
+import { networkCanonical, networkEqual, networkReferenceOf, networkSameScope, requireNetwork } from '../private/networkcontract.js';
+
+const ownerKey = (value: { organizationId: string; serviceId: string }): string => networkCanonical([value.organizationId, value.serviceId]);
+
+/**
+ * Internal DNS composition after validation. The public composers validate the whole projection
+ * first; these read only the validated projection and the captured selection, never an attachment
+ * journal, so their answers are a pure function of both.
+ *
+ * The local endpoints a composition serves, in projection order: every local endpoint, or exactly
+ * the selected ones, each named once and each local.
+ */
+export const dnsSourcesOf = (projection: IRuntimeNetworkProjection,
+  selected: readonly IRuntimeAuthorityReference[] | null): IRuntimeNetworkEndpoint[] => {
+  const local = projection.endpoints.filter(endpoint => networkSameScope(endpoint.lease, projection));
+  if (selected !== null) {
+    requireNetwork(new Set(selected.map(source => source.id)).size === selected.length);
+    for (const source of selected) requireNetwork(local.some(endpoint => networkEqual(networkReferenceOf(endpoint.lease), source)));
+  }
+  return local.filter(endpoint => selected === null || selected.some(source => networkEqual(networkReferenceOf(endpoint.lease), source)));
+};
+
+/**
+ * Each membership's ready replica addresses, sorted, read once per projection: one pass over the
+ * endpoints, so a name's A set costs a lookup instead of a scan of every endpoint (O(M+E), not
+ * O(M*E)). A membership without a ready replica has none and its names are declared NODATA.
+ */
+export const readyAddressesOf = (projection: IRuntimeNetworkProjection): Map<string, string[]> => {
+  const ready = new Map<string, string[]>();
+  for (const { ready: isReady, lease } of projection.endpoints) {
+    if (!isReady) continue;
+    const key = ownerKey(lease);
+    let addresses = ready.get(key);
+    if (!addresses) ready.set(key, addresses = []);
+    addresses.push(lease.ipv4.address);
+  }
+  for (const addresses of ready.values()) addresses.sort();
+  return ready;
+};
+
+const policyOf = (projection: IRuntimeNetworkProjection, networks: Map<string, IPrivateNetwork>, member: IServicePrivateNetworks) =>
+  composeServicePrivateNetworkDnsPolicy(member, member.attachments.map(attachment => networks.get(attachment.networkId)),
+    projection.protectedAuthority.resolvers);
+const byName = (left: { name: string }, right: { name: string }) => left.name < right.name ? -1 : 1;
+
+/** One union view per source (`composeRuntimeNetworkProjectionDnsViews`). */
+export const dnsViewsOf = (projection: IRuntimeNetworkProjection,
+  selected: readonly IRuntimeAuthorityReference[] | null): IRuntimeNetworkDnsView[] => {
+  const sources = dnsSourcesOf(projection, selected);
+  const networks = new Map(projection.networks.map(network => [network.id, network]));
+  const members = new Map(projection.memberships.map(member => [ownerKey(member), member]));
+  const ready = readyAddressesOf(projection);
+  return sources.map(({ lease }) => {
+    const member = members.get(ownerKey(lease))!, { organizationId, attachments } = member;
+    const policy = policyOf(projection, networks, member), attached = new Set(attachments.map(own => own.networkId));
+    const records: IRuntimeNetworkDnsView['records'] = [];
+    for (const target of projection.memberships) {
+      if (target.organizationId !== organizationId) continue;
+      const addresses = ready.get(ownerKey(target)) ?? [];
+      for (const attachment of target.attachments) {
+        if (!attached.has(attachment.networkId)) continue;
+        for (const alias of attachment.aliases) records.push({ name: buildPrivateNetworkFqdn(networks.get(attachment.networkId), alias), addresses: [...addresses] });
+      }
+    }
+    records.sort(byName);
+    return { source: networkReferenceOf(lease), sourceAddress: lease.ipv4.address, dnsServer: lease.dnsServer, policy, records };
+  });
+};
+
+/**
+ * One record set per network a selected source attaches, and per source its view without records
+ * (`composeRuntimeNetworkProjectionDnsRecordSets`). A network's set holds every alias of every
+ * membership attaching it, which the projection's validation confines to the network's own
+ * organization, so the union of a source's sets is its union view's records.
+ */
+export const dnsRecordSetsOf = (projection: IRuntimeNetworkProjection,
+  selected: readonly IRuntimeAuthorityReference[] | null): IRuntimeNetworkDnsRecordSets => {
+  const sources = dnsSourcesOf(projection, selected);
+  const networks = new Map(projection.networks.map(network => [network.id, network]));
+  const members = new Map(projection.memberships.map(member => [ownerKey(member), member]));
+  const suffixes = new Map<string, string>();
+  const views = sources.map(({ lease }) => {
+    const policy = policyOf(projection, networks, members.get(ownerKey(lease))!);
+    for (const network of policy.networkSuffixes) suffixes.set(network.networkId, network.dnsSuffix);
+    return { source: networkReferenceOf(lease), sourceAddress: lease.ipv4.address, dnsServer: lease.dnsServer,
+      policy, networkIds: policy.networkSuffixes.map(network => network.networkId) };
+  });
+  // Only the networks a selected source references, in network id order (the projection's order).
+  const sets = new Map<string, IRuntimeNetworkDnsRecordSet>();
+  for (const network of projection.networks) {
+    const dnsSuffix = suffixes.get(network.id);
+    if (dnsSuffix !== undefined) sets.set(network.id, { networkId: network.id, dnsSuffix, records: [] });
+  }
+  if (sets.size > 0) {
+    const ready = readyAddressesOf(projection);
+    for (const target of projection.memberships) {
+      for (const attachment of target.attachments) {
+        const set = sets.get(attachment.networkId);
+        if (!set) continue;
+        const addresses = ready.get(ownerKey(target)) ?? [];
+        for (const alias of attachment.aliases) set.records.push({ name: buildPrivateNetworkFqdn(networks.get(attachment.networkId), alias), addresses: [...addresses] });
+      }
+    }
+  }
+  const recordSets = [...sets.values()];
+  for (const set of recordSets) set.records.sort(byName);
+  return { recordSets, views };
+};

package/ts/data/networkprojection.ts

@@ -10,6 +10,7 @@ import { routerPacketGrantsOf, snapshotRouterProjection,
 import { hostPacketGrantsOf, snapshotHostProjection,
   type IRuntimeNetworkHostPacketGrant, type IRuntimeNetworkHostProjection } from './networkhost.js';
 import { privateMeshEndpointsOf, type IRuntimeNetworkPrivateMesh } from './networkprivatemesh.js';
+import { dnsRecordSetsOf, dnsViewsOf } from './networkdnscomposition.js';
 import { snapshotWorkloadIngressProjection, workloadIngressPacketGrantsOf,
   type IRuntimeNetworkWorkloadIngressPacketGrant, type IRuntimeNetworkWorkloadIngressProjection } from './networkworkloadingress.js';
 import { requireFirstProjectionRetirement, requireProjectionRetirement, snapshotRuntimeNetworkProjectionRetirement,
@@ -323,6 +324,42 @@ export interface IRuntimeNetworkDnsView {
   records: Array<{ name: string; addresses: string[] }>;
 }
 
+/**
+ * The DNS records of one private network, defined once for every source that attaches it
+ * (`composeRuntimeNetworkProjectionDnsRecordSets`).
+ */
+export interface IRuntimeNetworkDnsRecordSet {
+  networkId: string;
+  /** The network's zone, exactly its `IServicePrivateNetworkDnsPolicy.networkSuffixes` entry. */
+  dnsSuffix: string;
+  /**
+   * Every alias of every membership attaching the network, sorted by name, with its complete
+   * ready-replica A set; [] is declared NODATA, as in `IRuntimeNetworkDnsView.records`.
+   */
+  records: IRuntimeNetworkDnsView['records'];
+}
+
+/** One selected source: its union view without records, and the record sets it serves instead. */
+export interface IRuntimeNetworkDnsSetView {
+  source: IRuntimeAuthorityReference;
+  sourceAddress: string;
+  dnsServer: string;
+  policy: IServicePrivateNetworkDnsPolicy;
+  /**
+   * The `networkId` of each record set this source serves: its attached networks, in
+   * `policy.networkSuffixes` order. The union of those sets' records is exactly the records of its
+   * `IRuntimeNetworkDnsView`; no name is in two of them.
+   */
+  networkIds: string[];
+}
+
+export interface IRuntimeNetworkDnsRecordSets {
+  /** One per network some selected source attaches, and no other, sorted by network id. */
+  recordSets: IRuntimeNetworkDnsRecordSet[];
+  /** One per selected local source, in projection order, as `composeRuntimeNetworkProjectionDnsViews` answers. */
+  views: IRuntimeNetworkDnsSetView[];
+}
+
 export const runtimeNetworkProjectionContract = Object.freeze({
   workloadDigestDomain: 'serve.zone/runtime-network-workload-lease',
   projectionDigestDomain: 'serve.zone/runtime-network-projection',
@@ -763,31 +800,24 @@ export const composeRuntimeNetworkProjectionDnsViews = async (
   value: unknown, sourcesValue?: readonly IRuntimeAuthorityReference[],
 ): Promise<IRuntimeNetworkDnsView[]> => {
   const selected = sourcesValue === undefined ? null : networkList(captureNetwork(sourcesValue), 256, networkReference);
-  const projection = await validateRuntimeNetworkProjection(value);
-  const local = projection.endpoints.filter(endpoint => networkSameScope(endpoint.lease, projection));
-  if (selected !== null) {
-    requireNetwork(new Set(selected.map(source => source.id)).size === selected.length);
-    for (const source of selected) requireNetwork(local.some(endpoint => networkEqual(networkReferenceOf(endpoint.lease), source)));
-  }
-  const networks = new Map(projection.networks.map(network => [network.id, network]));
-  const members = new Map(projection.memberships.map(member => [ownerKey(member), member]));
-  return local.filter(endpoint => selected === null || selected.some(source => networkEqual(networkReferenceOf(endpoint.lease), source))).map(endpoint => {
-    const member = members.get(ownerKey(endpoint.lease))!;
-    const policy = composeServicePrivateNetworkDnsPolicy(member,
-      member.attachments.map(attachment => networks.get(attachment.networkId)), projection.protectedAuthority.resolvers);
-    const records: IRuntimeNetworkDnsView['records'] = [];
-    for (const target of projection.memberships) {
-      if (target.organizationId !== member.organizationId) continue;
-      const addresses = projection.endpoints.filter(candidate => candidate.ready && ownerKey(candidate.lease) === ownerKey(target))
-        .map(candidate => candidate.lease.ipv4.address).sort();
-      for (const attachment of target.attachments) {
-        if (!member.attachments.some(own => own.networkId === attachment.networkId)) continue;
-        for (const alias of attachment.aliases) records.push({ name: buildPrivateNetworkFqdn(networks.get(attachment.networkId), alias), addresses: [...addresses] });
-      }
-    }
-    records.sort((left, right) => left.name < right.name ? -1 : 1);
-    return { source: networkReferenceOf(endpoint.lease), sourceAddress: endpoint.lease.ipv4.address, dnsServer: endpoint.lease.dnsServer, policy, records };
-  });
+  return dnsViewsOf(await validateRuntimeNetworkProjection(value), selected);
+};
+
+/**
+ * The same DNS material with each network's records defined once: one record set per private
+ * network a selected local source attaches, and per source its view without records, naming its
+ * networks' sets in `policy.networkSuffixes` order. A source's sets together hold exactly the
+ * records of its `composeRuntimeNetworkProjectionDnsViews` view, so the material grows with sources
+ * plus names rather than with their product. Selection, validation and refusals are those of
+ * `composeRuntimeNetworkProjectionDnsViews`; the answer is a pure function of the validated
+ * projection and the selection, in a stable order. It names no consumer's identifiers: a consumer
+ * derives its own set ids.
+ */
+export const composeRuntimeNetworkProjectionDnsRecordSets = async (
+  value: unknown, sourcesValue?: readonly IRuntimeAuthorityReference[],
+): Promise<IRuntimeNetworkDnsRecordSets> => {
+  const selected = sourcesValue === undefined ? null : networkList(captureNetwork(sourcesValue), 256, networkReference);
+  return dnsRecordSetsOf(await validateRuntimeNetworkProjection(value), selected);
 };
 
 /** Bind immutable address material without a circular assignment-digest dependency. */

package/ts/requests/hostedapp.ts

@@ -1,6 +1,7 @@
 import * as plugins from '../plugins.js';
 import type * as data from '../data/index.js';
 import type { IIdentity, IIdentityCredential } from '../data/user.js';
+import { hostedAppStatusMessageMaximumLength } from '../data/hostedapp.js';
 import type {
   IHostedAppBootstrapAction,
   IHostedAppBootstrapActionRequest,
@@ -211,7 +212,8 @@ export const validateHostedAppCompleteBootstrapActionRequest = (
     errors.push('hosted app bootstrap completion must fence ready status');
   }
   if (request.message !== undefined
-    && (typeof request.message !== 'string' || request.message.length > 4000)) {
+    && (typeof request.message !== 'string'
+      || request.message.length > hostedAppStatusMessageMaximumLength)) {
     errors.push('hosted app bootstrap completion message must be bounded');
   }
   return errors;