@budibase/server 2.6.23 → 2.6.24-alpha.0

package/dist/integrations/firebase.js

@@ -1,174 +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 firestore_1 = require("@google-cloud/firestore");
-const SCHEMA = {
-    docs: "https://firebase.google.com/docs/firestore/quickstart",
-    friendlyName: "Firestore",
-    type: "Non-relational",
-    description: "Cloud Firestore is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud.",
-    datasource: {
-        email: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-        privateKey: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-        projectId: {
-            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,
-        },
-        delete: {
-            type: types_1.QueryType.JSON,
-        },
-    },
-    extra: {
-        collection: {
-            displayName: "Collection",
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-        filterField: {
-            displayName: "Filter field",
-            type: types_1.DatasourceFieldType.STRING,
-            required: false,
-        },
-        filter: {
-            displayName: "Filter comparison",
-            type: types_1.DatasourceFieldType.LIST,
-            required: false,
-            data: {
-                read: [
-                    "==",
-                    "<",
-                    "<=",
-                    "!=",
-                    ">=",
-                    ">",
-                    "array-contains",
-                    "in",
-                    "not-in",
-                    "array-contains-any",
-                ],
-            },
-        },
-        filterValue: {
-            displayName: "Filter value",
-            type: types_1.DatasourceFieldType.STRING,
-            required: false,
-        },
-    },
-};
-class FirebaseIntegration {
-    constructor(config) {
-        var _a;
-        this.config = config;
-        this.client = new firestore_1.Firestore({
-            projectId: config.projectId,
-            credentials: {
-                client_email: config.email,
-                private_key: (_a = config.privateKey) === null || _a === void 0 ? void 0 : _a.replace(/\\n/g, "\n"),
-            },
-        });
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const documentReference = this.client
-                    .collection(query.extra.collection)
-                    .doc();
-                yield documentReference.set(Object.assign(Object.assign({}, query.json), { id: documentReference.id }));
-                const snapshot = yield documentReference.get();
-                return snapshot.data();
-            }
-            catch (err) {
-                console.error("Error writing to Firestore", err);
-                throw err;
-            }
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let snapshot;
-                const collectionRef = this.client.collection(query.extra.collection);
-                if (query.extra.filterField &&
-                    query.extra.filter &&
-                    query.extra.filterValue) {
-                    snapshot = yield collectionRef
-                        .where(query.extra.filterField, query.extra.filter, query.extra.filterValue)
-                        .get();
-                }
-                else {
-                    snapshot = yield collectionRef.get();
-                }
-                const result = [];
-                snapshot.forEach(doc => result.push(doc.data()));
-                return result;
-            }
-            catch (err) {
-                console.error("Error querying Firestore", err);
-                throw err;
-            }
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.client
-                    .collection(query.extra.collection)
-                    .doc(query.json.id)
-                    .update(query.json);
-                return (yield this.client
-                    .collection(query.extra.collection)
-                    .doc(query.json.id)
-                    .get()).data();
-            }
-            catch (err) {
-                console.error("Error writing to Firestore", err);
-                throw err;
-            }
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.client
-                    .collection(query.extra.collection)
-                    .doc(query.json.id)
-                    .delete();
-                return true;
-            }
-            catch (err) {
-                console.error("Error deleting from Firestore", err);
-                throw err;
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: FirebaseIntegration,
-};

package/dist/integrations/googlesheets.js

@@ -1,455 +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 google_auth_library_1 = require("google-auth-library");
-const utils_1 = require("./utils");
-const google_spreadsheet_1 = require("google-spreadsheet");
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const backend_core_1 = require("@budibase/backend-core");
-const shared_core_1 = require("@budibase/shared-core");
-const constants_1 = require("../constants");
-const ALLOWED_TYPES = [
-    types_1.FieldType.STRING,
-    types_1.FieldType.FORMULA,
-    types_1.FieldType.NUMBER,
-    types_1.FieldType.LONGFORM,
-    types_1.FieldType.DATETIME,
-    types_1.FieldType.OPTIONS,
-    types_1.FieldType.BOOLEAN,
-    types_1.FieldType.BARCODEQR,
-];
-const SCHEMA = {
-    plus: true,
-    auth: {
-        type: "google",
-    },
-    relationships: false,
-    docs: "https://developers.google.com/sheets/api/quickstart/nodejs",
-    description: "Create and collaborate on online spreadsheets in real-time and from any device. ",
-    friendlyName: "Google Sheets",
-    type: "Spreadsheet",
-    datasource: {
-        spreadsheetId: {
-            display: "Google Sheet URL",
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                sheet: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                row: {
-                    type: types_1.QueryType.JSON,
-                    required: true,
-                },
-            },
-        },
-        read: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                sheet: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        update: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                sheet: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                rowIndex: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                row: {
-                    type: types_1.QueryType.JSON,
-                    required: true,
-                },
-            },
-        },
-        delete: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                sheet: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                rowIndex: {
-                    type: types_1.DatasourceFieldType.NUMBER,
-                    required: true,
-                },
-            },
-        },
-    },
-};
-class GoogleSheetsIntegration {
-    constructor(config) {
-        this.tables = {};
-        this.schemaErrors = {};
-        this.config = config;
-        const spreadsheetId = this.cleanSpreadsheetUrl(this.config.spreadsheetId);
-        this.client = new google_spreadsheet_1.GoogleSpreadsheet(spreadsheetId);
-    }
-    getBindingIdentifier() {
-        return "";
-    }
-    getStringConcat(parts) {
-        return "";
-    }
-    /**
-     * Pull the spreadsheet ID out from a valid google sheets URL
-     * @param spreadsheetId - the URL or standard spreadsheetId of the google sheet
-     * @returns spreadsheet Id of the google sheet
-     */
-    cleanSpreadsheetUrl(spreadsheetId) {
-        if (!spreadsheetId) {
-            throw new Error("You must set a spreadsheet ID in your configuration to fetch tables.");
-        }
-        const parts = spreadsheetId.split("/");
-        return parts.length > 5 ? parts[5] : spreadsheetId;
-    }
-    fetchAccessToken(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield (0, node_fetch_1.default)("https://www.googleapis.com/oauth2/v4/token", {
-                method: "POST",
-                body: JSON.stringify(Object.assign(Object.assign({}, payload), { grant_type: "refresh_token" })),
-                headers: {
-                    "Content-Type": "application/json",
-                },
-            });
-            const json = yield response.json();
-            if (response.status !== 200) {
-                throw new Error(`Error authenticating with google sheets. ${json.error_description}`);
-            }
-            return json;
-        });
-    }
-    connect() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Initialise oAuth client
-                let googleConfig = yield backend_core_1.configs.getGoogleDatasourceConfig();
-                if (!googleConfig) {
-                    throw new backend_core_1.HTTPError("Google config not found", 400);
-                }
-                const oauthClient = new google_auth_library_1.OAuth2Client({
-                    clientId: googleConfig.clientID,
-                    clientSecret: googleConfig.clientSecret,
-                });
-                const tokenResponse = yield this.fetchAccessToken({
-                    client_id: googleConfig.clientID,
-                    client_secret: googleConfig.clientSecret,
-                    refresh_token: this.config.auth.refreshToken,
-                });
-                oauthClient.setCredentials({
-                    refresh_token: this.config.auth.refreshToken,
-                    access_token: tokenResponse.access_token,
-                });
-                this.client.useOAuth2Client(oauthClient);
-                yield this.client.loadInfo();
-            }
-            catch (err) {
-                // this happens for xlsx imports
-                if ((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes("operation is not supported")) {
-                    err.message =
-                        "This operation is not supported - XLSX sheets must be converted.";
-                }
-                console.error("Error connecting to google sheets", err);
-                throw err;
-            }
-        });
-    }
-    getTableSchema(title, headerValues, id) {
-        // base table
-        const table = {
-            name: title,
-            primary: [constants_1.GOOGLE_SHEETS_PRIMARY_KEY],
-            schema: {},
-        };
-        if (id) {
-            table._id = id;
-        }
-        // build schema from headers
-        for (let header of headerValues) {
-            table.schema[header] = {
-                name: header,
-                type: types_1.FieldType.STRING,
-            };
-        }
-        return table;
-    }
-    buildSchema(datasourceId, entities) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // not fully configured yet
-            if (!this.config.auth) {
-                return;
-            }
-            yield this.connect();
-            const sheets = this.client.sheetsByIndex;
-            const tables = {};
-            for (let sheet of sheets) {
-                // must fetch rows to determine schema
-                yield sheet.getRows();
-                const id = (0, utils_1.buildExternalTableId)(datasourceId, sheet.title);
-                tables[sheet.title] = this.getTableSchema(sheet.title, sheet.headerValues, id);
-            }
-            const final = (0, utils_1.finaliseExternalTables)(tables, entities);
-            this.tables = final.tables;
-            this.schemaErrors = final.errors;
-        });
-    }
-    query(json) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        return __awaiter(this, void 0, void 0, function* () {
-            const sheet = json.endpoint.entityId;
-            switch (json.endpoint.operation) {
-                case types_1.Operation.CREATE:
-                    return this.create({ sheet, row: json.body });
-                case types_1.Operation.BULK_CREATE:
-                    return this.createBulk({ sheet, rows: json.body });
-                case types_1.Operation.READ:
-                    return this.read(Object.assign(Object.assign({}, json), { sheet }));
-                case types_1.Operation.UPDATE:
-                    return this.update({
-                        // exclude the header row and zero index
-                        rowIndex: ((_c = (_b = (_a = json.extra) === null || _a === void 0 ? void 0 : _a.idFilter) === null || _b === void 0 ? void 0 : _b.equal) === null || _c === void 0 ? void 0 : _c.rowNumber) - 2,
-                        sheet,
-                        row: json.body,
-                    });
-                case types_1.Operation.DELETE:
-                    return this.delete({
-                        // exclude the header row and zero index
-                        rowIndex: ((_f = (_e = (_d = json.extra) === null || _d === void 0 ? void 0 : _d.idFilter) === null || _e === void 0 ? void 0 : _e.equal) === null || _f === void 0 ? void 0 : _f.rowNumber) - 2,
-                        sheet,
-                    });
-                case types_1.Operation.CREATE_TABLE:
-                    return this.createTable((_g = json === null || json === void 0 ? void 0 : json.table) === null || _g === void 0 ? void 0 : _g.name);
-                case types_1.Operation.UPDATE_TABLE:
-                    return this.updateTable(json.table);
-                case types_1.Operation.DELETE_TABLE:
-                    return this.deleteTable((_h = json === null || json === void 0 ? void 0 : json.table) === null || _h === void 0 ? void 0 : _h.name);
-                default:
-                    throw new Error(`GSheets integration does not support "${json.endpoint.operation}".`);
-            }
-        });
-    }
-    buildRowObject(headers, values, rowNumber) {
-        const rowObject = { rowNumber };
-        for (let i = 0; i < headers.length; i++) {
-            rowObject._id = rowNumber;
-            rowObject[headers[i]] = values[i];
-        }
-        return rowObject;
-    }
-    createTable(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!name) {
-                throw new Error("Must provide name for new sheet.");
-            }
-            try {
-                yield this.connect();
-                return yield this.client.addSheet({ title: name, headerValues: [name] });
-            }
-            catch (err) {
-                console.error("Error creating new table in google sheets", err);
-                throw err;
-            }
-        });
-    }
-    updateTable(table) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.connect();
-            const sheet = this.client.sheetsByTitle[table.name];
-            yield sheet.loadHeaderRow();
-            if (table._rename) {
-                const headers = [];
-                for (let header of sheet.headerValues) {
-                    if (header === table._rename.old) {
-                        headers.push(table._rename.updated);
-                    }
-                    else {
-                        headers.push(header);
-                    }
-                }
-                try {
-                    yield sheet.setHeaderRow(headers);
-                }
-                catch (err) {
-                    console.error("Error updating column name in google sheets", err);
-                    throw err;
-                }
-            }
-            else {
-                const updatedHeaderValues = [...sheet.headerValues];
-                // add new column - doesn't currently exist
-                for (let [key, column] of Object.entries(table.schema)) {
-                    if (!ALLOWED_TYPES.includes(column.type)) {
-                        throw new Error(`Column type: ${column.type} not allowed for GSheets integration.`);
-                    }
-                    if (!sheet.headerValues.includes(key) &&
-                        column.type !== types_1.FieldType.FORMULA) {
-                        updatedHeaderValues.push(key);
-                    }
-                }
-                // clear out deleted columns
-                for (let key of sheet.headerValues) {
-                    if (!Object.keys(table.schema).includes(key)) {
-                        const idx = updatedHeaderValues.indexOf(key);
-                        updatedHeaderValues.splice(idx, 1);
-                    }
-                }
-                try {
-                    yield sheet.setHeaderRow(updatedHeaderValues);
-                }
-                catch (err) {
-                    console.error("Error updating table in google sheets", err);
-                    throw err;
-                }
-            }
-        });
-    }
-    deleteTable(sheet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const sheetToDelete = this.client.sheetsByTitle[sheet];
-                return yield sheetToDelete.delete();
-            }
-            catch (err) {
-                console.error("Error deleting table in google sheets", err);
-                throw err;
-            }
-        });
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const sheet = this.client.sheetsByTitle[query.sheet];
-                const rowToInsert = typeof query.row === "string" ? JSON.parse(query.row) : query.row;
-                const row = yield sheet.addRow(rowToInsert);
-                return [
-                    this.buildRowObject(sheet.headerValues, row._rawData, row._rowNumber),
-                ];
-            }
-            catch (err) {
-                console.error("Error writing to google sheets", err);
-                throw err;
-            }
-        });
-    }
-    createBulk(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const sheet = this.client.sheetsByTitle[query.sheet];
-                let rowsToInsert = [];
-                for (let row of query.rows) {
-                    rowsToInsert.push(typeof row === "string" ? JSON.parse(row) : row);
-                }
-                const rows = yield sheet.addRows(rowsToInsert);
-                return rows.map(row => this.buildRowObject(sheet.headerValues, row._rawData, row._rowNumber));
-            }
-            catch (err) {
-                console.error("Error bulk writing to google sheets", err);
-                throw err;
-            }
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const sheet = this.client.sheetsByTitle[query.sheet];
-                const rows = yield sheet.getRows();
-                const filtered = shared_core_1.dataFilters.runLuceneQuery(rows, query.filters);
-                const headerValues = sheet.headerValues;
-                let response = [];
-                for (let row of filtered) {
-                    response.push(this.buildRowObject(headerValues, row._rawData, row._rowNumber));
-                }
-                if (query.sort) {
-                    if (Object.keys(query.sort).length !== 1) {
-                        console.warn("Googlesheets does not support multiple sorting", {
-                            sortInfo: query.sort,
-                        });
-                    }
-                    const [sortField, sortInfo] = Object.entries(query.sort)[0];
-                    response = shared_core_1.dataFilters.luceneSort(response, sortField, sortInfo.direction, sortInfo.type);
-                }
-                return response;
-            }
-            catch (err) {
-                console.error("Error reading from google sheets", err);
-                throw err;
-            }
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const sheet = this.client.sheetsByTitle[query.sheet];
-                const rows = yield sheet.getRows();
-                const row = rows[query.rowIndex];
-                if (row) {
-                    const updateValues = typeof query.row === "string" ? JSON.parse(query.row) : query.row;
-                    for (let key in updateValues) {
-                        row[key] = updateValues[key];
-                    }
-                    yield row.save();
-                    return [
-                        this.buildRowObject(sheet.headerValues, row._rawData, row._rowNumber),
-                    ];
-                }
-                else {
-                    throw new Error("Row does not exist.");
-                }
-            }
-            catch (err) {
-                console.error("Error reading from google sheets", err);
-                throw err;
-            }
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.connect();
-            const sheet = this.client.sheetsByTitle[query.sheet];
-            const rows = yield sheet.getRows();
-            const row = rows[query.rowIndex];
-            if (row) {
-                yield row.delete();
-                return [{ deleted: query.rowIndex }];
-            }
-            else {
-                throw new Error("Row does not exist.");
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: GoogleSheetsIntegration,
-};