@formio/appserver 1.0.0

package/lib/actions/role/RoleAction.js

@@ -0,0 +1,171 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleAction = void 0;
+const debug = require('debug')('formio:actions:role');
+const error = require('debug')('formio:error');
+exports.RoleAction = {
+    // The action information.
+    get info() {
+        return {
+            name: 'role',
+            title: 'Role Assignment',
+            description: 'Provides the Role Assignment capabilities.',
+            priority: 1,
+            defaults: {
+                handler: ['after'],
+                method: ['create']
+            },
+            access: {
+                handler: false,
+                method: false
+            }
+        };
+    },
+    /**
+     * The settings form for this action.
+     * @param {*} scope
+     */
+    settingsForm(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [
+                {
+                    type: 'select',
+                    input: true,
+                    label: 'Resource Association',
+                    key: 'association',
+                    placeholder: 'Select the type of resource to perform role manipulation.',
+                    template: '<span>{{ item.title }}</span>',
+                    dataSrc: 'json',
+                    data: {
+                        json: JSON.stringify([
+                            {
+                                association: 'existing',
+                                title: 'Existing Resource'
+                            },
+                            {
+                                association: 'new',
+                                title: 'New Resource'
+                            }
+                        ])
+                    },
+                    valueProperty: 'association',
+                    multiple: false,
+                    validate: {
+                        required: true
+                    }
+                },
+                {
+                    type: 'select',
+                    input: true,
+                    label: 'Action Type',
+                    key: 'type',
+                    placeholder: 'Select whether this Action will Add or Remove the contained Role.',
+                    template: '<span>{{ item.title }}</span>',
+                    dataSrc: 'json',
+                    data: {
+                        json: JSON.stringify([
+                            {
+                                type: 'add',
+                                title: 'Add Role'
+                            },
+                            {
+                                type: 'remove',
+                                title: 'Remove Role'
+                            }
+                        ])
+                    },
+                    valueProperty: 'type',
+                    multiple: false,
+                    validate: {
+                        required: true
+                    }
+                },
+                {
+                    type: 'select',
+                    input: true,
+                    label: 'Role',
+                    key: 'role',
+                    placeholder: 'Select the Role that this action will Add or Remove.',
+                    template: '<span>{{ item.title }}</span>',
+                    dataSrc: 'json',
+                    data: { json: Object.values(scope.template.roles) },
+                    valueProperty: '_id',
+                    multiple: false,
+                    validate: {
+                        required: true
+                    }
+                }
+            ];
+        });
+    },
+    /**
+     * Returns the action middleware.
+     *
+     * @param {*} scope
+     */
+    executor(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+                debug('Role Action');
+                // Check the submission for the submissionId.
+                if (scope.action.settings.association !== 'existing' && scope.action.settings.association !== 'new') {
+                    error('Invalid setting `association` for the RoleAction; expecting `new` or `existing`.');
+                    return res.status(400).send('Invalid setting `association` for the RoleAction; expecting `new` or `existing`.');
+                }
+                // Error if operation type is not valid.
+                if (!scope.action.settings.type || (scope.action.settings.type !== 'add' && scope.action.settings.type !== 'remove')) {
+                    error('Invalid setting `type` for the RoleAction; expecting `add` or `remove`.');
+                    return res.status(400).send('Invalid setting `type` for the RoleAction; expecting `add` or `remove`.');
+                }
+                // Error if no resource is being returned.
+                if (scope.action.settings.association === 'new' && res.hasOwnProperty('resource') && !res.resource.item && scope.action.settings.role) {
+                    error('Invalid resource was provided for RoleAction association of `new`.');
+                    return res.status(400).send('Invalid resource was provided for RoleAction association of `new`.');
+                }
+                // Error if association is existing and valid data was not provided.
+                if (scope.action.settings.association === 'existing' && !scope.action.settings.role) {
+                    error('Missing role for RoleAction association of "existing". Must specify role to assign in action settings or a form component named "role"');
+                    return res.status(400).send('Missing role for RoleAction association of "existing". Must specify role to assign in action settings or a form component named "role"');
+                }
+                if (scope.action.settings.association === 'existing' && !res.resource.item) {
+                    error('Missing submission for RoleAction association of "existing:. Form must have a resource field named "submission".');
+                    return res.status(400).send('Missing submission for RoleAction association of "existing:. Form must have a resource field named "submission".');
+                }
+                // Determine the resources based on the current request.
+                let resource = res.resource ? (res.resource.item || req.body) : req.body;
+                let role = scope.utils.roleId(scope, scope.action.settings.role);
+                if (!resource.roles) {
+                    resource.roles = [];
+                }
+                const roleIndex = resource.roles.indexOf(role);
+                switch (scope.action.settings.type) {
+                    case 'add':
+                        if (roleIndex !== -1) {
+                            return next();
+                        }
+                        resource.roles.push(role);
+                        break;
+                    case 'remove':
+                        if (roleIndex === -1) {
+                            return next();
+                        }
+                        resource.roles.slice(roleIndex, 1);
+                        break;
+                }
+                debug('Updating user with roles', resource.roles);
+                // Update the user.
+                yield scope.db.update(scope, resource._id, resource, ['roles']);
+                next();
+            });
+        });
+    }
+};

package/lib/actions/save/SaveAction.d.ts

@@ -0,0 +1,29 @@
+import { ActionScope } from '../../types/action';
+import { SubmissionRequest, SubmissionResponse } from '../../types/submission';
+import { NextFunction } from 'express';
+export declare const SaveAction: {
+    readonly info: {
+        name: string;
+        title: string;
+        description: string;
+        priority: number;
+        defaults: {
+            handler: string[];
+            method: string[];
+        };
+        access: {
+            handler: boolean;
+            method: boolean;
+        };
+    };
+    mappingComponents(scope: ActionScope): Promise<any>;
+    /**
+     * The settings form for this action.
+     * @param {*} scope
+     */
+    settingsForm(scope: ActionScope): Promise<any>;
+    saveToForm(scope: ActionScope, resource: string): undefined;
+    childSubmission(scope: ActionScope, req: SubmissionRequest, res: SubmissionResponse, submission: any): any;
+    childResponse(scope: ActionScope, req: SubmissionRequest, res: SubmissionResponse): void;
+    executor(scope: ActionScope): Promise<(req: SubmissionRequest, res: SubmissionResponse, next: NextFunction) => Promise<void>>;
+};

package/lib/actions/save/SaveAction.js

@@ -0,0 +1,307 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveAction = void 0;
+const each_1 = __importDefault(require("lodash/each"));
+const set_1 = __importDefault(require("lodash/set"));
+const has_1 = __importDefault(require("lodash/has"));
+const get_1 = __importDefault(require("lodash/get"));
+const async_1 = __importDefault(require("async"));
+const debug = require('debug')('formio:actions:save');
+const error = require('debug')('formio:error');
+exports.SaveAction = {
+    // The action information.
+    get info() {
+        return {
+            name: 'save',
+            title: 'Save Submission',
+            description: 'Saves the submission into the database.',
+            priority: 10,
+            defaults: {
+                handler: ['before'],
+                method: ['create', 'update']
+            },
+            access: {
+                handler: false,
+                method: false
+            }
+        };
+    },
+    mappingComponents(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const components = [
+                {
+                    type: 'select',
+                    key: 'mapType',
+                    label: 'Request Mapping Type',
+                    persist: 'client-only',
+                    defaultValue: 'simple',
+                    dataSrc: 'values',
+                    data: {
+                        values: [
+                            { label: 'Simple', value: 'simple' },
+                            { label: 'Advanced', value: 'advanced' }
+                        ]
+                    }
+                },
+                {
+                    type: 'panel',
+                    title: 'Advanced Request Mapping',
+                    key: 'requestMappingPanel',
+                    customConditional: `show = row.mapType === 'advanced'`,
+                    components: [
+                        {
+                            input: true,
+                            label: "Request Mapping",
+                            key: "mapping",
+                            placeholder: "/** Example Code **/\nbody = submission;",
+                            rows: 8,
+                            defaultValue: "",
+                            persistent: true,
+                            editor: "ace",
+                            type: "textarea",
+                            description: "Manually perform a mapping of the request being made to the child resource. The 'body' is the req.body sent to the resource. You can use any standard evaluation context variables (form, submission, etc)."
+                        }
+                    ]
+                }
+            ];
+            for (let key in scope.template.resources) {
+                const form = scope.template.resources[key];
+                const mappings = {
+                    title: 'Simple Mappings',
+                    label: 'Simple Mappings',
+                    collapsible: false,
+                    key: 'mappings',
+                    type: 'panel',
+                    customConditional: `show = row.mapType === 'simple' && row.resource === "${key}"`,
+                    components: []
+                };
+                const toFields = [];
+                yield scope.utils.eachComponent(form.components, (component) => {
+                    if (['button'].indexOf(component.type) !== -1) {
+                        return;
+                    }
+                    toFields.push({ label: component.label || component.key, value: component.key });
+                });
+                yield scope.utils.eachComponent(scope.form.components, (component) => {
+                    if (['button'].indexOf(component.type) !== -1) {
+                        return;
+                    }
+                    mappings.components.push({
+                        type: 'select',
+                        key: `fields.${component.key}`,
+                        label: component.label,
+                        valueProperty: 'value',
+                        dataSrc: 'json',
+                        data: { json: toFields }
+                    });
+                });
+                components.push(mappings);
+            }
+            return components;
+        });
+    },
+    /**
+     * The settings form for this action.
+     * @param {*} scope
+     */
+    settingsForm(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resources = [];
+            for (let name in scope.template.resources) {
+                resources.push({
+                    label: scope.template.resources[name].title,
+                    value: name
+                });
+            }
+            return [
+                {
+                    type: 'select',
+                    key: 'resource',
+                    label: 'Save submission to',
+                    placeholder: 'This form',
+                    valueProperty: 'value',
+                    dataSrc: 'json',
+                    data: {
+                        json: resources
+                    },
+                    required: false
+                },
+                {
+                    type: 'textfield',
+                    key: 'property',
+                    label: 'Resource Property',
+                    placeholder: 'Assign this resource to the following property',
+                    customConditional: 'show = row.resource'
+                },
+                {
+                    legend: 'Resource Fields',
+                    key: 'resourceFields',
+                    type: 'fieldset',
+                    label: 'Resource Fields',
+                    customConditional: 'show = row.resource',
+                    components: [
+                        {
+                            label: 'Summary',
+                            key: 'summary',
+                            type: 'well',
+                            hideLabel: true,
+                            components: [
+                                {
+                                    label: 'HTML',
+                                    content: 'Below are the fields within the selected resource. For each of these fields, select the corresponding field within this form that you wish to map to the selected Resource. Simple mappings may be used for any component that is not nested within a container, editgrid, datagrid or other nested data component.',
+                                    refreshOnChange: false,
+                                    attrs: [{ attr: 'style', value: 'margin: 0' }],
+                                    key: 'html',
+                                    type: 'htmlelement'
+                                }
+                            ]
+                        }
+                    ].concat(yield exports.SaveAction.mappingComponents(scope))
+                },
+                {
+                    type: 'panel',
+                    title: 'Transform Mappings',
+                    key: 'transformPanel',
+                    components: [
+                        {
+                            input: true,
+                            label: "Transform Data",
+                            key: "transform",
+                            placeholder: "/** Example Code **/\ndata = submission.data;",
+                            rows: 8,
+                            defaultValue: "",
+                            persistent: true,
+                            editor: "ace",
+                            type: "textarea",
+                            description: "Available variables are submission and data (data is already transformed by simple mappings)."
+                        }
+                    ]
+                }
+            ];
+        });
+    },
+    saveToForm(scope, resource) {
+        let saveTo;
+        (0, each_1.default)(scope.template.resources, (form) => {
+            if (form.key === resource) {
+                saveTo = form;
+                return false;
+            }
+        });
+        if (!saveTo) {
+            (0, each_1.default)(scope.template.forms, (form) => {
+                if (form.key === resource) {
+                    saveTo = form;
+                    return false;
+                }
+            });
+        }
+        return saveTo;
+    },
+    // Create a child submission.
+    childSubmission(scope, req, res, submission) {
+        const { action } = scope;
+        let childSub = { data: {} };
+        if (action.settings.mapping) {
+            try {
+                childSub = scope.utils.evaluate(action.settings.mapping, scope.utils.evalContext(Object.assign(Object.assign({}, scope), { body: req.body }), req, res), 'body');
+            }
+            catch (err) {
+                console.log(`Error in mapping transform: ${err.message}`);
+            }
+        }
+        else {
+            (0, each_1.default)(action.settings.fields, function (field, key) {
+                if (field === 'data') {
+                    (0, set_1.default)(childSub.data, key, submission.data);
+                }
+                else if ((0, has_1.default)(submission.data, field)) {
+                    (0, set_1.default)(childSub.data, key, (0, get_1.default)(submission.data, field));
+                }
+            });
+        }
+        childSub.metadata = submission.metadata;
+        if (action.settings.transform) {
+            try {
+                childSub.data = scope.utils.evaluate(action.settings.transform, scope.utils.evalContext(scope, req, res), 'data');
+            }
+            catch (err) {
+                console.log(`Error in submission transform: ${err.message}`);
+            }
+        }
+        return childSub;
+    },
+    // Set the child response
+    childResponse(scope, req, res) {
+        var _a, _b;
+        const { action } = scope;
+        if ((_a = res.resource) === null || _a === void 0 ? void 0 : _a.item) {
+            // Set the action in the property.
+            if ((_b = action.settings) === null || _b === void 0 ? void 0 : _b.property) {
+                (0, set_1.default)(req.body.data, action.settings.property, res.resource.item);
+            }
+            // Save the reference in the external ids.
+            if (req.method === 'POST' && res.resource.item._id) {
+                // Save the external resource in the external ids.
+                req.body.externalIds = req.body.externalIds || [];
+                req.body.externalIds.push({
+                    type: 'resource',
+                    resource: action.settings.resource,
+                    id: res.resource.item._id.toString()
+                });
+            }
+        }
+    },
+    executor(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = scope.action;
+            return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                debug('Save Action');
+                if (req.skipSave || !req.body || (req.method !== 'POST' && req.method !== 'PUT')) {
+                    debug('Skipping save action');
+                    return next();
+                }
+                // If this is saving to another resource, then we need to use those handlers instead.
+                if ((_a = action.settings) === null || _a === void 0 ? void 0 : _a.resource) {
+                    debug('Saving to resource: ' + action.settings.resource);
+                    const saveTo = exports.SaveAction.saveToForm(scope, action.settings.resource);
+                    if (saveTo) {
+                        if (!saveTo.handlers) {
+                            error('Cannot find resource handlers.');
+                            return next('Cannot find resource handlers.');
+                        }
+                        const handlers = req.method === 'PUT' ? saveTo.handlers.update : saveTo.handlers.create;
+                        const childReq = scope.utils.childRequest(req);
+                        childReq.body = exports.SaveAction.childSubmission(scope, req, res, childReq.body);
+                        return async_1.default.series(handlers.map((handler) => async_1.default.apply(handler, childReq, res)), (err) => {
+                            if (err) {
+                                error(err);
+                                return next(err);
+                            }
+                            // Set the child response based on the response of the subform.
+                            exports.SaveAction.childResponse(scope, req, res);
+                            next();
+                        });
+                    }
+                }
+                // Save the submission.
+                req.scope.saveSubmission = true;
+                debug('Saving submission');
+                return next();
+            });
+        });
+    }
+};

package/lib/auth.d.ts

@@ -0,0 +1,5 @@
+import { AuthModule, AuthToken } from './types/server';
+export declare class Auth implements AuthModule {
+    token(user: AuthToken, secret: string, expire?: number): Promise<string>;
+    user(token: string, secret: string): Promise<AuthToken | null>;
+}

package/lib/auth.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const debug = require('debug')('formio:auth');
+const error = require('debug')('formio:error');
+class Auth {
+    token(user, secret, expire = 240) {
+        return __awaiter(this, void 0, void 0, function* () {
+            user = Object.assign({}, user);
+            delete user.iat;
+            delete user.exp;
+            return new Promise((resolve, reject) => {
+                if (!secret) {
+                    return reject(new Error('You cannot generate a token without a secret!'));
+                }
+                debug('auth.token()', user);
+                jsonwebtoken_1.default.sign(user, secret, {
+                    expiresIn: expire * 60,
+                }, (err, signed) => {
+                    if (err) {
+                        error(err);
+                        return reject(err);
+                    }
+                    resolve(signed || '');
+                });
+            });
+        });
+    }
+    user(token, secret) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!token) {
+                return Promise.resolve(null);
+            }
+            return new Promise((resolve, reject) => {
+                if (!secret) {
+                    return reject('You cannot authenticate without a JWT Secret!');
+                }
+                debug('auth.verify()', token);
+                jsonwebtoken_1.default.verify(token, secret, (err, payload) => {
+                    if (err) {
+                        error(err);
+                        if (err.name === 'JsonWebTokenError') {
+                            return reject({ message: 'Bad Token' });
+                        }
+                        if (err.name === 'TokenExpiredError') {
+                            return reject({ message: 'Token Expired' });
+                        }
+                        return reject(err);
+                    }
+                    debug('auth.user()', payload);
+                    resolve(payload);
+                });
+            });
+        });
+    }
+}
+exports.Auth = Auth;

package/lib/db.d.ts

@@ -0,0 +1,76 @@
+import { Collection, Db } from 'mongodb';
+import { DBConfig, ServerDB } from './types/server';
+import { FormScope } from './types/form';
+export declare class Database implements ServerDB {
+    config: DBConfig;
+    db: Db | null;
+    currentCollectionName: string;
+    currentCollection: Collection<Document> | null;
+    defaultCollection: Collection<Document> | null;
+    constructor(config: DBConfig);
+    ObjectId(id: any): any;
+    /**
+     * Connect to the database.
+     * @param {*} scope
+     * @returns
+     */
+    connect(): Promise<void>;
+    save(collectionName: string, item: any): Promise<import("mongodb").WithId<import("bson").Document> | null>;
+    load(collectionName: string): Promise<import("mongodb").WithId<import("bson").Document> | null | undefined>;
+    collection(scope: FormScope): Promise<Collection<Document> | null>;
+    /**
+     * Setup indexes.
+     */
+    setupIndexes(collection: Collection<Document> | null, scope?: FormScope): Promise<void>;
+    /**
+     * Add a field index
+     */
+    addIndex(collection: Collection<Document>, path: string): Promise<void>;
+    /**
+     * Remove a field index.
+     */
+    removeIndex(collection: Collection<Document>, path: string): Promise<void>;
+    /**
+     * Fetch a list of submissions from a table/collection.
+     * @param {*} table
+     * @param {*} query
+     */
+    index(scope: FormScope, query?: {}): Promise<import("mongodb").WithId<Document>[] | undefined>;
+    /**
+     * Create a new record.
+     */
+    create(scope: FormScope, record: any, allowFields?: string[]): Promise<import("mongodb").WithId<Document> | null | undefined>;
+    /**
+     * Return a query for a single mongo record.
+     * @param {*} form
+     * @param {*} id
+     * @returns
+     */
+    query(scope: FormScope, query?: any): any;
+    /**
+     * Find many records that match a query.
+     */
+    find(scope: FormScope, query?: any): Promise<import("mongodb").WithId<Document>[]>;
+    /**
+     * Find a record for a provided query.
+     */
+    findOne(scope: FormScope, query?: any): Promise<import("mongodb").WithId<Document> | null>;
+    /**
+     * Read a single submission from a form
+     *
+     * @param {*} table
+     * @param {*} query
+     */
+    read(scope: FormScope, id: string): Promise<import("mongodb").WithId<Document> | null>;
+    /**
+     * Update a single submission of a form.
+     *
+     * @param {*} table
+     * @param {*} query
+     */
+    update(scope: FormScope, id: string, update: any, allowFields?: string[]): Promise<import("mongodb").WithId<Document> | null>;
+    /**
+     * Delete a record from the database.
+     */
+    delete(scope: FormScope, id: string): Promise<boolean>;
+}