@budibase/server 1.0.26 → 1.0.27-alpha.11

package/dist/api/controllers/{query.js → query/index.js}

@@ -8,11 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { processString } = require("@budibase/string-templates");
-const CouchDB = require("../../db");
-const { generateQueryID, getQueryParams, isProdAppID, } = require("../../db/utils");
-const { BaseQueryVerbs } = require("../../constants");
-const { Thread, ThreadType } = require("../../threads");
+const CouchDB = require("../../../db");
+const { generateQueryID, getQueryParams, isProdAppID, } = require("../../../db/utils");
+const { BaseQueryVerbs } = require("../../../constants");
+const { Thread, ThreadType } = require("../../../threads");
+const { save: saveDatasource } = require("../datasource");
+const { RestImporter } = require("./import");
+const { invalidateDynamicVariables } = require("../../../threads/utils");
 const Runner = new Thread(ThreadType.QUERY, { timeoutMs: 10000 });
 // simple function to append "readable" to all read queries
 function enrichQueries(input) {
@@ -34,6 +36,38 @@ exports.fetch = function (ctx) {
         ctx.body = enrichQueries(body.rows.map(row => row.doc));
     });
 };
+exports.import = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const body = ctx.request.body;
+    const data = body.data;
+    const importer = new RestImporter(data);
+    yield importer.init();
+    let datasourceId;
+    if (!body.datasourceId) {
+        // construct new datasource
+        const info = yield importer.getInfo();
+        let datasource = {
+            type: "datasource",
+            source: "REST",
+            config: {
+                url: info.url,
+                defaultHeaders: [],
+            },
+            name: info.name,
+        };
+        // save the datasource
+        const datasourceCtx = Object.assign({}, ctx);
+        datasourceCtx.request.body.datasource = datasource;
+        yield saveDatasource(datasourceCtx);
+        datasourceId = datasourceCtx.body.datasource._id;
+    }
+    else {
+        // use existing datasource
+        datasourceId = body.datasourceId;
+    }
+    const importResult = yield importer.importQueries(ctx.appId, datasourceId);
+    ctx.body = Object.assign(Object.assign({}, importResult), { datasourceId });
+    ctx.status = 200;
+});
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -47,44 +81,6 @@ exports.save = function (ctx) {
         ctx.message = `Query ${query.name} saved successfully.`;
     });
 };
-function enrichQueryFields(fields, parameters = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const enrichedQuery = {};
-        // enrich the fields with dynamic parameters
-        for (let key of Object.keys(fields)) {
-            if (fields[key] == null) {
-                continue;
-            }
-            if (typeof fields[key] === "object") {
-                // enrich nested fields object
-                enrichedQuery[key] = yield enrichQueryFields(fields[key], parameters);
-            }
-            else if (typeof fields[key] === "string") {
-                // enrich string value as normal
-                enrichedQuery[key] = yield processString(fields[key], parameters, {
-                    noHelpers: true,
-                });
-            }
-            else {
-                enrichedQuery[key] = fields[key];
-            }
-        }
-        if (enrichedQuery.json ||
-            enrichedQuery.customData ||
-            enrichedQuery.requestBody) {
-            try {
-                enrichedQuery.json = JSON.parse(enrichedQuery.json ||
-                    enrichedQuery.customData ||
-                    enrichedQuery.requestBody);
-            }
-            catch (err) {
-                throw { message: `JSON Invalid - error: ${err}` };
-            }
-            delete enrichedQuery.customData;
-        }
-        return enrichedQuery;
-    });
-}
 exports.find = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -101,18 +97,24 @@ exports.preview = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
         const datasource = yield db.get(ctx.request.body.datasourceId);
-        const { fields, parameters, queryVerb, transformer } = ctx.request.body;
-        const enrichedQuery = yield enrichQueryFields(fields, parameters);
+        // preview may not have a queryId as it hasn't been saved, but if it does
+        // this stops dynamic variables from calling the same query
+        const { fields, parameters, queryVerb, transformer, queryId } = ctx.request.body;
         try {
-            const { rows, keys } = yield Runner.run({
+            const { rows, keys, info, extra } = yield Runner.run({
+                appId: ctx.appId,
                 datasource,
                 queryVerb,
-                query: enrichedQuery,
+                fields,
+                parameters,
                 transformer,
+                queryId,
             });
             ctx.body = {
                 rows,
                 schemaFields: [...new Set(keys)],
+                info,
+                extra,
             };
         }
         catch (err) {
@@ -120,30 +122,62 @@ exports.preview = function (ctx) {
         }
     });
 };
-exports.execute = function (ctx) {
+function execute(ctx, opts = { rowsOnly: false }) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
         const query = yield db.get(ctx.params.queryId);
         const datasource = yield db.get(query.datasourceId);
-        const enrichedQuery = yield enrichQueryFields(query.fields, ctx.request.body.parameters);
         // call the relevant CRUD method on the integration class
         try {
-            const { rows } = yield Runner.run({
+            const { rows, extra } = yield Runner.run({
+                appId: ctx.appId,
                 datasource,
                 queryVerb: query.queryVerb,
-                query: enrichedQuery,
+                fields: query.fields,
+                parameters: ctx.request.body.parameters,
                 transformer: query.transformer,
+                queryId: ctx.params.queryId,
             });
-            ctx.body = rows;
+            if (opts && opts.rowsOnly) {
+                ctx.body = rows;
+            }
+            else {
+                ctx.body = Object.assign({ data: rows }, extra);
+            }
         }
         catch (err) {
             ctx.throw(400, err);
         }
     });
+}
+exports.executeV1 = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return execute(ctx, { rowsOnly: true });
+    });
+};
+exports.executeV2 = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return execute(ctx, { rowsOnly: false });
+    });
 };
+const removeDynamicVariables = (db, queryId) => __awaiter(void 0, void 0, void 0, function* () {
+    const query = yield db.get(queryId);
+    const datasource = yield db.get(query.datasourceId);
+    const dynamicVariables = datasource.config.dynamicVariables;
+    if (dynamicVariables) {
+        // delete dynamic variables from the datasource
+        const newVariables = dynamicVariables.filter(dv => dv.queryId !== queryId);
+        datasource.config.dynamicVariables = newVariables;
+        yield db.put(datasource);
+        // invalidate the deleted variables
+        const variablesToDelete = dynamicVariables.filter(dv => dv.queryId === queryId);
+        yield invalidateDynamicVariables(variablesToDelete);
+    }
+});
 exports.destroy = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
+        yield removeDynamicVariables(db, ctx.params.queryId);
         yield db.remove(ctx.params.queryId, ctx.params.revId);
         ctx.message = `Query deleted.`;
         ctx.status = 200;

package/dist/api/controllers/query/validation.js

@@ -0,0 +1,38 @@
+"use strict";
+const joiValidator = require("../../../middleware/joi-validator");
+const Joi = require("joi");
+exports.queryValidation = () => {
+    return Joi.object({
+        _id: Joi.string(),
+        _rev: Joi.string(),
+        name: Joi.string().required(),
+        fields: Joi.object().required(),
+        datasourceId: Joi.string().required(),
+        readable: Joi.boolean(),
+        parameters: Joi.array().items(Joi.object({
+            name: Joi.string(),
+            default: Joi.string().allow(""),
+        })),
+        queryVerb: Joi.string().allow().required(),
+        extra: Joi.object().optional(),
+        schema: Joi.object({}).required().unknown(true),
+        transformer: Joi.string().optional(),
+        flags: Joi.object().optional(),
+    });
+};
+exports.generateQueryValidation = () => {
+    // prettier-ignore
+    return joiValidator.body(exports.queryValidation());
+};
+exports.generateQueryPreviewValidation = () => {
+    // prettier-ignore
+    return joiValidator.body(Joi.object({
+        fields: Joi.object().required(),
+        queryVerb: Joi.string().allow().required(),
+        extra: Joi.object().optional(),
+        datasourceId: Joi.string().required(),
+        transformer: Joi.string().optional(),
+        parameters: Joi.object({}).required().unknown(true),
+        queryId: Joi.string().optional(),
+    }));
+};

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

@@ -23,7 +23,7 @@ const CouchDB = require("../../../db");
 const linkRows = require("../../../db/linkedRows");
 const { getRowParams, generateRowID, DocumentTypes, InternalTables, } = require("../../../db/utils");
 const userController = require("../user");
-const { inputProcessing, outputProcessing, processAutoColumn, } = require("../../../utilities/rowProcessor");
+const { inputProcessing, outputProcessing, processAutoColumn, cleanupAttachments, } = require("../../../utilities/rowProcessor");
 const { FieldTypes } = require("../../../constants");
 const { isEqual } = require("lodash");
 const { validate, findRow } = require("./utils");
@@ -32,6 +32,7 @@ const { getGlobalUsersFromMetadata } = require("../../../utilities/global");
 const inMemoryViews = require("../../../db/inMemoryView");
 const env = require("../../../environment");
 const { migrateToInMemoryView, migrateToDesignView, getFromDesignDoc, getFromMemoryDoc, } = require("../view/utils");
+const { cloneDeep } = require("lodash/fp");
 const CALCULATION_TYPES = {
     SUM: "sum",
     COUNT: "count",
@@ -119,15 +120,15 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const inputs = ctx.request.body;
     const tableId = inputs.tableId;
     const isUserTable = tableId === InternalTables.USER_METADATA;
-    let dbRow;
+    let oldRow;
     try {
-        dbRow = yield db.get(inputs._id);
+        oldRow = yield db.get(inputs._id);
     }
     catch (err) {
         if (isUserTable) {
             // don't include the rev, it'll be the global rev
             // this time
-            dbRow = {
+            oldRow = {
                 _id: inputs._id,
             };
         }
@@ -137,13 +138,14 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     let dbTable = yield db.get(tableId);
     // need to build up full patch fields before coerce
+    let combinedRow = cloneDeep(oldRow);
     for (let key of Object.keys(inputs)) {
         if (!dbTable.schema[key])
             continue;
-        dbRow[key] = inputs[key];
+        combinedRow[key] = inputs[key];
     }
     // this returns the table and row incase they have been updated
-    let { table, row } = inputProcessing(ctx.user, dbTable, dbRow);
+    let { table, row } = inputProcessing(ctx.user, dbTable, combinedRow);
     const validateResult = yield validate({
         row,
         table,
@@ -159,6 +161,8 @@ exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         tableId: row.tableId,
         table,
     });
+    // check if any attachments removed
+    yield cleanupAttachments(appId, table, { oldRow, row });
     if (isUserTable) {
         // the row has been updated, need to put it into the ctx
         ctx.request.body = row;
@@ -284,6 +288,8 @@ exports.destroy = function (ctx) {
             row,
             tableId: row.tableId,
         });
+        // remove any attachments that were on the row from object storage
+        yield cleanupAttachments(appId, table, { row });
         let response;
         if (ctx.params.tableId === InternalTables.USER_METADATA) {
             ctx.params = {
@@ -325,6 +331,8 @@ exports.bulkDestroy = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     else {
         yield db.bulkDocs(rows.map(row => (Object.assign(Object.assign({}, row), { _deleted: true }))));
     }
+    // remove any attachments that were on the rows from object storage
+    yield cleanupAttachments(appId, table, { rows });
     yield Promise.all(updates);
     return { response: { ok: true }, rows };
 });

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

@@ -172,7 +172,8 @@ class QueryBuilder {
         }
         if (this.query.equal) {
             build(this.query.equal, (key, value) => {
-                if (!value) {
+                // 0 evaluates to false, which means we would return all rows if we don't check it
+                if (!value && value !== 0) {
                     return null;
                 }
                 return `${key}:${builder.preprocess(value, allPreProcessingOpts)}`;

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

@@ -57,24 +57,31 @@ exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0,
     const errors = {};
     for (let fieldName of Object.keys(table.schema)) {
         const constraints = cloneDeep(table.schema[fieldName].constraints);
+        const type = table.schema[fieldName].type;
         // special case for options, need to always allow unselected (null)
-        if (table.schema[fieldName].type ===
-            (FieldTypes.OPTIONS || FieldTypes.ARRAY) &&
+        if ((type === FieldTypes.OPTIONS || type === FieldTypes.ARRAY) &&
             constraints.inclusion) {
             constraints.inclusion.push(null);
         }
         let res;
         // Validate.js doesn't seem to handle array
-        if (table.schema[fieldName].type === FieldTypes.ARRAY &&
-            row[fieldName] &&
-            row[fieldName].length) {
+        if (type === FieldTypes.ARRAY && row[fieldName] && row[fieldName].length) {
             row[fieldName].map(val => {
                 if (!constraints.inclusion.includes(val)) {
                     errors[fieldName] = "Field not in list";
                 }
             });
         }
-        else if (table.schema[fieldName].type === FieldTypes.FORMULA) {
+        else if (type === FieldTypes.JSON && typeof row[fieldName] === "string") {
+            // this should only happen if there is an error
+            try {
+                JSON.parse(row[fieldName]);
+            }
+            catch (err) {
+                errors[fieldName] = [`Contains invalid JSON`];
+            }
+        }
+        else if (type === FieldTypes.FORMULA) {
             res = validateJs.single(processStringSync(table.schema[fieldName].formula, row), constraints);
         }
         else {

package/dist/api/controllers/user.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const CouchDB = require("../../db");
-const { generateUserMetadataID, getUserMetadataParams, } = require("../../db/utils");
+const { generateUserMetadataID, getUserMetadataParams, generateUserFlagID, } = require("../../db/utils");
 const { InternalTables } = require("../../db/utils");
 const { getGlobalUsers, getRawGlobalUser } = require("../../utilities/global");
 const { getFullUser } = require("../../utilities/users");
@@ -189,3 +189,39 @@ exports.findMetadata = function (ctx) {
         ctx.body = yield getFullUser(ctx, ctx.params.id);
     });
 };
+exports.setFlag = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const userId = ctx.user._id;
+        const { flag, value } = ctx.request.body;
+        if (!flag) {
+            ctx.throw(400, "Must supply a 'flag' field in request body.");
+        }
+        const flagDocId = generateUserFlagID(userId);
+        const db = new CouchDB(ctx.appId);
+        let doc;
+        try {
+            doc = yield db.get(flagDocId);
+        }
+        catch (err) {
+            doc = { _id: flagDocId };
+        }
+        doc[flag] = value || true;
+        yield db.put(doc);
+        ctx.body = { message: "Flag set successfully" };
+    });
+};
+exports.getFlags = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const userId = ctx.user._id;
+        const docId = generateUserFlagID(userId);
+        const db = new CouchDB(ctx.appId);
+        let doc;
+        try {
+            doc = yield db.get(docId);
+        }
+        catch (err) {
+            doc = { _id: docId };
+        }
+        ctx.body = doc;
+    });
+};

package/dist/api/controllers/webhook.js

@@ -65,6 +65,10 @@ exports.buildSchema = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         let automation = yield db.get(webhook.action.target);
         const autoOutputs = automation.definition.trigger.schema.outputs;
         let properties = webhook.bodySchema.properties;
+        // reset webhook outputs
+        autoOutputs.properties = {
+            body: autoOutputs.properties.body,
+        };
         for (let prop of Object.keys(properties)) {
             autoOutputs.properties[prop] = {
                 type: properties[prop].type,

package/dist/api/routes/query.js

@@ -2,46 +2,18 @@
 const Router = require("@koa/router");
 const queryController = require("../controllers/query");
 const authorized = require("../../middleware/authorized");
-const Joi = require("joi");
 const { PermissionLevels, PermissionTypes, BUILDER, } = require("@budibase/auth/permissions");
-const joiValidator = require("../../middleware/joi-validator");
 const { bodyResource, bodySubResource, paramResource, } = require("../../middleware/resourceId");
+const { generateQueryPreviewValidation, generateQueryValidation, } = require("../controllers/query/validation");
 const router = Router();
-function generateQueryValidation() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        _id: Joi.string(),
-        _rev: Joi.string(),
-        name: Joi.string().required(),
-        fields: Joi.object().required(),
-        datasourceId: Joi.string().required(),
-        readable: Joi.boolean(),
-        parameters: Joi.array().items(Joi.object({
-            name: Joi.string(),
-            default: Joi.string().allow(""),
-        })),
-        queryVerb: Joi.string().allow().required(),
-        extra: Joi.object().optional(),
-        schema: Joi.object({}).required().unknown(true),
-        transformer: Joi.string().optional(),
-    }));
-}
-function generateQueryPreviewValidation() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        fields: Joi.object().required(),
-        queryVerb: Joi.string().allow().required(),
-        extra: Joi.object().optional(),
-        datasourceId: Joi.string().required(),
-        transformer: Joi.string().optional(),
-        parameters: Joi.object({}).required().unknown(true)
-    }));
-}
 router
     .get("/api/queries", authorized(BUILDER), queryController.fetch)
     .post("/api/queries", bodySubResource("datasourceId", "_id"), authorized(BUILDER), generateQueryValidation(), queryController.save)
+    .post("/api/queries/import", authorized(BUILDER), queryController.import)
     .post("/api/queries/preview", bodyResource("datasourceId"), authorized(BUILDER), generateQueryPreviewValidation(), queryController.preview)
     .get("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.READ), queryController.find)
-    .post("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.WRITE), queryController.execute)
+    // DEPRECATED - use new query endpoint for future work
+    .post("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.WRITE), queryController.executeV1)
+    .post("/api/v2/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.WRITE), queryController.executeV2)
     .delete("/api/queries/:queryId/:revId", paramResource("queryId"), authorized(BUILDER), queryController.destroy);
 module.exports = router;

package/dist/api/routes/user.js

@@ -10,5 +10,7 @@ router
     .put("/api/users/metadata", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.updateMetadata)
     .post("/api/users/metadata/self", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.updateSelfMetadata)
     .delete("/api/users/metadata/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.destroyMetadata)
-    .post("/api/users/metadata/sync/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.syncUser);
+    .post("/api/users/metadata/sync/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.syncUser)
+    .post("/api/users/flags", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.setFlag)
+    .get("/api/users/flags", authorized(PermissionTypes.USER, PermissionLevels.READ), controller.getFlags);
 module.exports = router;

package/dist/automations/steps/executeQuery.js

@@ -55,6 +55,10 @@ exports.definition = {
                     type: "object",
                     description: "The response from the datasource execution",
                 },
+                info: {
+                    type: "object",
+                    description: "Some query types may return extra data, like headers from a REST query",
+                },
                 success: {
                     type: "boolean",
                     description: "Whether the action was successful",
@@ -85,14 +89,17 @@ exports.run = function ({ inputs, appId, emitter }) {
         });
         try {
             yield queryController.execute(ctx);
+            const _b = ctx.body, { data } = _b, rest = __rest(_b, ["data"]);
             return {
-                response: ctx.body,
+                response: data,
+                info: rest,
                 success: true,
             };
         }
         catch (err) {
             return {
                 success: false,
+                info: {},
                 response: automationUtils.getError(err),
             };
         }

package/dist/automations/steps/outgoingWebhook.js

@@ -20,11 +20,10 @@ const RequestType = {
 };
 const BODY_REQUESTS = [RequestType.POST, RequestType.PUT, RequestType.PATCH];
 /**
- * Note, there is some functionality in this that is not currently exposed as it
- * is complex and maybe better to be opinionated here.
- * GET/DELETE requests cannot handle body elements so they will not be sent if configured.
+ * NOTE: this functionality is deprecated - it no longer should be used.
  */
 exports.definition = {
+    deprecated: true,
     name: "Outgoing webhook",
     tagline: "Send a {{inputs.requestMethod}} request",
     icon: "Send",

package/dist/automations/utils.js

@@ -17,6 +17,7 @@ const newid = require("../db/newid");
 const { updateEntityMetadata } = require("../utilities");
 const { MetadataTypes } = require("../constants");
 const { getDeployedAppID } = require("@budibase/auth/db");
+const { cloneDeep } = require("lodash/fp");
 const WH_STEP_ID = definitions.WEBHOOK.stepId;
 const CRON_STEP_ID = definitions.CRON.stepId;
 const Runner = new Thread(ThreadType.AUTOMATION);
@@ -43,6 +44,15 @@ exports.updateTestHistory = (appId, automation, history) => __awaiter(void 0, vo
         return metadata;
     });
 });
+exports.removeDeprecated = definitions => {
+    const base = cloneDeep(definitions);
+    for (let key of Object.keys(base)) {
+        if (base[key].deprecated) {
+            delete base[key];
+        }
+    }
+    return base;
+};
 // end the repetition and the job itself
 exports.disableAllCrons = (appId) => __awaiter(void 0, void 0, void 0, function* () {
     const promises = [];

package/dist/db/utils.js

@@ -28,6 +28,7 @@ const DocumentTypes = {
     DEPLOYMENTS: "deployments",
     METADATA: "metadata",
     MEM_VIEW: "view",
+    USER_FLAG: "flag",
 };
 const ViewNames = {
     LINK: "by_link",
@@ -271,6 +272,13 @@ exports.getQueryParams = (datasourceId = null, otherProps = {}) => {
     }
     return getDocParams(DocumentTypes.QUERY, `${datasourceId}${SEPARATOR}`, otherProps);
 };
+/**
+ * Generates a new flag document ID.
+ * @returns {string} The ID of the flag document that was generated.
+ */
+exports.generateUserFlagID = userId => {
+    return `${DocumentTypes.USER_FLAG}${SEPARATOR}${userId}`;
+};
 exports.generateMetadataID = (type, entityId) => {
     return `${DocumentTypes.METADATA}${SEPARATOR}${type}${SEPARATOR}${entityId}`;
 };

package/dist/definitions/datasource.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterTypes = exports.IncludeRelationships = exports.SourceNames = exports.DatasourceFieldTypes = exports.QueryTypes = exports.SortDirection = exports.Operation = void 0;
+exports.AuthType = exports.FilterTypes = exports.IncludeRelationships = exports.SourceNames = exports.DatasourceFieldTypes = exports.QueryTypes = exports.SortDirection = exports.Operation = void 0;
 var Operation;
 (function (Operation) {
     Operation["CREATE"] = "CREATE";
@@ -66,3 +66,8 @@ var FilterTypes;
     FilterTypes["NOT_EMPTY"] = "notEmpty";
     FilterTypes["ONE_OF"] = "oneOf";
 })(FilterTypes = exports.FilterTypes || (exports.FilterTypes = {}));
+var AuthType;
+(function (AuthType) {
+    AuthType["BASIC"] = "basic";
+    AuthType["BEARER"] = "bearer";
+})(AuthType = exports.AuthType || (exports.AuthType = {}));

package/dist/integrations/base/sqlTable.js

@@ -29,7 +29,7 @@ function generateSchema(schema, table, tables, oldTable = null) {
             case FieldTypes.STRING:
             case FieldTypes.OPTIONS:
             case FieldTypes.LONGFORM:
-                schema.string(key);
+                schema.text(key);
                 break;
             case FieldTypes.NUMBER:
                 // if meta is specified then this is a junction table entry