@budibase/server 0.9.188 → 0.9.190-alpha.10

package/dist/api/controllers/row/ExternalRequest.js

@@ -24,12 +24,13 @@ const datasource_1 = require("../../../definitions/datasource");
 const utils_1 = require("../../../integrations/utils");
 var External;
 (function (External) {
-    const { makeExternalQuery } = require("./utils");
+    const { getDatasourceAndQuery } = require("./utils");
     const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
     const { breakExternalTableId, isSQL } = require("../../../integrations/utils");
     const { processObjectSync } = require("@budibase/string-templates");
     const { cloneDeep } = require("lodash/fp");
     const CouchDB = require("../../../db");
+    const { processFormulas } = require("../../../utilities/rowProcessor/utils");
     function buildFilters(id, filters, table) {
         const primary = table.primary;
         // if passed in array need to copy for shifting etc
@@ -94,8 +95,11 @@ var External;
         };
         // check the row and filters to make sure they aren't a key of some sort
         if (config.filters) {
-            for (let filter of Object.values(config.filters)) {
-                if (typeof filter !== "object" || Object.keys(filter).length === 0) {
+            for (let [key, filter] of Object.entries(config.filters)) {
+                // oneOf is an array, don't iterate it
+                if (typeof filter !== "object" ||
+                    Object.keys(filter).length === 0 ||
+                    key === datasource_1.FilterTypes.ONE_OF) {
                     continue;
                 }
                 iterateObject(filter);
@@ -151,8 +155,23 @@ var External;
         thisRow._rev = "rev";
         return thisRow;
     }
-    function isMany(field) {
-        return (field.relationshipType && field.relationshipType.split("-")[0] === "many");
+    function fixArrayTypes(row, table) {
+        for (let [fieldName, schema] of Object.entries(table.schema)) {
+            if (schema.type === FieldTypes.ARRAY &&
+                typeof row[fieldName] === "string") {
+                try {
+                    row[fieldName] = JSON.parse(row[fieldName]);
+                }
+                catch (err) {
+                    // couldn't convert back to array, ignore
+                    delete row[fieldName];
+                }
+            }
+        }
+        return row;
+    }
+    function isOneSide(field) {
+        return (field.relationshipType && field.relationshipType.split("-")[0] === "one");
     }
     class ExternalRequest {
         constructor(appId, operation, tableId, datasource) {
@@ -182,7 +201,10 @@ var External;
             let newRow = {}, manyRelationships = [];
             for (let [key, field] of Object.entries(table.schema)) {
                 // if set already, or not set just skip it
-                if ((!row[key] && row[key] !== "") || newRow[key] || field.autocolumn) {
+                if (row[key] == null ||
+                    newRow[key] ||
+                    field.autocolumn ||
+                    field.type === FieldTypes.FORMULA) {
                     continue;
                 }
                 // if its an empty string then it means return the column to null (if possible)
@@ -207,24 +229,35 @@ var External;
                 const linkTable = this.tables[linkTableName];
                 // @ts-ignore
                 const linkTablePrimary = linkTable.primary[0];
-                if (!isMany(field)) {
+                // one to many
+                if (isOneSide(field)) {
                     newRow[field.foreignKey || linkTablePrimary] = utils_1.breakRowIdField(row[key][0])[0];
                 }
-                else {
+                // many to many
+                else if (field.through) {
                     // we're not inserting a doc, will be a bunch of update calls
-                    const isUpdate = !field.through;
-                    const thisKey = isUpdate
-                        ? "id"
-                        : field.throughTo || linkTablePrimary;
-                    // @ts-ignore
-                    const otherKey = isUpdate
-                        ? field.fieldName
-                        : field.throughFrom || tablePrimary;
+                    const otherKey = field.throughFrom || linkTablePrimary;
+                    const thisKey = field.throughTo || tablePrimary;
                     row[key].map((relationship) => {
-                        // we don't really support composite keys for relationships, this is why [0] is used
                         manyRelationships.push({
                             tableId: field.through || field.tableId,
-                            isUpdate,
+                            isUpdate: false,
+                            key: otherKey,
+                            [otherKey]: utils_1.breakRowIdField(relationship)[0],
+                            // leave the ID for enrichment later
+                            [thisKey]: `{{ literal ${tablePrimary} }}`,
+                        });
+                    });
+                }
+                // many to one
+                else {
+                    const thisKey = "id";
+                    // @ts-ignore
+                    const otherKey = field.fieldName;
+                    row[key].map((relationship) => {
+                        manyRelationships.push({
+                            tableId: field.tableId,
+                            isUpdate: true,
                             key: otherKey,
                             [thisKey]: utils_1.breakRowIdField(relationship)[0],
                             // leave the ID for enrichment later
@@ -278,7 +311,7 @@ var External;
             return rows;
         }
         outputProcessing(rows = [], table, relationships) {
-            if (rows[0].read === true) {
+            if (!rows || rows.length === 0 || rows[0].read === true) {
                 return [];
             }
             let finalRows = {};
@@ -290,12 +323,15 @@ var External;
                     finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
                     continue;
                 }
-                const thisRow = basicProcessing(row, table);
+                const thisRow = fixArrayTypes(basicProcessing(row, table), table);
+                if (thisRow._id == null) {
+                    throw "Unable to generate row ID for SQL rows";
+                }
                 finalRows[thisRow._id] = thisRow;
                 // do this at end once its been added to the final rows
                 finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
             }
-            return Object.values(finalRows);
+            return processFormulas(table, Object.values(finalRows));
         }
         /**
          * Gets the list of relationship JSON structures based on the columns in the table,
@@ -329,8 +365,8 @@ var External;
                     const { tableName: throughTableName } = breakExternalTableId(field.through);
                     definition.through = throughTableName;
                     // don't support composite keys for relationships
-                    definition.from = field.throughFrom || table.primary[0];
-                    definition.to = field.throughTo || linkTable.primary[0];
+                    definition.from = field.throughTo || table.primary[0];
+                    definition.to = field.throughFrom || linkTable.primary[0];
                     definition.fromPrimary = table.primary[0];
                     definition.toPrimary = linkTable.primary[0];
                 }
@@ -352,24 +388,34 @@ var External;
                 // make a new request to get the row with all its relationships
                 // we need this to work out if any relationships need removed
                 for (let field of Object.values(table.schema)) {
-                    if (field.type !== FieldTypes.LINK || !field.fieldName) {
+                    if (field.type !== FieldTypes.LINK ||
+                        !field.fieldName ||
+                        isOneSide(field)) {
                         continue;
                     }
                     const isMany = field.relationshipType === RelationshipTypes.MANY_TO_MANY;
                     const tableId = isMany ? field.through : field.tableId;
-                    const manyKey = field.throughFrom || primaryKey;
+                    const { tableName: relatedTableName } = breakExternalTableId(tableId);
+                    // @ts-ignore
+                    const linkPrimaryKey = this.tables[relatedTableName].primary[0];
+                    const manyKey = field.throughTo || primaryKey;
+                    const lookupField = isMany ? primaryKey : field.foreignKey;
                     const fieldName = isMany ? manyKey : field.fieldName;
-                    const response = yield makeExternalQuery(this.appId, {
+                    if (!lookupField || !row[lookupField]) {
+                        continue;
+                    }
+                    const response = yield getDatasourceAndQuery(this.appId, {
                         endpoint: getEndpoint(tableId, DataSourceOperation.READ),
                         filters: {
                             equal: {
-                                [fieldName]: row[primaryKey],
+                                [fieldName]: row[lookupField],
                             },
                         },
                     });
                     // this is the response from knex if no rows found
                     const rows = !response[0].read ? response : [];
-                    related[fieldName] = { rows, isMany, tableId };
+                    const storeTo = isMany ? field.throughFrom || linkPrimaryKey : manyKey;
+                    related[storeTo] = { rows, isMany, tableId };
                 }
                 return related;
             });
@@ -403,7 +449,7 @@ var External;
                         ? DataSourceOperation.UPDATE
                         : DataSourceOperation.CREATE;
                     if (!found) {
-                        promises.push(makeExternalQuery(appId, {
+                        promises.push(getDatasourceAndQuery(appId, {
                             endpoint: getEndpoint(tableId, operation),
                             // if we're doing many relationships then we're writing, only one response
                             body,
@@ -430,7 +476,7 @@ var External;
                                 ? DataSourceOperation.DELETE
                                 : DataSourceOperation.UPDATE;
                             const body = isMany ? null : { [colName]: null };
-                            promises.push(makeExternalQuery(this.appId, {
+                            promises.push(getDatasourceAndQuery(this.appId, {
                                 endpoint: getEndpoint(tableId, op),
                                 body,
                                 filters,
@@ -449,13 +495,14 @@ var External;
          * is more performant and has the added benefit of protecting against this scenario.
          */
         buildFields(table, includeRelations = datasource_1.IncludeRelationships.INCLUDE) {
-            function extractNonLinkFieldNames(table, existing = []) {
+            function extractRealFields(table, existing = []) {
                 return Object.entries(table.schema)
                     .filter(column => column[1].type !== FieldTypes.LINK &&
+                    column[1].type !== FieldTypes.FORMULA &&
                     !existing.find((field) => field === column[0]))
                     .map(column => `${table.name}.${column[0]}`);
             }
-            let fields = extractNonLinkFieldNames(table);
+            let fields = extractRealFields(table);
             for (let field of Object.values(table.schema)) {
                 if (field.type !== FieldTypes.LINK || !includeRelations) {
                     continue;
@@ -463,7 +510,7 @@ var External;
                 const { tableName: linkTableName } = breakExternalTableId(field.tableId);
                 const linkTable = this.tables[linkTableName];
                 if (linkTable) {
-                    const linkedFields = extractNonLinkFieldNames(linkTable, fields);
+                    const linkedFields = extractRealFields(linkTable, fields);
                     fields = fields.concat(linkedFields);
                 }
             }
@@ -487,7 +534,7 @@ var External;
                     throw `Unable to process query, table "${tableName}" not defined.`;
                 }
                 // look for specific components of config which may not be considered acceptable
-                let { id, row, filters, sort, paginate } = cleanupConfig(config, table);
+                let { id, row, filters, sort, paginate, rows } = cleanupConfig(config, table);
                 filters = buildFilters(id, filters || {}, table);
                 const relationships = this.buildRelationships(table);
                 // clean up row on ingress using schema
@@ -511,7 +558,7 @@ var External;
                     sort,
                     paginate,
                     relationships,
-                    body: row,
+                    body: row || rows,
                     // pass an id filter into extra, purely for mysql/returning
                     extra: {
                         idFilter: buildFilters(id || generateIdForRow(row, table), {}, table),
@@ -521,7 +568,7 @@ var External;
                     },
                 };
                 // can't really use response right now
-                const response = yield makeExternalQuery(appId, json);
+                const response = yield getDatasourceAndQuery(appId, json);
                 // handle many to many relationships now if we know the ID (could be auto increment)
                 if (operation !== DataSourceOperation.READ &&
                     processed.manyRelationships) {

package/dist/api/controllers/row/external.js

@@ -41,6 +41,7 @@ function handleRequest(appId, operation, tableId, opts = {}) {
         return new ExternalRequest(appId, operation, tableId, opts.datasource).run(opts);
     });
 }
+exports.handleRequest = handleRequest;
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     const inputs = ctx.request.body;
@@ -64,7 +65,8 @@ exports.save = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
 exports.fetchView = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     // there are no views in external data sources, shouldn't ever be called
     // for now just fetch
-    ctx.params.tableId = ctx.params.viewName.split("all_")[1];
+    const split = ctx.params.viewName.split("all_");
+    ctx.params.tableId = split[1] ? split[1] : split[0];
     return exports.fetch(ctx);
 });
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {

package/dist/api/controllers/row/utils.js

@@ -14,8 +14,8 @@ const CouchDB = require("../../../db");
 const { InternalTables } = require("../../../db/utils");
 const userController = require("../user");
 const { FieldTypes } = require("../../../constants");
-const { integrations } = require("../../../integrations");
 const { processStringSync } = require("@budibase/string-templates");
+const { makeExternalQuery } = require("../../../integrations/base/utils");
 validateJs.extend(validateJs.validators.datetime, {
     parse: function (value) {
         return new Date(value).getTime();
@@ -25,19 +25,11 @@ validateJs.extend(validateJs.validators.datetime, {
         return new Date(value).toISOString();
     },
 });
-exports.makeExternalQuery = (appId, json) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getDatasourceAndQuery = (appId, json) => __awaiter(void 0, void 0, void 0, function* () {
     const datasourceId = json.endpoint.datasourceId;
     const db = new CouchDB(appId);
     const datasource = yield db.get(datasourceId);
-    const Integration = integrations[datasource.source];
-    // query is the opinionated function
-    if (Integration.prototype.query) {
-        const integration = new Integration(datasource.config);
-        return integration.query(json);
-    }
-    else {
-        throw "Datasource does not support query.";
-    }
+    return makeExternalQuery(datasource, json);
 });
 exports.findRow = (ctx, db, tableId, rowId) => __awaiter(void 0, void 0, void 0, function* () {
     let row;
@@ -73,7 +65,9 @@ exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0,
         }
         let res;
         // Validate.js doesn't seem to handle array
-        if (table.schema[fieldName].type === FieldTypes.ARRAY) {
+        if (table.schema[fieldName].type === FieldTypes.ARRAY &&
+            row[fieldName] &&
+            row[fieldName].length) {
             row[fieldName].map(val => {
                 if (!constraints.inclusion.includes(val)) {
                     errors[fieldName] = "Field not in list";

package/dist/api/controllers/table/external.js

@@ -0,0 +1,249 @@
+"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());
+    });
+};
+const CouchDB = require("../../../db");
+const { buildExternalTableId, breakExternalTableId, } = require("../../../integrations/utils");
+const { getTable, generateForeignKey, generateJunctionTableName, foreignKeyStructure, hasTypeChanged, } = require("./utils");
+const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
+const { makeExternalQuery } = require("../../../integrations/base/utils");
+const { cloneDeep } = require("lodash/fp");
+const csvParser = require("../../../utilities/csvParser");
+const { handleRequest } = require("../row/external");
+function makeTableRequest(datasource, operation, table, tables, oldTable = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = {
+            endpoint: {
+                datasourceId: datasource._id,
+                entityId: table._id,
+                operation,
+            },
+            meta: {
+                tables,
+            },
+            table,
+        };
+        if (oldTable) {
+            json.meta.table = oldTable;
+        }
+        return makeExternalQuery(datasource, json);
+    });
+}
+function cleanupRelationships(table, tables, oldTable = null) {
+    const tableToIterate = oldTable ? oldTable : table;
+    // clean up relationships in couch table schemas
+    for (let [key, schema] of Object.entries(tableToIterate.schema)) {
+        if (schema.type === FieldTypes.LINK &&
+            (!oldTable || table.schema[key] == null)) {
+            const relatedTable = Object.values(tables).find(table => table._id === schema.tableId);
+            const foreignKey = schema.foreignKey;
+            if (!relatedTable || !foreignKey) {
+                continue;
+            }
+            for (let [relatedKey, relatedSchema] of Object.entries(relatedTable.schema)) {
+                if (relatedSchema.type === FieldTypes.LINK &&
+                    relatedSchema.fieldName === foreignKey) {
+                    delete relatedTable.schema[relatedKey];
+                }
+            }
+        }
+    }
+}
+function getDatasourceId(table) {
+    if (!table) {
+        throw "No table supplied";
+    }
+    if (table.sourceId) {
+        return table.sourceId;
+    }
+    return breakExternalTableId(table._id).datasourceId;
+}
+function otherRelationshipType(type) {
+    if (type === RelationshipTypes.MANY_TO_MANY) {
+        return RelationshipTypes.MANY_TO_MANY;
+    }
+    return type === RelationshipTypes.ONE_TO_MANY
+        ? RelationshipTypes.MANY_TO_ONE
+        : RelationshipTypes.ONE_TO_MANY;
+}
+function generateManyLinkSchema(datasource, column, table, relatedTable) {
+    const primary = table.name + table.primary[0];
+    const relatedPrimary = relatedTable.name + relatedTable.primary[0];
+    const jcTblName = generateJunctionTableName(column, table, relatedTable);
+    // first create the new table
+    const junctionTable = {
+        _id: buildExternalTableId(datasource._id, jcTblName),
+        name: jcTblName,
+        primary: [primary, relatedPrimary],
+        constrained: [primary, relatedPrimary],
+        schema: {
+            [primary]: foreignKeyStructure(primary, {
+                toTable: table.name,
+                toKey: table.primary[0],
+            }),
+            [relatedPrimary]: foreignKeyStructure(relatedPrimary, {
+                toTable: relatedTable.name,
+                toKey: relatedTable.primary[0],
+            }),
+        },
+    };
+    column.through = junctionTable._id;
+    column.throughFrom = primary;
+    column.throughTo = relatedPrimary;
+    column.fieldName = relatedPrimary;
+    return junctionTable;
+}
+function generateLinkSchema(column, table, relatedTable, type) {
+    const isOneSide = type === RelationshipTypes.ONE_TO_MANY;
+    const primary = isOneSide ? relatedTable.primary[0] : table.primary[0];
+    // generate a foreign key
+    const foreignKey = generateForeignKey(column, relatedTable);
+    column.relationshipType = type;
+    column.foreignKey = isOneSide ? foreignKey : primary;
+    column.fieldName = isOneSide ? primary : foreignKey;
+    return foreignKey;
+}
+function generateRelatedSchema(linkColumn, table, relatedTable, columnName) {
+    // generate column for other table
+    const relatedSchema = cloneDeep(linkColumn);
+    // swap them from the main link
+    if (linkColumn.foreignKey) {
+        relatedSchema.fieldName = linkColumn.foreignKey;
+        relatedSchema.foreignKey = linkColumn.fieldName;
+    }
+    // is many to many
+    else {
+        // don't need to copy through, already got it
+        relatedSchema.fieldName = linkColumn.throughFrom;
+        relatedSchema.throughTo = linkColumn.throughFrom;
+        relatedSchema.throughFrom = linkColumn.throughTo;
+    }
+    relatedSchema.relationshipType = otherRelationshipType(linkColumn.relationshipType);
+    relatedSchema.tableId = relatedTable._id;
+    relatedSchema.name = columnName;
+    table.schema[columnName] = relatedSchema;
+}
+function isRelationshipSetup(column) {
+    return column.foreignKey || column.through;
+}
+exports.save = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = ctx.request.body;
+        // can't do this right now
+        delete table.dataImport;
+        const datasourceId = getDatasourceId(ctx.request.body);
+        // table doesn't exist already, note that it is created
+        if (!table._id) {
+            table.created = true;
+        }
+        let tableToSave = Object.assign({ type: "table", _id: buildExternalTableId(datasourceId, table.name) }, table);
+        let oldTable;
+        if (ctx.request.body && ctx.request.body._id) {
+            oldTable = yield getTable(appId, ctx.request.body._id);
+        }
+        if (hasTypeChanged(tableToSave, oldTable)) {
+            ctx.throw(400, "A column type has changed.");
+        }
+        const db = new CouchDB(appId);
+        const datasource = yield db.get(datasourceId);
+        const oldTables = cloneDeep(datasource.entities);
+        const tables = datasource.entities;
+        const extraTablesToUpdate = [];
+        // check if relations need setup
+        for (let schema of Object.values(tableToSave.schema)) {
+            if (schema.type !== FieldTypes.LINK || isRelationshipSetup(schema)) {
+                continue;
+            }
+            const relatedTable = Object.values(tables).find(table => table._id === schema.tableId);
+            const relatedColumnName = schema.fieldName;
+            const relationType = schema.relationshipType;
+            if (relationType === RelationshipTypes.MANY_TO_MANY) {
+                const junctionTable = generateManyLinkSchema(datasource, schema, table, relatedTable);
+                if (tables[junctionTable.name]) {
+                    throw "Junction table already exists, cannot create another relationship.";
+                }
+                tables[junctionTable.name] = junctionTable;
+                extraTablesToUpdate.push(junctionTable);
+            }
+            else {
+                const fkTable = relationType === RelationshipTypes.ONE_TO_MANY ? table : relatedTable;
+                const foreignKey = generateLinkSchema(schema, table, relatedTable, relationType);
+                fkTable.schema[foreignKey] = foreignKeyStructure(foreignKey);
+                if (fkTable.constrained == null) {
+                    fkTable.constrained = [];
+                }
+                if (fkTable.constrained.indexOf(foreignKey) === -1) {
+                    fkTable.constrained.push(foreignKey);
+                }
+                // foreign key is in other table, need to save it to external
+                if (fkTable._id !== table._id) {
+                    extraTablesToUpdate.push(fkTable);
+                }
+            }
+            generateRelatedSchema(schema, relatedTable, table, relatedColumnName);
+            schema.main = true;
+        }
+        cleanupRelationships(tableToSave, tables, oldTable);
+        const operation = oldTable
+            ? DataSourceOperation.UPDATE_TABLE
+            : DataSourceOperation.CREATE_TABLE;
+        yield makeTableRequest(datasource, operation, tableToSave, tables, oldTable);
+        // update any extra tables (like foreign keys in other tables)
+        for (let extraTable of extraTablesToUpdate) {
+            const oldExtraTable = oldTables[extraTable.name];
+            let op = oldExtraTable
+                ? DataSourceOperation.UPDATE_TABLE
+                : DataSourceOperation.CREATE_TABLE;
+            yield makeTableRequest(datasource, op, extraTable, tables, oldExtraTable);
+        }
+        // make sure the constrained list, all still exist
+        if (Array.isArray(tableToSave.constrained)) {
+            tableToSave.constrained = tableToSave.constrained.filter(constraint => Object.keys(tableToSave.schema).includes(constraint));
+        }
+        // store it into couch now for budibase reference
+        datasource.entities[tableToSave.name] = tableToSave;
+        yield db.put(datasource);
+        return tableToSave;
+    });
+};
+exports.destroy = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const tableToDelete = yield getTable(appId, ctx.params.tableId);
+        if (!tableToDelete || !tableToDelete.created) {
+            ctx.throw(400, "Cannot delete tables which weren't created in Budibase.");
+        }
+        const datasourceId = getDatasourceId(tableToDelete);
+        const db = new CouchDB(appId);
+        const datasource = yield db.get(datasourceId);
+        const tables = datasource.entities;
+        const operation = DataSourceOperation.DELETE_TABLE;
+        yield makeTableRequest(datasource, operation, tableToDelete, tables);
+        cleanupRelationships(tableToDelete, tables);
+        delete datasource.entities[tableToDelete.name];
+        yield db.put(datasource);
+        return tableToDelete;
+    });
+};
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = yield getTable(appId, ctx.params.tableId);
+        const { dataImport } = ctx.request.body;
+        if (!dataImport || !dataImport.schema || !dataImport.csvString) {
+            ctx.throw(400, "Provided data import information is invalid.");
+        }
+        const rows = yield csvParser.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
+        yield handleRequest(appId, DataSourceOperation.BULK_CREATE, table._id, {
+            rows,
+        });
+        return table;
+    });
+};