@finos/legend-cube-builder 0.0.3 → 0.0.5

package/lib/stores/source-picker/CubeInlineModelTabState.js

@@ -0,0 +1,734 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FUNCTION_SOURCE_DEFINITION, FunctionSource, getRelationalDisplayName, parseValue, RELATIONAL_TABLE_SOURCE_DEFINITION, RelationalTableSource, resolveCubeType, getFunctionParameterValueError, Schema, } from '@finos/legend-cube';
+import { assertErrorThrown } from '@finos/legend-shared';
+import { action, computed, flow, flowResult, makeObservable, observable, } from 'mobx';
+import { CubeEngineError, CubeEngineErrorKind, CubeTableFlag, } from '../../graph-manager/CubeEngine.js';
+import { getRuntimesForDatabase } from '../../graph-manager/CubeModelOutlineHelper.js';
+import { isCubeSampleDataOffered, loadCubeModelOutline } from '../CubeHost.js';
+import { recheckCubeFunctionSources } from '../CubeFunctionRecheck.js';
+import { CUBE_FUNCTION_MESSAGE } from '../../__lib__/LegendCubeFunctionLabels.js';
+import { createTextModel } from '../LocalModelCatalog.js';
+import { CubeSourcePickerTabKey, CUBE_TABLE_PREVIEW_DELAY_MS, generateCubeNodeIds, } from './CubeSourcePickerTab.js';
+const toMessage = (error) => {
+    assertErrorThrown(error);
+    return error instanceof CubeEngineError ? error.firstLine : error.message;
+};
+/** Whether a table can be picked: a table with a column Cube can't read can't */
+export const isTableSelectable = (table) => !table.flags.includes(CubeTableFlag.UNAVAILABLE);
+/** What the tab adds from the model: a table, or a function that returns a relation (PLAN §6.5) */
+export var CubeModelReadKind;
+(function (CubeModelReadKind) {
+    CubeModelReadKind["TABLE"] = "table";
+    CubeModelReadKind["FUNCTION"] = "function";
+})(CubeModelReadKind || (CubeModelReadKind = {}));
+/**
+ * A parameter's value from its text: none for empty text, whatever the type,
+ * so an optional String left empty passes `[]`, not `''`
+ */
+export const readCubeFunctionValue = (text, parameter) => (text === '' ? undefined : parseValue(text, parameter.type));
+/** A function's parameters as Cube types: `[0..1]` ones optional */
+export const getCubeFunctionParameters = (fn) => fn.parameters.map((parameter) => ({
+    name: parameter.name,
+    type: resolveCubeType(parameter.type),
+    optional: parameter.multiplicity === '[0..1]',
+}));
+/**
+ * The source picker's Model tab (PLAN §6.2.7, Settled before M1.8): model,
+ * then database, then a runtime keyed by that database, then schema and
+ * table. A step with a single choice is picked automatically. The first
+ * table fixes the cube's model and runtime; later tables come from the same
+ * database and runtime. A table is added only once its schema has resolved.
+ * It serves every cube no other tab claims, e.g. one on Pure text.
+ */
+export class CubeInlineModelTabState {
+    key = CubeSourcePickerTabKey.MODEL;
+    label = 'Sample Data';
+    editorState;
+    model;
+    /** The model is Pure text the user pastes, not a bundled one */
+    isPastingModel = false;
+    pastedModelText = '';
+    /** The model the paste box last loaded: only it keeps the box shown */
+    pastedModel;
+    outline;
+    isLoadingModel = false;
+    databasePath;
+    runtimePath;
+    schemaName;
+    /** The picked tables, in the order picked; several are added at once */
+    tableNames = [];
+    tableSearch = '';
+    /** Whether the tab adds a table or a function */
+    readKind = CubeModelReadKind.TABLE;
+    functionSearch = '';
+    /** The picked function's full name */
+    functionSignature;
+    /** The text entered for each of its parameters */
+    functionValueTexts = [];
+    /** The runtime picked for a function that leaves it to its caller */
+    functionRuntimePath;
+    isResolving = false;
+    /** The table whose columns the tab shows under the list: the one picked last */
+    previewTableName;
+    /**
+     * The columns of each table previewed, or why they couldn't be read, by
+     * database, schema and table; Add takes them, so it asks the engine only
+     * for the others (the review of the demo, 2026-10-13)
+     */
+    previewSchemas = new Map();
+    /** Counts the model, database or runtime changes, so a late preview is dropped */
+    previewGeneration = 0;
+    /** The preview waiting for the clicks to pause */
+    previewTimer;
+    /** Why the outline or the table couldn't be loaded, shown in the dialog */
+    error;
+    /** Counts Add presses: closing the dialog moves it on, so the pending Add is dropped */
+    confirmRequest = 0;
+    constructor(editorState) {
+        makeObservable(this, {
+            model: observable.ref,
+            isPastingModel: observable,
+            pastedModelText: observable,
+            outline: observable.ref,
+            isLoadingModel: observable,
+            databasePath: observable,
+            runtimePath: observable,
+            schemaName: observable,
+            tableNames: observable.ref,
+            tableName: computed,
+            tableSearch: observable,
+            readKind: observable,
+            functionSearch: observable,
+            functionSignature: observable,
+            functionValueTexts: observable.ref,
+            functionRuntimePath: observable,
+            isResolving: observable,
+            previewTableName: observable,
+            previewSchemas: observable.ref,
+            previewedColumns: computed,
+            loadPreview: flow,
+            functions: computed,
+            pickedFunction: computed,
+            functionParameters: computed,
+            functionValues: computed,
+            functionRuntime: computed,
+            functionRuntimes: computed,
+            functionProblem: computed,
+            setReadKind: action,
+            setFunctionSearch: action,
+            selectFunction: action,
+            setFunctionValueText: action,
+            selectFunctionRuntime: action,
+            error: observable,
+            fixedContext: computed,
+            fixedDatabasePath: computed,
+            databases: computed,
+            runtimes: computed,
+            schemas: computed,
+            tables: computed,
+            schemaTables: computed,
+            canConfirm: computed,
+            isBusy: computed,
+            open: action,
+            close: action,
+            selectDatabase: action,
+            selectRuntime: action,
+            selectSchema: action,
+            selectTable: action,
+            toggleTable: action,
+            setTableSearch: action,
+            startPastingModel: action,
+            setPastedModelText: action,
+            selectModel: flow,
+            loadPastedModel: flow,
+            confirm: flow,
+            confirmFunction: flow,
+        });
+        this.editorState = editorState;
+    }
+    get models() {
+        return this.editorState.host.modelCatalog.models;
+    }
+    /** Once the cube has a model, every table comes from it */
+    get fixedContext() {
+        return this.editorState.document.context;
+    }
+    /** Once the cube has a table, every other one comes from its database */
+    get fixedDatabasePath() {
+        return this.editorState.document.query.nodes.find((node) => node instanceof RelationalTableSource)?.database;
+    }
+    get databases() {
+        const databases = this.outline?.databases ?? [];
+        const fixedRuntime = this.fixedContext?.runtime;
+        return databases.filter((database) => (this.fixedDatabasePath === undefined ||
+            database.path === this.fixedDatabasePath) &&
+            (fixedRuntime === undefined ||
+                (this.outline &&
+                    getRuntimesForDatabase(this.outline, database.path).some((runtime) => runtime.path === fixedRuntime))));
+    }
+    get runtimes() {
+        if (!this.outline || this.databasePath === undefined) {
+            return [];
+        }
+        const fixedRuntime = this.fixedContext?.runtime;
+        return getRuntimesForDatabase(this.outline, this.databasePath).filter((runtime) => fixedRuntime === undefined || runtime.path === fixedRuntime);
+    }
+    get schemas() {
+        return (this.databases.find((database) => database.path === this.databasePath)
+            ?.schemas ?? []);
+    }
+    /** The schema's tables, views left out */
+    get schemaTables() {
+        return (this.schemas
+            .find((schema) => schema.name === this.schemaName)
+            ?.tables.filter((table) => !table.isView) ?? []);
+    }
+    /** The one picked table; none when several are */
+    get tableName() {
+        return this.tableNames.length === 1 ? this.tableNames[0] : undefined;
+    }
+    /** The schema's tables, views left out, filtered by the search text */
+    get tables() {
+        const search = this.tableSearch.trim().toLowerCase();
+        return (this.schemas.find((schema) => schema.name === this.schemaName)?.tables ??
+            []).filter((table) => !table.isView &&
+            getRelationalDisplayName(table.name).toLowerCase().includes(search));
+    }
+    /** The model's functions that return a relation, filtered by the search text */
+    get functions() {
+        const search = this.functionSearch.trim().toLowerCase();
+        return (this.outline?.functions ?? []).filter((fn) => fn.path.toLowerCase().includes(search));
+    }
+    get pickedFunction() {
+        return this.outline?.functions?.find((fn) => fn.signature === this.functionSignature);
+    }
+    get functionParameters() {
+        const fn = this.pickedFunction;
+        return fn ? getCubeFunctionParameters(fn) : [];
+    }
+    /** The value entered for each parameter */
+    get functionValues() {
+        return this.functionParameters.map((parameter, index) => readCubeFunctionValue(this.functionValueTexts[index] ?? '', parameter));
+    }
+    /**
+     * The runtimes a function that leaves the runtime to its caller can run
+     * on: the cube's, once it has one, else every runtime of the model
+     */
+    get functionRuntimes() {
+        const fixedRuntime = this.fixedContext?.runtime;
+        return (this.outline?.runtimes ?? []).filter((runtime) => fixedRuntime === undefined || runtime.path === fixedRuntime);
+    }
+    /**
+     * The runtime the picked function runs on: its own, when its body names
+     * one; else the one picked
+     */
+    get functionRuntime() {
+        return this.pickedFunction?.runtime ?? this.functionRuntimePath;
+    }
+    /** Why the picked function can't be added, if it can't */
+    get functionProblem() {
+        const fn = this.pickedFunction;
+        if (!fn) {
+            return undefined;
+        }
+        if (fn.problem !== undefined) {
+            return fn.problem;
+        }
+        const fixedRuntime = this.fixedContext?.runtime;
+        return fn.runtime !== undefined &&
+            fixedRuntime !== undefined &&
+            fn.runtime !== fixedRuntime
+            ? CUBE_FUNCTION_MESSAGE.OTHER_RUNTIME(fn.runtime, fixedRuntime)
+            : undefined;
+    }
+    /** The host serves the tab unless it offers no sample data */
+    get isAvailable() {
+        return isCubeSampleDataOffered(this.editorState.host);
+    }
+    get isBusy() {
+        return this.isLoadingModel || this.isResolving;
+    }
+    /** The tab claims no cube: the dialog gives it every cube no other tab claims */
+    ownsContext(context) {
+        return false;
+    }
+    get canConfirm() {
+        if (this.readKind === CubeModelReadKind.FUNCTION) {
+            return (!this.isLoadingModel &&
+                !this.isResolving &&
+                this.model !== undefined &&
+                this.pickedFunction !== undefined &&
+                this.functionProblem === undefined &&
+                this.functionRuntime !== undefined &&
+                this.functionParameters.every((parameter, index) => getFunctionParameterValueError(parameter, this.functionValues[index]) === undefined));
+        }
+        // a picked table hidden by the search still counts
+        const tables = this.tableNames.map((name) => this.schemaTables.find((candidate) => candidate.name === name));
+        return (!this.isLoadingModel &&
+            !this.isResolving &&
+            this.model !== undefined &&
+            this.runtimePath !== undefined &&
+            tables.length > 0 &&
+            tables.every((table) => table !== undefined && isTableSelectable(table)));
+    }
+    /**
+     * When the dialog opens on the tab: on the cube's model, else the pasted
+     * model while the paste box is shown, else the bundled model picked last,
+     * else the first one. A model whose outline failed to load is loaded again.
+     */
+    open() {
+        this.error = undefined;
+        const model = this.fixedContext?.model ??
+            (this.isPastingModel
+                ? this.model
+                : (this.models.find((bundled) => bundled.model === this.model) ??
+                    this.models[0])?.model);
+        if (!model) {
+            return;
+        }
+        if (model !== this.model || !this.outline) {
+            flowResult(this.selectModel(model)).catch(this.editorState.host.applicationStore.alertUnhandledError);
+        }
+        else if (this.databasePath !== undefined &&
+            !this.databases.some((database) => database.path === this.databasePath)) {
+            // the cube changed since the last pick, e.g. by undo
+            const [onlyDatabase, ...otherDatabases] = this.databases;
+            this.selectDatabase(onlyDatabase && !otherDatabases.length ? onlyDatabase.path : undefined);
+        }
+        else {
+            this.followFixedRuntime();
+        }
+    }
+    /**
+     * Takes the cube's runtime once it has one, e.g. a function's (PLAN
+     * §6.5): its table and function steps can't pick another
+     */
+    followFixedRuntime() {
+        const fixedRuntime = this.fixedContext?.runtime;
+        if (fixedRuntime === undefined) {
+            return;
+        }
+        if (this.runtimes.some((runtime) => runtime.path === fixedRuntime)) {
+            this.runtimePath = fixedRuntime;
+        }
+        if (this.functionRuntimes.some((runtime) => runtime.path === fixedRuntime)) {
+            this.functionRuntimePath = fixedRuntime;
+        }
+    }
+    /** When the dialog closes: a table still being typed is not added */
+    close() {
+        this.confirmRequest++;
+        this.isResolving = false;
+        this.cancelPreview();
+    }
+    /** Offers a text box for a Pure model in place of the bundled ones */
+    startPastingModel() {
+        this.isPastingModel = true;
+        this.model = undefined;
+        this.outline = undefined;
+        this.error = undefined;
+        this.isLoadingModel = false;
+        this.resetFrom('database');
+    }
+    setPastedModelText(text) {
+        this.pastedModelText = text;
+    }
+    /**
+     * Loads the pasted Pure text as the model: the cube will hold the text
+     * itself, so it counts towards the size a saved cube can have
+     */
+    *loadPastedModel() {
+        if (this.pastedModelText.trim()) {
+            this.pastedModel = createTextModel(this.pastedModelText);
+            yield flowResult(this.selectModel(this.pastedModel));
+        }
+    }
+    /**
+     * Loads a model's outline. Any model but the one the paste box loaded ends
+     * pasting, e.g. a bundled model, or the model of a cube opened meanwhile.
+     */
+    *selectModel(model) {
+        this.isPastingModel = model === this.pastedModel;
+        this.model = model;
+        this.outline = undefined;
+        this.error = undefined;
+        this.resetFrom('database');
+        this.isLoadingModel = true;
+        try {
+            const outline = (yield loadCubeModelOutline(this.editorState.host, model));
+            if (this.model !== model) {
+                return;
+            }
+            this.outline = outline;
+            const [onlyDatabase, ...otherDatabases] = this.databases;
+            if (onlyDatabase && !otherDatabases.length) {
+                this.selectDatabase(onlyDatabase.path);
+            }
+        }
+        catch (error) {
+            if (this.model === model) {
+                this.error = toMessage(error);
+            }
+        }
+        finally {
+            if (this.model === model) {
+                this.isLoadingModel = false;
+            }
+        }
+    }
+    selectDatabase(path) {
+        this.databasePath = path;
+        this.resetFrom('runtime');
+        const [onlyRuntime, ...otherRuntimes] = this.runtimes;
+        if (onlyRuntime && !otherRuntimes.length) {
+            this.runtimePath = onlyRuntime.path;
+        }
+        const [onlySchema, ...otherSchemas] = this.schemas;
+        if (onlySchema && !otherSchemas.length) {
+            this.schemaName = onlySchema.name;
+        }
+    }
+    selectRuntime(path) {
+        this.runtimePath = path;
+    }
+    selectSchema(name) {
+        this.schemaName = name;
+        this.resetFrom('table');
+    }
+    /** Picks the table alone, in place of any picked, and previews its columns */
+    selectTable(name) {
+        this.tableNames = name === undefined ? [] : [name];
+        this.error = undefined;
+        this.preview(name);
+    }
+    /** Adds the table to the picked ones, previewing it, or takes it out */
+    toggleTable(name) {
+        const adding = !this.tableNames.includes(name);
+        this.tableNames = adding
+            ? [...this.tableNames, name]
+            : this.tableNames.filter((each) => each !== name);
+        this.error = undefined;
+        this.preview(adding ? name : this.tableNames.at(-1));
+    }
+    previewKey(table) {
+        return `${this.databasePath ?? ''}\u0000${this.schemaName ?? ''}\u0000${table}`;
+    }
+    /** The previewed table's columns, `undefined` while they load, or why they couldn't be read */
+    get previewedColumns() {
+        const name = this.previewTableName;
+        return name === undefined
+            ? undefined
+            : this.previewSchemas.get(this.previewKey(name));
+    }
+    /**
+     * Previews the table once the clicks pause, so picking several in a row
+     * asks the engine for the last only; Add, Close and another pick cancel it
+     */
+    preview(name) {
+        this.previewTableName = name;
+        this.cancelPreview();
+        if (name !== undefined) {
+            this.previewTimer = setTimeout(() => {
+                this.previewTimer = undefined;
+                flowResult(this.loadPreview(name)).catch(this.editorState.host.applicationStore.alertUnhandledError);
+            }, CUBE_TABLE_PREVIEW_DELAY_MS);
+        }
+    }
+    cancelPreview() {
+        if (this.previewTimer !== undefined) {
+            clearTimeout(this.previewTimer);
+            this.previewTimer = undefined;
+        }
+    }
+    /** Reads a table's columns from the engine, once a table and a model's database */
+    *loadPreview(name) {
+        const key = this.previewKey(name);
+        const model = this.model;
+        const database = this.databasePath;
+        const schemaName = this.schemaName;
+        if (this.previewSchemas.has(key) ||
+            !model ||
+            database === undefined ||
+            schemaName === undefined) {
+            return;
+        }
+        const generation = this.previewGeneration;
+        // an id of its own, as the engine stamps the table's accessor with it
+        const id = this.editorState.document.query.generateId(RelationalTableSource.TYPE);
+        let answer;
+        try {
+            const typed = (yield this.editorState.host.engine.resolveSchemas(model, new Map([[id, [database, schemaName, name]]])));
+            const schema = typed.get(id);
+            answer =
+                schema instanceof Schema
+                    ? schema
+                    : (schema?.message ?? 'The engine gave no schema for this table');
+        }
+        catch (error) {
+            answer = toMessage(error);
+        }
+        if (generation === this.previewGeneration) {
+            this.previewSchemas = new Map(this.previewSchemas).set(key, answer);
+        }
+    }
+    /** How many sources Add adds */
+    get pickedCount() {
+        return this.readKind === CubeModelReadKind.FUNCTION
+            ? 1
+            : this.tableNames.length;
+    }
+    setTableSearch(search) {
+        this.tableSearch = search;
+    }
+    /**
+     * What the tab reads: a model's tables or functions; a project's tables
+     * and functions each have a tab of their own (user, 2026-10-13)
+     */
+    get readKinds() {
+        return [CubeModelReadKind.TABLE, CubeModelReadKind.FUNCTION];
+    }
+    /** Reads tables or functions, when the tab reads that kind */
+    setReadKind(kind) {
+        if (this.readKinds.includes(kind)) {
+            this.readKind = kind;
+            this.error = undefined;
+        }
+    }
+    setFunctionSearch(search) {
+        this.functionSearch = search;
+    }
+    /** Picks a function; its parameters start empty, and its runtime is the only one there is */
+    selectFunction(signature) {
+        if (signature === this.functionSignature) {
+            return;
+        }
+        this.functionSignature = signature;
+        this.functionValueTexts = [];
+        this.error = undefined;
+        const [onlyRuntime, ...otherRuntimes] = this.functionRuntimes;
+        this.functionRuntimePath =
+            onlyRuntime && !otherRuntimes.length ? onlyRuntime.path : undefined;
+    }
+    setFunctionValueText(index, text) {
+        const texts = [...this.functionValueTexts];
+        texts[index] = text;
+        this.functionValueTexts = texts;
+    }
+    selectFunctionRuntime(path) {
+        this.functionRuntimePath = path;
+    }
+    /**
+     * Types the picked table with the engine, then adds it; the first table
+     * also sets the cube's model and runtime, in the same undo step. The cube
+     * may have changed while the engine answered: the table is added only if
+     * the cube still has the same model and runtime and can take it. Gives
+     * whether the table was added.
+     */
+    *confirm() {
+        if (!this.canConfirm) {
+            return false;
+        }
+        if (this.readKind === CubeModelReadKind.FUNCTION) {
+            return (yield flowResult(this.confirmFunction()));
+        }
+        const { editorState } = this;
+        const model = this.model;
+        const runtime = this.runtimePath;
+        const database = this.databasePath;
+        const schemaName = this.schemaName;
+        const names = [...this.tableNames];
+        const contextBefore = editorState.document.context;
+        // the engine stamps each table's accessor with its node id, so the ids come first
+        const ids = generateCubeNodeIds(editorState.document.query, RelationalTableSource.TYPE, names.length);
+        this.cancelPreview();
+        const request = ++this.confirmRequest;
+        this.isResolving = true;
+        this.error = undefined;
+        try {
+            // a table previewed has its columns already: the engine types the others
+            const previewed = new Map();
+            names.forEach((table, index) => {
+                const schema = this.previewSchemas.get(this.previewKey(table));
+                if (schema instanceof Schema) {
+                    previewed.set(ids[index], schema);
+                }
+            });
+            const toType = names
+                .map((table, index) => [ids[index], table])
+                .filter(([id]) => !previewed.has(id));
+            const typed = new Map(previewed);
+            if (toType.length) {
+                const answer = (yield editorState.host.engine.resolveSchemas(model, new Map(toType.map(([id, table]) => [id, [database, schemaName, table]]))));
+                answer.forEach((schema, id) => typed.set(id, schema));
+            }
+            if (request !== this.confirmRequest) {
+                return false;
+            }
+            const { document } = editorState;
+            if (document.context !== contextBefore) {
+                throw new Error(`The cube changed while the table was loading; pick the table again.`);
+            }
+            // each table typed is added, in the order picked; the first one picked
+            // is the one that runs on an empty cube, as a single table would be
+            let query = document.query;
+            const added = [];
+            const failed = [];
+            // with several tables, each failure names its table
+            const named = (table, message) => names.length > 1
+                ? `${getRelationalDisplayName(table)}: ${message}`
+                : message;
+            names.forEach((table, index) => {
+                const id = ids[index];
+                const schema = typed.get(id);
+                if (schema === undefined || schema instanceof CubeEngineError) {
+                    failed.push(named(table, schema?.message ?? 'The engine gave no schema for this table'));
+                    return;
+                }
+                const node = RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(id, {
+                    database,
+                    schema: schemaName,
+                    table,
+                }), { kind: 'resolved', schema });
+                if (!query.canAdd(node)) {
+                    failed.push(named(table, 'The cube changed while the table was loading; pick the table again.'));
+                    return;
+                }
+                query = query.add(node);
+                added.push(table);
+            });
+            if (added.length) {
+                // the first table sets the model and runtime; a cube saved with a model
+                // but no runtime takes the picked runtime and keeps the rest
+                editorState.applyDocument(document.context?.runtime !== undefined
+                    ? document.withQuery(query)
+                    : document
+                        .withContext({
+                        ...document.context,
+                        model: document.context?.model ?? model,
+                        runtime,
+                    })
+                        .withQuery(query));
+            }
+            if (failed.length) {
+                // the tables added aren't picked any more, so Add again adds only the others
+                this.tableNames = names.filter((table) => !added.includes(table));
+                this.error = failed.join('\n');
+                return false;
+            }
+            this.resetFrom('table');
+            return true;
+        }
+        catch (error) {
+            if (request === this.confirmRequest) {
+                this.error = toMessage(error);
+            }
+            return false;
+        }
+        finally {
+            if (request === this.confirmRequest) {
+                this.isResolving = false;
+            }
+        }
+    }
+    /**
+     * Types the picked function's call with the engine, then adds it with its
+     * values; the first source also sets the cube's model and runtime, in the
+     * same undo step: the function's own runtime when its body names one
+     * (PLAN §6.5). Gives whether the function was added.
+     */
+    *confirmFunction() {
+        const { editorState } = this;
+        const model = this.model;
+        const fn = this.pickedFunction;
+        const runtime = this.functionRuntime;
+        const contextBefore = editorState.document.context;
+        const id = editorState.document.query.generateId(FunctionSource.TYPE);
+        const unresolved = FUNCTION_SOURCE_DEFINITION.fromCoordinates(id, {
+            function: fn.path,
+            signature: fn.signature,
+            parameters: this.functionParameters,
+            values: this.functionValues,
+        });
+        const request = ++this.confirmRequest;
+        this.isResolving = true;
+        this.error = undefined;
+        try {
+            const typed = (yield recheckCubeFunctionSources(editorState.host.engine, model, [unresolved]));
+            if (request !== this.confirmRequest) {
+                return false;
+            }
+            const schema = typed.get(id);
+            if (schema === undefined || schema instanceof CubeEngineError) {
+                throw (schema ??
+                    new CubeEngineError(CubeEngineErrorKind.COMPILE, CUBE_FUNCTION_MESSAGE.NO_ANSWER));
+            }
+            const node = FUNCTION_SOURCE_DEFINITION.resolve(unresolved, {
+                kind: 'resolved',
+                schema,
+            });
+            const { document } = editorState;
+            if (document.context !== contextBefore || !document.query.canAdd(node)) {
+                throw new Error(CUBE_FUNCTION_MESSAGE.CUBE_CHANGED);
+            }
+            const query = document.query.add(node);
+            editorState.applyDocument(document.context?.runtime !== undefined
+                ? document.withQuery(query)
+                : document
+                    .withContext({
+                    ...document.context,
+                    model: document.context?.model ?? model,
+                    runtime,
+                })
+                    .withQuery(query));
+            this.functionSignature = undefined;
+            this.functionValueTexts = [];
+            return true;
+        }
+        catch (error) {
+            if (request === this.confirmRequest) {
+                this.error = toMessage(error);
+            }
+            return false;
+        }
+        finally {
+            if (request === this.confirmRequest) {
+                this.isResolving = false;
+            }
+        }
+    }
+    resetFrom(step) {
+        if (step === 'database') {
+            this.databasePath = undefined;
+            this.functionSignature = undefined;
+            this.functionValueTexts = [];
+            this.functionRuntimePath = undefined;
+            this.functionSearch = '';
+        }
+        if (step === 'database' || step === 'runtime') {
+            this.runtimePath = undefined;
+            this.schemaName = undefined;
+            // another model or database: its previews go, and late ones are dropped
+            this.previewGeneration++;
+            this.previewSchemas = new Map();
+        }
+        this.tableNames = [];
+        this.tableSearch = '';
+        this.previewTableName = undefined;
+        this.cancelPreview();
+    }
+}
+//# sourceMappingURL=CubeInlineModelTabState.js.map