@true-sight/model-schema 1.0.0

package/dist/dsl/registry/explore-registry.d.ts

@@ -0,0 +1,22 @@
+import type { ManifestExpr } from '../../types/manifest-expr.types.js';
+import type { JoinRelationship, JoinType } from '../../types/manifest.types.js';
+export type ViewConstructor = new (...args: unknown[]) => object;
+export type ExploreOptions = {
+    name: string;
+    label: string;
+    from: ViewConstructor;
+};
+export type JoinScope = Record<string, unknown>;
+export type JoinOptions = {
+    relationship: JoinRelationship;
+    type: JoinType;
+    sqlOn: (scope: JoinScope) => ManifestExpr;
+};
+export type JoinEntry = {
+    propertyKey: string;
+    options: JoinOptions;
+};
+export declare function registerExplore(ctor: object, options: ExploreOptions): void;
+export declare function getExploreMeta(ctor: object): ExploreOptions | undefined;
+export declare function addJoin(prototype: object, entry: JoinEntry): void;
+export declare function getJoins(prototype: object): JoinEntry[];

package/dist/dsl/registry/explore-registry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerExplore = registerExplore;
+exports.getExploreMeta = getExploreMeta;
+exports.addJoin = addJoin;
+exports.getJoins = getJoins;
+const exploreMeta = new WeakMap();
+const joinMeta = new WeakMap();
+function registerExplore(ctor, options) {
+    exploreMeta.set(ctor, options);
+}
+function getExploreMeta(ctor) {
+    return exploreMeta.get(ctor);
+}
+function addJoin(prototype, entry) {
+    const existing = joinMeta.get(prototype) ?? [];
+    existing.push(entry);
+    joinMeta.set(prototype, existing);
+}
+function getJoins(prototype) {
+    return joinMeta.get(prototype) ?? [];
+}

package/dist/dsl/registry/model-registry.d.ts

@@ -0,0 +1,9 @@
+import type { ViewConstructor } from './explore-registry.js';
+export type ModelOptions = {
+    name: string;
+    label: string;
+    connection: string;
+    explores: ViewConstructor[];
+};
+export declare function registerModel(ctor: object, options: ModelOptions): void;
+export declare function getModelMeta(ctor: object): ModelOptions | undefined;

package/dist/dsl/registry/model-registry.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModel = registerModel;
+exports.getModelMeta = getModelMeta;
+const modelMeta = new WeakMap();
+function registerModel(ctor, options) {
+    modelMeta.set(ctor, options);
+}
+function getModelMeta(ctor) {
+    return modelMeta.get(ctor);
+}

package/dist/dsl/registry/view-registry.d.ts

@@ -0,0 +1,32 @@
+import type { AggregateType, DimensionType } from '../../types/manifest.types.js';
+export type ViewOptions = {
+    name: string;
+    label: string;
+    table: string;
+};
+export type DimensionOptions = {
+    groupLabel: string;
+    label: string;
+    type: DimensionType;
+};
+export type MeasureOptions = {
+    groupLabel: string;
+    label: string;
+    type: AggregateType;
+};
+export type DimensionEntry = {
+    propertyKey: string;
+    options: DimensionOptions;
+};
+export type MeasureEntry = {
+    propertyKey: string;
+    options: MeasureOptions;
+};
+export declare function registerView(ctor: object, options: ViewOptions): void;
+export declare function getViewMeta(ctor: object): ViewOptions | undefined;
+export declare function getViewName(ctor: object): string | undefined;
+export declare function setViewNameBrand(ctor: object, name: string): void;
+export declare function addDimension(prototype: object, entry: DimensionEntry): void;
+export declare function getDimensions(prototype: object): DimensionEntry[];
+export declare function addMeasure(prototype: object, entry: MeasureEntry): void;
+export declare function getMeasures(prototype: object): MeasureEntry[];

package/dist/dsl/registry/view-registry.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerView = registerView;
+exports.getViewMeta = getViewMeta;
+exports.getViewName = getViewName;
+exports.setViewNameBrand = setViewNameBrand;
+exports.addDimension = addDimension;
+exports.getDimensions = getDimensions;
+exports.addMeasure = addMeasure;
+exports.getMeasures = getMeasures;
+const viewMeta = new WeakMap();
+const dimensionMeta = new WeakMap();
+const measureMeta = new WeakMap();
+function registerView(ctor, options) {
+    viewMeta.set(ctor, options);
+}
+function getViewMeta(ctor) {
+    return viewMeta.get(ctor);
+}
+function getViewName(ctor) {
+    return getViewMeta(ctor)?.name;
+}
+function setViewNameBrand(ctor, name) {
+    ctor.__viewName = name;
+}
+function appendEntry(map, target, entry) {
+    const existing = map.get(target) ?? [];
+    existing.push(entry);
+    map.set(target, existing);
+}
+function addDimension(prototype, entry) {
+    appendEntry(dimensionMeta, prototype, entry);
+}
+function getDimensions(prototype) {
+    return dimensionMeta.get(prototype) ?? [];
+}
+function addMeasure(prototype, entry) {
+    appendEntry(measureMeta, prototype, entry);
+}
+function getMeasures(prototype) {
+    return measureMeta.get(prototype) ?? [];
+}

package/dist/dsl/types/join-scope.types.d.ts

@@ -0,0 +1,9 @@
+import type { ManifestExpr } from '../../types/manifest-expr.types.js';
+import type { JoinScopeProxy } from './view-name-map.types.js';
+export type JoinScopeCallback = (...proxies: JoinScopeProxy[]) => ManifestExpr;
+export type JoinScopeSqlOn = (scope: Record<string, unknown>) => ManifestExpr;
+export interface JoinScopeTagged {
+    readonly __joinScopeBrand: symbol;
+    readonly fn: JoinScopeCallback;
+}
+export declare function isJoinScopeTagged(value: unknown): value is JoinScopeTagged;

package/dist/dsl/types/join-scope.types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJoinScopeTagged = isJoinScopeTagged;
+function isJoinScopeTagged(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value !== null &&
+        '__joinScopeBrand' in value);
+}

package/dist/dsl/types/view-name-map.types.d.ts

@@ -0,0 +1,13 @@
+import type { Field } from '../expr/field.js';
+import type { ViewConstructor, ViewProxy } from './view-proxy.types.js';
+/** Augment in consumer repos to map @View({ name }) → view class. */
+export interface ViewNameMap {
+}
+export type ViewProxyByName<N extends string> = N extends keyof ViewNameMap & string ? ViewProxy<ViewNameMap[N]> : ViewProxy<ViewConstructor>;
+/** Positional join callback proxy — index allows join-only columns. */
+export type JoinScopeProxy = {
+    [key: string]: Field<unknown>;
+};
+export type JoinScopeProxies<Names extends readonly string[]> = {
+    [I in keyof Names]: I extends `${number}` ? ViewProxyByName<Names[I] & string> : never;
+};

package/dist/dsl/types/view-name-map.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dsl/types/view-proxy.types.d.ts

@@ -0,0 +1,13 @@
+import type { Field } from '../expr/field.js';
+export type ViewConstructor = new (...args: unknown[]) => object;
+export type DimensionKeys<V extends ViewConstructor> = {
+    [K in keyof InstanceType<V>]: InstanceType<V>[K] extends Field<infer _> ? K : never;
+}[keyof InstanceType<V>];
+export type ViewProxy<V extends ViewConstructor> = {
+    [K in DimensionKeys<V>]: InstanceType<V>[K];
+} & {
+    [key: string]: Field<unknown>;
+};
+export interface ViewBrand {
+    readonly __viewName?: string;
+}

package/dist/dsl/types/view-proxy.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { SCHEMA_VERSION } from './constants.js';
+export type { AggregateKind, AggregateExpr, ComparisonExpr, ComparisonKind, JoinOn, JoinPair, LogicExpr, LogicKind, ManifestExpr, ManifestExprObject, NotExpr, RawExpr, RefString, } from './types/manifest-expr.types.js';
+export { isJoinPair, isManifestExprObject, isRefString, REF_STRING_PATTERN, } from './types/manifest-expr.types.js';
+export type { AggregateType, DimensionDefinition, DimensionType, Explore as ManifestExplore, ExploreJoin, JoinRelationship, JoinType, MeasurementDefinition, Model as ManifestModel, ModelManifest, ViewDefinition, } from './types/manifest.types.js';
+export type { ManifestValidationError, ValidationResult, } from './validate/validation-result.js';
+export { validateManifest } from './validate/validate-manifest.js';
+export { Field, field, count, sum, min, max, raw, joinScope, isJoinScopeTagged } from './dsl/expr/index.js';
+export type { JoinScopeCallback, JoinScopeSqlOn, JoinScopeTagged } from './dsl/types/join-scope.types.js';
+export { View, Dimension, Measure, Explore, Join, Model } from './dsl/decorators/index.js';
+export type { ViewProxy, ViewConstructor } from './dsl/types/view-proxy.types.js';
+export type { ViewNameMap, ViewProxyByName, } from './dsl/types/view-name-map.types.js';
+export { compileView, compileExplore, compileModel, compileModels } from './dsl/compile/index.js';
+export { MissingMetadataError, InvalidMeasureError, JoinScopeError, DuplicateNameError, } from './dsl/errors/compile-errors.js';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateNameError = exports.JoinScopeError = exports.InvalidMeasureError = exports.MissingMetadataError = exports.compileModels = exports.compileModel = exports.compileExplore = exports.compileView = exports.Model = exports.Join = exports.Explore = exports.Measure = exports.Dimension = exports.View = exports.isJoinScopeTagged = exports.joinScope = exports.raw = exports.max = exports.min = exports.sum = exports.count = exports.field = exports.Field = exports.validateManifest = exports.REF_STRING_PATTERN = exports.isRefString = exports.isManifestExprObject = exports.isJoinPair = exports.SCHEMA_VERSION = void 0;
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "SCHEMA_VERSION", { enumerable: true, get: function () { return constants_js_1.SCHEMA_VERSION; } });
+var manifest_expr_types_js_1 = require("./types/manifest-expr.types.js");
+Object.defineProperty(exports, "isJoinPair", { enumerable: true, get: function () { return manifest_expr_types_js_1.isJoinPair; } });
+Object.defineProperty(exports, "isManifestExprObject", { enumerable: true, get: function () { return manifest_expr_types_js_1.isManifestExprObject; } });
+Object.defineProperty(exports, "isRefString", { enumerable: true, get: function () { return manifest_expr_types_js_1.isRefString; } });
+Object.defineProperty(exports, "REF_STRING_PATTERN", { enumerable: true, get: function () { return manifest_expr_types_js_1.REF_STRING_PATTERN; } });
+var validate_manifest_js_1 = require("./validate/validate-manifest.js");
+Object.defineProperty(exports, "validateManifest", { enumerable: true, get: function () { return validate_manifest_js_1.validateManifest; } });
+var index_js_1 = require("./dsl/expr/index.js");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return index_js_1.Field; } });
+Object.defineProperty(exports, "field", { enumerable: true, get: function () { return index_js_1.field; } });
+Object.defineProperty(exports, "count", { enumerable: true, get: function () { return index_js_1.count; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return index_js_1.sum; } });
+Object.defineProperty(exports, "min", { enumerable: true, get: function () { return index_js_1.min; } });
+Object.defineProperty(exports, "max", { enumerable: true, get: function () { return index_js_1.max; } });
+Object.defineProperty(exports, "raw", { enumerable: true, get: function () { return index_js_1.raw; } });
+Object.defineProperty(exports, "joinScope", { enumerable: true, get: function () { return index_js_1.joinScope; } });
+Object.defineProperty(exports, "isJoinScopeTagged", { enumerable: true, get: function () { return index_js_1.isJoinScopeTagged; } });
+var index_js_2 = require("./dsl/decorators/index.js");
+Object.defineProperty(exports, "View", { enumerable: true, get: function () { return index_js_2.View; } });
+Object.defineProperty(exports, "Dimension", { enumerable: true, get: function () { return index_js_2.Dimension; } });
+Object.defineProperty(exports, "Measure", { enumerable: true, get: function () { return index_js_2.Measure; } });
+Object.defineProperty(exports, "Explore", { enumerable: true, get: function () { return index_js_2.Explore; } });
+Object.defineProperty(exports, "Join", { enumerable: true, get: function () { return index_js_2.Join; } });
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return index_js_2.Model; } });
+var index_js_3 = require("./dsl/compile/index.js");
+Object.defineProperty(exports, "compileView", { enumerable: true, get: function () { return index_js_3.compileView; } });
+Object.defineProperty(exports, "compileExplore", { enumerable: true, get: function () { return index_js_3.compileExplore; } });
+Object.defineProperty(exports, "compileModel", { enumerable: true, get: function () { return index_js_3.compileModel; } });
+Object.defineProperty(exports, "compileModels", { enumerable: true, get: function () { return index_js_3.compileModels; } });
+var compile_errors_js_1 = require("./dsl/errors/compile-errors.js");
+Object.defineProperty(exports, "MissingMetadataError", { enumerable: true, get: function () { return compile_errors_js_1.MissingMetadataError; } });
+Object.defineProperty(exports, "InvalidMeasureError", { enumerable: true, get: function () { return compile_errors_js_1.InvalidMeasureError; } });
+Object.defineProperty(exports, "JoinScopeError", { enumerable: true, get: function () { return compile_errors_js_1.JoinScopeError; } });
+Object.defineProperty(exports, "DuplicateNameError", { enumerable: true, get: function () { return compile_errors_js_1.DuplicateNameError; } });

package/dist/types/manifest-expr.types.d.ts

@@ -0,0 +1,37 @@
+export declare const REF_STRING_PATTERN: RegExp;
+export type RefString = `${string}.${string}`;
+export type ComparisonKind = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
+export type LogicKind = 'and' | 'or';
+export type AggregateKind = 'count' | 'sum' | 'min' | 'max';
+export type RawExpr = {
+    kind: 'raw';
+    sql: string;
+};
+export type ComparisonExpr = {
+    kind: ComparisonKind;
+    left: ManifestExpr;
+    right: ManifestExpr;
+};
+export type LogicExpr = {
+    kind: LogicKind;
+    left: ManifestExpr;
+    right: ManifestExpr;
+};
+export type NotExpr = {
+    kind: 'not';
+    operand: ManifestExpr;
+};
+export type AggregateExpr = {
+    kind: 'aggregate';
+    fn: AggregateKind;
+    operand: ManifestExpr;
+};
+export type ManifestExprObject = RawExpr | ComparisonExpr | LogicExpr | NotExpr | AggregateExpr;
+export type ManifestExpr = RefString | ManifestExprObject;
+export type JoinPair = {
+    pair: [string, string];
+};
+export type JoinOn = JoinPair | ManifestExpr;
+export declare function isRefString(value: unknown): value is RefString;
+export declare function isManifestExprObject(value: unknown): value is ManifestExprObject;
+export declare function isJoinPair(value: unknown): value is JoinPair;

package/dist/types/manifest-expr.types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REF_STRING_PATTERN = void 0;
+exports.isRefString = isRefString;
+exports.isManifestExprObject = isManifestExprObject;
+exports.isJoinPair = isJoinPair;
+exports.REF_STRING_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*$/;
+function isRefString(value) {
+    return typeof value === 'string' && exports.REF_STRING_PATTERN.test(value);
+}
+function isManifestExprObject(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    return 'kind' in value && typeof value.kind === 'string';
+}
+function isJoinPair(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const pair = value.pair;
+    return (Array.isArray(pair) &&
+        pair.length === 2 &&
+        typeof pair[0] === 'string' &&
+        typeof pair[1] === 'string');
+}

package/dist/types/manifest.types.d.ts

@@ -0,0 +1,54 @@
+import type { JoinOn, ManifestExpr } from './manifest-expr.types.js';
+export type DimensionType = 'integer' | 'string' | 'date' | 'datetime' | 'boolean';
+export type AggregateType = 'sum' | 'count' | 'min' | 'max';
+export type JoinType = 'inner' | 'left' | 'right' | 'full';
+export type JoinRelationship = 'one_to_one' | 'one_to_many' | 'many_to_one' | 'many_to_many';
+export interface ExploreJoin {
+    name: string;
+    fromView: string;
+    on: JoinOn;
+    type: JoinType;
+    relationship: JoinRelationship;
+}
+export interface DimensionDefinition {
+    groupLabel: string;
+    name: string;
+    label: string;
+    type: DimensionType;
+    expression: ManifestExpr;
+}
+export interface MeasurementDefinition {
+    groupLabel: string;
+    name: string;
+    label: string;
+    type: AggregateType;
+    expression: ManifestExpr;
+}
+export interface ViewDefinition {
+    name: string;
+    label: string;
+    sql: {
+        tableName: string;
+    };
+    dimensions: DimensionDefinition[];
+    measurements: MeasurementDefinition[];
+}
+export interface Explore {
+    name: string;
+    label: string;
+    from: string;
+    joins: ExploreJoin[];
+    views: ViewDefinition[];
+}
+export interface Model {
+    name: string;
+    label: string;
+    connectionName: string;
+    explores: Explore[];
+}
+export interface ModelManifest {
+    schemaVersion: '1.1';
+    generatedAt: string;
+    sourceCommit?: string;
+    models: Model[];
+}

package/dist/types/manifest.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validate/expr-semantic.d.ts

@@ -0,0 +1,6 @@
+import type { AggregateType } from '../types/manifest.types.js';
+import type { JoinOn, ManifestExpr } from '../types/manifest-expr.types.js';
+import type { ManifestValidationError } from './validation-result.js';
+export declare function validateDimensionExpression(expression: ManifestExpr, viewNames: Set<string>, path: string): ManifestValidationError[];
+export declare function validateMeasurementExpression(expression: ManifestExpr, expectedType: AggregateType, viewNames: Set<string>, path: string): ManifestValidationError[];
+export declare function validateJoinOn(on: JoinOn, viewNames: Set<string>, fromView: string, joinFromView: string, path: string): ManifestValidationError[];

package/dist/validate/expr-semantic.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDimensionExpression = validateDimensionExpression;
+exports.validateMeasurementExpression = validateMeasurementExpression;
+exports.validateJoinOn = validateJoinOn;
+const manifest_expr_types_js_1 = require("../types/manifest-expr.types.js");
+function refViewName(ref) {
+    return ref.split('.')[0] ?? '';
+}
+function validateRefInViews(ref, viewNames, path, errors) {
+    const viewName = refViewName(ref);
+    if (!viewNames.has(viewName)) {
+        errors.push({
+            path,
+            message: `expression references unknown view "${viewName}"`,
+        });
+    }
+}
+function collectExprSemanticErrors(expr, viewNames, path, errors, allowRaw) {
+    if ((0, manifest_expr_types_js_1.isRefString)(expr)) {
+        validateRefInViews(expr, viewNames, path, errors);
+        return;
+    }
+    if (!(0, manifest_expr_types_js_1.isManifestExprObject)(expr)) {
+        errors.push({ path, message: 'invalid expression' });
+        return;
+    }
+    switch (expr.kind) {
+        case 'raw':
+            if (!allowRaw) {
+                errors.push({ path, message: 'raw expressions are not allowed here' });
+            }
+            return;
+        case 'not':
+            collectExprSemanticErrors(expr.operand, viewNames, `${path}.operand`, errors, allowRaw);
+            return;
+        case 'aggregate':
+            collectExprSemanticErrors(expr.operand, viewNames, `${path}.operand`, errors, false);
+            return;
+        case 'eq':
+        case 'neq':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+        case 'and':
+        case 'or':
+            collectExprSemanticErrors(expr.left, viewNames, `${path}.left`, errors, allowRaw);
+            collectExprSemanticErrors(expr.right, viewNames, `${path}.right`, errors, allowRaw);
+            return;
+        default: {
+            const _exhaustive = expr;
+            errors.push({ path, message: `unknown expression kind: ${_exhaustive.kind}` });
+        }
+    }
+}
+function validateDimensionExpression(expression, viewNames, path) {
+    const errors = [];
+    if (!(0, manifest_expr_types_js_1.isRefString)(expression)) {
+        errors.push({
+            path,
+            message: 'dimension expression must be a view.field ref string',
+        });
+        return errors;
+    }
+    validateRefInViews(expression, viewNames, path, errors);
+    return errors;
+}
+function validateMeasurementExpression(expression, expectedType, viewNames, path) {
+    const errors = [];
+    if (!(0, manifest_expr_types_js_1.isManifestExprObject)(expression) || expression.kind !== 'aggregate') {
+        errors.push({
+            path,
+            message: 'measurement expression must be an aggregate node',
+        });
+        return errors;
+    }
+    if (expression.fn !== expectedType) {
+        errors.push({
+            path: `${path}.fn`,
+            message: `aggregate fn "${expression.fn}" does not match measurement type "${expectedType}"`,
+        });
+    }
+    if (!(0, manifest_expr_types_js_1.isRefString)(expression.operand)) {
+        errors.push({
+            path: `${path}.operand`,
+            message: 'measurement aggregate operand must be a view.field ref string',
+        });
+    }
+    else {
+        validateRefInViews(expression.operand, viewNames, `${path}.operand`, errors);
+    }
+    return errors;
+}
+function validateJoinOn(on, viewNames, fromView, joinFromView, path) {
+    const errors = [];
+    if ((0, manifest_expr_types_js_1.isJoinPair)(on)) {
+        if (on.pair[0].trim().length === 0 || on.pair[1].trim().length === 0) {
+            errors.push({ path: `${path}.pair`, message: 'pair fields must not be empty' });
+        }
+        if (!viewNames.has(fromView)) {
+            errors.push({
+                path,
+                message: `pair join references unknown from view "${fromView}"`,
+            });
+        }
+        if (!viewNames.has(joinFromView)) {
+            errors.push({
+                path,
+                message: `pair join references unknown joined view "${joinFromView}"`,
+            });
+        }
+        return errors;
+    }
+    collectExprSemanticErrors(on, viewNames, path, errors, true);
+    return errors;
+}

package/dist/validate/semantic-rules.d.ts

@@ -0,0 +1,3 @@
+import type { ModelManifest } from '../types/manifest.types.js';
+import type { ManifestValidationError } from './validation-result.js';
+export declare function collectSemanticErrors(manifest: ModelManifest): ManifestValidationError[];

package/dist/validate/semantic-rules.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSemanticErrors = collectSemanticErrors;
+const expr_semantic_js_1 = require("./expr-semantic.js");
+function duplicateNameErrors(names, pathPrefix, entityLabel) {
+    const seen = new Map();
+    const errors = [];
+    names.forEach((name, index) => {
+        if (seen.has(name)) {
+            errors.push({
+                path: `${pathPrefix}[${index}].name`,
+                message: `duplicate ${entityLabel} name: ${name}`,
+            });
+        }
+        else {
+            seen.set(name, index);
+        }
+    });
+    return errors;
+}
+function collectSemanticErrors(manifest) {
+    const errors = [];
+    if (manifest.models.length === 0) {
+        errors.push({ path: 'models', message: 'models must not be empty' });
+        return errors;
+    }
+    errors.push(...duplicateNameErrors(manifest.models.map((model) => model.name), 'models', 'model'));
+    manifest.models.forEach((model, modelIndex) => {
+        const modelPath = `models[${modelIndex}]`;
+        if (model.connectionName.trim().length === 0) {
+            errors.push({
+                path: `${modelPath}.connectionName`,
+                message: 'connectionName must not be empty',
+            });
+        }
+        errors.push(...duplicateNameErrors(model.explores.map((explore) => explore.name), `${modelPath}.explores`, 'explore'));
+        model.explores.forEach((explore, exploreIndex) => {
+            const explorePath = `${modelPath}.explores[${exploreIndex}]`;
+            const viewNames = new Set(explore.views.map((view) => view.name));
+            if (!viewNames.has(explore.from)) {
+                errors.push({
+                    path: `${explorePath}.from`,
+                    message: `from view "${explore.from}" is not in explore views`,
+                });
+            }
+            explore.joins.forEach((join, joinIndex) => {
+                if (!viewNames.has(join.fromView)) {
+                    errors.push({
+                        path: `${explorePath}.joins[${joinIndex}].fromView`,
+                        message: `join fromView "${join.fromView}" is not in explore views`,
+                    });
+                }
+                errors.push(...(0, expr_semantic_js_1.validateJoinOn)(join.on, viewNames, explore.from, join.fromView, `${explorePath}.joins[${joinIndex}].on`));
+            });
+            explore.views.forEach((view, viewIndex) => {
+                const viewPath = `${explorePath}.views[${viewIndex}]`;
+                errors.push(...duplicateNameErrors(view.dimensions.map((dimension) => dimension.name), `${viewPath}.dimensions`, 'dimension'), ...duplicateNameErrors(view.measurements.map((measurement) => measurement.name), `${viewPath}.measurements`, 'measurement'));
+                view.dimensions.forEach((dimension, dimensionIndex) => {
+                    errors.push(...(0, expr_semantic_js_1.validateDimensionExpression)(dimension.expression, viewNames, `${viewPath}.dimensions[${dimensionIndex}].expression`));
+                });
+                view.measurements.forEach((measurement, measurementIndex) => {
+                    errors.push(...(0, expr_semantic_js_1.validateMeasurementExpression)(measurement.expression, measurement.type, viewNames, `${viewPath}.measurements[${measurementIndex}].expression`));
+                });
+            });
+        });
+    });
+    return errors;
+}

package/dist/validate/structural.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationResult } from './validation-result.js';
+export declare function validateStructure(input: unknown): ValidationResult;

package/dist/validate/structural.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStructure = validateStructure;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ajv_1 = __importDefault(require("ajv"));
+const manifestSchema = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)((0, node_path_1.dirname)(__filename), '../../manifest.schema.json'), 'utf-8'));
+const ajv = new ajv_1.default({ allErrors: true, strict: false });
+const validateJson = ajv.compile(manifestSchema);
+function mapAjvError(error) {
+    const path = error.instancePath.replace(/^\//, '').replace(/\//g, '.');
+    const prefix = path.length > 0 ? `${path}: ` : '';
+    return { path, message: `${prefix}${error.message ?? 'invalid value'}`.trim() };
+}
+function validateStructure(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        return { ok: false, errors: [{ path: '', message: 'expected object' }] };
+    }
+    if (!validateJson(input)) {
+        const errors = (validateJson.errors ?? []).map(mapAjvError);
+        return { ok: false, errors: errors.length > 0 ? errors : [{ path: '', message: 'invalid manifest' }] };
+    }
+    return { ok: true };
+}

package/dist/validate/validate-manifest.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationResult } from './validation-result.js';
+export declare function validateManifest(input: unknown): ValidationResult;

package/dist/validate/validate-manifest.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateManifest = validateManifest;
+const semantic_rules_js_1 = require("./semantic-rules.js");
+const structural_js_1 = require("./structural.js");
+function validateManifest(input) {
+    const structural = (0, structural_js_1.validateStructure)(input);
+    if (!structural.ok) {
+        return structural;
+    }
+    const semanticErrors = (0, semantic_rules_js_1.collectSemanticErrors)(input);
+    if (semanticErrors.length > 0) {
+        return { ok: false, errors: semanticErrors };
+    }
+    return { ok: true };
+}

package/dist/validate/validation-result.d.ts

@@ -0,0 +1,10 @@
+export type ManifestValidationError = {
+    path: string;
+    message: string;
+};
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    errors: ManifestValidationError[];
+};

package/dist/validate/validation-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });