@saltcorn/data 0.6.2-beta.1 → 0.6.2-beta.2

package/dist/plugin-helper.js

@@ -0,0 +1,1158 @@
+"use strict";
+/**
+ * Plugin-helper
+ * @category saltcorn-data
+ * @module plugin-helper
+ */
+const View = require("./models/view");
+const Field = require("./models/field");
+const Table = require("./models/table");
+const Trigger = require("./models/trigger");
+const { getState } = require("./db/state");
+const db = require("./db");
+const { contract, is } = require("contractis");
+const { fieldlike, is_table_query, is_column, is_tablely, } = require("./contracts");
+const { link } = require("@saltcorn/markup");
+const { button, a, label, text, i } = require("@saltcorn/markup/tags");
+const { applyAsync, InvalidConfiguration } = require("./utils");
+const { jsexprToSQL } = require("./models/expression");
+/**
+ *
+ * @param {string} url
+ * @param {string} label
+ * @param {boolean} [popup]
+ * @param {string} [link_style = ""]
+ * @param {string} [link_size = ""]
+ * @param {string} [link_icon = ""]
+ * @param {string} [textStyle = ""]
+ * @param {string} [link_bgcol]
+ * @param {string} [link_bordercol]
+ * @param {string} [link_textcol]
+ * @returns {button|a}
+ */
+const link_view = (url, label, popup, link_style = "", link_size = "", link_icon = "", textStyle = "", link_bgcol, link_bordercol, link_textcol) => {
+    let style = link_style === "btn btn-custom-color"
+        ? `background-color: ${link_bgcol || "#000000"};border-color: ${link_bordercol || "#000000"}; color: ${link_textcol || "#000000"}`
+        : null;
+    if (popup) {
+        return button({
+            class: [
+                textStyle,
+                link_style,
+                link_size,
+                !link_style && "btn btn-link",
+            ],
+            onClick: `ajax_modal('${url}')`,
+            style,
+        }, link_icon ? i({ class: link_icon }) + " " : "", label);
+    }
+    else
+        return a({
+            href: url,
+            class: [textStyle, link_style, link_size],
+            style,
+        }, link_icon ? i({ class: link_icon }) + " " : "", text(label));
+};
+/**
+ * @function
+ * @param {object} [state]
+ * @returns {string}
+ */
+const stateToQueryString = contract(is.fun(is.maybe(is.obj()), is.str), (state) => {
+    if (!state || Object.keys(state).length === 0)
+        return "";
+    return ("?" +
+        Object.entries(state)
+            .map(([k, v]) => k === "id"
+            ? null
+            : `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .filter((s) => !!s)
+            .join("&"));
+});
+/**
+ * @function
+ * @param {Field[]} fields
+ * @param {boolean}
+ * @returns {object}
+ */
+const calcfldViewOptions = contract(is.fun([is.array(is.class("Field")), is.str], is.obj({ field_view_options: is.objVals(is.array(is.str)) })), (fields, mode) => {
+    const isEdit = mode === "edit";
+    const isFilter = mode === "filter";
+    let fvs = {};
+    const handlesTextStyle = {};
+    fields.forEach((f) => {
+        handlesTextStyle[f.name] = [];
+        if (f.type === "File") {
+            if (!isEdit && !isFilter)
+                fvs[f.name] = Object.keys(getState().fileviews);
+            else
+                fvs[f.name] = ["upload"];
+        }
+        else if (f.type === "Key") {
+            if (isEdit)
+                fvs[f.name] = Object.keys(getState().keyFieldviews);
+            else {
+                if (f.reftable && f.reftable.fields) {
+                    const { field_view_options } = calcfldViewOptions(f.reftable.fields, mode);
+                    for (const jf of f.reftable.fields) {
+                        fvs[`${f.name}.${jf.name}`] = field_view_options[jf.name];
+                    }
+                }
+                fvs[f.name] = ["show"];
+            }
+            Object.entries(getState().keyFieldviews).forEach(([k, v]) => {
+                if (v && v.handlesTextStyle)
+                    handlesTextStyle[f.name].push(k);
+            });
+        }
+        else if (f.type && f.type.fieldviews) {
+            const tfvs = Object.entries(f.type.fieldviews).filter(([k, fv]) => f.calculated ? !fv.isEdit : !fv.isEdit || isEdit || isFilter);
+            let tfvs_ordered = [];
+            if (isEdit) {
+                tfvs_ordered = [
+                    ...tfvs.filter(([k, fv]) => fv.isEdit),
+                    ...tfvs.filter(([k, fv]) => !fv.isEdit && !fv.isFilter),
+                ];
+            }
+            else if (isFilter) {
+                tfvs_ordered = [
+                    ...tfvs.filter(([k, fv]) => fv.isFilter),
+                    ...tfvs.filter(([k, fv]) => fv.isEdit),
+                ];
+            }
+            else
+                tfvs_ordered = tfvs.filter(([k, fv]) => !fv.isFilter);
+            fvs[f.name] = tfvs_ordered.map(([k, fv]) => {
+                if (fv && fv.handlesTextStyle)
+                    handlesTextStyle[f.name].push(k);
+                return k;
+            });
+        }
+    });
+    return { field_view_options: fvs, handlesTextStyle };
+});
+/**
+ * @function
+ * @param {Field[]} fields
+ * @param {boolean}
+ * @returns {Promise<object>}
+ */
+const calcfldViewConfig = contract(is.fun([is.array(is.class("Field")), is.bool], is.promise(is.obj())), async (fields, isEdit) => {
+    const fieldViewConfigForms = {};
+    for (const f of fields) {
+        fieldViewConfigForms[f.name] = {};
+        const fieldviews = f.type === "Key"
+            ? getState().keyFieldviews
+            : (f.type && f.type.fieldviews) || {};
+        for (const [nm, fv] of Object.entries(fieldviews)) {
+            if (fv.configFields)
+                fieldViewConfigForms[f.name][nm] = await applyAsync(fv.configFields, f);
+        }
+    }
+    return fieldViewConfigForms;
+});
+/**
+ * @function
+ * @param {Table|object} table
+ * @param {string} viewname
+ * @param {boolean}
+ * @returns {Promise<object[]>}
+ */
+const get_link_view_opts = contract(is.fun([is_tablely, is.str], is.promise(is.array(is.obj({ label: is.str, name: is.str })))), async (table, viewname) => {
+    const own_link_views = await View.find_possible_links_to_table(table);
+    const link_view_opts = own_link_views
+        .filter((v) => v.name !== viewname)
+        .map((v) => ({
+        label: `${v.name} [${v.viewtemplate} ${table.name}]`,
+        name: `Own:${v.name}`,
+    }));
+    const link_view_names = new Set();
+    const child_views = await get_child_views(table, viewname);
+    for (const { relation, related_table, views } of child_views) {
+        for (const view of views) {
+            const name = `${view.name}.${related_table.name}.${relation.name}`;
+            link_view_names.add(name);
+            link_view_opts.push({
+                name: `ChildList:${view.name}.${related_table.name}.${relation.name}`,
+                label: `${view.name} [${view.viewtemplate} ${related_table.name}.${relation.label}]`,
+            });
+        }
+    }
+    const parent_views = await get_parent_views(table, viewname);
+    for (const { relation, related_table, views } of parent_views) {
+        for (const view of views) {
+            link_view_opts.push({
+                name: `ParentShow:${view.name}.${related_table.name}.${relation.name}`,
+                label: `${view.name} [${view.viewtemplate} ${relation.name}.${related_table.name}]`,
+            });
+        }
+    }
+    const onetoone_views = await get_onetoone_views(table, viewname);
+    for (const { relation, related_table, views } of onetoone_views) {
+        for (const view of views) {
+            const name = `${view.name}.${related_table.name}.${relation.name}`;
+            if (!link_view_names.has(name))
+                link_view_opts.push({
+                    name: `OneToOneShow:${view.name}.${related_table.name}.${relation.name}`,
+                    label: `${view.name} [${view.viewtemplate} ${related_table.name}.${relation.label}]`,
+                });
+        }
+    }
+    const independent_views = await View.find_all_views_where(({ state_fields }) => !state_fields.some((sf) => sf.required));
+    independent_views.forEach((view) => {
+        link_view_opts.push({
+            label: `${view.name} [${view.viewtemplate}]`,
+            name: `Independent:${view.name}`,
+        });
+    });
+    return link_view_opts;
+});
+/**
+ * Get Action configuration fields
+ * @param {object} action
+ * @param {object} table
+ * @returns {Promise<object[]>}
+ */
+const getActionConfigFields = async (action, table) => typeof action.configFields === "function"
+    ? await action.configFields({ table })
+    : action.configFields || [];
+/**
+ * @function
+ * @param {Table|object} table
+ * @param {string} viewname
+ * @param {object} req
+ * @returns {Promise<object[]>}
+ */
+const field_picker_fields = contract(is.fun(is.obj({ table: is_tablely, viewname: is.str }), is.promise(is.array(fieldlike))), async ({ table, viewname, req }) => {
+    const __ = (...s) => (req ? req.__(...s) : s.join(""));
+    const fields = await table.getFields();
+    for (const field of fields) {
+        if (field.type === "Key") {
+            field.reftable = await Table.findOne({ name: field.reftable_name });
+            if (field.reftable)
+                await field.reftable.getFields();
+        }
+    }
+    const boolfields = fields.filter((f) => f.type && f.type.name === "Bool");
+    const stateActions = getState().actions;
+    const stateActionKeys = Object.entries(stateActions)
+        .filter(([k, v]) => !v.requireRow && !v.disableInList)
+        .map(([k, v]) => k);
+    const actions = [
+        "Delete",
+        ...boolfields.map((f) => `Toggle ${f.name}`),
+        ...stateActionKeys,
+    ];
+    const triggers = await Trigger.find({
+        when_trigger: { or: ["API call", "Never"] },
+    });
+    triggers.forEach((tr) => {
+        actions.push(tr.name);
+    });
+    const actionConfigFields = [];
+    for (const [name, action] of Object.entries(stateActions)) {
+        if (!stateActionKeys.includes(name))
+            continue;
+        const cfgFields = await getActionConfigFields(action, table);
+        for (const field of cfgFields) {
+            const cfgFld = {
+                ...field,
+                showIf: {
+                    action_name: name,
+                    type: "Action",
+                    ...(field.showIf || {}),
+                },
+            };
+            if (cfgFld.input_type === "code")
+                cfgFld.input_type = "textarea";
+            actionConfigFields.push(cfgFld);
+        }
+    }
+    const fldOptions = fields.map((f) => f.name);
+    const { field_view_options } = calcfldViewOptions(fields, "show");
+    const fieldViewConfigForms = await calcfldViewConfig(fields, false);
+    const fvConfigFields = [];
+    for (const [field_name, fvOptFields] of Object.entries(fieldViewConfigForms)) {
+        for (const [fieldview, formFields] of Object.entries(fvOptFields)) {
+            for (const formField of formFields) {
+                fvConfigFields.push({
+                    ...formField,
+                    showIf: {
+                        type: "Field",
+                        field_name,
+                        fieldview,
+                    },
+                });
+            }
+        }
+    }
+    const link_view_opts = await get_link_view_opts(table, viewname);
+    const { parent_field_list } = await table.get_parent_relations(true);
+    const { child_field_list, child_relations, } = await table.get_child_relations();
+    const aggStatOptions = {};
+    const agg_field_opts = child_relations.map(({ table, key_field }) => {
+        aggStatOptions[`${table.name}.${key_field.name}`] = [
+            "Count",
+            "Avg",
+            "Sum",
+            "Max",
+            "Min",
+        ];
+        table.fields.forEach((f) => {
+            if (f.type && f.type.name === "Date") {
+                aggStatOptions[`${table.name}.${key_field.name}`].push(`Latest ${f.name}`);
+            }
+        });
+        return {
+            name: `agg_field`,
+            label: __("On Field"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: table.fields
+                    .filter((f) => !f.calculated || f.stored)
+                    .map((f) => f.name),
+            },
+            showIf: {
+                agg_relation: `${table.name}.${key_field.name}`,
+                type: "Aggregation",
+            },
+        };
+    });
+    return [
+        {
+            name: "type",
+            label: __("Type"),
+            type: "String",
+            required: true,
+            attributes: {
+                //TODO omit when no options
+                options: [
+                    {
+                        name: "Field",
+                        label: __(`Field in %s table`, table.name),
+                    },
+                    { name: "Action", label: __("Action on row") },
+                    ...(link_view_opts.length > 0
+                        ? [{ name: "ViewLink", label: __("Link to other view") }]
+                        : []),
+                    { name: "Link", label: __("Link to anywhere") },
+                    ...(parent_field_list.length > 0
+                        ? [{ name: "JoinField", label: __("Join Field") }]
+                        : []),
+                    ...(child_field_list.length > 0
+                        ? [{ name: "Aggregation", label: __("Aggregation") }]
+                        : []),
+                ],
+            },
+        },
+        {
+            name: "field_name",
+            label: __("Field"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: fldOptions,
+            },
+            showIf: { type: "Field" },
+        },
+        {
+            name: "fieldview",
+            label: __("Field view"),
+            type: "String",
+            required: false,
+            attributes: {
+                calcOptions: ["field_name", field_view_options],
+            },
+            showIf: { type: "Field" },
+        },
+        ...fvConfigFields,
+        {
+            name: "action_name",
+            label: __("Action"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: actions,
+            },
+            showIf: { type: "Action" },
+        },
+        {
+            name: "action_label",
+            label: __("Action Label"),
+            type: "String",
+            showIf: { type: "Action" },
+        },
+        {
+            name: "action_label_formula",
+            label: __("Action label is a formula?"),
+            type: "Bool",
+            required: false,
+            showIf: { type: "Action" },
+        },
+        {
+            name: "action_style",
+            label: __("Action Style"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: [
+                    { name: "btn-primary", label: "Primary button" },
+                    { name: "btn-secondary", label: "Secondary button" },
+                    { name: "btn-success", label: "Success button" },
+                    { name: "btn-danger", label: "Danger button" },
+                    { name: "btn-outline-primary", label: "Primary outline button" },
+                    {
+                        name: "btn-outline-secondary",
+                        label: "Secondary outline button",
+                    },
+                    { name: "btn-link", label: "Link" },
+                ],
+            },
+            showIf: { type: "Action" },
+        },
+        {
+            name: "action_size",
+            label: __("Button size"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: [
+                    { name: "", label: "Standard" },
+                    { name: "btn-lg", label: "Large" },
+                    { name: "btn-sm", label: "Small" },
+                    { name: "btn-block", label: "Block" },
+                    { name: "btn-block btn-lg", label: "Large block" },
+                ],
+            },
+            showIf: { type: "Action" },
+        },
+        {
+            name: "confirm",
+            label: __("User confirmation?"),
+            type: "Bool",
+            showIf: { type: "Action" },
+        },
+        ...actionConfigFields,
+        {
+            name: "view",
+            label: __("View"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: link_view_opts,
+            },
+            showIf: { type: "ViewLink" },
+        },
+        {
+            name: "view_label",
+            label: __("View label"),
+            sublabel: __("Leave blank for default label."),
+            type: "String",
+            required: false,
+            showIf: { type: "ViewLink" },
+        },
+        {
+            name: "view_label_formula",
+            label: __("View label is a formula?"),
+            type: "Bool",
+            required: false,
+            showIf: { type: "ViewLink" },
+        },
+        {
+            name: "in_modal",
+            label: __("Open in popup modal?"),
+            type: "Bool",
+            required: false,
+            showIf: { type: "ViewLink" },
+        },
+        {
+            name: "link_style",
+            label: __("Link Style"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: [
+                    { name: "", label: "Link" },
+                    { name: "btn btn-primary", label: "Primary button" },
+                    { name: "btn btn-secondary", label: "Secondary button" },
+                    { name: "btn btn-success", label: "Success button" },
+                    { name: "btn btn-danger", label: "Danger button" },
+                    {
+                        name: "btn btn-outline-primary",
+                        label: "Primary outline button",
+                    },
+                    {
+                        name: "btn btn-outline-secondary",
+                        label: "Secondary outline button",
+                    },
+                ],
+            },
+            showIf: { type: "ViewLink" },
+        },
+        {
+            name: "link_size",
+            label: __("Link size"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: [
+                    { name: "", label: "Standard" },
+                    { name: "btn-lg", label: "Large" },
+                    { name: "btn-sm", label: "Small" },
+                    { name: "btn-block", label: "Block" },
+                    { name: "btn-block btn-lg", label: "Large block" },
+                ],
+            },
+            showIf: { type: "ViewLink" },
+        },
+        {
+            name: "link_text",
+            label: __("Link text"),
+            type: "String",
+            required: true,
+            showIf: { type: "Link" },
+        },
+        {
+            name: "link_text_formula",
+            label: __("Link text is a formula?"),
+            type: "Bool",
+            required: false,
+            showIf: { type: "Link" },
+        },
+        {
+            name: "link_url",
+            label: __("Link URL"),
+            type: "String",
+            required: true,
+            showIf: { type: "Link" },
+        },
+        {
+            name: "link_url_formula",
+            label: __("Link URL is a formula?"),
+            type: "Bool",
+            required: false,
+            showIf: { type: "Link" },
+        },
+        {
+            name: "link_target_blank",
+            label: __("Open in new tab"),
+            type: "Bool",
+            required: false,
+            showIf: { type: "Link" },
+        },
+        {
+            name: "join_field",
+            label: __("Join Field"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: parent_field_list,
+            },
+            showIf: { type: "JoinField" },
+        },
+        {
+            name: "agg_relation",
+            label: __("Relation"),
+            type: "String",
+            required: true,
+            attributes: {
+                options: child_field_list,
+            },
+            showIf: { type: "Aggregation" },
+        },
+        ...agg_field_opts,
+        {
+            name: "stat",
+            label: __("Statistic"),
+            type: "String",
+            required: true,
+            attributes: {
+                calcOptions: ["agg_relation", aggStatOptions],
+            },
+            showIf: { type: "Aggregation" },
+        },
+        {
+            name: "aggwhere",
+            label: __("Where"),
+            sublabel: __("Formula"),
+            type: "String",
+            required: false,
+            showIf: { type: "Aggregation" },
+        },
+        {
+            name: "state_field",
+            label: __("In search form"),
+            type: "Bool",
+            showIf: { type: "Field" },
+        },
+        {
+            name: "header_label",
+            label: __("Header label"),
+            type: "String",
+        },
+        {
+            name: "col_width",
+            label: __("Column width"),
+            type: "Integer",
+        },
+        {
+            name: "col_width_units",
+            label: __("Column width units"),
+            type: "String",
+            required: true,
+            fieldview: "radio_group",
+            attributes: {
+                inline: true,
+                options: ["px", "%", "vw", "em", "rem"],
+            },
+        },
+    ];
+});
+/**
+ * get_child_views Contract
+ * @function
+ * @param {Table|object} table
+ * @param {string} viewname
+ * @returns {Promise<object[]>}
+ */
+const get_child_views = contract(is.fun([is_tablely, is.str], is.promise(is.array(is.obj({
+    relation: is.class("Field"),
+    related_table: is.class("Table"),
+    views: is.array(is.class("View")),
+})))), async (table, viewname) => {
+    const rels = await Field.find({ reftable_name: table.name });
+    var child_views = [];
+    for (const relation of rels) {
+        const related_table = await Table.findOne({ id: relation.table_id });
+        const views = await View.find_table_views_where(related_table.id, ({ state_fields, viewrow }) => viewrow.name !== viewname && state_fields.every((sf) => !sf.required));
+        child_views.push({ relation, related_table, views });
+    }
+    return child_views;
+});
+/**
+ * get_parent_views Contract
+ * @function
+ * @param {Table|object} table
+ * @param {string} viewname
+ * @returns {Promise<object[]>}
+ */
+const get_parent_views = contract(is.fun([is_tablely, is.str], is.promise(is.array(is.obj({
+    relation: is.class("Field"),
+    related_table: is.class("Table"),
+    views: is.array(is.class("View")),
+})))), async (table, viewname) => {
+    var parent_views = [];
+    const parentrels = (await table.getFields()).filter((f) => f.is_fkey && f.type !== "File");
+    for (const relation of parentrels) {
+        const related_table = await Table.findOne({
+            name: relation.reftable_name,
+        });
+        const views = await View.find_table_views_where(related_table, ({ state_fields, viewrow }) => viewrow.name !== viewname &&
+            state_fields.some((sf) => sf.name === "id"));
+        parent_views.push({ relation, related_table, views });
+    }
+    return parent_views;
+});
+/**
+ * get_onetoone_views Contract
+ * @function
+ * @param {Table|is_tablely} table
+ * @param {string} viewname
+ * @returns {Promise<object[]>}
+ */
+const get_onetoone_views = contract(is.fun([is_tablely, is.str], is.promise(is.array(is.obj({
+    relation: is.class("Field"),
+    related_table: is.class("Table"),
+    views: is.array(is.class("View")),
+})))), async (table, viewname) => {
+    const rels = await Field.find({
+        reftable_name: table.name,
+        is_unique: true,
+    });
+    var child_views = [];
+    for (const relation of rels) {
+        const related_table = await Table.findOne({ id: relation.table_id });
+        const views = await View.find_table_views_where(related_table.id, ({ state_fields, viewrow }) => viewrow.name !== viewname &&
+            state_fields.some((sf) => sf.name === "id"));
+        child_views.push({ relation, related_table, views });
+    }
+    return child_views;
+});
+/**
+ * picked_fields_to_query Contract
+ * @function
+ * @param {object[]} columns
+ * @param {Field[]} fields
+ * @throws {InvalidConfiguration}
+ * @returns {object}
+ */
+const picked_fields_to_query = contract(is.fun([is.array(is_column), is.array(is.class("Field"))], is_table_query), (columns, fields) => {
+    var joinFields = {};
+    var aggregations = {};
+    (columns || []).forEach((column) => {
+        if (column.type === "JoinField") {
+            if (column.join_field && column.join_field.split) {
+                const kpath = column.join_field.split(".");
+                if (kpath.length === 2) {
+                    const [refNm, targetNm] = kpath;
+                    joinFields[`${refNm}_${targetNm}`] = {
+                        ref: refNm,
+                        target: targetNm,
+                    };
+                }
+                else {
+                    const [refNm, through, targetNm] = kpath;
+                    joinFields[`${refNm}_${through}_${targetNm}`] = {
+                        ref: refNm,
+                        target: targetNm,
+                        through,
+                    };
+                }
+            }
+            else {
+                throw new InvalidConfiguration(`Join field is specified as column but no join field is chosen`);
+            }
+        }
+        else if (column.type === "ViewLink") {
+            if (column.view && column.view.split) {
+                const [vtype, vrest] = column.view.split(":");
+                if (vtype === "ParentShow") {
+                    const [pviewnm, ptbl, pfld] = vrest.split(".");
+                    const field = fields.find((f) => f.name === pfld);
+                    if (field && field.attributes.summary_field)
+                        joinFields[`summary_field_${ptbl.toLowerCase()}`] = {
+                            ref: pfld,
+                            target: field.attributes.summary_field,
+                        };
+                }
+            }
+        }
+        else if (column.type === "Aggregation") {
+            //console.log(column)
+            if (column.agg_relation && column.agg_relation.split) {
+                const [table, fld] = column.agg_relation.split(".");
+                const field = column.agg_field;
+                const targetNm = (column.stat.replace(" ", "") +
+                    "_" +
+                    table +
+                    "_" +
+                    fld +
+                    db.sqlsanitize(column.aggwhere || "")).toLowerCase();
+                aggregations[targetNm] = {
+                    table,
+                    ref: fld,
+                    where: jsexprToSQL(column.aggwhere),
+                    field,
+                    aggregate: column.stat,
+                };
+            }
+        }
+    });
+    return { joinFields, aggregations };
+});
+/**
+ * @function
+ * @param {object}
+ * @param {object}
+ * @param {string} - missing in contract
+ * @returns {object}
+ */
+const stateFieldsToQuery = contract(is.fun(is.obj(), is.obj()), ({ state, fields, prefix = "" }) => {
+    let q = {};
+    const stateKeys = Object.keys(state);
+    if (state._sortby) {
+        const field = fields.find((f) => f.name === state._sortby);
+        //this is ok because it has to match fieldname
+        if (field)
+            q.orderBy = state._sortby;
+        if (state._sortdesc)
+            q.orderDesc = true;
+    }
+    if (state._pagesize)
+        q.limit = parseInt(state._pagesize);
+    if (state._pagesize && state._page)
+        q.offset = (parseInt(state._page) - 1) * parseInt(state._pagesize);
+    const latNear = stateKeys.find((k) => k.startsWith("_near_lat_"));
+    const longNear = stateKeys.find((k) => k.startsWith("_near_long_"));
+    if (latNear && longNear) {
+        const latField = prefix + db.sqlsanitize(latNear.replace("_near_lat_", ""));
+        const longField = prefix + db.sqlsanitize(longNear.replace("_near_long_", ""));
+        const lat = parseFloat(state[latNear]);
+        const long = parseFloat(state[longNear]);
+        q.orderBy = { distance: { lat, long, latField, longField } };
+    }
+    return q;
+});
+/**
+ *
+ * @param {object} container
+ * @param {string} key
+ * @param {object} x
+ * @returns {void}
+ */
+const addOrCreateList = (container, key, x) => {
+    if (container[key])
+        container[key].push(x);
+    else
+        container[key] = [x];
+};
+/**
+ * @function
+ * @param {object} opts
+ * @param {Field[]} opts.fields
+ * @param {object} opts.state missing in contract
+ * @param {boolean} [opts.approximate = true]
+ * @returns {object}
+ */
+const stateFieldsToWhere = contract(is.fun(is.obj({
+    fields: is.array(is.class("Field")),
+    approximate: is.maybe(is.bool),
+}), is.obj()), ({ fields, state, approximate = true }) => {
+    var qstate = {};
+    Object.entries(state).forEach(([k, v]) => {
+        if (k === "_fts") {
+            qstate[k] = { searchTerm: v.replace(/\0/g, ""), fields };
+            return;
+        }
+        const field = fields.find((fld) => fld.name == k);
+        if (k.startsWith("_fromdate_")) {
+            const datefield = db.sqlsanitize(k.replace("_fromdate_", ""));
+            const dfield = fields.find((fld) => fld.name == datefield);
+            if (dfield)
+                addOrCreateList(qstate, datefield, { gt: new Date(v), equal: true });
+        }
+        else if (k.startsWith("_todate_")) {
+            const datefield = db.sqlsanitize(k.replace("_todate_", ""));
+            const dfield = fields.find((fld) => fld.name == datefield);
+            if (dfield)
+                addOrCreateList(qstate, datefield, { lt: new Date(v), equal: true });
+        }
+        else if (k.startsWith("_gte_")) {
+            const datefield = db.sqlsanitize(k.replace("_gte_", ""));
+            const dfield = fields.find((fld) => fld.name == datefield);
+            if (dfield)
+                addOrCreateList(qstate, datefield, { gt: v, equal: true });
+        }
+        else if (k.startsWith("_lte_")) {
+            const datefield = db.sqlsanitize(k.replace("_lte_", ""));
+            const dfield = fields.find((fld) => fld.name == datefield);
+            if (dfield)
+                addOrCreateList(qstate, datefield, { lt: v, equal: true });
+        }
+        else if (field &&
+            field.type.name === "String" &&
+            !(field.attributes && field.attributes.options) &&
+            approximate) {
+            qstate[k] = { ilike: v };
+        }
+        else if (field && field.type.name === "Bool" && state[k] === "?") {
+            // omit
+        }
+        else if (field && field.type && field.type.read)
+            qstate[k] = Array.isArray(v)
+                ? { or: v.map(field.type.read) }
+                : field.type.read(v);
+        else if (field)
+            qstate[k] = v;
+        else if (k.includes(".")) {
+            const kpath = k.split(".");
+            if (kpath.length === 3) {
+                const [jtNm, jFieldNm, lblField] = kpath;
+                qstate.id = [
+                    ...(qstate.id ? [qstate.id] : []),
+                    {
+                        // where id in (select jFieldNm from jtnm where lblField=v)
+                        inSelect: {
+                            table: `${db.getTenantSchemaPrefix()}"${db.sqlsanitize(jtNm)}"`,
+                            field: db.sqlsanitize(jFieldNm),
+                            where: { [db.sqlsanitize(lblField)]: v },
+                        },
+                    },
+                ];
+            }
+        }
+    });
+    return qstate;
+});
+/**
+ * initial_config_all_fields Contract
+ * @function
+ * @param {boolean}
+ * @returns {function}
+ */
+const initial_config_all_fields = contract(is.fun(is.bool, is.fun(is.obj({ table_id: is.posint }), is.promise(is.obj({ columns: is.array(is.obj()), layout: is.obj() })))), (isEdit) => async ({ table_id, exttable_name }) => {
+    const table = await Table.findOne(table_id ? { id: table_id } : { name: exttable_name });
+    const fields = (await table.getFields()).filter((f) => !f.primary_key && (!isEdit || !f.calculated));
+    var cfg = { columns: [] };
+    var aboves = [null];
+    fields.forEach((f) => {
+        if (!f.type)
+            return;
+        const flabel = {
+            above: [
+                null,
+                {
+                    type: "blank",
+                    block: false,
+                    contents: f.label,
+                    textStyle: "",
+                    ...(isEdit ? { labelFor: f.name } : {}),
+                },
+            ],
+        };
+        if (f.is_fkey &&
+            f.type !== "File" &&
+            f.reftable_name !== "users" &&
+            !isEdit) {
+            cfg.columns.push({
+                type: "JoinField",
+                join_field: `${f.name}.${f.attributes.summary_field}`,
+            });
+            aboves.push({
+                widths: [2, 10],
+                besides: [
+                    flabel,
+                    {
+                        above: [
+                            null,
+                            {
+                                type: "join_field",
+                                block: false,
+                                textStyle: "",
+                                join_field: `${f.name}.${f.attributes.summary_field}`,
+                            },
+                        ],
+                    },
+                ],
+            });
+        }
+        else if (f.reftable_name !== "users") {
+            const fvNm = f.type.fieldviews
+                ? Object.entries(f.type.fieldviews).find(([nm, fv]) => fv.isEdit === isEdit)[0]
+                : f.type === "File" && !isEdit
+                    ? Object.keys(getState().fileviews)[0]
+                    : f.type === "File" && isEdit
+                        ? "upload"
+                        : f.type === "Key"
+                            ? "select"
+                            : undefined;
+            cfg.columns.push({
+                field_name: f.name,
+                type: "Field",
+                fieldview: fvNm,
+                state_field: true,
+            });
+            aboves.push({
+                widths: [2, 10],
+                besides: [
+                    flabel,
+                    {
+                        above: [
+                            null,
+                            {
+                                type: "field",
+                                block: false,
+                                fieldview: fvNm,
+                                textStyle: "",
+                                field_name: f.name,
+                            },
+                        ],
+                    },
+                ],
+            });
+        }
+        aboves.push({ type: "line_break" });
+    });
+    if (isEdit)
+        aboves.push({
+            type: "action",
+            block: false,
+            minRole: 10,
+            action_name: "Save",
+        });
+    cfg.layout = { above: aboves };
+    return cfg;
+});
+/**
+ *
+ * @param {string} x
+ * @returns {number|undefined}
+ */
+const strictParseInt = (x) => {
+    const y = +x;
+    return !isNaN(y) && y ? y : undefined;
+};
+/**
+ *
+ * @param {object} state
+ * @param {object[]} fields
+ * @returns {object}
+ */
+const readState = (state, fields, req) => {
+    fields.forEach((f) => {
+        const current = state[f.name];
+        if (typeof current !== "undefined") {
+            if (Array.isArray(current) && f.type.read) {
+                state[f.name] = current.map(f.type.read);
+            }
+            else if (f.type.read)
+                state[f.name] = f.type.read(current);
+            else if (typeof current === "string" && current.startsWith("Preset:")) {
+                const preset = f.presets[current.replace("Preset:", "")];
+                state[f.name] = preset(req);
+            }
+            else if (f.type === "Key" || f.type === "File")
+                state[f.name] =
+                    current === "null" || current === "" || current === null
+                        ? null
+                        : getState().types[f.reftype].read(current);
+        }
+    });
+    return state;
+};
+/**
+ *
+ * @param {object} state
+ * @param {object[]} fields
+ * @returns {boolean|*}
+ */
+const readStateStrict = (state, fields) => {
+    let hasErrors = false;
+    fields.forEach((f) => {
+        const current = state[f.name];
+        //console.log(f.name, current, typeof current);
+        if (typeof current !== "undefined") {
+            if (f.type.read) {
+                const readval = f.type.read(current);
+                if (typeof readval === "undefined") {
+                    if (current === "" && !f.required)
+                        delete state[f.name];
+                    else
+                        hasErrors = true;
+                }
+                if (f.type && f.type.validate) {
+                    const vres = f.type.validate(f.attributes || {})(readval);
+                    if (vres.error)
+                        hasErrors = true;
+                }
+                state[f.name] = readval;
+            }
+            else if (f.type === "Key" || f.type === "File")
+                state[f.name] =
+                    current === "null" || current === "" || current === null
+                        ? null
+                        : +current;
+        }
+        else if (f.required && !f.primary_key)
+            hasErrors = true;
+    });
+    return hasErrors ? false : state;
+};
+/**
+ *
+ * @param {function} get_json_list
+ * @param {object[]} fields0
+ * @returns {object}
+ */
+const json_list_to_external_table = (get_json_list, fields0) => {
+    const fields = fields0.map((f) => f.constructor.name === Object.name ? new Field(f) : f);
+    const getRows = async (where = {}, selopts = {}) => {
+        let data_in = await get_json_list({ where, ...selopts });
+        const restricts = Object.entries(where);
+        const data_filtered = restricts.length === 0
+            ? data_in
+            : data_in.filter((x) => restricts.every(([k, v]) => x[k] === v));
+        if (selopts.orderBy) {
+            const cmp = selopts.orderDesc
+                ? new Function("a,b", `return b.${selopts.orderBy}-a.${selopts.orderBy}`)
+                : new Function("a,b", `return a.${selopts.orderBy}-b.${selopts.orderBy}`);
+            data_filtered.sort(cmp);
+        }
+        if (selopts.limit)
+            return data_filtered.slice(selopts.offset || 0, (selopts.offset || 0) + selopts.limit);
+        else
+            return data_filtered;
+    };
+    const tbl = {
+        getFields() {
+            return fields;
+        },
+        fields,
+        getRows,
+        get min_role_read() {
+            const roles = getState().getConfig("exttables_min_role_read", {});
+            return roles[tbl.name] || 10;
+        },
+        getJoinedRows(opts = {}) {
+            const { where, ...rest } = opts;
+            return getRows(where || {}, rest || {});
+        },
+        async countRows(where) {
+            let data_in = await get_json_list({ where });
+            return data_in.length;
+        },
+        get_child_relations() {
+            return { child_relations: [], child_field_list: [] };
+        },
+        get_parent_relations() {
+            return { parent_relations: [], parent_field_list: [] };
+        },
+        external: true,
+        owner_fieldname() {
+            return null;
+        },
+        async distinctValues(fldNm) {
+            let data_in = await get_json_list({});
+            const s = new Set(data_in.map((x) => x[fldNm]));
+            return [...s];
+        },
+    };
+    return tbl;
+};
+/**
+ *
+ * @param {object} col
+ * @param {object} req
+ * @param {...*} rest
+ * @returns {Promise<*>}
+ */
+const run_action_column = async ({ col, req, ...rest }) => {
+    let state_action = getState().actions[col.action_name];
+    let configuration;
+    if (state_action)
+        configuration = col.configuration;
+    else {
+        const trigger = await Trigger.findOne({ name: col.action_name });
+        state_action = getState().actions[trigger.action];
+        configuration = trigger.configuration;
+    }
+    return await state_action.run({
+        configuration,
+        user: req.user,
+        req,
+        ...rest,
+    });
+};
+module.exports = {
+    field_picker_fields,
+    picked_fields_to_query,
+    get_child_views,
+    get_parent_views,
+    stateFieldsToWhere,
+    stateFieldsToQuery,
+    initial_config_all_fields,
+    calcfldViewOptions,
+    get_link_view_opts,
+    is_column,
+    readState,
+    readStateStrict,
+    stateToQueryString,
+    link_view,
+    getActionConfigFields,
+    calcfldViewConfig,
+    strictParseInt,
+    run_action_column,
+    json_list_to_external_table,
+};
+//# sourceMappingURL=plugin-helper.js.map