@hypequery/protocol 0.1.0 → 0.2.0

package/dist/expressions/types.d.ts

@@ -0,0 +1,77 @@
+import type { ProtocolIdentifier, ProtocolQualifiedIdentifier } from '../identifiers/index.js';
+import type { CanonicalValue } from '../values/index.js';
+export type ProtocolBinaryOperator = 'add' | 'subtract' | 'multiply' | 'divide';
+export type ProtocolFunctionName = 'nullIfZero' | 'coalesce' | 'round' | 'floor' | 'ceil';
+export type ProtocolComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'between' | 'like';
+export type ProtocolAggregation = 'sum' | 'count' | 'countDistinct' | 'avg' | 'min' | 'max' | 'argMax' | 'argMin' | 'percentile' | 'stddev' | 'variance';
+export type ProtocolExpression = {
+    readonly kind: 'reference';
+    readonly name: ProtocolQualifiedIdentifier;
+} | {
+    readonly kind: 'literal';
+    readonly value: CanonicalValue;
+} | {
+    readonly kind: 'binary';
+    readonly operator: ProtocolBinaryOperator;
+    readonly left: ProtocolExpression;
+    readonly right: ProtocolExpression;
+} | {
+    readonly kind: 'call';
+    readonly function: ProtocolFunctionName;
+    readonly args: readonly ProtocolExpression[];
+} | {
+    readonly kind: 'comparison';
+    readonly operator: ProtocolComparisonOperator;
+    readonly left: ProtocolExpression;
+    readonly right: ProtocolExpression;
+} | {
+    readonly kind: 'logical';
+    readonly operator: 'and' | 'or';
+    readonly operands: readonly ProtocolExpression[];
+} | {
+    readonly kind: 'logical';
+    readonly operator: 'not';
+    readonly operand: ProtocolExpression;
+} | {
+    readonly kind: 'aggregate';
+    readonly aggregation: ProtocolAggregation;
+    readonly field: ProtocolQualifiedIdentifier;
+    readonly argField?: ProtocolQualifiedIdentifier;
+    readonly level?: number;
+    readonly filters?: readonly ProtocolExpression[];
+};
+export type ProtocolTimeGrain = 'day' | 'week' | 'month' | 'quarter' | 'year';
+export interface ProtocolOrderBy {
+    readonly field: ProtocolQualifiedIdentifier;
+    readonly direction: 'asc' | 'desc';
+}
+interface ProtocolQueryCommon {
+    readonly dataset: ProtocolIdentifier;
+    readonly dimensions?: readonly ProtocolQualifiedIdentifier[];
+    readonly filters?: readonly ProtocolExpression[];
+    readonly orderBy?: readonly ProtocolOrderBy[];
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly by?: ProtocolTimeGrain;
+    readonly includeMeta?: boolean;
+}
+export interface ProtocolDatasetQuery extends ProtocolQueryCommon {
+    readonly kind: 'dataset';
+    readonly measures?: readonly ProtocolIdentifier[];
+}
+export interface ProtocolMetricQuery extends ProtocolQueryCommon {
+    readonly kind: 'metric';
+    readonly metric: ProtocolIdentifier;
+}
+export type ProtocolSemanticQuery = ProtocolDatasetQuery | ProtocolMetricQuery;
+export interface ProtocolExpressionLimits {
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    readonly maxCollectionItems: number;
+}
+export interface ProtocolExpressionOptions {
+    readonly limits?: Partial<ProtocolExpressionLimits>;
+}
+export type ProtocolExpressionErrorCode = 'HQ_EXPRESSION_TYPE' | 'HQ_EXPRESSION_UNKNOWN_FIELD' | 'HQ_EXPRESSION_UNKNOWN_KIND' | 'HQ_EXPRESSION_INVALID_IDENTIFIER' | 'HQ_EXPRESSION_INVALID_VALUE' | 'HQ_EXPRESSION_INVALID_OPERATOR' | 'HQ_EXPRESSION_INVALID_ARITY' | 'HQ_EXPRESSION_INVALID_AGGREGATION' | 'HQ_EXPRESSION_INVALID_QUERY' | 'HQ_EXPRESSION_TOO_DEEP' | 'HQ_EXPRESSION_TOO_MANY_NODES' | 'HQ_EXPRESSION_TOO_MANY_ITEMS' | 'HQ_EXPRESSION_UNSAFE_OBJECT';
+export {};
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/expressions/types.js

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

package/dist/expressions/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ProtocolExpression, ProtocolExpressionOptions, ProtocolSemanticQuery } from './types.js';
+export declare function validateProtocolExpression(input: unknown, options?: ProtocolExpressionOptions): ProtocolExpression;
+export declare function validateProtocolSemanticQuery(input: unknown, options?: ProtocolExpressionOptions): ProtocolSemanticQuery;
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/expressions/validate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAEV,kBAAkB,EAElB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AA4PpB,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,yBAA8B,GACtC,kBAAkB,CAEpB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,yBAA8B,GACtC,qBAAqB,CAiDvB"}

package/dist/expressions/validate.js

@@ -0,0 +1,338 @@
+import { ProtocolIdentifierError, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, } from '../identifiers/index.js';
+import { ProtocolValueError, validateCanonicalValue } from '../values/index.js';
+import { expressionError } from './errors.js';
+import { resolveExpressionLimits } from './limits.js';
+const BINARY = new Set(['add', 'subtract', 'multiply', 'divide']);
+const COMPARISONS = new Set(['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'between', 'like']);
+const AGGREGATIONS = new Set([
+    'sum', 'count', 'countDistinct', 'avg', 'min', 'max',
+    'argMax', 'argMin', 'percentile', 'stddev', 'variance',
+]);
+const GRAINS = new Set(['day', 'week', 'month', 'quarter', 'year']);
+const CALL_ARITY = Object.freeze({
+    nullIfZero: [1, 1],
+    coalesce: [2, 2],
+    round: [1, 2],
+    floor: [1, 1],
+    ceil: [1, 1],
+});
+function requireRecord(input, path) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        expressionError('HQ_EXPRESSION_TYPE', path);
+    }
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) {
+        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    if (Object.getOwnPropertySymbols(input).length > 0) {
+        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
+    }
+    for (const descriptor of Object.values(descriptors)) {
+        if (!descriptor.enumerable || !('value' in descriptor)) {
+            expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
+        }
+    }
+    return input;
+}
+function exactFields(value, required, optional, path) {
+    const allowed = new Set([...required, ...optional]);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key))
+            expressionError('HQ_EXPRESSION_UNKNOWN_FIELD', `${path}.${key}`);
+    }
+    for (const key of required) {
+        if (!Object.hasOwn(value, key))
+            expressionError('HQ_EXPRESSION_TYPE', `${path}.${key}`);
+    }
+}
+function stringValue(value, path) {
+    if (typeof value !== 'string')
+        expressionError('HQ_EXPRESSION_TYPE', path);
+    return value;
+}
+function identifier(value, path, qualified = true) {
+    try {
+        return qualified ? parseProtocolQualifiedIdentifier(value) : parseProtocolIdentifier(value);
+    }
+    catch (error) {
+        if (error instanceof ProtocolIdentifierError) {
+            expressionError('HQ_EXPRESSION_INVALID_IDENTIFIER', path);
+        }
+        throw error;
+    }
+}
+function enter(value, depth, state, path) {
+    if (depth > state.limits.maxDepth)
+        expressionError('HQ_EXPRESSION_TOO_DEEP', path);
+    state.nodes += 1;
+    if (state.nodes > state.limits.maxNodes)
+        expressionError('HQ_EXPRESSION_TOO_MANY_NODES', path);
+    if (state.active.has(value))
+        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
+    state.active.add(value);
+}
+function arrayValue(value, path, state) {
+    if (!Array.isArray(value))
+        expressionError('HQ_EXPRESSION_TYPE', path);
+    if (Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length > 0) {
+        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
+    }
+    if (value.length > state.limits.maxCollectionItems)
+        expressionError('HQ_EXPRESSION_TOO_MANY_ITEMS', path);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = descriptors[String(index)];
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+            expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', `${path}[${index}]`);
+        }
+    }
+    if (Object.keys(value).length !== value.length) {
+        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
+    }
+    return value;
+}
+function freezeRecord(entries) {
+    return Object.freeze(Object.assign(Object.create(null), entries));
+}
+function validateExpression(input, path, depth, state) {
+    const value = requireRecord(input, path);
+    enter(value, depth, state, path);
+    try {
+        const kind = stringValue(value.kind, `${path}.kind`);
+        switch (kind) {
+            case 'reference': {
+                exactFields(value, ['kind', 'name'], [], path);
+                return freezeRecord({ kind, name: identifier(value.name, `${path}.name`) });
+            }
+            case 'literal': {
+                exactFields(value, ['kind', 'value'], [], path);
+                try {
+                    return freezeRecord({ kind, value: validateCanonicalValue(value.value) });
+                }
+                catch (error) {
+                    if (error instanceof ProtocolValueError)
+                        expressionError('HQ_EXPRESSION_INVALID_VALUE', `${path}.value`);
+                    throw error;
+                }
+            }
+            case 'binary': {
+                exactFields(value, ['kind', 'operator', 'left', 'right'], [], path);
+                const operator = stringValue(value.operator, `${path}.operator`);
+                if (!BINARY.has(operator))
+                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.operator`);
+                return freezeRecord({
+                    kind,
+                    operator,
+                    left: validateExpression(value.left, `${path}.left`, depth + 1, state),
+                    right: validateExpression(value.right, `${path}.right`, depth + 1, state),
+                });
+            }
+            case 'call': {
+                exactFields(value, ['kind', 'function', 'args'], [], path);
+                const fn = stringValue(value.function, `${path}.function`);
+                const arity = CALL_ARITY[fn];
+                if (!arity)
+                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.function`);
+                const args = arrayValue(value.args, `${path}.args`, state);
+                if (args.length < arity[0] || args.length > arity[1]) {
+                    expressionError('HQ_EXPRESSION_INVALID_ARITY', `${path}.args`);
+                }
+                return freezeRecord({
+                    kind,
+                    function: fn,
+                    args: Object.freeze(args.map((arg, index) => validateExpression(arg, `${path}.args[${index}]`, depth + 1, state))),
+                });
+            }
+            case 'comparison': {
+                exactFields(value, ['kind', 'operator', 'left', 'right'], [], path);
+                const operator = stringValue(value.operator, `${path}.operator`);
+                if (!COMPARISONS.has(operator))
+                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.operator`);
+                const left = validateExpression(value.left, `${path}.left`, depth + 1, state);
+                const right = validateExpression(value.right, `${path}.right`, depth + 1, state);
+                validateComparisonOperands(operator, right, `${path}.right`);
+                return freezeRecord({
+                    kind,
+                    operator,
+                    left,
+                    right,
+                });
+            }
+            case 'logical': {
+                exactFields(value, ['kind', 'operator'], ['operand', 'operands'], path);
+                const operator = stringValue(value.operator, `${path}.operator`);
+                if (operator === 'not') {
+                    if (!Object.hasOwn(value, 'operand') || Object.hasOwn(value, 'operands')) {
+                        expressionError('HQ_EXPRESSION_INVALID_ARITY', path);
+                    }
+                    return freezeRecord({ kind, operator, operand: validateExpression(value.operand, `${path}.operand`, depth + 1, state) });
+                }
+                if (operator !== 'and' && operator !== 'or')
+                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.operator`);
+                if (!Object.hasOwn(value, 'operands') || Object.hasOwn(value, 'operand')) {
+                    expressionError('HQ_EXPRESSION_INVALID_ARITY', path);
+                }
+                const operands = arrayValue(value.operands, `${path}.operands`, state);
+                if (operands.length < 2)
+                    expressionError('HQ_EXPRESSION_INVALID_ARITY', `${path}.operands`);
+                return freezeRecord({
+                    kind,
+                    operator,
+                    operands: Object.freeze(operands.map((operand, index) => validateExpression(operand, `${path}.operands[${index}]`, depth + 1, state))),
+                });
+            }
+            case 'aggregate':
+                return validateAggregate(value, path, depth, state);
+            default:
+                expressionError('HQ_EXPRESSION_UNKNOWN_KIND', `${path}.kind`);
+        }
+    }
+    finally {
+        state.active.delete(value);
+    }
+}
+function validateComparisonOperands(operator, right, path) {
+    if (operator === 'like') {
+        if (right.kind !== 'literal' || typeof right.value !== 'string') {
+            expressionError('HQ_EXPRESSION_INVALID_VALUE', path);
+        }
+        return;
+    }
+    if (operator !== 'in' && operator !== 'notIn' && operator !== 'between')
+        return;
+    if (right.kind !== 'literal' || typeof right.value !== 'object' || right.value === null
+        || !('$hypequery' in right.value)) {
+        expressionError('HQ_EXPRESSION_INVALID_VALUE', path);
+    }
+    const tag = right.value.$hypequery;
+    const expectedType = operator === 'between' ? 'tuple' : 'array';
+    if (tag.type !== expectedType || !('values' in tag)) {
+        expressionError('HQ_EXPRESSION_INVALID_VALUE', path);
+    }
+    const requiredLength = operator === 'between' ? 2 : undefined;
+    if (tag.values.length === 0 || (requiredLength !== undefined && tag.values.length !== requiredLength)) {
+        expressionError('HQ_EXPRESSION_INVALID_ARITY', path);
+    }
+}
+function validateAggregate(value, path, depth, state) {
+    exactFields(value, ['kind', 'aggregation', 'field'], ['argField', 'level', 'filters'], path);
+    const aggregation = stringValue(value.aggregation, `${path}.aggregation`);
+    if (!AGGREGATIONS.has(aggregation))
+        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', `${path}.aggregation`);
+    const isArg = aggregation === 'argMax' || aggregation === 'argMin';
+    const isPercentile = aggregation === 'percentile';
+    if (isArg !== Object.hasOwn(value, 'argField') || isPercentile !== Object.hasOwn(value, 'level')) {
+        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', path);
+    }
+    if (isArg && Object.hasOwn(value, 'filters'))
+        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', `${path}.filters`);
+    const level = value.level;
+    if (isPercentile && (typeof level !== 'number' || !Number.isFinite(level) || level < 0 || level > 1)) {
+        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', `${path}.level`);
+    }
+    const filters = value.filters === undefined ? undefined : arrayValue(value.filters, `${path}.filters`, state);
+    return freezeRecord({
+        kind: 'aggregate',
+        aggregation,
+        field: identifier(value.field, `${path}.field`),
+        ...(isArg ? { argField: identifier(value.argField, `${path}.argField`) } : {}),
+        ...(isPercentile ? { level } : {}),
+        ...(filters ? {
+            filters: Object.freeze(filters.map((filter, index) => validatePredicate(filter, `${path}.filters[${index}]`, depth + 1, state, 'HQ_EXPRESSION_INVALID_AGGREGATION'))),
+        } : {}),
+    });
+}
+function newState(options) {
+    return { limits: resolveExpressionLimits(options), active: new WeakSet(), nodes: 0 };
+}
+export function validateProtocolExpression(input, options = {}) {
+    return validateExpression(input, '$', 1, newState(options));
+}
+export function validateProtocolSemanticQuery(input, options = {}) {
+    const state = newState(options);
+    const value = requireRecord(input, '$');
+    enter(value, 1, state, '$');
+    try {
+        const kind = stringValue(value.kind, '$.kind');
+        const metric = kind === 'metric';
+        if (!metric && kind !== 'dataset')
+            expressionError('HQ_EXPRESSION_INVALID_QUERY', '$.kind');
+        exactFields(value, metric ? ['kind', 'dataset', 'metric'] : ['kind', 'dataset'], metric
+            ? ['dimensions', 'filters', 'orderBy', 'limit', 'offset', 'by', 'includeMeta']
+            : ['dimensions', 'measures', 'filters', 'orderBy', 'limit', 'offset', 'by', 'includeMeta'], '$');
+        const result = {
+            kind,
+            dataset: identifier(value.dataset, '$.dataset', false),
+            ...(metric ? { metric: identifier(value.metric, '$.metric', false) } : {}),
+        };
+        copyIdentifierArray(value, result, 'dimensions', true, state);
+        if (!metric)
+            copyIdentifierArray(value, result, 'measures', false, state);
+        if (value.filters !== undefined) {
+            const filters = arrayValue(value.filters, '$.filters', state);
+            result.filters = Object.freeze(filters.map((filter, index) => validatePredicate(filter, `$.filters[${index}]`, 1, state, 'HQ_EXPRESSION_INVALID_QUERY')));
+        }
+        if (value.orderBy !== undefined)
+            result.orderBy = validateOrderBy(value.orderBy, state);
+        copyInteger(value, result, 'limit', 0);
+        copyInteger(value, result, 'offset', 0);
+        if (value.by !== undefined) {
+            const grain = stringValue(value.by, '$.by');
+            if (!GRAINS.has(grain))
+                expressionError('HQ_EXPRESSION_INVALID_QUERY', '$.by');
+            result.by = grain;
+        }
+        if (value.includeMeta !== undefined) {
+            if (typeof value.includeMeta !== 'boolean')
+                expressionError('HQ_EXPRESSION_INVALID_QUERY', '$.includeMeta');
+            result.includeMeta = value.includeMeta;
+        }
+        return freezeRecord(result);
+    }
+    finally {
+        state.active.delete(value);
+    }
+}
+function validatePredicate(input, path, depth, state, errorCode) {
+    const expression = validateExpression(input, path, depth, state);
+    if (!isPredicate(expression))
+        expressionError(errorCode, path);
+    return expression;
+}
+function isPredicate(expression) {
+    if (expression.kind === 'comparison')
+        return true;
+    if (expression.kind !== 'logical')
+        return false;
+    return expression.operator === 'not'
+        ? isPredicate(expression.operand)
+        : expression.operands.every(isPredicate);
+}
+function copyIdentifierArray(source, target, key, qualified, state) {
+    if (source[key] === undefined)
+        return;
+    const values = arrayValue(source[key], `$.${key}`, state);
+    target[key] = Object.freeze(values.map((item, index) => identifier(item, `$.${key}[${index}]`, qualified)));
+}
+function copyInteger(source, target, key, minimum) {
+    if (source[key] === undefined)
+        return;
+    const value = source[key];
+    if (!Number.isSafeInteger(value) || value < minimum) {
+        expressionError('HQ_EXPRESSION_INVALID_QUERY', `$.${key}`);
+    }
+    target[key] = value;
+}
+function validateOrderBy(input, state) {
+    const values = arrayValue(input, '$.orderBy', state);
+    return Object.freeze(values.map((item, index) => {
+        const path = `$.orderBy[${index}]`;
+        const value = requireRecord(item, path);
+        exactFields(value, ['field', 'direction'], [], path);
+        const direction = stringValue(value.direction, `${path}.direction`);
+        if (direction !== 'asc' && direction !== 'desc')
+            expressionError('HQ_EXPRESSION_INVALID_QUERY', `${path}.direction`);
+        return freezeRecord({ field: identifier(value.field, `${path}.field`), direction });
+    }));
+}

package/dist/identifiers/identifiers.d.ts

@@ -0,0 +1,14 @@
+import { type ProtocolIdentifier, type ProtocolIdentifierErrorCode, type ProtocolQualifiedIdentifier } from './types.js';
+export declare class ProtocolIdentifierError extends TypeError {
+    readonly code: ProtocolIdentifierErrorCode;
+    constructor(code: ProtocolIdentifierErrorCode);
+}
+/** Parses one portable, case-sensitive logical identifier segment. */
+export declare function parseProtocolIdentifier(input: unknown): ProtocolIdentifier;
+/** Parses a dot-qualified portable identifier without normalizing it. */
+export declare function parseProtocolQualifiedIdentifier(input: unknown): ProtocolQualifiedIdentifier;
+export declare function splitProtocolQualifiedIdentifier(input: ProtocolQualifiedIdentifier): readonly ProtocolIdentifier[];
+export declare function joinProtocolQualifiedIdentifier(segments: readonly unknown[]): ProtocolQualifiedIdentifier;
+export declare function isProtocolIdentifier(input: unknown): input is ProtocolIdentifier;
+export declare function isProtocolQualifiedIdentifier(input: unknown): input is ProtocolQualifiedIdentifier;
+//# sourceMappingURL=identifiers.d.ts.map

package/dist/identifiers/identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../../src/identifiers/identifiers.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EACjC,MAAM,YAAY,CAAC;AAMpB,qBAAa,uBAAwB,SAAQ,SAAS;IACpD,QAAQ,CAAC,IAAI,EAAE,2BAA2B,CAAC;gBAE/B,IAAI,EAAE,2BAA2B;CAK9C;AAmBD,sEAAsE;AACtE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,kBAAkB,CAE1E;AAED,yEAAyE;AACzE,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,GACb,2BAA2B,CAc7B;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,2BAA2B,GACjC,SAAS,kBAAkB,EAAE,CAE/B;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,2BAA2B,CAY7B;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAOhF;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CAOtC"}

package/dist/identifiers/identifiers.js

@@ -0,0 +1,87 @@
+import { PROTOCOL_IDENTIFIER_LIMITS, } from './types.js';
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_PREFIX = '__hypequery';
+const textEncoder = new TextEncoder();
+export class ProtocolIdentifierError extends TypeError {
+    code;
+    constructor(code) {
+        super(code);
+        this.name = 'ProtocolIdentifierError';
+        this.code = code;
+    }
+}
+function identifierError(code) {
+    throw new ProtocolIdentifierError(code);
+}
+function parseSegment(input, emptyCode) {
+    if (typeof input !== 'string')
+        identifierError('HQ_IDENTIFIER_TYPE');
+    if (input.length === 0)
+        identifierError(emptyCode);
+    if (textEncoder.encode(input).byteLength > PROTOCOL_IDENTIFIER_LIMITS.maxSegmentBytes) {
+        identifierError('HQ_IDENTIFIER_TOO_LONG');
+    }
+    if (!IDENTIFIER_PATTERN.test(input))
+        identifierError('HQ_IDENTIFIER_INVALID_FORMAT');
+    if (input.toLowerCase().startsWith(RESERVED_PREFIX)) {
+        identifierError('HQ_IDENTIFIER_RESERVED');
+    }
+    return input;
+}
+/** Parses one portable, case-sensitive logical identifier segment. */
+export function parseProtocolIdentifier(input) {
+    return parseSegment(input, 'HQ_IDENTIFIER_EMPTY');
+}
+/** Parses a dot-qualified portable identifier without normalizing it. */
+export function parseProtocolQualifiedIdentifier(input) {
+    if (typeof input !== 'string')
+        identifierError('HQ_IDENTIFIER_TYPE');
+    if (input.length === 0)
+        identifierError('HQ_IDENTIFIER_EMPTY');
+    if (textEncoder.encode(input).byteLength > PROTOCOL_IDENTIFIER_LIMITS.maxQualifiedBytes) {
+        identifierError('HQ_IDENTIFIER_TOO_LONG');
+    }
+    const segments = input.split('.');
+    if (segments.length > PROTOCOL_IDENTIFIER_LIMITS.maxSegments) {
+        identifierError('HQ_IDENTIFIER_TOO_MANY_SEGMENTS');
+    }
+    for (const segment of segments) {
+        parseSegment(segment, 'HQ_IDENTIFIER_INVALID_FORMAT');
+    }
+    return input;
+}
+export function splitProtocolQualifiedIdentifier(input) {
+    return Object.freeze(input.split('.'));
+}
+export function joinProtocolQualifiedIdentifier(segments) {
+    if (segments.length === 0)
+        identifierError('HQ_IDENTIFIER_EMPTY');
+    if (segments.length > PROTOCOL_IDENTIFIER_LIMITS.maxSegments) {
+        identifierError('HQ_IDENTIFIER_TOO_MANY_SEGMENTS');
+    }
+    const value = segments
+        .map((segment) => parseSegment(segment, 'HQ_IDENTIFIER_INVALID_FORMAT'))
+        .join('.');
+    if (value.length > PROTOCOL_IDENTIFIER_LIMITS.maxQualifiedBytes) {
+        identifierError('HQ_IDENTIFIER_TOO_LONG');
+    }
+    return value;
+}
+export function isProtocolIdentifier(input) {
+    try {
+        parseProtocolIdentifier(input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isProtocolQualifiedIdentifier(input) {
+    try {
+        parseProtocolQualifiedIdentifier(input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/identifiers/index.d.ts

@@ -0,0 +1,4 @@
+export { ProtocolIdentifierError, isProtocolIdentifier, isProtocolQualifiedIdentifier, joinProtocolQualifiedIdentifier, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, splitProtocolQualifiedIdentifier, } from './identifiers.js';
+export { PROTOCOL_IDENTIFIER_LIMITS } from './types.js';
+export type { ProtocolIdentifier, ProtocolIdentifierErrorCode, ProtocolQualifiedIdentifier, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/identifiers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/identifiers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,EACvB,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,YAAY,EACV,kBAAkB,EAClB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,YAAY,CAAC"}

package/dist/identifiers/index.js

@@ -0,0 +1,2 @@
+export { ProtocolIdentifierError, isProtocolIdentifier, isProtocolQualifiedIdentifier, joinProtocolQualifiedIdentifier, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, splitProtocolQualifiedIdentifier, } from './identifiers.js';
+export { PROTOCOL_IDENTIFIER_LIMITS } from './types.js';

package/dist/identifiers/types.d.ts

@@ -0,0 +1,16 @@
+export declare const PROTOCOL_IDENTIFIER_LIMITS: Readonly<{
+    readonly maxSegmentBytes: 128;
+    readonly maxQualifiedBytes: 512;
+    readonly maxSegments: 8;
+}>;
+declare const protocolIdentifierBrand: unique symbol;
+declare const protocolQualifiedIdentifierBrand: unique symbol;
+export type ProtocolIdentifier = string & {
+    readonly [protocolIdentifierBrand]: true;
+};
+export type ProtocolQualifiedIdentifier = string & {
+    readonly [protocolQualifiedIdentifierBrand]: true;
+};
+export type ProtocolIdentifierErrorCode = 'HQ_IDENTIFIER_TYPE' | 'HQ_IDENTIFIER_EMPTY' | 'HQ_IDENTIFIER_TOO_LONG' | 'HQ_IDENTIFIER_INVALID_FORMAT' | 'HQ_IDENTIFIER_RESERVED' | 'HQ_IDENTIFIER_TOO_MANY_SEGMENTS';
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/identifiers/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;EAI5B,CAAC;AAEZ,OAAO,CAAC,MAAM,uBAAuB,EAAE,OAAO,MAAM,CAAC;AACrD,OAAO,CAAC,MAAM,gCAAgC,EAAE,OAAO,MAAM,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IACxC,QAAQ,CAAC,CAAC,uBAAuB,CAAC,EAAE,IAAI,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG;IACjD,QAAQ,CAAC,CAAC,gCAAgC,CAAC,EAAE,IAAI,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACnC,oBAAoB,GACpB,qBAAqB,GACrB,wBAAwB,GACxB,8BAA8B,GAC9B,wBAAwB,GACxB,iCAAiC,CAAC"}

package/dist/identifiers/types.js

@@ -0,0 +1,5 @@
+export const PROTOCOL_IDENTIFIER_LIMITS = Object.freeze({
+    maxSegmentBytes: 128,
+    maxQualifiedBytes: 512,
+    maxSegments: 8,
+});

package/dist/index.d.ts

@@ -1,9 +1,13 @@
-/**
- * Public TypeScript reference implementation for the Hypequery protocol.
- *
- * The scaffold intentionally exports no runtime contract. Each future export
- * must implement an accepted specification and ship with normative fixtures.
- * See `specs/security-protocol/` in the repository.
- */
-export {};
+export { DEFAULT_CANONICAL_VALUE_LIMITS, ProtocolValueError, decodeCanonicalValue, encodeCanonicalValue, encodeCanonicalValueToString, hashCanonicalValue, validateCanonicalValue, } from './values/index.js';
+export type { ArrayTaggedValue, BytesTaggedValue, CanonicalValue, CanonicalValueLimits, CanonicalValueOptions, DateTaggedValue, DatetimeTaggedValue, DecimalTaggedValue, EnumTaggedValue, IntegerTaggedValue, MapTaggedValue, ProtocolValueErrorCode, TaggedValue, TupleTaggedValue, UuidTaggedValue, } from './values/index.js';
+export { PROTOCOL_IDENTIFIER_LIMITS, ProtocolIdentifierError, isProtocolIdentifier, isProtocolQualifiedIdentifier, joinProtocolQualifiedIdentifier, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, splitProtocolQualifiedIdentifier, } from './identifiers/index.js';
+export { DEFAULT_PROTOCOL_EXPRESSION_LIMITS, ProtocolExpressionError, validateProtocolExpression, validateProtocolSemanticQuery, } from './expressions/index.js';
+export { DEFAULT_PROTOCOL_SCHEMA_LIMITS, ProtocolSchemaError, validateProtocolSchema, } from './schemas/index.js';
+export type { ProtocolSchema, ProtocolSchemaErrorCode, ProtocolSchemaLimits, ProtocolSchemaOptions, } from './schemas/index.js';
+export type { ProtocolAggregation, ProtocolBinaryOperator, ProtocolComparisonOperator, ProtocolDatasetQuery, ProtocolExpression, ProtocolExpressionErrorCode, ProtocolExpressionLimits, ProtocolExpressionOptions, ProtocolFunctionName, ProtocolMetricQuery, ProtocolOrderBy, ProtocolSemanticQuery, ProtocolTimeGrain, } from './expressions/index.js';
+export type { ProtocolIdentifier, ProtocolIdentifierErrorCode, ProtocolQualifiedIdentifier, } from './identifiers/index.js';
+export { DEFAULT_PROTOCOL_QUERY_IMPLEMENTATION_LIMITS, ProtocolQueryImplementationError, validateProtocolQueryImplementation, validateProtocolSqlExpression, } from './query-implementations/index.js';
+export { DEFAULT_PROTOCOL_DEPLOYMENT_LIMITS, ProtocolDeploymentError, validateProtocolDatasetContract, validateProtocolDeploymentContract, } from './deployments/index.js';
+export type { ProtocolAccessPolicy, ProtocolDatasetContract, ProtocolDatasetDimension, ProtocolDatasetFieldSource, ProtocolDatasetFieldType, ProtocolDatasetFilter, ProtocolDatasetLimits, ProtocolDatasetMeasure, ProtocolDatasetMetric, ProtocolDatasetRelationship, ProtocolDatasetTenantPolicy, ProtocolDeploymentContract, ProtocolDeploymentErrorCode, ProtocolDeploymentLimits, ProtocolDeploymentOptions, ProtocolEndpointPolicy, ProtocolEndpointTenantPolicy, ProtocolNamedQueryContract, ProtocolRuntimeArtifact, } from './deployments/index.js';
+export type { ProtocolQueryImplementation, ProtocolQueryImplementationErrorCode, ProtocolQueryImplementationLimits, ProtocolQueryImplementationOptions, ProtocolSqlDialect, ProtocolSqlExpression, ProtocolSqlParameter, ProtocolSqlParameterSource, ProtocolSqlTenantPolicy, } from './query-implementations/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,4BAA4B,EAC5B,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACtB,WAAW,EACX,gBAAgB,EAChB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,oBAAoB,EACpB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,EACvB,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,kCAAkC,EAClC,uBAAuB,EACvB,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,8BAA8B,EAC9B,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,EAClB,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,kBAAkB,EAClB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,4CAA4C,EAC5C,gCAAgC,EAChC,mCAAmC,EACnC,6BAA6B,GAC9B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,kCAAkC,EAClC,uBAAuB,EACvB,+BAA+B,EAC/B,kCAAkC,GACnC,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,2BAA2B,EAC3B,2BAA2B,EAC3B,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,sBAAsB,EACtB,4BAA4B,EAC5B,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,2BAA2B,EAC3B,oCAAoC,EACpC,iCAAiC,EACjC,kCAAkC,EAClC,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -1 +1,6 @@
-export {};
+export { DEFAULT_CANONICAL_VALUE_LIMITS, ProtocolValueError, decodeCanonicalValue, encodeCanonicalValue, encodeCanonicalValueToString, hashCanonicalValue, validateCanonicalValue, } from './values/index.js';
+export { PROTOCOL_IDENTIFIER_LIMITS, ProtocolIdentifierError, isProtocolIdentifier, isProtocolQualifiedIdentifier, joinProtocolQualifiedIdentifier, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, splitProtocolQualifiedIdentifier, } from './identifiers/index.js';
+export { DEFAULT_PROTOCOL_EXPRESSION_LIMITS, ProtocolExpressionError, validateProtocolExpression, validateProtocolSemanticQuery, } from './expressions/index.js';
+export { DEFAULT_PROTOCOL_SCHEMA_LIMITS, ProtocolSchemaError, validateProtocolSchema, } from './schemas/index.js';
+export { DEFAULT_PROTOCOL_QUERY_IMPLEMENTATION_LIMITS, ProtocolQueryImplementationError, validateProtocolQueryImplementation, validateProtocolSqlExpression, } from './query-implementations/index.js';
+export { DEFAULT_PROTOCOL_DEPLOYMENT_LIMITS, ProtocolDeploymentError, validateProtocolDatasetContract, validateProtocolDeploymentContract, } from './deployments/index.js';

package/dist/query-implementations/errors.d.ts

@@ -0,0 +1,8 @@
+import type { ProtocolQueryImplementationErrorCode } from './types.js';
+export declare class ProtocolQueryImplementationError extends TypeError {
+    readonly code: ProtocolQueryImplementationErrorCode;
+    readonly path: string;
+    constructor(code: ProtocolQueryImplementationErrorCode, path?: string);
+}
+export declare function queryImplementationError(code: ProtocolQueryImplementationErrorCode, path?: string): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/query-implementations/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/query-implementations/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,YAAY,CAAC;AAEvE,qBAAa,gCAAiC,SAAQ,SAAS;IAC7D,QAAQ,CAAC,IAAI,EAAE,oCAAoC,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,oCAAoC,EAAE,IAAI,SAAM;CAMnE;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,oCAAoC,EAC1C,IAAI,SAAM,GACT,KAAK,CAEP"}