@budibase/server 0.0.32 → 0.0.999-alpha.30

package/dist/integrations/firebase.js

@@ -0,0 +1,174 @@
+"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

@@ -0,0 +1,455 @@
+"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,
+};