@true-sight/model-schema 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const SCHEMA_VERSION: "1.1";

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_VERSION = void 0;
+exports.SCHEMA_VERSION = '1.1';

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

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import type { Explore } from '../../types/manifest.types.js';
+import { type ViewConstructor } from '../registry/explore-registry.js';
+export declare function compileExplore(ExploreClass: ViewConstructor): Explore;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileExplore = compileExplore;
+require("reflect-metadata");
+const compile_errors_js_1 = require("../errors/compile-errors.js");
+const explore_registry_js_1 = require("../registry/explore-registry.js");
+const view_registry_js_1 = require("../registry/view-registry.js");
+const compile_view_js_1 = require("./compile-view.js");
+const join_helpers_js_1 = require("./join-helpers.js");
+function compileExplore(ExploreClass) {
+    const exploreMeta = (0, explore_registry_js_1.getExploreMeta)(ExploreClass);
+    if (!exploreMeta) {
+        throw new compile_errors_js_1.MissingMetadataError('Explore', ExploreClass.name);
+    }
+    const fromViewMeta = (0, view_registry_js_1.getViewMeta)(exploreMeta.from);
+    if (!fromViewMeta) {
+        throw new compile_errors_js_1.MissingMetadataError('View', exploreMeta.from.name);
+    }
+    const joinEntries = (0, explore_registry_js_1.getJoins)(ExploreClass.prototype);
+    const scopedViewNames = [fromViewMeta.name];
+    const viewClasses = new Map([
+        [fromViewMeta.name, exploreMeta.from],
+    ]);
+    const joins = [];
+    for (const entry of joinEntries) {
+        const fromViewClass = Reflect.getMetadata('design:type', ExploreClass.prototype, entry.propertyKey);
+        if (!fromViewClass) {
+            throw new compile_errors_js_1.MissingMetadataError('Join fromView', `${ExploreClass.name}.${entry.propertyKey}`);
+        }
+        const joinViewMeta = (0, view_registry_js_1.getViewMeta)(fromViewClass);
+        if (!joinViewMeta) {
+            throw new compile_errors_js_1.MissingMetadataError('View', fromViewClass.name);
+        }
+        const scopeViewNames = [...scopedViewNames, joinViewMeta.name];
+        const scope = (0, join_helpers_js_1.createJoinScope)(scopeViewNames);
+        const allowedViews = new Set(scopeViewNames);
+        const rawExpr = entry.options.sqlOn(scope);
+        (0, join_helpers_js_1.assertJoinScope)(rawExpr, allowedViews, exploreMeta.name, entry.propertyKey);
+        const on = (0, join_helpers_js_1.emitJoinOn)(fromViewMeta.name, joinViewMeta.name, rawExpr);
+        joins.push({
+            name: entry.propertyKey,
+            fromView: joinViewMeta.name,
+            on,
+            type: entry.options.type,
+            relationship: entry.options.relationship,
+        });
+        if (!viewClasses.has(joinViewMeta.name)) {
+            viewClasses.set(joinViewMeta.name, fromViewClass);
+        }
+        scopedViewNames.push(joinViewMeta.name);
+    }
+    const views = [...viewClasses.values()].map((ViewClass) => (0, compile_view_js_1.compileView)(ViewClass));
+    return {
+        name: exploreMeta.name,
+        label: exploreMeta.label,
+        from: fromViewMeta.name,
+        joins,
+        views,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { Model } from '../../types/manifest.types.js';
+import type { ViewConstructor } from '../registry/explore-registry.js';
+export declare function compileModel(ModelClass: ViewConstructor): Model;
+export declare function compileModels(classes: ViewConstructor[]): Model[];

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileModel = compileModel;
+exports.compileModels = compileModels;
+const compile_errors_js_1 = require("../errors/compile-errors.js");
+const model_registry_js_1 = require("../registry/model-registry.js");
+const compile_explore_js_1 = require("./compile-explore.js");
+function compileModel(ModelClass) {
+    const meta = (0, model_registry_js_1.getModelMeta)(ModelClass);
+    if (!meta) {
+        throw new compile_errors_js_1.MissingMetadataError('Model', ModelClass.name);
+    }
+    const exploreNames = new Set();
+    const explores = meta.explores.map((ExploreClass) => {
+        const compiled = (0, compile_explore_js_1.compileExplore)(ExploreClass);
+        if (exploreNames.has(compiled.name)) {
+            throw new compile_errors_js_1.DuplicateNameError('explore', compiled.name, meta.name);
+        }
+        exploreNames.add(compiled.name);
+        return compiled;
+    });
+    return {
+        name: meta.name,
+        label: meta.label,
+        connectionName: meta.connection,
+        explores,
+    };
+}
+function compileModels(classes) {
+    const modelNames = new Set();
+    return classes.map((ModelClass) => {
+        const model = compileModel(ModelClass);
+        if (modelNames.has(model.name)) {
+            throw new compile_errors_js_1.DuplicateNameError('model', model.name);
+        }
+        modelNames.add(model.name);
+        return model;
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { ViewDefinition } from '../../types/manifest.types.js';
+export declare function compileView(ViewClass: new (...args: unknown[]) => object): ViewDefinition;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileView = compileView;
+const manifest_expr_types_js_1 = require("../../types/manifest-expr.types.js");
+const compile_errors_js_1 = require("../errors/compile-errors.js");
+const view_registry_js_1 = require("../registry/view-registry.js");
+function compileView(ViewClass) {
+    const viewMeta = (0, view_registry_js_1.getViewMeta)(ViewClass);
+    if (!viewMeta) {
+        throw new compile_errors_js_1.MissingMetadataError('View', ViewClass.name);
+    }
+    const dimensionEntries = (0, view_registry_js_1.getDimensions)(ViewClass.prototype);
+    const measureEntries = (0, view_registry_js_1.getMeasures)(ViewClass.prototype);
+    const instance = new ViewClass();
+    const dimensions = dimensionEntries.map((entry) => ({
+        groupLabel: entry.options.groupLabel,
+        name: entry.propertyKey,
+        label: entry.options.label,
+        type: entry.options.type,
+        expression: `${viewMeta.name}.${entry.propertyKey}`,
+    }));
+    const measurements = measureEntries.map((entry) => {
+        const raw = instance[entry.propertyKey];
+        const expression = validateMeasureExpression(raw, entry.options.type, viewMeta.name, entry.propertyKey);
+        return {
+            groupLabel: entry.options.groupLabel,
+            name: entry.propertyKey,
+            label: entry.options.label,
+            type: entry.options.type,
+            expression,
+        };
+    });
+    return {
+        name: viewMeta.name,
+        label: viewMeta.label,
+        sql: { tableName: viewMeta.table },
+        dimensions,
+        measurements,
+    };
+}
+function validateMeasureExpression(value, expectedType, viewName, propertyKey) {
+    if (!(0, manifest_expr_types_js_1.isManifestExprObject)(value) || value.kind !== 'aggregate') {
+        throw new compile_errors_js_1.InvalidMeasureError(viewName, propertyKey, 'expression must be an aggregate node');
+    }
+    if (value.fn !== expectedType) {
+        throw new compile_errors_js_1.InvalidMeasureError(viewName, propertyKey, `aggregate fn '${value.fn}' does not match measure type '${expectedType}'`);
+    }
+    if (!(0, manifest_expr_types_js_1.isRefString)(value.operand)) {
+        throw new compile_errors_js_1.InvalidMeasureError(viewName, propertyKey, 'aggregate operand must be a view.field ref string');
+    }
+    const expectedPrefix = `${viewName}.`;
+    if (!value.operand.startsWith(expectedPrefix)) {
+        throw new compile_errors_js_1.InvalidMeasureError(viewName, propertyKey, `operand '${value.operand}' must reference view '${viewName}'`);
+    }
+    return value;
+}

package/dist/dsl/compile/index.d.ts

@@ -0,0 +1,3 @@
+export { compileView } from './compile-view.js';
+export { compileExplore } from './compile-explore.js';
+export { compileModel, compileModels } from './compile-model.js';

package/dist/dsl/compile/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileModels = exports.compileModel = exports.compileExplore = exports.compileView = void 0;
+var compile_view_js_1 = require("./compile-view.js");
+Object.defineProperty(exports, "compileView", { enumerable: true, get: function () { return compile_view_js_1.compileView; } });
+var compile_explore_js_1 = require("./compile-explore.js");
+Object.defineProperty(exports, "compileExplore", { enumerable: true, get: function () { return compile_explore_js_1.compileExplore; } });
+var compile_model_js_1 = require("./compile-model.js");
+Object.defineProperty(exports, "compileModel", { enumerable: true, get: function () { return compile_model_js_1.compileModel; } });
+Object.defineProperty(exports, "compileModels", { enumerable: true, get: function () { return compile_model_js_1.compileModels; } });

package/dist/dsl/compile/join-helpers.d.ts

@@ -0,0 +1,5 @@
+import type { JoinOn, ManifestExpr } from '../../types/manifest-expr.types.js';
+export declare function createJoinScope(viewNames: string[]): Record<string, unknown>;
+export declare function collectRefViews(expr: ManifestExpr): Set<string>;
+export declare function assertJoinScope(expr: ManifestExpr, allowedViews: Set<string>, exploreName: string, joinName: string): void;
+export declare function emitJoinOn(fromViewName: string, joinFromViewName: string, expr: ManifestExpr): JoinOn;

package/dist/dsl/compile/join-helpers.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJoinScope = createJoinScope;
+exports.collectRefViews = collectRefViews;
+exports.assertJoinScope = assertJoinScope;
+exports.emitJoinOn = emitJoinOn;
+const manifest_expr_types_js_1 = require("../../types/manifest-expr.types.js");
+const compile_errors_js_1 = require("../errors/compile-errors.js");
+const field_js_1 = require("../expr/field.js");
+function createJoinScope(viewNames) {
+    const scope = {};
+    for (const viewName of viewNames) {
+        scope[viewName] = createViewProxy(viewName);
+    }
+    return scope;
+}
+function createViewProxy(viewName) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (typeof prop !== 'string') {
+                return undefined;
+            }
+            return (0, field_js_1.field)(viewName, prop);
+        },
+    });
+}
+function collectRefViews(expr) {
+    const views = new Set();
+    for (const ref of collectRefs(expr)) {
+        views.add(ref.split('.')[0]);
+    }
+    return views;
+}
+function collectRefs(expr) {
+    if ((0, manifest_expr_types_js_1.isRefString)(expr)) {
+        return [expr];
+    }
+    if (!(0, manifest_expr_types_js_1.isManifestExprObject)(expr)) {
+        return [];
+    }
+    switch (expr.kind) {
+        case 'raw':
+            return [];
+        case 'not':
+            return collectRefs(expr.operand);
+        case 'aggregate':
+            return collectRefs(expr.operand);
+        case 'eq':
+        case 'neq':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            return [...collectRefs(expr.left), ...collectRefs(expr.right)];
+        case 'and':
+        case 'or':
+            return [...collectRefs(expr.left), ...collectRefs(expr.right)];
+    }
+}
+function assertJoinScope(expr, allowedViews, exploreName, joinName) {
+    for (const viewName of collectRefViews(expr)) {
+        if (!allowedViews.has(viewName)) {
+            throw new compile_errors_js_1.JoinScopeError(exploreName, joinName, viewName);
+        }
+    }
+}
+function emitJoinOn(fromViewName, joinFromViewName, expr) {
+    const pair = tryEmitPair(fromViewName, joinFromViewName, expr);
+    return pair ?? expr;
+}
+function tryEmitPair(fromViewName, joinFromViewName, expr) {
+    if (!(0, manifest_expr_types_js_1.isManifestExprObject)(expr) || expr.kind !== 'eq') {
+        return null;
+    }
+    const { left, right } = expr;
+    if (!(0, manifest_expr_types_js_1.isRefString)(left) || !(0, manifest_expr_types_js_1.isRefString)(right)) {
+        return null;
+    }
+    const [leftView, leftField] = left.split('.');
+    const [rightView, rightField] = right.split('.');
+    if (leftView === fromViewName && rightView === joinFromViewName) {
+        return { pair: [leftField, rightField] };
+    }
+    if (leftView === joinFromViewName && rightView === fromViewName) {
+        return { pair: [rightField, leftField] };
+    }
+    return null;
+}

package/dist/dsl/decorators/dimension.decorator.d.ts

@@ -0,0 +1,2 @@
+import { type DimensionOptions } from '../registry/view-registry.js';
+export declare function Dimension(options: DimensionOptions): (target: object, propertyKey: string | symbol) => void;

package/dist/dsl/decorators/dimension.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dimension = Dimension;
+const view_registry_js_1 = require("../registry/view-registry.js");
+function Dimension(options) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string') {
+            return;
+        }
+        (0, view_registry_js_1.addDimension)(target, { propertyKey, options });
+    };
+}

package/dist/dsl/decorators/explore.decorator.d.ts

@@ -0,0 +1,2 @@
+import { type ExploreOptions } from '../registry/explore-registry.js';
+export declare function Explore(options: ExploreOptions): (target: new (...args: unknown[]) => object) => void;

package/dist/dsl/decorators/explore.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Explore = Explore;
+const explore_registry_js_1 = require("../registry/explore-registry.js");
+function Explore(options) {
+    return (target) => {
+        (0, explore_registry_js_1.registerExplore)(target, options);
+    };
+}

package/dist/dsl/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export { View } from './view.decorator.js';
+export { Dimension } from './dimension.decorator.js';
+export { Measure } from './measure.decorator.js';
+export { Explore } from './explore.decorator.js';
+export { Join } from './join.decorator.js';
+export { Model } from './model.decorator.js';
+export { joinScope, isJoinScopeTagged } from '../expr/join-scope.js';

package/dist/dsl/decorators/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJoinScopeTagged = exports.joinScope = exports.Model = exports.Join = exports.Explore = exports.Measure = exports.Dimension = exports.View = void 0;
+var view_decorator_js_1 = require("./view.decorator.js");
+Object.defineProperty(exports, "View", { enumerable: true, get: function () { return view_decorator_js_1.View; } });
+var dimension_decorator_js_1 = require("./dimension.decorator.js");
+Object.defineProperty(exports, "Dimension", { enumerable: true, get: function () { return dimension_decorator_js_1.Dimension; } });
+var measure_decorator_js_1 = require("./measure.decorator.js");
+Object.defineProperty(exports, "Measure", { enumerable: true, get: function () { return measure_decorator_js_1.Measure; } });
+var explore_decorator_js_1 = require("./explore.decorator.js");
+Object.defineProperty(exports, "Explore", { enumerable: true, get: function () { return explore_decorator_js_1.Explore; } });
+var join_decorator_js_1 = require("./join.decorator.js");
+Object.defineProperty(exports, "Join", { enumerable: true, get: function () { return join_decorator_js_1.Join; } });
+var model_decorator_js_1 = require("./model.decorator.js");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_decorator_js_1.Model; } });
+var join_scope_js_1 = require("../expr/join-scope.js");
+Object.defineProperty(exports, "joinScope", { enumerable: true, get: function () { return join_scope_js_1.joinScope; } });
+Object.defineProperty(exports, "isJoinScopeTagged", { enumerable: true, get: function () { return join_scope_js_1.isJoinScopeTagged; } });

package/dist/dsl/decorators/join.decorator.d.ts

@@ -0,0 +1,2 @@
+import { type JoinOptions } from '../registry/explore-registry.js';
+export declare function Join(options: JoinOptions): (target: object, propertyKey: string | symbol) => void;

package/dist/dsl/decorators/join.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Join = Join;
+const explore_registry_js_1 = require("../registry/explore-registry.js");
+function Join(options) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string') {
+            return;
+        }
+        (0, explore_registry_js_1.addJoin)(target, { propertyKey, options });
+    };
+}

package/dist/dsl/decorators/measure.decorator.d.ts

@@ -0,0 +1,2 @@
+import { type MeasureOptions } from '../registry/view-registry.js';
+export declare function Measure(options: MeasureOptions): (target: object, propertyKey: string | symbol) => void;

package/dist/dsl/decorators/measure.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Measure = Measure;
+const view_registry_js_1 = require("../registry/view-registry.js");
+function Measure(options) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string') {
+            return;
+        }
+        (0, view_registry_js_1.addMeasure)(target, { propertyKey, options });
+    };
+}

package/dist/dsl/decorators/model.decorator.d.ts

@@ -0,0 +1,2 @@
+import { type ModelOptions } from '../registry/model-registry.js';
+export declare function Model(options: ModelOptions): (target: new (...args: unknown[]) => object) => void;

package/dist/dsl/decorators/model.decorator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = Model;
+const model_registry_js_1 = require("../registry/model-registry.js");
+function Model(options) {
+    return (target) => {
+        (0, model_registry_js_1.registerModel)(target, options);
+    };
+}

package/dist/dsl/decorators/view.decorator.d.ts

@@ -0,0 +1,4 @@
+import { type ViewOptions } from '../registry/view-registry.js';
+export declare function View(options: ViewOptions): (target: ViewConstructor) => void;
+type ViewConstructor = new (...args: unknown[]) => object;
+export {};

package/dist/dsl/decorators/view.decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.View = View;
+const view_registry_js_1 = require("../registry/view-registry.js");
+const field_js_1 = require("../expr/field.js");
+function View(options) {
+    return (target) => {
+        (0, view_registry_js_1.registerView)(target, options);
+        (0, view_registry_js_1.setViewNameBrand)(target, options.name);
+        for (const entry of (0, view_registry_js_1.getDimensions)(target.prototype)) {
+            Object.defineProperty(target.prototype, entry.propertyKey, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    return (0, field_js_1.field)(options.name, entry.propertyKey);
+                },
+            });
+        }
+    };
+}

package/dist/dsl/errors/compile-errors.d.ts

@@ -0,0 +1,12 @@
+export declare class MissingMetadataError extends Error {
+    constructor(kind: string, className: string);
+}
+export declare class InvalidMeasureError extends Error {
+    constructor(viewName: string, propertyKey: string, reason: string);
+}
+export declare class JoinScopeError extends Error {
+    constructor(exploreName: string, joinName: string, viewName: string);
+}
+export declare class DuplicateNameError extends Error {
+    constructor(kind: string, name: string, context?: string);
+}

package/dist/dsl/errors/compile-errors.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateNameError = exports.JoinScopeError = exports.InvalidMeasureError = exports.MissingMetadataError = void 0;
+class MissingMetadataError extends Error {
+    constructor(kind, className) {
+        super(`${kind} metadata missing on ${className}`);
+        this.name = 'MissingMetadataError';
+    }
+}
+exports.MissingMetadataError = MissingMetadataError;
+class InvalidMeasureError extends Error {
+    constructor(viewName, propertyKey, reason) {
+        super(`Invalid measure '${viewName}.${propertyKey}': ${reason}`);
+        this.name = 'InvalidMeasureError';
+    }
+}
+exports.InvalidMeasureError = InvalidMeasureError;
+class JoinScopeError extends Error {
+    constructor(exploreName, joinName, viewName) {
+        super(`Join '${joinName}' on explore '${exploreName}' references view '${viewName}' outside scope`);
+        this.name = 'JoinScopeError';
+    }
+}
+exports.JoinScopeError = JoinScopeError;
+class DuplicateNameError extends Error {
+    constructor(kind, name, context) {
+        super(context
+            ? `Duplicate ${kind} "${name}" in ${context}`
+            : `Duplicate ${kind} "${name}"`);
+        this.name = 'DuplicateNameError';
+    }
+}
+exports.DuplicateNameError = DuplicateNameError;

package/dist/dsl/expr/aggregates.d.ts

@@ -0,0 +1,6 @@
+import type { ManifestExpr } from '../../types/manifest-expr.types.js';
+import type { Field } from './field.js';
+export declare function count(field: Field<unknown>): ManifestExpr;
+export declare function sum(field: Field<unknown>): ManifestExpr;
+export declare function min(field: Field<unknown>): ManifestExpr;
+export declare function max(field: Field<unknown>): ManifestExpr;

package/dist/dsl/expr/aggregates.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.count = count;
+exports.sum = sum;
+exports.min = min;
+exports.max = max;
+function aggregate(fn, field) {
+    return { kind: 'aggregate', fn, operand: field.ref };
+}
+function count(field) {
+    return aggregate('count', field);
+}
+function sum(field) {
+    return aggregate('sum', field);
+}
+function min(field) {
+    return aggregate('min', field);
+}
+function max(field) {
+    return aggregate('max', field);
+}

package/dist/dsl/expr/field.d.ts

@@ -0,0 +1,15 @@
+import type { ManifestExpr, RefString } from '../../types/manifest-expr.types.js';
+export declare class Field<T> {
+    readonly ref: RefString;
+    constructor(viewName: string, fieldName: string);
+    eq(other: Field<unknown> | ManifestExpr): ManifestExpr;
+    neq(other: Field<unknown> | ManifestExpr): ManifestExpr;
+    gt(other: Field<unknown> | ManifestExpr): ManifestExpr;
+    gte(other: Field<unknown> | ManifestExpr): ManifestExpr;
+    lt(other: Field<unknown> | ManifestExpr): ManifestExpr;
+    lte(other: Field<unknown> | ManifestExpr): ManifestExpr;
+    and(other: ManifestExpr): ManifestExpr;
+    or(other: ManifestExpr): ManifestExpr;
+    not(): ManifestExpr;
+}
+export declare function field<T>(viewName: string, fieldName: string): Field<T>;

package/dist/dsl/expr/field.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = void 0;
+exports.field = field;
+class Field {
+    ref;
+    constructor(viewName, fieldName) {
+        this.ref = `${viewName}.${fieldName}`;
+    }
+    eq(other) {
+        return { kind: 'eq', left: this.ref, right: toExpr(other) };
+    }
+    neq(other) {
+        return { kind: 'neq', left: this.ref, right: toExpr(other) };
+    }
+    gt(other) {
+        return { kind: 'gt', left: this.ref, right: toExpr(other) };
+    }
+    gte(other) {
+        return { kind: 'gte', left: this.ref, right: toExpr(other) };
+    }
+    lt(other) {
+        return { kind: 'lt', left: this.ref, right: toExpr(other) };
+    }
+    lte(other) {
+        return { kind: 'lte', left: this.ref, right: toExpr(other) };
+    }
+    and(other) {
+        return { kind: 'and', left: this.ref, right: other };
+    }
+    or(other) {
+        return { kind: 'or', left: this.ref, right: other };
+    }
+    not() {
+        return { kind: 'not', operand: this.ref };
+    }
+}
+exports.Field = Field;
+function field(viewName, fieldName) {
+    return new Field(viewName, fieldName);
+}
+function toExpr(value) {
+    return value instanceof Field ? value.ref : value;
+}

package/dist/dsl/expr/index.d.ts

@@ -0,0 +1,4 @@
+export { Field, field } from './field.js';
+export { count, max, min, sum } from './aggregates.js';
+export { raw } from './raw.js';
+export { joinScope, isJoinScopeTagged } from './join-scope.js';

package/dist/dsl/expr/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJoinScopeTagged = exports.joinScope = exports.raw = exports.sum = exports.min = exports.max = exports.count = exports.field = exports.Field = void 0;
+var field_js_1 = require("./field.js");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_js_1.Field; } });
+Object.defineProperty(exports, "field", { enumerable: true, get: function () { return field_js_1.field; } });
+var aggregates_js_1 = require("./aggregates.js");
+Object.defineProperty(exports, "count", { enumerable: true, get: function () { return aggregates_js_1.count; } });
+Object.defineProperty(exports, "max", { enumerable: true, get: function () { return aggregates_js_1.max; } });
+Object.defineProperty(exports, "min", { enumerable: true, get: function () { return aggregates_js_1.min; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return aggregates_js_1.sum; } });
+var raw_js_1 = require("./raw.js");
+Object.defineProperty(exports, "raw", { enumerable: true, get: function () { return raw_js_1.raw; } });
+var join_scope_js_1 = require("./join-scope.js");
+Object.defineProperty(exports, "joinScope", { enumerable: true, get: function () { return join_scope_js_1.joinScope; } });
+Object.defineProperty(exports, "isJoinScopeTagged", { enumerable: true, get: function () { return join_scope_js_1.isJoinScopeTagged; } });

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

@@ -0,0 +1,5 @@
+import type { ManifestExpr } from '../../types/manifest-expr.types.js';
+import type { JoinScopeProxy } from '../types/view-name-map.types.js';
+import type { JoinScopeSqlOn, JoinScopeTagged } from '../types/join-scope.types.js';
+export declare function joinScope(fn: (...proxies: JoinScopeProxy[]) => ManifestExpr): JoinScopeSqlOn & JoinScopeTagged;
+export { isJoinScopeTagged } from '../types/join-scope.types.js';

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJoinScopeTagged = void 0;
+exports.joinScope = joinScope;
+const joinScopeBrand = Symbol('joinScope');
+function wrapJoinScope(fn) {
+    const tagged = {
+        __joinScopeBrand: joinScopeBrand,
+        fn,
+    };
+    const sqlOn = ((scope) => {
+        const viewNames = Object.keys(scope);
+        const proxies = viewNames.map((name) => scope[name]);
+        return tagged.fn(...proxies);
+    });
+    Object.assign(sqlOn, tagged);
+    return sqlOn;
+}
+function joinScope(fn) {
+    return wrapJoinScope(fn);
+}
+var join_scope_types_js_1 = require("../types/join-scope.types.js");
+Object.defineProperty(exports, "isJoinScopeTagged", { enumerable: true, get: function () { return join_scope_types_js_1.isJoinScopeTagged; } });

package/dist/dsl/expr/raw.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestExpr } from '../../types/manifest-expr.types.js';
+export declare function raw(sql: string): ManifestExpr;

package/dist/dsl/expr/raw.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raw = raw;
+function raw(sql) {
+    return { kind: 'raw', sql };
+}