@hops-ops/distributed 0.0.0

package/dist/replica/identity/clone.d.ts

@@ -0,0 +1,6 @@
+import type { GraphqlVariables } from '../../types.js';
+import type { ReplicaValue } from '../types.js';
+export declare function canonicalVariables(variables: GraphqlVariables): string;
+export declare function cloneJsonObject(value: GraphqlVariables): Readonly<Record<string, ReplicaValue>>;
+export declare function cloneJsonValue(value: unknown, ancestors?: Set<object>): ReplicaValue;
+export declare function canonicalCacheValue(value: ReplicaValue): string;

package/dist/replica/identity/clone.js

@@ -0,0 +1,54 @@
+import { freezeRecord } from '../../lib/freeze-record.js';
+export function canonicalVariables(variables) {
+    return canonicalCacheValue(cloneJsonObject(variables));
+}
+export function cloneJsonObject(value) {
+    const entries = [];
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry === undefined)
+            continue;
+        entries.push([key, cloneJsonValue(entry)]);
+    }
+    return freezeRecord(entries);
+}
+export function cloneJsonValue(value, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean' ||
+        typeof value === 'number') {
+        if (typeof value === 'number' && !Number.isFinite(value)) {
+            throw new TypeError('replica values must contain only finite numbers');
+        }
+        return value;
+    }
+    if (typeof value !== 'object') {
+        throw new TypeError('replica values must be JSON-compatible');
+    }
+    if (ancestors.has(value))
+        throw new TypeError('replica values must not contain cycles');
+    ancestors.add(value);
+    let cloned;
+    if (Array.isArray(value)) {
+        cloned = Object.freeze(value.map((entry) => cloneJsonValue(entry, ancestors)));
+    }
+    else {
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError('replica objects must be plain JSON objects');
+        }
+        cloned = freezeRecord(Object.entries(value).flatMap(([key, entry]) => entry === undefined ? [] : [[key, cloneJsonValue(entry, ancestors)]]));
+    }
+    ancestors.delete(value);
+    return cloned;
+}
+export function canonicalCacheValue(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalCacheValue).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalCacheValue(record[key])}`)
+        .join(',')}}`;
+}

package/dist/replica/identity/codec.d.ts

@@ -0,0 +1,48 @@
+import type { GraphqlVariables } from '../../types.js';
+import type { ReplicaOperationArtifact, ReplicaVariableCodecArtifact, ReplicaVariableCodecLimits, ReplicaVariableFilterInputDefinition, ReplicaVariableFilterInputField, ReplicaVariableInputDefinition, ReplicaVariableInputRef, ReplicaVariableOrderInputDefinition, ReplicaValue } from '../types.js';
+export type VariableCodecRegistry = {
+    readonly limits: ReplicaVariableCodecLimits;
+    readonly variables: ReadonlyMap<string, ReplicaVariableInputRef>;
+    readonly inputs: ReadonlyMap<string, ReplicaVariableInputDefinition>;
+};
+/**
+ * Apply the exact compiler-owned GraphQL input coercion contract before an
+ * operation can acquire cache identity or reach a transport.
+ */
+export declare function canonicalizeOperationVariables<TData, TVariables extends GraphqlVariables>(artifact: ReplicaOperationArtifact<TData, TVariables>, variables: TVariables): TVariables;
+export declare function validateVariableCodec(codec: ReplicaVariableCodecArtifact): VariableCodecRegistry;
+export declare function validateInputRef(value: unknown, path: string, inputs: ReadonlyMap<string, ReplicaVariableInputDefinition>, limits: ReplicaVariableCodecLimits, active: Set<object>, depth: number): void;
+export declare function validateInputDefinition(value: ReplicaVariableInputDefinition, path: string, inputs: ReadonlyMap<string, ReplicaVariableInputDefinition>, active: Set<object>, depth: number): void;
+export declare function validateFilterInputDefinition(definition: ReplicaVariableFilterInputDefinition, path: string, inputs: ReadonlyMap<string, ReplicaVariableInputDefinition>, active: Set<object>, depth: number): void;
+export declare function validateOrderInputDefinition(definition: ReplicaVariableOrderInputDefinition, path: string, active: Set<object>): void;
+export declare function canonicalizeInputRef(input: ReplicaVariableInputRef, value: unknown, registry: VariableCodecRegistry, path: string, active: Set<object>, depth: number): ReplicaValue;
+export declare function canonicalizeInputDefinition(definition: ReplicaVariableInputDefinition, value: unknown, registry: VariableCodecRegistry, path: string, active: Set<object>, depth: number, filterBaseDepth: number | undefined): ReplicaValue;
+export declare function canonicalizeFilterInput(definition: ReplicaVariableFilterInputDefinition, value: unknown, registry: VariableCodecRegistry, path: string, active: Set<object>, depth: number, filterDepth: number): ReplicaValue;
+export declare function canonicalizeFilterComparison(field: ReplicaVariableFilterInputField, value: unknown, path: string, active: Set<object>, depth: number, limits: ReplicaVariableCodecLimits): ReplicaValue;
+export declare function canonicalizeOrderInput(definition: ReplicaVariableOrderInputDefinition, value: unknown, path: string, active: Set<object>, depth: number): ReplicaValue;
+export declare function canonicalizeScalar(scalar: string, codec: string, value: unknown, path: string): ReplicaValue;
+export declare function canonicalizeBase64(value: unknown, path: string): string;
+export declare function cloneCanonicalJsonObject(value: unknown, path: string, active: Set<object>, depth: number, omitUndefined: boolean): Readonly<Record<string, ReplicaValue>>;
+export declare function cloneCanonicalJsonValue(value: unknown, path: string, active: Set<object>, depth: number, omitUndefined: boolean): ReplicaValue;
+export declare function validateScalarContract(scalar: unknown, codec: unknown, path: string): void;
+export declare function validateFilterOperatorContract(scalar: string, operator: string, path: string): void;
+export declare function validateStringInventory(value: unknown, path: string): void;
+export declare function artifactRecord(value: unknown, path: string, expectedKeys?: readonly string[]): Record<string, unknown>;
+export declare function artifactRecordEntries(value: unknown, path: string): Array<readonly [string, unknown]>;
+export declare function inputRecordEntries(value: unknown, path: string): Array<readonly [string, unknown]>;
+export declare function dataRecordEntries(value: unknown, path: string, fail: (path: string) => never): Array<readonly [string, unknown]>;
+export declare function exactArtifactKeys(value: Record<string, unknown>, path: string, expected: readonly string[], entries?: (readonly [string, unknown])[]): void;
+export declare function artifactArray(value: unknown, path: string): readonly unknown[];
+export declare function inputArrayValues(value: readonly unknown[], path: string): readonly unknown[];
+export declare function arrayDataValues(value: readonly unknown[], path: string, fail: (path: string) => never): readonly unknown[];
+export declare function withActiveArtifact(value: object, active: Set<object>, path: string, run: () => void): void;
+export declare function beginValue(value: object, active: Set<object>, path: string): void;
+export declare function assertGraphqlName(value: unknown, path: string): asserts value is string;
+export declare function assertNonemptyString(value: unknown, path: string): asserts value is string;
+export declare function assertBoolean(value: unknown, path: string): asserts value is boolean;
+export declare function validateCodecLimit(value: unknown, path: string): number;
+export declare function checkCodecDepth(depth: number, path: string): void;
+export declare function checkValueDepth(depth: number, path: string): void;
+export declare function checkFilterDepth(depth: number, limits: ReplicaVariableCodecLimits, path: string): void;
+export declare function variableCodecInvalid(path: string): never;
+export declare function variableValueInvalid(path: string, detail: string): never;