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

package/dist/base-plugin/actions.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @param {object} opts
+ * @param {object} opts.row
+ * @param {object} opts.table
+ * @param {object} opts.channel
+ * @param {object} opts.configuration
+ * @param {object} opts.user
+ * @param {...*} opts.rest
+ * @returns {Promise<object>}
+ */
+declare function run_code({ row, table, channel, configuration: { code, run_where }, user, ...rest }: {
+    row: object;
+    table: object;
+    channel: object;
+    configuration: object;
+    user: object;
+    rest: any[];
+}): Promise<object>;
+export namespace blocks {
+    export const disableInBuilder: boolean;
+    export const disableInList: boolean;
+    export const configFields: {
+        name: string;
+        input_type: string;
+    }[];
+    export { run_code as run };
+}
+export namespace emit_event {
+    export function configFields_1(): object[];
+    export { configFields_1 as configFields };
+    export function run({ row, configuration: { eventType, channel, payload }, user, }: {
+        row: object;
+        configuration: object;
+        user: object;
+    }): Promise<void>;
+}
+export namespace webhook {
+    const configFields_2: ({
+        name: string;
+        label: string;
+        type: string;
+        sublabel: string;
+        fieldview?: undefined;
+    } | {
+        name: string;
+        label: string;
+        sublabel: string;
+        type: string;
+        fieldview: string;
+    })[];
+    export { configFields_2 as configFields };
+    export function run_1({ row, configuration: { url, body } }: {
+        url: string;
+        body: object;
+    }): Promise<object>;
+    export { run_1 as run };
+}
+export namespace find_or_create_dm_room {
+    export function configFields_3(): Promise<object[]>;
+    export { configFields_3 as configFields };
+    export function run_2({ row, table, configuration: { viewname }, user }: {
+        row: object;
+        table: any;
+        configuration: object;
+        user: object;
+    }): Promise<object>;
+    export { run_2 as run };
+}
+export namespace send_email {
+    export function configFields_4({ table }: {
+        table: object;
+    }): Promise<object[]>;
+    export { configFields_4 as configFields };
+    export const requireRow: boolean;
+    export function run_3({ row, table, configuration: { viewname, subject, to_email, to_email_field, to_email_fixed, }, user, }: {
+        row: object;
+        table: object;
+        configuration: object;
+        user: object;
+    }): Promise<object>;
+    export { run_3 as run };
+}
+export namespace insert_joined_row {
+    export function configFields_5({ table }: {
+        table: object;
+    }): Promise<object[]>;
+    export { configFields_5 as configFields };
+    const requireRow_1: boolean;
+    export { requireRow_1 as requireRow };
+    export function run_4({ row, table, configuration: { joined_table }, user }: {
+        row: object;
+        table: object;
+        configuration: object;
+        user: object;
+    }): Promise<object>;
+    export { run_4 as run };
+}
+export namespace duplicate_row {
+    export function configFields_6(): Promise<object[]>;
+    export { configFields_6 as configFields };
+    const requireRow_2: boolean;
+    export { requireRow_2 as requireRow };
+    export function run_5({ row, table, user }: {
+        row: object;
+        table: object;
+        user: any;
+    }): Promise<object>;
+    export { run_5 as run };
+}
+export namespace recalculate_stored_fields {
+    export function configFields_7({ table }: {
+        table: object;
+    }): Promise<object[]>;
+    export { configFields_7 as configFields };
+    export function run_6({ configuration: { table } }: {
+        configuration: object;
+    }): Promise<void>;
+    export { run_6 as run };
+}
+export namespace insert_any_row {
+    export function configFields_8({ table }: {
+        table: any;
+    }): Promise<object[]>;
+    export { configFields_8 as configFields };
+    export function run_7({ row, configuration: { row_expr, table }, user, ...rest }: {
+        row: object;
+        configuration: object;
+        user: object;
+        rest: any;
+    }): Promise<boolean | object>;
+    export { run_7 as run };
+}
+export namespace run_js_code {
+    export function configFields_9({ table }: {
+        table: object;
+    }): Promise<object[]>;
+    export { configFields_9 as configFields };
+    export { run_code as run };
+}
+export {};
+//# sourceMappingURL=actions.d.ts.map

package/dist/base-plugin/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../base-plugin/actions.js"],"names":[],"mappings":"AA6BA;;;;;;;;;GASG;AACH;IARwB,GAAG,EAAhB,MAAM;IACO,KAAK,EAAlB,MAAM;IACO,OAAO,EAApB,MAAM;IACO,aAAa,EAA1B,MAAM;IACO,IAAI,EAAjB,MAAM;IACK,IAAI;IACb,QAAQ,MAAM,CAAC,CAqD3B;;;;;;;;;;;IAqCiB,2CAqBb;;IAQI;;;;sBAWJ;;;;;;;;;;;;;;;;;IA8BI;;;wBAMJ;;;;IAYa,oDAeb;;IAUI;;;;;wBAyCJ;;;;IAca;;0BA4Db;;;IAUI;;;;;wBAkDJ;;;;IAca;;0BAYb;;;;IAUI;;;;;wBAeJ;;;;IAYa,oDAAQ;;;;IASjB;;;;wBAMJ;;;;IAca;;0BAWb;;IAMI;;sBAGJ;;;;IAca;;0BAkBb;;IASI;;;;;kCAWJ;;;;IAca;;0BA4Bb"}

package/dist/base-plugin/actions.js

@@ -0,0 +1,551 @@
+"use strict";
+/**
+ * Action description
+ * @category saltcorn-data
+ * @module base-plugin/actions
+ * @subcategory base-plugin
+ */
+const fetch = require("node-fetch");
+const vm = require("vm");
+const Table = require("../models/table");
+const View = require("../models/view");
+const { getState } = require("../db/state");
+const User = require("../models/user");
+const Trigger = require("../models/trigger");
+const { getMailTransport, transformBootstrapEmail, } = require("../models/email");
+const { mockReqRes } = require("../tests/mocks");
+const { get_async_expression_function, recalculate_for_stored, } = require("../models/expression");
+const { div, code } = require("@saltcorn/markup/tags");
+const { sleep } = require("../utils");
+const db = require("../db");
+//action use cases: field modify, like/rate (insert join), notify, send row to webhook
+// todo add translation
+/**
+ * @param {object} opts
+ * @param {object} opts.row
+ * @param {object} opts.table
+ * @param {object} opts.channel
+ * @param {object} opts.configuration
+ * @param {object} opts.user
+ * @param {...*} opts.rest
+ * @returns {Promise<object>}
+ */
+const run_code = async ({ row, table, channel, configuration: { code, run_where }, user, ...rest }) => {
+    if (run_where === "Client page")
+        return { eval_js: code };
+    const Actions = {};
+    Object.entries(getState().actions).forEach(([k, v]) => {
+        Actions[k] = (args = {}) => {
+            v.run({ row, table, user, configuration: args, ...rest, ...args });
+        };
+    });
+    const trigger_actions = await Trigger.find({
+        when_trigger: { or: ["API call", "Never"] },
+    });
+    for (const trigger of trigger_actions) {
+        const state_action = getState().actions[trigger.action];
+        Actions[trigger.name] = (args = {}) => {
+            state_action.run({
+                row,
+                table,
+                configuration: trigger.configuration,
+                user,
+                ...rest,
+                ...args,
+            });
+        };
+    }
+    const emitEvent = (eventType, channel, payload) => Trigger.emitEvent(eventType, channel, user, payload);
+    const fetchJSON = async (...args) => await (await fetch(...args)).json();
+    const f = vm.runInNewContext(`async () => {${code}}`, {
+        Table,
+        table,
+        row,
+        user,
+        console,
+        Actions,
+        emitEvent,
+        sleep,
+        fetchJSON,
+        fetch,
+        channel: table ? table.name : channel,
+        ...(row || {}),
+        ...getState().function_context,
+        ...rest,
+    });
+    return await f();
+};
+module.exports = {
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    blocks: {
+        disableInBuilder: true,
+        disableInList: true,
+        configFields: [
+            {
+                name: "workspace",
+                input_type: "hidden",
+            },
+            {
+                name: "code",
+                input_type: "hidden",
+            },
+        ],
+        /**
+         * @type {base-plugin/actions~run_code}
+         * @see base-plugin/actions~run_code
+         */
+        run: run_code,
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    emit_event: {
+        /**
+         * @returns {object[]}
+         */
+        configFields: () => [
+            {
+                name: "eventType",
+                label: "Event type",
+                required: true,
+                input_type: "select",
+                options: Trigger.when_options,
+            },
+            {
+                name: "channel",
+                label: "Channel",
+                type: "String",
+                fieldview: "textarea",
+            },
+            {
+                name: "payload",
+                label: "Payload JSON",
+                sublabel: "Leave blank to use row from table",
+                type: "String",
+                fieldview: "textarea",
+            },
+        ],
+        /**
+         * @param {object} opts
+         * @param {object} opts.row
+         * @param {object} opts.configuration
+         * @param {object} opts.user
+         * @returns {Promise<void>}
+         */
+        run: async ({ row, configuration: { eventType, channel, payload }, user, }) => {
+            return await Trigger.emitEvent(eventType, channel, user, payload ? JSON.parse(payload) : row);
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    webhook: {
+        configFields: [
+            {
+                name: "url",
+                label: "URL",
+                type: "String",
+                sublabel: "Trigger will call specified URL",
+            },
+            {
+                name: "body",
+                label: "JSON body",
+                sublabel: "Leave blank to use row from table",
+                type: "String",
+                fieldview: "textarea", // I think that textarea is better
+            },
+        ],
+        /**
+         * @param {object} opts
+         * @param {string} opts.url
+         * @param {object} opts.body
+         * @returns {Promise<object>}
+         */
+        run: async ({ row, configuration: { url, body } }) => {
+            return await fetch(url, {
+                method: "post",
+                body: body || JSON.stringify(row),
+                headers: { "Content-Type": "application/json" },
+            });
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    find_or_create_dm_room: {
+        /**
+         * @returns {Promise<object[]>}
+         */
+        configFields: async () => {
+            const views = await View.find_all_views_where(({ viewrow }) => viewrow.viewtemplate === "Room");
+            const view_opts = views.map((v) => v.name);
+            return [
+                {
+                    name: "viewname",
+                    label: "Room view",
+                    sublabel: "Select a view with the Room viewtemplate",
+                    input_type: "select",
+                    options: view_opts,
+                },
+            ];
+        },
+        /**
+         * @param {object} opts
+         * @param {object} opts.row
+         * @param {*} opts.table
+         * @param {object} opts.configuration
+         * @param {object} opts.user
+         * @returns {Promise<object>}
+         */
+        run: async ({ row, table, configuration: { viewname }, user }) => {
+            const view = await View.findOne({ name: viewname });
+            const { participant_field } = view.configuration;
+            const [part_table_name, part_key_to_room, part_user_field,] = participant_field.split(".");
+            const roomtable = Table.findOne({ id: view.table_id });
+            const parttable = Table.findOne({ name: part_table_name });
+            //find a room that has both participants
+            // select id from rooms r where uid1 in (select id from participants where...) and
+            const { rows } = await db.query(`with my_rooms as (select "${part_key_to_room}" from "${db.getTenantSchema()}"."${db.sqlsanitize(part_table_name)}" where "${part_user_field}" = $1)          
+        select * from "${db.getTenantSchema()}"."${db.sqlsanitize(roomtable.name)}" r where r.id in (select "${part_key_to_room}" from my_rooms) 
+        and $2 in (select "${part_user_field}" from "${db.getTenantSchema()}"."${db.sqlsanitize(part_table_name)}" where "${part_key_to_room}" = r.id)`, [user.id, row.id]);
+            if (rows.length > 0) {
+                return { goto: `/view/${viewname}?id=${rows[0].id}` };
+            }
+            else {
+                //create room
+                const room_id = await roomtable.insertRow({});
+                await parttable.insertRow({
+                    [part_user_field]: user.id,
+                    [part_key_to_room]: room_id,
+                });
+                await parttable.insertRow({
+                    [part_user_field]: row.id,
+                    [part_key_to_room]: room_id,
+                });
+                return { goto: `/view/${viewname}?id=${room_id}` };
+            }
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    send_email: {
+        /**
+         * @param {object} opts
+         * @param {object} opts.table
+         * @returns {Promise<object[]>}
+         */
+        configFields: async ({ table }) => {
+            if (!table)
+                return [];
+            const views = await View.find_table_views_where(table, ({ viewtemplate }) => viewtemplate.runMany || viewtemplate.renderRows);
+            const view_opts = views.map((v) => v.name);
+            const fields = await table.getFields();
+            const field_opts = fields
+                .filter((f) => (f.type && f.type.name === "String") || f.reftable_name === "users")
+                .map((f) => f.name);
+            return [
+                {
+                    name: "viewname",
+                    label: "View to send",
+                    sublabel: "Select a view that can render a single record - for instance, of the Show template.",
+                    input_type: "select",
+                    options: view_opts,
+                },
+                {
+                    name: "to_email",
+                    label: "Recipient email address",
+                    sublabel: "Select email addresses for send email. Choose option to get more information",
+                    input_type: "select",
+                    required: true,
+                    options: ["Fixed", "User", "Field"],
+                },
+                {
+                    name: "to_email_field",
+                    label: "Field with email address",
+                    sublabel: "Field with email address a String, or Key to user who will receive email",
+                    input_type: "select",
+                    options: field_opts,
+                    showIf: { to_email: "Field" },
+                },
+                {
+                    name: "to_email_fixed",
+                    label: "Fixed address",
+                    sublabel: "Email address to send emails",
+                    type: "String",
+                    showIf: { to_email: "Fixed" },
+                },
+                {
+                    name: "subject",
+                    label: "Subject",
+                    sublabel: "Subject of email",
+                    type: "String",
+                    required: true,
+                },
+            ];
+        },
+        requireRow: true,
+        /**
+         * @param {object} opts
+         * @param {object} opts.row
+         * @param {object} opts.table
+         * @param {object} opts.configuration
+         * @param {object} opts.user
+         * @returns {Promise<object>}
+         */
+        run: async ({ row, table, configuration: { viewname, subject, to_email, to_email_field, to_email_fixed, }, user, }) => {
+            let to_addr;
+            switch (to_email) {
+                case "Fixed":
+                    to_addr = to_email_fixed;
+                    break;
+                case "User":
+                    to_addr = user.email;
+                    break;
+                case "Field":
+                    const fields = await table.getFields();
+                    const field = fields.find((f) => f.name === to_email_field);
+                    if (field && field.type.name === "String")
+                        to_addr = row[to_email_field];
+                    else if (field && field.reftable_name === "users") {
+                        const refuser = await User.findOne({ id: row[to_email_field] });
+                        to_addr = refuser.email;
+                    }
+                    break;
+            }
+            const view = await View.findOne({ name: viewname });
+            const htmlBs = await view.run({ id: row.id }, mockReqRes);
+            const html = await transformBootstrapEmail(htmlBs);
+            console.log("Sending email from %s to %s with subject %s to_email", getState().getConfig("email_from"), to_addr, subject, to_addr);
+            const email = {
+                from: getState().getConfig("email_from"),
+                to: to_addr,
+                subject,
+                html,
+            };
+            //console.log(email);
+            await getMailTransport().sendMail(email);
+            return { notify: `E-mail sent to ${to_addr}` };
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    insert_joined_row: {
+        /**
+         * @param {object} opts
+         * @param {object} opts.table
+         * @returns {Promise<object[]>}
+         */
+        configFields: async ({ table }) => {
+            if (!table)
+                return [];
+            const { child_field_list } = await table.get_child_relations();
+            return [
+                {
+                    name: "joined_table",
+                    label: "Relation",
+                    sublabel: "Relation",
+                    input_type: "select",
+                    options: child_field_list,
+                },
+            ];
+        },
+        requireRow: true,
+        /**
+         * @param {object} opts
+         * @param {object} opts.row
+         * @param {object} opts.table
+         * @param {object} opts.configuration
+         * @param {object} opts.user
+         * @returns {Promise<object>}
+         */
+        run: async ({ row, table, configuration: { joined_table }, user }) => {
+            const [join_table_name, join_field] = joined_table.split(".");
+            const joinTable = await Table.findOne({ name: join_table_name });
+            const fields = await joinTable.getFields();
+            const newRow = { [join_field]: row.id };
+            for (const field of fields) {
+                if (field.type === "Key" &&
+                    field.reftable_name === "users" &&
+                    user &&
+                    user.id)
+                    newRow[field.name] = user.id;
+            }
+            return await joinTable.insertRow(newRow);
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    duplicate_row: {
+        /**
+         * @returns {Promise<object[]>}
+         */
+        configFields: () => [],
+        requireRow: true,
+        /**
+         * @param {object} opts
+         * @param {object} opts.row
+         * @param {object} opts.table
+         * @param {*} opts.user
+         * @returns {Promise<object>}
+         */
+        run: async ({ row, table, user }) => {
+            const newRow = { ...row };
+            await table.getFields();
+            delete newRow[table.pk_name];
+            await table.insertRow(newRow);
+            return { reload_page: true };
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    recalculate_stored_fields: {
+        /**
+         * @param {object} opts
+         * @param {object} opts.table
+         * @returns {Promise<object[]>}
+         */
+        configFields: async ({ table }) => {
+            const tables = await Table.find();
+            return [
+                {
+                    name: "table",
+                    label: "Table",
+                    sublabel: "Table on which to recalculate stored calculated fields",
+                    input_type: "select",
+                    options: tables.map((t) => t.name),
+                },
+            ];
+        },
+        /**
+         * @param {object} opts
+         * @param {object} opts.configuration
+         * @returns {Promise<void>}
+         */
+        run: async ({ configuration: { table } }) => {
+            const table_for_recalc = await Table.findOne({ name: table });
+            recalculate_for_stored(table_for_recalc);
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    insert_any_row: {
+        /**
+         * @param {object} opts
+         * @param {*} opts.table
+         * @returns {Promise<object[]>}
+         */
+        configFields: async ({ table }) => {
+            const tables = await Table.find();
+            return [
+                {
+                    name: "table",
+                    label: "Table",
+                    sublabel: "Table to insert rows in",
+                    input_type: "select",
+                    options: tables.map((t) => t.name),
+                },
+                {
+                    name: "row_expr",
+                    label: "Row expression",
+                    sublabel: "Expression for JavaScript object",
+                    type: "String",
+                    fieldview: "textarea",
+                },
+            ];
+        },
+        /**
+         * @param {object} opts
+         * @param {object} opts.row
+         * @param {object} opts.configuration
+         * @param {object} opts.user
+         * @param {...*} opts.rest
+         * @returns {Promise<object|boolean>}
+         */
+        run: async ({ row, configuration: { row_expr, table }, user, ...rest }) => {
+            const f = get_async_expression_function(row_expr, [], {
+                row: row || {},
+                user,
+                console,
+            });
+            const calcrow = await f({});
+            const table_for_insert = await Table.findOne({ name: table });
+            const res = await table_for_insert.tryInsertRow(calcrow, user && user.id);
+            if (res.error)
+                return res;
+            else
+                return true;
+        },
+    },
+    /**
+     * @namespace
+     * @category saltcorn-data
+     * @subcategory actions
+     */
+    run_js_code: {
+        /**
+         * @param {object} opts
+         * @param {object} opts.table
+         * @returns {Promise<object[]>}
+         */
+        configFields: async ({ table }) => {
+            const fields = table ? (await table.getFields()).map((f) => f.name) : [];
+            const vars = [
+                ...(table ? ["row"] : []),
+                "user",
+                "console",
+                "Actions",
+                "Table",
+                ...(table ? ["table"] : []),
+                ...fields,
+            ]
+                .map((f) => code(f))
+                .join(", ");
+            return [
+                {
+                    name: "code",
+                    label: "Code",
+                    input_type: "code",
+                    attributes: { mode: "application/javascript" },
+                    sublabel: div("Variables in scope: ", vars),
+                },
+                {
+                    name: "run_where",
+                    label: "Run where",
+                    input_type: "select",
+                    options: ["Server", "Client page"],
+                },
+            ];
+        },
+        /**
+         * @type {base-plugin/actions~run_code}
+         * @see base-plugin/actions~run_code
+         **/
+        run: run_code,
+    },
+};
+//# sourceMappingURL=actions.js.map