@budibase/server 2.6.22 → 2.6.24-alpha.0

package/dist/integrations/base/sqlTable.js

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const knex_1 = require("knex");
-const types_1 = require("@budibase/types");
-const utils_1 = require("../utils");
-const constants_1 = require("../../constants");
-function generateSchema(schema, table, tables, oldTable = null, renamed) {
-    let primaryKey = table && table.primary ? table.primary[0] : null;
-    const columns = Object.values(table.schema);
-    // all columns in a junction table will be meta
-    let metaCols = columns.filter(col => col.meta);
-    let isJunction = metaCols.length === columns.length;
-    // can't change primary once its set for now
-    if (primaryKey && !oldTable && !isJunction) {
-        schema.increments(primaryKey).primary();
-    }
-    else if (!oldTable && isJunction) {
-        schema.primary(metaCols.map(col => col.name));
-    }
-    // check if any columns need added
-    const foreignKeys = Object.values(table.schema).map(col => col.foreignKey);
-    for (let [key, column] of Object.entries(table.schema)) {
-        // skip things that are already correct
-        const oldColumn = oldTable ? oldTable.schema[key] : null;
-        if ((oldColumn && oldColumn.type) ||
-            (primaryKey === key && !isJunction) ||
-            (renamed === null || renamed === void 0 ? void 0 : renamed.updated) === key) {
-            continue;
-        }
-        switch (column.type) {
-            case constants_1.FieldTypes.STRING:
-            case constants_1.FieldTypes.OPTIONS:
-            case constants_1.FieldTypes.LONGFORM:
-            case constants_1.FieldTypes.BARCODEQR:
-                schema.text(key);
-                break;
-            case constants_1.FieldTypes.NUMBER:
-                // if meta is specified then this is a junction table entry
-                if (column.meta && column.meta.toKey && column.meta.toTable) {
-                    const { toKey, toTable } = column.meta;
-                    schema.integer(key).unsigned();
-                    schema.foreign(key).references(`${toTable}.${toKey}`);
-                }
-                else if (foreignKeys.indexOf(key) === -1) {
-                    schema.float(key);
-                }
-                break;
-            case constants_1.FieldTypes.BOOLEAN:
-                schema.boolean(key);
-                break;
-            case constants_1.FieldTypes.DATETIME:
-                schema.datetime(key, {
-                    useTz: !column.ignoreTimezones,
-                });
-                break;
-            case constants_1.FieldTypes.ARRAY:
-                schema.json(key);
-                break;
-            case constants_1.FieldTypes.LINK:
-                // this side of the relationship doesn't need any SQL work
-                if (column.relationshipType !== constants_1.RelationshipTypes.MANY_TO_ONE &&
-                    column.relationshipType !== constants_1.RelationshipTypes.MANY_TO_MANY) {
-                    if (!column.foreignKey || !column.tableId) {
-                        throw "Invalid relationship schema";
-                    }
-                    const { tableName } = (0, utils_1.breakExternalTableId)(column.tableId);
-                    // @ts-ignore
-                    const relatedTable = tables[tableName];
-                    if (!relatedTable) {
-                        throw "Referenced table doesn't exist";
-                    }
-                    const relatedPrimary = relatedTable.primary[0];
-                    const externalType = relatedTable.schema[relatedPrimary].externalType;
-                    if (externalType) {
-                        schema.specificType(column.foreignKey, externalType);
-                    }
-                    else {
-                        schema.integer(column.foreignKey).unsigned();
-                    }
-                    schema
-                        .foreign(column.foreignKey)
-                        .references(`${tableName}.${relatedPrimary}`);
-                }
-                break;
-        }
-    }
-    if (renamed) {
-        schema.renameColumn(renamed.old, renamed.updated);
-    }
-    // need to check if any columns have been deleted
-    if (oldTable) {
-        const deletedColumns = Object.entries(oldTable.schema)
-            .filter(([key, schema]) => schema.type !== constants_1.FieldTypes.LINK &&
-            schema.type !== constants_1.FieldTypes.FORMULA &&
-            table.schema[key] == null)
-            .map(([key]) => key);
-        deletedColumns.forEach(key => {
-            if ((renamed === null || renamed === void 0 ? void 0 : renamed.old) === key) {
-                return;
-            }
-            if (oldTable.constrained && oldTable.constrained.indexOf(key) !== -1) {
-                schema.dropForeign(key);
-            }
-            schema.dropColumn(key);
-        });
-    }
-    return schema;
-}
-function buildCreateTable(knex, table, tables) {
-    return knex.createTable(table.name, schema => {
-        generateSchema(schema, table, tables);
-    });
-}
-function buildUpdateTable(knex, table, tables, oldTable, renamed) {
-    return knex.alterTable(table.name, schema => {
-        generateSchema(schema, table, tables, oldTable, renamed);
-    });
-}
-function buildDeleteTable(knex, table) {
-    return knex.dropTable(table.name);
-}
-class SqlTableQueryBuilder {
-    // pass through client to get flavour of SQL
-    constructor(client) {
-        this.sqlClient = client;
-    }
-    getSqlClient() {
-        return this.sqlClient;
-    }
-    /**
-     * @param json the input JSON structure from which an SQL query will be built.
-     * @return {string} the operation that was found in the JSON.
-     */
-    _operation(json) {
-        return json.endpoint.operation;
-    }
-    _tableQuery(json) {
-        var _a;
-        let client = (0, knex_1.knex)({ client: this.sqlClient }).schema;
-        if ((_a = json === null || json === void 0 ? void 0 : json.endpoint) === null || _a === void 0 ? void 0 : _a.schema) {
-            client = client.withSchema(json.endpoint.schema);
-        }
-        let query;
-        if (!json.table || !json.meta || !json.meta.tables) {
-            throw "Cannot execute without table being specified";
-        }
-        switch (this._operation(json)) {
-            case types_1.Operation.CREATE_TABLE:
-                query = buildCreateTable(client, json.table, json.meta.tables);
-                break;
-            case types_1.Operation.UPDATE_TABLE:
-                if (!json.meta || !json.meta.table) {
-                    throw "Must specify old table for update";
-                }
-                query = buildUpdateTable(client, json.table, json.meta.tables, json.meta.table, json.meta.renamed);
-                break;
-            case types_1.Operation.DELETE_TABLE:
-                query = buildDeleteTable(client, json.table);
-                break;
-            default:
-                throw "Table operation is of unknown type";
-        }
-        return query.toSQL();
-    }
-}
-exports.default = SqlTableQueryBuilder;
-module.exports = SqlTableQueryBuilder;

package/dist/integrations/base/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/integrations/couchdb.js

@@ -1,125 +0,0 @@
-"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 });
-const types_1 = require("@budibase/types");
-const backend_core_1 = require("@budibase/backend-core");
-const SCHEMA = {
-    docs: "https://docs.couchdb.org/en/stable/",
-    friendlyName: "CouchDB",
-    type: "Non-relational",
-    description: "Apache CouchDB is an open-source document-oriented NoSQL database, implemented in Erlang.",
-    datasource: {
-        url: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-            default: "http://localhost:5984",
-        },
-        database: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.JSON,
-        },
-        read: {
-            type: types_1.QueryType.JSON,
-        },
-        update: {
-            type: types_1.QueryType.JSON,
-        },
-        get: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                id: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        delete: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                id: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-    },
-};
-class CouchDBIntegration {
-    constructor(config) {
-        this.config = config;
-        this.client = backend_core_1.db.DatabaseWithConnection(config.database, config.url);
-    }
-    query(command, errorMsg, query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.client[command](query.id || query.json);
-            }
-            catch (err) {
-                console.error(errorMsg, err);
-                throw err;
-            }
-        });
-    }
-    parse(query) {
-        return typeof query.json === "string" ? JSON.parse(query.json) : query.json;
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parsed = this.parse(query);
-            return this.query("post", "Error writing to couchDB", { json: parsed });
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parsed = this.parse(query);
-            const result = yield this.query("allDocs", "Error querying couchDB", {
-                json: Object.assign({ include_docs: true }, parsed),
-            });
-            return result.rows.map((row) => row.doc);
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parsed = this.parse(query);
-            if (!(parsed === null || parsed === void 0 ? void 0 : parsed._rev) && (parsed === null || parsed === void 0 ? void 0 : parsed._id)) {
-                const oldDoc = yield this.get({ id: parsed._id });
-                parsed._rev = oldDoc._rev;
-            }
-            return this.query("put", "Error updating couchDB document", {
-                json: parsed,
-            });
-        });
-    }
-    get(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.query("get", "Error retrieving couchDB document by ID", {
-                id: query.id,
-            });
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const doc = yield this.query("get", "Cannot find doc to be deleted", query);
-            return this.query("remove", "Error deleting couchDB document", {
-                json: doc,
-            });
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: CouchDBIntegration,
-};

package/dist/integrations/dynamodb.js

@@ -1,194 +0,0 @@
-"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 });
-const types_1 = require("@budibase/types");
-const aws_sdk_1 = __importDefault(require("aws-sdk"));
-const dynamoClient_1 = require("../db/dynamoClient");
-const SCHEMA = {
-    docs: "https://github.com/dabit3/dynamodb-documentclient-cheat-sheet",
-    description: "Amazon DynamoDB is a key-value and document database that delivers single-digit millisecond performance at any scale.",
-    friendlyName: "DynamoDB",
-    type: "Non-relational",
-    datasource: {
-        region: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-            default: "us-east-1",
-        },
-        accessKeyId: {
-            type: types_1.DatasourceFieldType.PASSWORD,
-            required: true,
-        },
-        secretAccessKey: {
-            type: types_1.DatasourceFieldType.PASSWORD,
-            required: true,
-        },
-        endpoint: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: false,
-            default: "https://dynamodb.us-east-1.amazonaws.com",
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        read: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            readable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                index: {
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-            },
-        },
-        scan: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            readable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                index: {
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-            },
-        },
-        describe: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            readable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        get: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            readable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        update: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        delete: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            fields: {
-                table: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-    },
-};
-class DynamoDBIntegration {
-    constructor(config) {
-        var _a, _b;
-        this.config = config;
-        // User is using a local dynamoDB endpoint, don't auth with remote
-        if ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.endpoint) === null || _b === void 0 ? void 0 : _b.includes("localhost")) {
-            // @ts-ignore
-            this.config = {};
-        }
-        this.config = Object.assign(Object.assign({}, this.config), { currentClockSkew: true, region: config.region || dynamoClient_1.AWS_REGION, endpoint: config.endpoint || undefined });
-        this.client = new aws_sdk_1.default.DynamoDB.DocumentClient(this.config);
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ TableName: query.table }, query.json);
-            return this.client.put(params).promise();
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ TableName: query.table, IndexName: query.index ? query.index : undefined }, query.json);
-            const response = yield this.client.query(params).promise();
-            if (response.Items) {
-                return response.Items;
-            }
-            return response;
-        });
-    }
-    scan(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ TableName: query.table, IndexName: query.index ? query.index : undefined }, query.json);
-            const response = yield this.client.scan(params).promise();
-            if (response.Items) {
-                return response.Items;
-            }
-            return response;
-        });
-    }
-    describe(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                TableName: query.table,
-            };
-            return new aws_sdk_1.default.DynamoDB(this.config).describeTable(params).promise();
-        });
-    }
-    get(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ TableName: query.table }, query.json);
-            return this.client.get(params).promise();
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ TableName: query.table }, query.json);
-            return this.client.update(params).promise();
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const params = Object.assign({ TableName: query.table }, query.json);
-            return this.client.delete(params).promise();
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: DynamoDBIntegration,
-};

package/dist/integrations/elasticsearch.js

@@ -1,186 +0,0 @@
-"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 });
-const types_1 = require("@budibase/types");
-const elasticsearch_1 = require("@elastic/elasticsearch");
-const SCHEMA = {
-    docs: "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
-    description: "Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents.",
-    friendlyName: "ElasticSearch",
-    type: "Non-relational",
-    datasource: {
-        url: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-            default: "http://localhost:9200",
-        },
-        ssl: {
-            type: types_1.DatasourceFieldType.BOOLEAN,
-            default: false,
-            required: false,
-        },
-        rejectUnauthorized: {
-            type: types_1.DatasourceFieldType.BOOLEAN,
-            default: true,
-            required: false,
-        },
-        ca: {
-            type: types_1.DatasourceFieldType.LONGFORM,
-            default: false,
-            required: false,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            fields: {
-                index: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        read: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            fields: {
-                index: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        update: {
-            type: types_1.QueryType.FIELDS,
-            customisable: true,
-            fields: {
-                id: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                index: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        delete: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                id: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                index: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-    },
-};
-class ElasticSearchIntegration {
-    constructor(config) {
-        this.config = config;
-        const clientConfig = {
-            node: this.config.url,
-        };
-        if (this.config.ssl) {
-            clientConfig.ssl = {
-                rejectUnauthorized: this.config.rejectUnauthorized,
-                ca: this.config.ca || undefined,
-            };
-        }
-        this.client = new elasticsearch_1.Client(clientConfig);
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { index, json } = query;
-            try {
-                const result = yield this.client.index({
-                    index,
-                    body: json,
-                });
-                return result.body;
-            }
-            catch (err) {
-                console.error("Error writing to elasticsearch", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { index, json } = query;
-            try {
-                const result = yield this.client.search({
-                    index: index,
-                    body: json,
-                });
-                return result.body.hits.hits.map(({ _source }) => _source);
-            }
-            catch (err) {
-                console.error("Error querying elasticsearch", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { id, index, json } = query;
-            try {
-                const result = yield this.client.update({
-                    id,
-                    index,
-                    body: json,
-                });
-                return result.body;
-            }
-            catch (err) {
-                console.error("Error querying elasticsearch", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { id, index } = query;
-            try {
-                const result = yield this.client.delete({
-                    id,
-                    index,
-                });
-                return result.body;
-            }
-            catch (err) {
-                console.error("Error deleting from elasticsearch", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: ElasticSearchIntegration,
-};