@malloydata/malloy 0.0.239-dev250226010331 → 0.0.239-dev250227145856

package/dist/api/core.js

@@ -0,0 +1,448 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statedCompileQuery = exports.newCompileQueryState = exports.compileSource = exports.compileModel = exports.DEFAULT_LOG_RANGE = exports._statedCompileModel = exports.statedCompileSource = exports.statedCompileModel = exports.newCompileSourceState = exports.newCompileModelState = exports.updateCompileModelState = exports.compileQuery = void 0;
+const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
+const lang_1 = require("../lang");
+const model_1 = require("../model");
+const to_stable_1 = require("../to_stable");
+const sql_block_1 = require("../model/sql_block");
+// TODO find where this should go...
+function tableKey(connectionName, tablePath) {
+    return `${connectionName}:${tablePath}`;
+}
+function makeSQLSourceDef(sql, dialect) {
+    return {
+        type: 'sql_select',
+        selectStr: sql.sql,
+        connection: sql.connection_name,
+        dialect: dialect,
+        fields: sql.schema ? getSchemaFields(sql.schema) : [],
+        name: (0, sql_block_1.sqlKey)(sql.connection_name, sql.sql),
+    };
+}
+function makeTableSourceDef(table, dialect) {
+    return {
+        type: 'table',
+        tablePath: table.name,
+        connection: table.connection_name,
+        dialect: dialect,
+        fields: table.schema ? getSchemaFields(table.schema) : [],
+        name: tableKey(table.connection_name, table.name),
+    };
+}
+function convertNumberSubtype(subtype) {
+    if (subtype === undefined)
+        return undefined;
+    if (subtype === 'decimal')
+        return 'float';
+    return 'integer';
+}
+function typeDefFromField(type) {
+    switch (type.kind) {
+        case 'string_type':
+            return { type: 'string' };
+        case 'number_type':
+            return { type: 'number', numberType: convertNumberSubtype(type.subtype) };
+        case 'boolean_type':
+            return { type: 'boolean' };
+        case 'timestamp_type':
+            return { type: 'timestamp', timeframe: type.timeframe };
+        case 'date_type':
+            return { type: 'date', timeframe: type.timeframe };
+        case 'sql_native_type':
+            return { type: 'sql native', rawType: type.sql_type };
+        case 'json_type':
+            return { type: 'json' };
+        case 'array_type': {
+            if (type.element_type.kind === 'record_type') {
+                return {
+                    type: 'array',
+                    elementTypeDef: { type: 'record_element' },
+                    fields: type.element_type.fields.map(convertDimension),
+                };
+            }
+            else {
+                const elementTypeDef = typeDefFromField(type.element_type);
+                if (elementTypeDef.type === 'record') {
+                    throw new Error('Arrays of records should be a repeated record type');
+                }
+                return {
+                    type: 'array',
+                    elementTypeDef,
+                };
+            }
+        }
+        case 'record_type':
+            return { type: 'record', fields: type.fields.map(convertDimension) };
+    }
+}
+function convertDimension(field) {
+    const typeDef = typeDefFromField(field.type);
+    return (0, model_1.mkFieldDef)(typeDef, field.name);
+}
+function convertTableField(field) {
+    if (field.kind !== 'dimension') {
+        throw new Error('Table schemas must only have dimension fields');
+    }
+    return convertDimension(field);
+}
+function getSchemaFields(schema) {
+    const fields = [];
+    for (const field of schema.fields) {
+        fields.push(convertTableField(field));
+    }
+    return fields;
+}
+function compilerNeedsToUpdate(compilerNeeds) {
+    var _a, _b, _c, _d, _e, _f;
+    const update = {
+        urls: {},
+        tables: {},
+        compileSQL: {},
+        translations: {},
+    };
+    if (compilerNeeds) {
+        for (const file of (_a = compilerNeeds.files) !== null && _a !== void 0 ? _a : []) {
+            if (file.contents !== undefined) {
+                update.urls[file.url] = file.contents;
+            }
+        }
+        for (const table of (_b = compilerNeeds.table_schemas) !== null && _b !== void 0 ? _b : []) {
+            const connection = (_c = compilerNeeds.connections) === null || _c === void 0 ? void 0 : _c.find(c => c.name === table.connection_name);
+            if (connection && table.schema && connection.dialect) {
+                update.tables[tableKey(table.connection_name, table.name)] =
+                    makeTableSourceDef(table, connection.dialect);
+            }
+        }
+        for (const sql of (_d = compilerNeeds.sql_schemas) !== null && _d !== void 0 ? _d : []) {
+            const connection = (_e = compilerNeeds.connections) === null || _e === void 0 ? void 0 : _e.find(c => c.name === sql.connection_name);
+            if (connection && connection.dialect) {
+                update.compileSQL[(0, sql_block_1.sqlKey)(sql.connection_name, sql.sql)] =
+                    makeSQLSourceDef(sql, connection.dialect);
+            }
+        }
+        for (const translation of (_f = compilerNeeds.translations) !== null && _f !== void 0 ? _f : []) {
+            if (translation.compiled_model_json) {
+                const modelDef = JSON.parse(translation.compiled_model_json);
+                update.translations[translation.url] = modelDef;
+            }
+        }
+    }
+    return update;
+}
+function convertCompilerNeeds(compileSQL, urls, tables) {
+    var _a, _b, _c;
+    const compilerNeeds = {};
+    const neededConnections = new Set();
+    if (compileSQL !== undefined) {
+        compilerNeeds.sql_schemas = [
+            {
+                sql: compileSQL.selectStr,
+                connection_name: compileSQL.connection,
+            },
+        ];
+        neededConnections.add(compileSQL.connection);
+    }
+    if (urls !== undefined) {
+        for (const url of urls) {
+            (_a = compilerNeeds.files) !== null && _a !== void 0 ? _a : (compilerNeeds.files = []);
+            compilerNeeds.files.push({ url });
+        }
+    }
+    if (tables !== undefined) {
+        for (const key in tables) {
+            const table = tables[key];
+            // TODO do we even support default connections any more?
+            const connectionName = (_b = table.connectionName) !== null && _b !== void 0 ? _b : '__default__';
+            (_c = compilerNeeds.table_schemas) !== null && _c !== void 0 ? _c : (compilerNeeds.table_schemas = []);
+            compilerNeeds.table_schemas.push({
+                name: table.tablePath,
+                connection_name: connectionName,
+            });
+            neededConnections.add(connectionName);
+        }
+    }
+    if (neededConnections.size > 0) {
+        compilerNeeds.connections = Array.from(neededConnections).map(c => ({
+            name: c,
+        }));
+    }
+    return compilerNeeds;
+}
+function compileQuery(request, state) {
+    state !== null && state !== void 0 ? state : (state = newCompileQueryState(request));
+    return statedCompileQuery(state);
+}
+exports.compileQuery = compileQuery;
+function updateCompileModelState(state, needs) {
+    function performUpdate(state, update) {
+        var _a, _b;
+        state.translator.update(update);
+        if (state.extending) {
+            performUpdate(state.extending, update);
+        }
+        if (!state.hasSource) {
+            state.hasSource =
+                (_b = (_a = needs === null || needs === void 0 ? void 0 : needs.files) === null || _a === void 0 ? void 0 : _a.some(f => f.url === state.translator.sourceURL)) !== null && _b !== void 0 ? _b : false;
+        }
+    }
+    const update = compilerNeedsToUpdate(needs);
+    performUpdate(state, update);
+}
+exports.updateCompileModelState = updateCompileModelState;
+function _newCompileModelState(modelURL, compilerNeeds, extendURL) {
+    var _a, _b;
+    const translator = new lang_1.MalloyTranslator(modelURL, null, compilerNeedsToUpdate(compilerNeeds));
+    const hasSource = (_b = (_a = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.files) === null || _a === void 0 ? void 0 : _a.some(f => f.url === modelURL)) !== null && _b !== void 0 ? _b : false;
+    if (extendURL) {
+        return {
+            extending: _newCompileModelState(extendURL, compilerNeeds),
+            translator,
+            done: false,
+            hasSource,
+        };
+    }
+    else {
+        return {
+            translator,
+            done: false,
+            hasSource,
+        };
+    }
+}
+function newCompileModelState(request) {
+    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url);
+}
+exports.newCompileModelState = newCompileModelState;
+function newCompileSourceState(request) {
+    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url);
+}
+exports.newCompileSourceState = newCompileSourceState;
+// function hasNeeds(needs: Malloy.CompilerNeeds | undefined): boolean {
+//   if (needs === undefined) return false;
+//   if (needs.files && needs.files.length > 0) return true;
+//   if (needs.table_schemas && needs.table_schemas.length > 0) return true;
+//   if (needs.sql_schemas && needs.sql_schemas.length > 0) return true;
+//   if (needs.connections && needs.connections.length > 0) return true;
+//   return false;
+// }
+function statedCompileModel(state) {
+    return wrapResponse(_statedCompileModel(state), state.translator.sourceURL);
+}
+exports.statedCompileModel = statedCompileModel;
+function statedCompileSource(state, name) {
+    return extractSource(_statedCompileModel(state), name, state.translator.sourceURL);
+}
+exports.statedCompileSource = statedCompileSource;
+function _statedCompileModel(state) {
+    let extendingModel = undefined;
+    if (state.extending) {
+        if (!state.extending.done) {
+            const extendingResult = _statedCompileModel(state.extending);
+            if (!state.extending.done) {
+                return extendingResult;
+            }
+        }
+        extendingModel = state.extending.translator.modelDef;
+    }
+    if (!state.hasSource) {
+        return {
+            compilerNeeds: convertCompilerNeeds(undefined, [state.translator.sourceURL], undefined),
+        };
+    }
+    const result = state.translator.translate(extendingModel);
+    if (result.final) {
+        state.done = true;
+        if (result.modelDef) {
+            return {
+                model: (0, to_stable_1.modelDefToModelInfo)(result.modelDef),
+                modelDef: result.modelDef,
+            };
+        }
+        else {
+            if (result.problems === undefined || result.problems.length === 0) {
+                throw new Error('No problems found, but no model either');
+            }
+            return {
+                logs: result.problems,
+            };
+        }
+    }
+    else {
+        const compilerNeeds = convertCompilerNeeds(result.compileSQL, result.urls, result.tables);
+        return { compilerNeeds, logs: result.problems };
+    }
+}
+exports._statedCompileModel = _statedCompileModel;
+exports.DEFAULT_LOG_RANGE = {
+    start: {
+        line: 0,
+        character: 0,
+    },
+    end: {
+        line: 0,
+        character: 0,
+    },
+};
+function mapLogs(logs, defaultURL) {
+    return logs.map(log => {
+        var _a, _b, _c, _d;
+        return ({
+            severity: log.severity,
+            message: log.message,
+            range: (_b = (_a = log.at) === null || _a === void 0 ? void 0 : _a.range) !== null && _b !== void 0 ? _b : exports.DEFAULT_LOG_RANGE,
+            url: (_d = (_c = log.at) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : defaultURL,
+        });
+    });
+}
+function wrapResponse(response, defaultURL) {
+    const logs = response.logs ? mapLogs(response.logs, defaultURL) : undefined;
+    if (response.compilerNeeds) {
+        return { compiler_needs: response.compilerNeeds, logs };
+    }
+    else {
+        return { model: response.model, logs };
+    }
+}
+function _compileModel(modelURL, compilerNeeds, extendURL, state) {
+    state !== null && state !== void 0 ? state : (state = _newCompileModelState(modelURL, compilerNeeds, extendURL));
+    return _statedCompileModel(state);
+}
+function compileModel(request, state) {
+    state !== null && state !== void 0 ? state : (state = newCompileModelState(request));
+    return statedCompileModel(state);
+}
+exports.compileModel = compileModel;
+function compileSource(request) {
+    const state = newCompileSourceState(request);
+    return statedCompileSource(state, request.name);
+}
+exports.compileSource = compileSource;
+// Given the URL to a model and a name of a queryable thing, get a StableSourceDef
+function extractSource(result, name, defaultURL) {
+    const logs = result.logs ? mapLogs(result.logs, defaultURL) : undefined;
+    if (result.model) {
+        const source = result.model.entries.find(e => e.name === name);
+        if (source === undefined) {
+            return {
+                logs: [
+                    ...(logs !== null && logs !== void 0 ? logs : []),
+                    {
+                        url: defaultURL,
+                        severity: 'error',
+                        message: `Model does not contain a source named ${name}`,
+                        range: exports.DEFAULT_LOG_RANGE,
+                    },
+                ],
+            };
+        }
+        return { source, logs };
+    }
+    else {
+        return { compiler_needs: result.compilerNeeds, logs };
+    }
+}
+// Given a StableQueryDef and the URL to a model, run it and return a StableResult
+// Given a StableQueryDef and the URL to a model, compile it and return a StableResultDef
+// Given a StableQueryDef and the URL to a model, validate it and return a list of StableErrors
+// Given a URL to a model and the name of a source, run the indexing query
+function newCompileQueryState(request) {
+    var _a, _b;
+    const queryMalloy = Malloy.queryToMalloy(request.query);
+    const needs = {
+        ...((_a = request.compiler_needs) !== null && _a !== void 0 ? _a : {}),
+    };
+    const queryURL = 'internal://query.malloy';
+    needs.files = [
+        {
+            url: queryURL,
+            contents: queryMalloy,
+        },
+        ...((_b = needs.files) !== null && _b !== void 0 ? _b : []),
+    ];
+    return _newCompileModelState(queryURL, needs, request.model_url);
+}
+exports.newCompileQueryState = newCompileQueryState;
+function statedCompileQuery(state) {
+    const result = _statedCompileModel(state);
+    // TODO this can expose the internal URL... is there a better way to handle URL-less errors from the compiler?
+    const defaultURL = state.translator.sourceURL;
+    const logs = result.logs ? mapLogs(result.logs, defaultURL) : undefined;
+    if (result.model) {
+        const queries = result.modelDef.queryList;
+        if (queries.length === 0) {
+            return {
+                logs: [
+                    ...(logs !== null && logs !== void 0 ? logs : []),
+                    {
+                        url: defaultURL,
+                        severity: 'error',
+                        message: 'Internal error: No queries found',
+                        range: exports.DEFAULT_LOG_RANGE,
+                    },
+                ],
+            };
+        }
+        const index = queries.length - 1;
+        const query = result.modelDef.queryList[index];
+        const schema = result.model.anonymous_queries[index].schema;
+        try {
+            const queryModel = new model_1.QueryModel(result.modelDef);
+            const translatedQuery = queryModel.compileQuery(query);
+            return {
+                result: {
+                    sql: translatedQuery.sql,
+                    schema,
+                    connection_name: translatedQuery.connectionName,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                logs: [
+                    ...(logs !== null && logs !== void 0 ? logs : []),
+                    {
+                        url: defaultURL,
+                        severity: 'error',
+                        message: `Internal compiler error: ${error.message}`,
+                        range: exports.DEFAULT_LOG_RANGE,
+                    },
+                ],
+            };
+        }
+    }
+    else {
+        return { compiler_needs: result.compilerNeeds, logs };
+    }
+}
+exports.statedCompileQuery = statedCompileQuery;
+//# sourceMappingURL=core.js.map

package/dist/api/index.d.ts

@@ -0,0 +1,3 @@
+export * as sessioned from './sessioned';
+export * as stateless from './stateless';
+export * as asynchronous from './asynchronous';

package/dist/api/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asynchronous = exports.stateless = exports.sessioned = void 0;
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+exports.sessioned = __importStar(require("./sessioned"));
+exports.stateless = __importStar(require("./stateless"));
+exports.asynchronous = __importStar(require("./asynchronous"));
+//# sourceMappingURL=index.js.map

package/dist/api/sessioned.d.ts

@@ -0,0 +1,10 @@
+import * as Malloy from '@malloydata/malloy-interfaces';
+export type TTL = {
+    'seconds': number;
+} | Date;
+export interface OptionsBase {
+    ttl?: TTL;
+}
+export declare function compileModel(request: Malloy.CompileModelRequest, options?: OptionsBase): Malloy.CompileModelResponse;
+export declare function compileSource(request: Malloy.CompileSourceRequest, options?: OptionsBase): Malloy.CompileSourceResponse;
+export declare function compileQuery(request: Malloy.CompileQueryRequest, options?: OptionsBase): Malloy.CompileQueryResponse;