@malloydata/malloy 0.0.391 → 0.0.392

package/dist/model/expression_compiler.js

@@ -9,6 +9,7 @@ exports.generateFunctionCallExpression = generateFunctionCallExpression;
 exports.generateFieldFragment = generateFieldFragment;
 exports.generateOutputFieldFragment = generateOutputFieldFragment;
 exports.generateParameterFragment = generateParameterFragment;
+exports.generateGivenFragment = generateGivenFragment;
 exports.generateFilterFragment = generateFilterFragment;
 exports.generateDimFragment = generateDimFragment;
 exports.generateUngroupedFragment = generateUngroupedFragment;
@@ -112,6 +113,8 @@ function compileExpr(resultSet, context, expr, state = new utils_1.GenerateState
                 return generateFieldFragment(resultSet, context, expr, state);
             case 'parameter':
                 return generateParameterFragment(resultSet, context, expr, state);
+            case 'given':
+                return generateGivenFragment(resultSet, context, expr, state);
             case 'filteredExpr':
                 return generateFilterFragment(resultSet, context, expr, state);
             case 'all':
@@ -247,7 +250,7 @@ function exprToSQL(resultSet, context, exprToTranslate, state = new utils_1.Gene
     return compiled.sql;
 }
 function generateAppliedFilter(context, filterMatchExpr, qi) {
-    var _a;
+    var _a, _b, _c;
     let filterExpr = filterMatchExpr.kids.filterExpr;
     while (filterExpr.node === '()') {
         filterExpr = filterExpr.e;
@@ -263,6 +266,22 @@ function generateAppliedFilter(context, filterMatchExpr, qi) {
             throw new Error(`Parameter ${name} was expected to be a filter expression`);
         }
     }
+    if (filterExpr.node === 'given') {
+        const id = filterExpr.id;
+        const supplied = (_c = (_b = context.prepareResultOptions) === null || _b === void 0 ? void 0 : _b.resolvedGivens) === null || _c === void 0 ? void 0 : _c.get(id);
+        if (supplied !== undefined) {
+            filterExpr = supplied;
+        }
+        else {
+            const decl = context.getModel().givens[id];
+            if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined) {
+                filterExpr = decl.default;
+            }
+            else {
+                throw new Error(unsatisfiedGivenMessage(filterExpr.refName));
+            }
+        }
+    }
     if (filterExpr.node !== 'filterLiteral') {
         throw new Error('Can only use filter expression literals or parameters as filter expressions');
     }
@@ -580,6 +599,27 @@ function generateParameterFragment(resultSet, context, expr, state) {
     }
     throw new Error(`Can't generate SQL, no value for ${expr.path}`);
 }
+function generateGivenFragment(resultSet, context, expr, state) {
+    var _a, _b;
+    const id = expr.id;
+    const supplied = (_b = (_a = context.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.resolvedGivens) === null || _b === void 0 ? void 0 : _b.get(id);
+    if (supplied !== undefined) {
+        return exprToSQL(resultSet, context, supplied, state);
+    }
+    // The default may itself be a `$OTHER`-bearing expression — recursive
+    // compile handles default chains.
+    const decl = context.getModel().givens[id];
+    if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined) {
+        return exprToSQL(resultSet, context, decl.default, state);
+    }
+    throw new Error(unsatisfiedGivenMessage(expr.refName));
+}
+function unsatisfiedGivenMessage(refName) {
+    return (`Given '${refName}' has no value and no default. ` +
+        `To fix: supply it via \`.run({givens: {${refName}: ...}})\` if it's in scope, ` +
+        'or add a default at its declaration, ' +
+        `or import the given by name so a value can be supplied (e.g. \`import { ${refName} } from "..."\`).`);
+}
 function generateFilterFragment(resultSet, context, expr, state) {
     const allWhere = new utils_1.AndChain(state.whereSQL);
     for (const cond of expr.kids.filterList) {

package/dist/model/given_binding.d.ts

@@ -0,0 +1,2 @@
+import type { Expr, GivenID, GivenValue, ModelDef } from './malloy_types';
+export declare function resolveSuppliedGivens(supplied: Record<string, GivenValue> | undefined, modelDef: ModelDef | undefined): Map<GivenID, Expr>;

package/dist/model/given_binding.js

@@ -0,0 +1,204 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSuppliedGivens = resolveSuppliedGivens;
+const luxon_1 = require("luxon");
+const closest_match_1 = require("../util/closest_match");
+const malloy_types_1 = require("./malloy_types");
+function resolveSuppliedGivens(supplied, modelDef) {
+    var _a;
+    const out = new Map();
+    if (!supplied || !modelDef)
+        return out;
+    const givens = (_a = modelDef.givens) !== null && _a !== void 0 ? _a : {};
+    // Object.entries skips inherited properties — protects against
+    // prototype pollution from e.g. an Object.create(...)-derived input.
+    for (const [name, value] of Object.entries(supplied)) {
+        if (value === undefined) {
+            throw new Error(`givens.${name}: explicit undefined is not a valid value. ` +
+                'Omit the key to defer to declaration default or a lower supply ' +
+                'layer; use null for an explicit null value.');
+        }
+        const entry = modelDef.contents[name];
+        if (!entry || entry.type !== 'given') {
+            const surfaceNames = [];
+            for (const [k, v] of Object.entries(modelDef.contents)) {
+                if (v.type === 'given')
+                    surfaceNames.push(k);
+            }
+            const suggestion = (0, closest_match_1.closestMatch)(name, surfaceNames);
+            const hint = suggestion ? ` (did you mean '${suggestion}'?)` : '';
+            throw new Error(`givens: unknown given '${name}'${hint}. Model surfaces [${surfaceNames.join(', ')}]`);
+        }
+        const decl = givens[entry.id];
+        if (!decl) {
+            // The namespace entry should never out-live its declaration — if it
+            // does, that's a translator bug, not a caller error.
+            throw new Error(`givens: internal error: namespace entry '${name}' has no declaration. Likely a compiler bug.`);
+        }
+        out.set(entry.id, valueToExpr(name, decl.type, value));
+    }
+    return out;
+}
+function valueToExpr(path, type, value) {
+    var _a, _b;
+    if (value === null) {
+        return { node: 'null' };
+    }
+    switch (type.type) {
+        case 'string': {
+            if (typeof value !== 'string') {
+                throw new TypeError(`givens.${path}: expected string, got ${describeJs(value)}`);
+            }
+            return { node: 'stringLiteral', literal: value };
+        }
+        case 'number': {
+            let lit;
+            if (typeof value === 'number') {
+                if (!Number.isFinite(value)) {
+                    throw new TypeError(`givens.${path}: number must be finite, got ${value}`);
+                }
+                lit = String(value);
+            }
+            else if (typeof value === 'bigint') {
+                lit = value.toString();
+            }
+            else if (typeof value === 'string') {
+                if (!/^-?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/.test(value)) {
+                    throw new TypeError(`givens.${path}: number-as-string must be numeric, got '${value}'`);
+                }
+                lit = value;
+            }
+            else {
+                throw new TypeError(`givens.${path}: expected number | bigint | string, got ${describeJs(value)}`);
+            }
+            return { node: 'numberLiteral', literal: lit };
+        }
+        case 'boolean': {
+            if (typeof value !== 'boolean') {
+                throw new TypeError(`givens.${path}: expected boolean, got ${describeJs(value)}`);
+            }
+            return { node: value ? 'true' : 'false' };
+        }
+        case 'date': {
+            if (typeof value !== 'string') {
+                throw new TypeError(`givens.${path}: expected ISO date string 'YYYY-MM-DD', got ${describeJs(value)}`);
+            }
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+                throw new TypeError(`givens.${path}: date must match 'YYYY-MM-DD', got '${value}'`);
+            }
+            return { node: 'dateLiteral', literal: value, typeDef: { type: 'date' } };
+        }
+        case 'timestamp': {
+            // Naive timestamp: wall-clock value with no offset. Reject JS Date
+            // (it's a UTC instant — wrong shape) and reject offset-bearing
+            // strings (those want 'timestamptz'). Parse the rest with Luxon and
+            // emit canonical "YYYY-MM-DD HH:MM:SS.sss" for the dialect.
+            if (typeof value !== 'string') {
+                throw new TypeError(`givens.${path}: expected ISO timestamp string (no offset), got ${describeJs(value)}`);
+            }
+            if (/Z$|[+-]\d{2}:?\d{2}$/.test(value)) {
+                throw new TypeError(`givens.${path}: 'timestamp' is naive — use 'timestamptz' for offset/zoned values, got '${value}'`);
+            }
+            // ISO uses T-separator; SQL form uses space. Accept both.
+            let dt = luxon_1.DateTime.fromISO(value, { zone: 'utc' });
+            if (!dt.isValid)
+                dt = luxon_1.DateTime.fromSQL(value, { zone: 'utc' });
+            if (!dt.isValid) {
+                throw new TypeError(`givens.${path}: invalid timestamp value '${value}': ${(_a = dt.invalidReason) !== null && _a !== void 0 ? _a : 'unknown'}`);
+            }
+            return {
+                node: 'timestampLiteral',
+                literal: dt.toFormat('yyyy-MM-dd HH:mm:ss.SSS'),
+                typeDef: { type: 'timestamp' },
+            };
+        }
+        case 'timestamptz': {
+            let dt;
+            if (value instanceof Date) {
+                dt = luxon_1.DateTime.fromJSDate(value, { zone: 'utc' });
+            }
+            else if (typeof value === 'string') {
+                dt = luxon_1.DateTime.fromISO(value, { setZone: true });
+                if (dt.isValid)
+                    dt = dt.toUTC();
+            }
+            else {
+                throw new TypeError(`givens.${path}: expected JS Date or ISO timestamptz string, got ${describeJs(value)}`);
+            }
+            if (!dt.isValid) {
+                throw new TypeError(`givens.${path}: invalid timestamptz value '${value}': ${(_b = dt.invalidReason) !== null && _b !== void 0 ? _b : 'unknown'}`);
+            }
+            return {
+                node: 'timestamptzLiteral',
+                literal: dt.toFormat('yyyy-MM-dd HH:mm:ss.SSS'),
+                typeDef: { type: 'timestamptz' },
+                timezone: 'UTC',
+            };
+        }
+        case 'filter expression': {
+            if (typeof value !== 'string') {
+                throw new TypeError(`givens.${path}: filter<T> givens require a JS string of Malloy filter source, got ${describeJs(value)}`);
+            }
+            return { node: 'filterLiteral', filterSrc: value };
+        }
+        case 'array': {
+            if (!Array.isArray(value)) {
+                throw new TypeError(`givens.${path}: expected array, got ${describeJs(value)}`);
+            }
+            // RepeatedRecord (array of records) carries `record_element` as its
+            // element type and the record's schema in `fields`. Each element is
+            // a record of that schema. BasicArray carries a non-record element
+            // type directly.
+            const elemType = (0, malloy_types_1.isRepeatedRecord)(type)
+                ? { type: 'record', fields: type.fields }
+                : type.elementTypeDef;
+            const values = value.map((el, i) => valueToExpr(`${path}[${i}]`, elemType, el));
+            return { node: 'arrayLiteral', kids: { values }, typeDef: type };
+        }
+        case 'record': {
+            if (typeof value !== 'object' ||
+                Array.isArray(value) ||
+                value instanceof Date) {
+                throw new TypeError(`givens.${path}: expected object, got ${describeJs(value)}`);
+            }
+            const obj = value;
+            const declared = new Set(type.fields.map(f => f.name));
+            for (const k of Object.keys(obj)) {
+                if (!declared.has(k)) {
+                    throw new TypeError(`givens.${path}.${k}: unexpected key (not in record type [${[...declared].join(', ')}])`);
+                }
+            }
+            const kids = (0, malloy_types_1.mkSafeRecord)();
+            for (const field of type.fields) {
+                if (!(field.name in obj)) {
+                    throw new TypeError(`givens.${path}.${field.name}: missing required key`);
+                }
+                kids[field.name] = valueToExpr(`${path}.${field.name}`, malloy_types_1.TD.atomicDef(field), obj[field.name]);
+            }
+            return { node: 'recordLiteral', kids, typeDef: type };
+        }
+        case 'json':
+        case 'sql native':
+        case 'error':
+            throw new Error(`givens.${path}: type '${type.type}' is not bindable`);
+        default: {
+            // Exhaustiveness: future GivenTypeDef additions will trip this.
+            const _x = type;
+            throw new Error(`givens.${path}: unhandled given type ${JSON.stringify(_x)}`);
+        }
+    }
+}
+function describeJs(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (value instanceof Date)
+        return 'Date';
+    return typeof value;
+}
+//# sourceMappingURL=given_binding.js.map

package/dist/model/index.d.ts

@@ -4,7 +4,7 @@ import { QueryQuery } from './query_query';
 import { QueryModelImpl } from './query_model_impl';
 export { QueryField, QueryStruct, QueryQuery, QueryModelImpl as QueryModel };
 export { getResultStructDefForQuery, getResultStructDefForView, } from './query_model_impl';
-export { indent, composeSQLExpr, makeDigest, mkModelDef, pathToKey, } from './utils';
+export { indent, composeSQLExpr, makeDigest, mkModelDef, pathToKey, typeDefToString, } from './utils';
 export { constantExprToSQL } from './constant_expression_compiler';
 export { getCompiledSQL } from './sql_compiled';
 export { mkSourceID, mkBuildID, mkQuerySourceDef, mkSQLSourceDef, mkTableSourceDef, resolveSourceID, registerSource, hasSourceRegistryEntry, } from './source_def_utils';

package/dist/model/index.js

@@ -36,7 +36,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasSourceRegistryEntry = exports.registerSource = exports.resolveSourceID = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkBuildID = exports.mkSourceID = exports.getCompiledSQL = exports.constantExprToSQL = exports.pathToKey = exports.mkModelDef = exports.makeDigest = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
+exports.hasSourceRegistryEntry = exports.registerSource = exports.resolveSourceID = exports.mkTableSourceDef = exports.mkSQLSourceDef = exports.mkQuerySourceDef = exports.mkBuildID = exports.mkSourceID = exports.getCompiledSQL = exports.constantExprToSQL = exports.typeDefToString = exports.pathToKey = exports.mkModelDef = exports.makeDigest = exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
 __exportStar(require("./malloy_types"), exports);
 const query_node_1 = require("./query_node");
 Object.defineProperty(exports, "QueryField", { enumerable: true, get: function () { return query_node_1.QueryField; } });
@@ -61,6 +61,7 @@ Object.defineProperty(exports, "composeSQLExpr", { enumerable: true, get: functi
 Object.defineProperty(exports, "makeDigest", { enumerable: true, get: function () { return utils_1.makeDigest; } });
 Object.defineProperty(exports, "mkModelDef", { enumerable: true, get: function () { return utils_1.mkModelDef; } });
 Object.defineProperty(exports, "pathToKey", { enumerable: true, get: function () { return utils_1.pathToKey; } });
+Object.defineProperty(exports, "typeDefToString", { enumerable: true, get: function () { return utils_1.typeDefToString; } });
 var constant_expression_compiler_1 = require("./constant_expression_compiler");
 Object.defineProperty(exports, "constantExprToSQL", { enumerable: true, get: function () { return constant_expression_compiler_1.constantExprToSQL; } });
 var sql_compiled_1 = require("./sql_compiled");