@rathnasgala2/schemas 2.11.0 → 2.12.0

package/src/internal/http-problem-contract.js

@@ -1,35 +0,0 @@
-export const HTTP_PROBLEM_EXAMPLE_RULES =
-  /** @type {Readonly<
-   *   Record<string, {statuses: readonly number[], retryable: boolean}>
-   * >} */ (
-    Object.freeze({
-      AUTHENTICATION_REQUIRED: { statuses: [401], retryable: false },
-      AUTHORIZATION_DENIED: { statuses: [403], retryable: false },
-      CAPABILITY_EXPIRED: { statuses: [410], retryable: false },
-      CAPABILITY_UNAVAILABLE: { statuses: [503], retryable: false },
-      COMMAND_REPLAY_CONFLICT: { statuses: [409], retryable: false },
-      DEPENDENCY_UNAVAILABLE: { statuses: [503], retryable: true },
-      DESTINATION_MUTATION_IN_PROGRESS: { statuses: [409], retryable: false },
-      INVALID_SOURCE_STATE: { statuses: [409], retryable: false },
-      RATE_LIMITED: { statuses: [429], retryable: true },
-      REAUTH_REQUIRED: { statuses: [401], retryable: false },
-      REPORTING_CAPABILITY_INVALID: { statuses: [401], retryable: false },
-      REQUEST_FIELD_UNKNOWN: { statuses: [400], retryable: false },
-      RESOURCE_NOT_FOUND: { statuses: [404], retryable: false },
-      RESPONSE_REPRESENTATION_LIMIT_EXCEEDED: {
-        statuses: [500],
-        retryable: false,
-      },
-      STALE_AGGREGATE_VERSION: { statuses: [412], retryable: false },
-      VALIDATION_FAILED: {
-        statuses: [400, 413, 415, 422],
-        retryable: false,
-      },
-      VERIFICATION_EVIDENCE_LIMIT_EXCEEDED: {
-        statuses: [422],
-        retryable: false,
-      },
-      WORKLOAD_BINDING_INVALID: { statuses: [403], retryable: false },
-      WORKLOAD_REPLAYED: { statuses: [409], retryable: false },
-    })
-  );

package/src/internal/managed-evidence-journal.js

@@ -1,160 +0,0 @@
-import { canonicalizeJcs } from './canonical-jcs.js';
-import {
-  appendManagedEvidenceHead,
-  digestManagedEvidenceEntry,
-  digestManagedEvidenceGenesis,
-} from './digest-profiles.js';
-import { SemanticValidationError } from './semver.js';
-
-const DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/u;
-
-/**
- * Raise one stable journal diagnostic.
- *
- * @returns {never}
- */
-function invalidJournal() {
-  throw new SemanticValidationError('MANAGED_EVIDENCE_JOURNAL_INVALID');
-}
-
-/**
- * Require an ordinary JSON object.
- *
- * @param {unknown} value candidate value
- * @returns {Record<string, unknown>} object
- */
-function asObject(value) {
-  if (
-    value === null ||
-    typeof value !== 'object' ||
-    Array.isArray(value) ||
-    Object.getPrototypeOf(value) !== Object.prototype
-  ) {
-    return invalidJournal();
-  }
-  return /** @type {Record<string, unknown>} */ (value);
-}
-
-/**
- * Require an object's exact member set.
- *
- * @param {Record<string, unknown>} value object
- * @param {readonly string[]} keys exact keys
- * @returns {void}
- */
-function requireKeys(value, keys) {
-  const actual = Object.keys(value).sort();
-  const expected = [...keys].sort();
-  if (
-    actual.length !== expected.length ||
-    actual.some((key, index) => key !== expected[index])
-  ) {
-    invalidJournal();
-  }
-}
-
-/**
- * Require a canonical tagged SHA-256 digest.
- *
- * @param {unknown} value candidate digest
- * @returns {string} digest
- */
-function requireDigest(value) {
-  if (typeof value !== 'string' || !DIGEST_PATTERN.test(value)) {
-    return invalidJournal();
-  }
-  return value;
-}
-
-/**
- * Validate a complete managed evidence journal against receipt coordinates.
- *
- * This is an internal validator context, not a portable wire shape. Each entry
- * is the stored response projection without receipt/page fields; the owning
- * API schema supplies structural validation for each attempt and observation.
- *
- * @param {{
- *   operationId: string,
- *   runAttempt: number,
- *   entries: unknown[],
- *   receiptEntryCount: number,
- *   receiptHeadDigest: string
- * }} context complete retained journal context
- * @returns {{entryCount: number, headDigest: string}} validated terminal state
- */
-export function validateManagedEvidenceJournal(context) {
-  const {
-    operationId,
-    runAttempt,
-    entries,
-    receiptEntryCount,
-    receiptHeadDigest,
-  } = context;
-  if (
-    typeof operationId !== 'string' ||
-    operationId.length === 0 ||
-    !Number.isInteger(runAttempt) ||
-    runAttempt < 1 ||
-    runAttempt > 51 ||
-    !Array.isArray(entries) ||
-    entries.length < 1 ||
-    entries.length > 1_100 ||
-    receiptEntryCount !== entries.length
-  ) {
-    return invalidJournal();
-  }
-
-  let headDigest = digestManagedEvidenceGenesis({ operationId, runAttempt });
-  const wrappers = new Set();
-  const identities = new Set();
-  const nextSequence = { attempt: 1, observation: 1 };
-  for (let index = 0; index < entries.length; index += 1) {
-    const entry = asObject(entries[index]);
-    const entryType = entry.entryType;
-    if (entryType !== 'attempt' && entryType !== 'observation') {
-      return invalidJournal();
-    }
-    const selectedMember = entryType;
-    requireKeys(entry, [
-      'entryNumber',
-      'previousHeadDigest',
-      'entryType',
-      selectedMember,
-      'entryDigest',
-      'headDigest',
-    ]);
-    if (entry.entryNumber !== index + 1) return invalidJournal();
-    if (requireDigest(entry.previousHeadDigest) !== headDigest) {
-      return invalidJournal();
-    }
-    const record = asObject(entry[selectedMember]);
-    if (record.sequence !== nextSequence[entryType]) return invalidJournal();
-    nextSequence[entryType] += 1;
-    const identityName =
-      entryType === 'attempt' ? 'stageAttemptId' : 'observationId';
-    const identity = record[identityName];
-    if (typeof identity !== 'string' || identity.length === 0) {
-      return invalidJournal();
-    }
-    const typedIdentity = `${entryType}:${identity}`;
-    if (identities.has(typedIdentity)) return invalidJournal();
-    identities.add(typedIdentity);
-
-    const wrapper = { entryType, [selectedMember]: record };
-    const wrapperBytes = canonicalizeJcs(wrapper);
-    if (wrappers.has(wrapperBytes)) return invalidJournal();
-    wrappers.add(wrapperBytes);
-    const entryDigest = digestManagedEvidenceEntry(wrapper);
-    if (requireDigest(entry.entryDigest) !== entryDigest) {
-      return invalidJournal();
-    }
-    headDigest = appendManagedEvidenceHead(headDigest, entryDigest);
-    if (requireDigest(entry.headDigest) !== headDigest) {
-      return invalidJournal();
-    }
-  }
-  if (requireDigest(receiptHeadDigest) !== headDigest) {
-    return invalidJournal();
-  }
-  return { entryCount: entries.length, headDigest };
-}

package/src/internal/public-runtime-origins.js

@@ -1,143 +0,0 @@
-import { createHash } from 'node:crypto';
-
-import { canonicalizeJcsBytes } from './canonical-jcs.js';
-import { validateRfc3339 } from './portable-scalars.js';
-
-const DOMAIN = 'GALA-PUBLIC-RUNTIME-ORIGINS-V2\0';
-const MAXIMUM_VALIDITY_MILLISECONDS = 300_000;
-const CATALOG_BINDING_FIELDS = [
-  'environment',
-  'generation',
-  'appOrigin',
-  'apiOrigin',
-  'schemaDocsOrigin',
-  'publicRecoveryBase',
-  'transactionalLinkBase',
-  'sourceCatalogGeneration',
-  'sourceCatalogDigest',
-  'appArtifactDigest',
-];
-const EXPECTED_BINDING_FIELDS = [
-  ...CATALOG_BINDING_FIELDS,
-  'documentOrigin',
-  'observedAt',
-];
-
-/**
- * Require a plain JSON object.
- *
- * @param {unknown} value candidate value
- * @param {string} code diagnostic code
- * @returns {Record<string, unknown>} checked record
- */
-function asRecord(value, code) {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    throw new TypeError(code);
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw new TypeError(code);
-  }
-  return /** @type {Record<string, unknown>} */ (value);
-}
-
-/**
- * Require and parse one canonical Gala timestamp.
- *
- * @param {unknown} value candidate timestamp
- * @param {string} code diagnostic code
- * @returns {number} epoch milliseconds
- */
-function timestamp(value, code) {
-  if (typeof value !== 'string') throw new TypeError(code);
-  try {
-    validateRfc3339(value);
-  } catch {
-    throw new TypeError(code);
-  }
-  const milliseconds = Date.parse(value);
-  if (!Number.isFinite(milliseconds)) throw new TypeError(code);
-  return milliseconds;
-}
-
-/**
- * Project a public-runtime-origins record for its self-excluding digest.
- *
- * @param {unknown} value complete or pre-digest runtime-origins record
- * @returns {Record<string, unknown>} record without payloadDigest
- */
-export function projectPublicRuntimeOrigins(value) {
-  const record = asRecord(value, 'PUBLIC_RUNTIME_ORIGINS_RECORD_INVALID');
-  return Object.fromEntries(
-    Object.entries(record).filter(([key]) => key !== 'payloadDigest'),
-  );
-}
-
-/**
- * Compute the runtime-origins self-excluding domain-separated digest.
- *
- * @param {unknown} value complete or pre-digest runtime-origins record
- * @returns {string} tagged SHA-256 digest
- */
-export function digestPublicRuntimeOrigins(value) {
-  return `sha256:${createHash('sha256')
-    .update(DOMAIN, 'utf8')
-    .update(canonicalizeJcsBytes(projectPublicRuntimeOrigins(value)))
-    .digest('base64url')}`;
-}
-
-/**
- * Validate runtime-origin time, digest and exact App binding semantics.
- *
- * @param {unknown} value structurally valid runtime-origins record
- * @param {unknown} expectedBinding expected catalog, document-origin and observation binding
- * @returns {void}
- */
-export function validatePublicRuntimeOrigins(value, expectedBinding) {
-  const record = asRecord(value, 'PUBLIC_RUNTIME_ORIGINS_RECORD_INVALID');
-  const binding = asRecord(
-    expectedBinding,
-    'PUBLIC_RUNTIME_ORIGINS_BINDING_INVALID',
-  );
-  if (
-    Object.keys(binding).length !== EXPECTED_BINDING_FIELDS.length ||
-    EXPECTED_BINDING_FIELDS.some((field) => !Object.hasOwn(binding, field))
-  ) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_BINDING_INVALID');
-  }
-  const issuedAt = timestamp(
-    record.issuedAt,
-    'PUBLIC_RUNTIME_ORIGINS_TIME_INVALID',
-  );
-  const expiresAt = timestamp(
-    record.expiresAt,
-    'PUBLIC_RUNTIME_ORIGINS_TIME_INVALID',
-  );
-  if (
-    expiresAt <= issuedAt ||
-    expiresAt - issuedAt > MAXIMUM_VALIDITY_MILLISECONDS
-  ) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_TIME_INVALID');
-  }
-  if (record.payloadDigest !== digestPublicRuntimeOrigins(record)) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_DIGEST_INVALID');
-  }
-  if (
-    CATALOG_BINDING_FIELDS.some((field) => record[field] !== binding[field])
-  ) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_BINDING_INVALID');
-  }
-  if (record.appOrigin !== binding.documentOrigin) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_APP_ORIGIN_INVALID');
-  }
-  const observedAt = timestamp(
-    binding.observedAt,
-    'PUBLIC_RUNTIME_ORIGINS_TIME_INVALID',
-  );
-  if (observedAt < issuedAt) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_TIME_INVALID');
-  }
-  if (observedAt >= expiresAt) {
-    throw new TypeError('PUBLIC_RUNTIME_ORIGINS_EXPIRED');
-  }
-}