@hypequery/protocol 0.1.0 → 0.2.0

package/dist/values/parser.js

@@ -0,0 +1,254 @@
+import { valueError } from './errors.js';
+const textEncoder = new TextEncoder();
+class DuplicateAwareJsonParser {
+    source;
+    limits;
+    index = 0;
+    syntaxNodes = 0;
+    constructor(source, limits) {
+        this.source = source;
+        this.limits = limits;
+    }
+    parse() {
+        this.skipWhitespace();
+        const value = this.parseValue(0);
+        this.skipWhitespace();
+        if (this.index !== this.source.length) {
+            valueError('HQ_VALUE_INVALID_JSON');
+        }
+        return value;
+    }
+    parseValue(depth) {
+        this.syntaxNodes += 1;
+        if (this.syntaxNodes > this.limits.maxNodes * 16) {
+            valueError('HQ_VALUE_TOO_MANY_NODES');
+        }
+        if (depth > this.limits.maxDepth * 4 + 8) {
+            valueError('HQ_VALUE_TOO_DEEP');
+        }
+        const token = this.source[this.index];
+        if (token === '"')
+            return this.parseString();
+        if (token === '{')
+            return this.parseObject(depth + 1);
+        if (token === '[')
+            return this.parseArray(depth + 1);
+        if (token === 't')
+            return this.parseLiteral('true', true);
+        if (token === 'f')
+            return this.parseLiteral('false', false);
+        if (token === 'n')
+            return this.parseLiteral('null', null);
+        if (token === '-' || (token !== undefined && token >= '0' && token <= '9')) {
+            return this.parseNumber();
+        }
+        valueError('HQ_VALUE_INVALID_JSON');
+    }
+    parseLiteral(source, value) {
+        if (this.source.slice(this.index, this.index + source.length) !== source) {
+            valueError('HQ_VALUE_INVALID_JSON');
+        }
+        this.index += source.length;
+        return value;
+    }
+    parseObject(depth) {
+        this.index += 1;
+        this.skipWhitespace();
+        const result = Object.create(null);
+        const keys = new Set();
+        if (this.source[this.index] === '}') {
+            this.index += 1;
+            return result;
+        }
+        while (true) {
+            if (this.source[this.index] !== '"') {
+                valueError('HQ_VALUE_INVALID_JSON');
+            }
+            const key = this.parseString();
+            if (keys.has(key)) {
+                valueError('HQ_VALUE_DUPLICATE_KEY');
+            }
+            keys.add(key);
+            this.skipWhitespace();
+            if (this.source[this.index] !== ':') {
+                valueError('HQ_VALUE_INVALID_JSON');
+            }
+            this.index += 1;
+            this.skipWhitespace();
+            const value = this.parseValue(depth);
+            Object.defineProperty(result, key, {
+                value,
+                enumerable: true,
+                configurable: false,
+                writable: false,
+            });
+            this.skipWhitespace();
+            const separator = this.source[this.index];
+            if (separator === '}') {
+                this.index += 1;
+                return result;
+            }
+            if (separator !== ',') {
+                valueError('HQ_VALUE_INVALID_JSON');
+            }
+            this.index += 1;
+            this.skipWhitespace();
+        }
+    }
+    parseArray(depth) {
+        this.index += 1;
+        this.skipWhitespace();
+        const result = [];
+        if (this.source[this.index] === ']') {
+            this.index += 1;
+            return result;
+        }
+        while (true) {
+            result.push(this.parseValue(depth));
+            this.skipWhitespace();
+            const separator = this.source[this.index];
+            if (separator === ']') {
+                this.index += 1;
+                return result;
+            }
+            if (separator !== ',') {
+                valueError('HQ_VALUE_INVALID_JSON');
+            }
+            this.index += 1;
+            this.skipWhitespace();
+        }
+    }
+    parseString() {
+        this.index += 1;
+        let result = '';
+        while (this.index < this.source.length) {
+            const character = this.source[this.index];
+            if (character === '"') {
+                this.index += 1;
+                return result;
+            }
+            if (character === '\\') {
+                this.index += 1;
+                result += this.parseEscape();
+                continue;
+            }
+            const code = this.source.charCodeAt(this.index);
+            if (code <= 0x1f) {
+                valueError('HQ_VALUE_INVALID_JSON');
+            }
+            if (code >= 0xd800 && code <= 0xdbff) {
+                const low = this.source.charCodeAt(this.index + 1);
+                if (low < 0xdc00 || low > 0xdfff) {
+                    valueError('HQ_VALUE_INVALID_UNICODE');
+                }
+                result += character + this.source[this.index + 1];
+                this.index += 2;
+                continue;
+            }
+            if (code >= 0xdc00 && code <= 0xdfff) {
+                valueError('HQ_VALUE_INVALID_UNICODE');
+            }
+            result += character;
+            this.index += 1;
+        }
+        valueError('HQ_VALUE_INVALID_JSON');
+    }
+    parseEscape() {
+        const escape = this.source[this.index];
+        this.index += 1;
+        const simple = {
+            '"': '"',
+            '\\': '\\',
+            '/': '/',
+            b: '\b',
+            f: '\f',
+            n: '\n',
+            r: '\r',
+            t: '\t',
+        };
+        if (escape !== undefined && Object.hasOwn(simple, escape)) {
+            return simple[escape];
+        }
+        if (escape !== 'u') {
+            valueError('HQ_VALUE_INVALID_JSON');
+        }
+        const high = this.parseHexCodeUnit();
+        if (high >= 0xd800 && high <= 0xdbff) {
+            if (this.source.slice(this.index, this.index + 2) !== '\\u') {
+                valueError('HQ_VALUE_INVALID_UNICODE');
+            }
+            this.index += 2;
+            const low = this.parseHexCodeUnit();
+            if (low < 0xdc00 || low > 0xdfff) {
+                valueError('HQ_VALUE_INVALID_UNICODE');
+            }
+            return String.fromCharCode(high, low);
+        }
+        if (high >= 0xdc00 && high <= 0xdfff) {
+            valueError('HQ_VALUE_INVALID_UNICODE');
+        }
+        return String.fromCharCode(high);
+    }
+    parseHexCodeUnit() {
+        const value = this.source.slice(this.index, this.index + 4);
+        if (!/^[0-9a-fA-F]{4}$/.test(value)) {
+            valueError('HQ_VALUE_INVALID_JSON');
+        }
+        this.index += 4;
+        return Number.parseInt(value, 16);
+    }
+    parseNumber() {
+        const match = this.source.slice(this.index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+        if (!match) {
+            valueError('HQ_VALUE_INVALID_JSON');
+        }
+        const token = match[0];
+        this.index += token.length;
+        const value = Number(token);
+        if (!Number.isFinite(value)) {
+            valueError('HQ_VALUE_NON_FINITE_FLOAT');
+        }
+        if (Object.is(value, -0)) {
+            valueError('HQ_VALUE_NEGATIVE_ZERO');
+        }
+        return value;
+    }
+    skipWhitespace() {
+        while (this.source[this.index] === ' '
+            || this.source[this.index] === '\n'
+            || this.source[this.index] === '\r'
+            || this.source[this.index] === '\t') {
+            this.index += 1;
+        }
+    }
+}
+export function parseDuplicateAwareJson(input, limits) {
+    let source;
+    let byteLength;
+    if (typeof input === 'string') {
+        if (input.length > limits.maxInputBytes) {
+            valueError('HQ_VALUE_TOO_LARGE');
+        }
+        source = input;
+        byteLength = textEncoder.encode(input).byteLength;
+    }
+    else if (input instanceof Uint8Array) {
+        byteLength = input.byteLength;
+        try {
+            source = new TextDecoder('utf-8', { fatal: true }).decode(input);
+        }
+        catch {
+            valueError('HQ_VALUE_INVALID_UNICODE');
+        }
+    }
+    else {
+        valueError('HQ_VALUE_INVALID_JSON');
+    }
+    if (byteLength > limits.maxInputBytes) {
+        valueError('HQ_VALUE_TOO_LARGE');
+    }
+    if (source.charCodeAt(0) === 0xfeff) {
+        valueError('HQ_VALUE_INVALID_JSON');
+    }
+    return new DuplicateAwareJsonParser(source, limits).parse();
+}

package/dist/values/snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { CanonicalValueLimits } from './types.js';
+export declare function snapshotPlainData(input: unknown, limits: Readonly<CanonicalValueLimits>): unknown;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/values/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/values/snapshot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAgJvD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GACrC,OAAO,CAMT"}

package/dist/values/snapshot.js

@@ -0,0 +1,96 @@
+import { valueError } from './errors.js';
+function incrementNodes(state, path) {
+    state.nodes += 1;
+    // Structural tag fields add overhead beyond logical value nodes. This guard
+    // prevents unbounded allocation before exact logical validation runs.
+    if (state.nodes > state.limits.maxNodes * 16) {
+        valueError('HQ_VALUE_TOO_MANY_NODES', path);
+    }
+}
+function snapshotArray(input, state, path, syntaxDepth) {
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    const ownKeys = Reflect.ownKeys(descriptors);
+    const lengthDescriptor = descriptors.length;
+    if (!lengthDescriptor || typeof lengthDescriptor.value !== 'number') {
+        valueError('HQ_VALUE_UNSAFE_OBJECT', path);
+    }
+    const length = lengthDescriptor.value;
+    if (!Number.isSafeInteger(length) || length < 0 || length > state.limits.maxNodes * 2) {
+        valueError('HQ_VALUE_TOO_MANY_NODES', path);
+    }
+    for (const key of ownKeys) {
+        if (key === 'length')
+            continue;
+        if (typeof key !== 'string' || !/^(0|[1-9]\d*)$/.test(key)) {
+            valueError('HQ_VALUE_UNSAFE_OBJECT', path);
+        }
+    }
+    const result = [];
+    for (let index = 0; index < length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+            valueError('HQ_VALUE_INVALID_FORMAT', `${path}[${index}]`);
+        }
+        result.push(snapshotUnknown(descriptor.value, state, `${path}[${index}]`, syntaxDepth + 1));
+    }
+    return result;
+}
+function snapshotObject(input, state, path, syntaxDepth) {
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) {
+        valueError('HQ_VALUE_UNSAFE_OBJECT', path);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    const result = Object.create(null);
+    for (const key of Reflect.ownKeys(descriptors)) {
+        if (typeof key !== 'string') {
+            valueError('HQ_VALUE_UNSAFE_OBJECT', path);
+        }
+        const descriptor = descriptors[key];
+        if (!descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+            valueError('HQ_VALUE_UNSAFE_OBJECT', `${path}.${key}`);
+        }
+        Object.defineProperty(result, key, {
+            value: snapshotUnknown(descriptor.value, state, `${path}.${key}`, syntaxDepth + 1),
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    return result;
+}
+function snapshotUnknown(input, state, path, syntaxDepth) {
+    incrementNodes(state, path);
+    if (syntaxDepth > state.limits.maxDepth * 4 + 8) {
+        valueError('HQ_VALUE_TOO_DEEP', path);
+    }
+    if (input === null
+        || typeof input === 'boolean'
+        || typeof input === 'string'
+        || typeof input === 'number') {
+        return input;
+    }
+    if (typeof input !== 'object') {
+        valueError('HQ_VALUE_UNSAFE_OBJECT', path);
+    }
+    if (state.active.has(input)) {
+        valueError('HQ_VALUE_INVALID_FORMAT', path);
+    }
+    state.active.add(input);
+    try {
+        if (Array.isArray(input)) {
+            return snapshotArray(input, state, path, syntaxDepth);
+        }
+        return snapshotObject(input, state, path, syntaxDepth);
+    }
+    finally {
+        state.active.delete(input);
+    }
+}
+export function snapshotPlainData(input, limits) {
+    return snapshotUnknown(input, {
+        limits,
+        active: new WeakSet(),
+        nodes: 0,
+    }, '$', 0);
+}

package/dist/values/types.d.ts

@@ -0,0 +1,78 @@
+export interface CanonicalValueLimits {
+    readonly maxInputBytes: number;
+    readonly maxCanonicalBytes: number;
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    readonly maxCollectionItems: number;
+    readonly maxStringBytes: number;
+    readonly maxDecodedBytes: number;
+}
+export interface CanonicalValueOptions {
+    /** Product policy may lower, but never raise, the version 1 limits. */
+    readonly limits?: Partial<CanonicalValueLimits>;
+    /** Containing ClickHouse type when validation depends on schema context. */
+    readonly declaredClickHouseType?: string;
+}
+interface TagEnvelope<T> {
+    readonly $hypequery: T;
+}
+interface VersionOneTag {
+    readonly type: string;
+    readonly version: 1;
+}
+export type IntegerTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'integer';
+    readonly bits: 8 | 16 | 32 | 64 | 128 | 256;
+    readonly signed: boolean;
+    readonly value: string;
+}>;
+export type DecimalTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'decimal';
+    readonly coefficient: string;
+    readonly precision: number;
+    readonly scale: number;
+}>;
+export type DateTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'date';
+    readonly clickhouseType: 'Date' | 'Date32';
+    readonly value: string;
+}>;
+export type DatetimeTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'datetime';
+    readonly clickhouseType: 'DateTime' | 'DateTime64';
+    readonly precision: number;
+    readonly timezone: string;
+    readonly value: string;
+}>;
+export type UuidTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'uuid';
+    readonly value: string;
+}>;
+export type BytesTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'bytes';
+    readonly encoding: 'base64url';
+    readonly value: string;
+}>;
+export type EnumTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'enum';
+    readonly bits: 8 | 16;
+    readonly code: number;
+    readonly label: string;
+}>;
+export type ArrayTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'array';
+    readonly values: readonly CanonicalValue[];
+}>;
+export type TupleTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'tuple';
+    readonly values: readonly CanonicalValue[];
+}>;
+export type MapTaggedValue = TagEnvelope<VersionOneTag & {
+    readonly type: 'map';
+    readonly entries: readonly (readonly [CanonicalValue, CanonicalValue])[];
+}>;
+export type TaggedValue = IntegerTaggedValue | DecimalTaggedValue | DateTaggedValue | DatetimeTaggedValue | UuidTaggedValue | BytesTaggedValue | EnumTaggedValue | ArrayTaggedValue | TupleTaggedValue | MapTaggedValue;
+/** Native numbers always carry floating-point semantics. Integers are tagged. */
+export type CanonicalValue = null | boolean | string | number | TaggedValue;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/values/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/values/types.ts"],"names":[],"mappings":"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"}

package/dist/values/types.js

@@ -0,0 +1 @@
+export {};

package/dist/values/validate.d.ts

@@ -0,0 +1,7 @@
+import type { CanonicalValue, CanonicalValueLimits, CanonicalValueOptions } from './types.js';
+export declare function validateCanonicalValue(input: unknown, options?: CanonicalValueOptions): CanonicalValue;
+/** Package-internal path for arbitrary input when limits are already resolved. */
+export declare function validateCanonicalValueWithLimits(input: unknown, limits: Readonly<CanonicalValueLimits>, declaredClickHouseType?: string): CanonicalValue;
+/** Package-internal path for trees created by the duplicate-aware parser. */
+export declare function validateParsedCanonicalValue(parsed: unknown, limits: Readonly<CanonicalValueLimits>, declaredClickHouseType?: string): CanonicalValue;
+//# sourceMappingURL=validate.d.ts.map

package/dist/values/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/values/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AA0VpB,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAOhB;AAYD,kFAAkF;AAClF,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EACtC,sBAAsB,CAAC,EAAE,MAAM,GAC9B,cAAc,CAGhB;AAED,6EAA6E;AAC7E,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EACtC,sBAAsB,CAAC,EAAE,MAAM,GAC9B,cAAc,CAEhB"}