@budibase/server 1.0.46-alpha.4 → 1.0.46-alpha.8

package/dist/api/controllers/application.js

@@ -20,7 +20,7 @@ const { cloneDeep } = require("lodash/fp");
 const { processObject } = require("@budibase/string-templates");
 const { getAllApps, isDevAppID, getDeployedAppID, Replication, } = require("@budibase/backend-core/db");
 const { USERS_TABLE_SCHEMA } = require("../../constants");
-const { getDeployedApps, removeAppFromUserRoles, } = require("../../utilities/workerRequests");
+const { removeAppFromUserRoles } = require("../../utilities/workerRequests");
 const { clientLibraryPath, stringToReadStream } = require("../../utilities");
 const { getAllLocks } = require("../../utilities/redis");
 const { updateClientLibrary, backupClientLibrary, revertClientLibrary, } = require("../../utilities/fileSystem/clientLibrary");
@@ -49,31 +49,44 @@ function getUserRoleId(ctx) {
         ? BUILTIN_ROLE_IDS.PUBLIC
         : ctx.user.role._id;
 }
-function getAppUrlIfNotInUse(ctx) {
+function getAppUrl(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
+        // construct the url
         let url;
         if (ctx.request.body.url) {
+            // if the url is provided, use that
             url = encodeURI(ctx.request.body.url);
         }
         else if (ctx.request.body.name) {
+            // otherwise use the name
             url = encodeURI(`${ctx.request.body.name}`);
         }
         if (url) {
             url = `/${url.replace(URL_REGEX_SLASH, "")}`.toLowerCase();
         }
-        if (!env.SELF_HOSTED) {
-            return url;
-        }
-        const deployedApps = yield getDeployedApps();
-        if (url &&
-            deployedApps[url] != null &&
-            ctx.params != null &&
-            deployedApps[url].appId !== ctx.params.appId) {
-            ctx.throw(400, "App name/URL is already in use.");
-        }
         return url;
     });
 }
+const checkAppUrl = (ctx, apps, url, currentAppId) => {
+    if (currentAppId) {
+        apps = apps.filter(app => app.appId !== currentAppId);
+    }
+    if (apps.some(app => app.url === url)) {
+        ctx.throw(400, "App URL is already in use.");
+    }
+};
+const checkAppName = (ctx, apps, name, currentAppId) => {
+    // TODO: Replace with Joi
+    if (!name) {
+        ctx.throw(400, "Name is required");
+    }
+    if (currentAppId) {
+        apps = apps.filter(app => app.appId !== currentAppId);
+    }
+    if (apps.some(app => app.name === name)) {
+        ctx.throw(400, "App name is already in use.");
+    }
+};
 function createInstance(template) {
     return __awaiter(this, void 0, void 0, function* () {
         const tenantId = isMultiTenant() ? getTenantId() : null;
@@ -167,6 +180,11 @@ exports.fetchAppPackage = (ctx) => __awaiter(void 0, void 0, void 0, function* (
     };
 });
 exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const apps = yield getAllApps(CouchDB, { dev: true });
+    const name = ctx.request.body.name;
+    checkAppName(ctx, apps, name);
+    const url = yield getAppUrl(ctx);
+    checkAppUrl(ctx, apps, url);
     const { useTemplate, templateKey, templateString } = ctx.request.body;
     const instanceConfig = {
         useTemplate,
@@ -178,7 +196,6 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     }
     const instance = yield createInstance(instanceConfig);
     const appId = instance._id;
-    const url = yield getAppUrlIfNotInUse(ctx);
     const db = new CouchDB(appId);
     let _rev;
     try {
@@ -196,7 +213,7 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         type: "app",
         version: packageJson.version,
         componentLibraries: ["@budibase/standard-components"],
-        name: ctx.request.body.name,
+        name: name,
         url: url,
         template: ctx.request.body.template,
         instance: instance,
@@ -219,8 +236,21 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     ctx.status = 200;
     ctx.body = newApplication;
 });
+// This endpoint currently operates as a PATCH rather than a PUT
+// Thus name and url fields are handled only if present
 exports.update = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const data = yield updateAppPackage(ctx, ctx.request.body, ctx.params.appId);
+    const apps = yield getAllApps(CouchDB, { dev: true });
+    // validation
+    const name = ctx.request.body.name;
+    if (name) {
+        checkAppName(ctx, apps, name, ctx.params.appId);
+    }
+    const url = yield getAppUrl(ctx);
+    if (url) {
+        checkAppUrl(ctx, apps, url, ctx.params.appId);
+        ctx.request.body.url = url;
+    }
+    const data = yield updateAppPackage(ctx.request.body, ctx.params.appId);
     ctx.status = 200;
     ctx.body = data;
 });
@@ -239,7 +269,7 @@ exports.updateClient = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         version: packageJson.version,
         revertableVersion: currentVersion,
     };
-    const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
+    const data = yield updateAppPackage(appPackageUpdates, ctx.params.appId);
     ctx.status = 200;
     ctx.body = data;
 });
@@ -259,7 +289,7 @@ exports.revertClient = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         version: application.revertableVersion,
         revertableVersion: null,
     };
-    const data = yield updateAppPackage(ctx, appPackageUpdates, ctx.params.appId);
+    const data = yield updateAppPackage(appPackageUpdates, ctx.params.appId);
     ctx.status = 200;
     ctx.body = data;
 });
@@ -326,11 +356,10 @@ exports.sync = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         };
     }
 });
-const updateAppPackage = (ctx, appPackage, appId) => __awaiter(void 0, void 0, void 0, function* () {
-    const url = yield getAppUrlIfNotInUse(ctx);
+const updateAppPackage = (appPackage, appId) => __awaiter(void 0, void 0, void 0, function* () {
     const db = new CouchDB(appId);
     const application = yield db.get(DocumentTypes.APP_METADATA);
-    const newAppPackage = Object.assign(Object.assign(Object.assign({}, application), appPackage), { url });
+    const newAppPackage = Object.assign(Object.assign({}, application), appPackage);
     if (appPackage._rev !== application._rev) {
         newAppPackage._rev = application._rev;
     }

package/dist/api/controllers/auth.js

@@ -24,6 +24,8 @@ exports.fetchSelf = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const user = yield getFullUser(ctx, userId);
     // this shouldn't be returned by the app self
     delete user.roles;
+    // forward the csrf token from the session
+    user.csrfToken = ctx.user.csrfToken;
     if (appId) {
         const db = new CouchDB(appId);
         // remove the full roles structure
@@ -31,6 +33,8 @@ exports.fetchSelf = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const userTable = yield db.get(InternalTables.USER_METADATA);
             const metadata = yield db.get(userId);
+            // make sure there is never a stale csrf token
+            delete metadata.csrfToken;
             // specifically needs to make sure is enriched
             ctx.body = yield outputProcessing(ctx, userTable, Object.assign(Object.assign({}, user), metadata));
         }

package/dist/api/controllers/datasource.js

@@ -28,6 +28,12 @@ exports.fetch = function (ctx) {
         const datasources = (yield database.allDocs(getDatasourceParams(null, {
             include_docs: true,
         }))).rows.map(row => row.doc);
+        for (let datasource of datasources) {
+            if (datasource.config && datasource.config.auth) {
+                // strip secrets from response so they don't show in the network request
+                delete datasource.config.auth;
+            }
+        }
         ctx.body = [bbInternalDb, ...datasources];
     });
 };
@@ -78,8 +84,13 @@ exports.update = function (ctx) {
         const db = new CouchDB(ctx.appId);
         const datasourceId = ctx.params.datasourceId;
         let datasource = yield db.get(datasourceId);
+        const auth = datasource.config.auth;
         yield invalidateVariables(datasource, ctx.request.body);
         datasource = Object.assign(Object.assign({}, datasource), ctx.request.body);
+        if (auth && !ctx.request.body.auth) {
+            // don't strip auth config from DB
+            datasource.config.auth = auth;
+        }
         const response = yield db.put(datasource);
         datasource._rev = response.rev;
         // Drain connection pools when configuration is changed

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

@@ -130,6 +130,15 @@ function execute(ctx, opts = { rowsOnly: false }) {
         const db = new CouchDB(ctx.appId);
         const query = yield db.get(ctx.params.queryId);
         const datasource = yield db.get(query.datasourceId);
+        const enrichedParameters = ctx.request.body.parameters || {};
+        // make sure parameters are fully enriched with defaults
+        if (query && query.parameters) {
+            for (let parameter of query.parameters) {
+                if (!enrichedParameters[parameter.name]) {
+                    enrichedParameters[parameter.name] = parameter.default;
+                }
+            }
+        }
         // call the relevant CRUD method on the integration class
         try {
             const { rows, pagination, extra } = yield Runner.run({
@@ -138,7 +147,7 @@ function execute(ctx, opts = { rowsOnly: false }) {
                 queryVerb: query.queryVerb,
                 fields: query.fields,
                 pagination: ctx.request.body.pagination,
-                parameters: ctx.request.body.parameters,
+                parameters: enrichedParameters,
                 transformer: query.transformer,
                 queryId: ctx.params.queryId,
             });
@@ -170,8 +179,7 @@ const removeDynamicVariables = (db, queryId) => __awaiter(void 0, void 0, void 0
     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;
+        datasource.config.dynamicVariables = dynamicVariables.filter(dv => dv.queryId !== queryId);
         yield db.put(datasource);
         // invalidate the deleted variables
         const variablesToDelete = dynamicVariables.filter(dv => dv.queryId === queryId);

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

@@ -59,8 +59,7 @@ exports.validate = ({ appId, tableId, row, table }) => __awaiter(void 0, void 0,
         const constraints = cloneDeep(table.schema[fieldName].constraints);
         const type = table.schema[fieldName].type;
         // special case for options, need to always allow unselected (null)
-        if ((type === FieldTypes.OPTIONS || type === FieldTypes.ARRAY) &&
-            constraints.inclusion) {
+        if (type === FieldTypes.OPTIONS && constraints.inclusion) {
             constraints.inclusion.push(null);
         }
         let res;

package/dist/api/controllers/static/index.js

@@ -14,7 +14,7 @@ const { resolve, join } = require("../../../utilities/centralPath");
 const uuid = require("uuid");
 const { ObjectStoreBuckets } = require("../../../constants");
 const { processString } = require("@budibase/string-templates");
-const { getDeployedApps } = require("../../../utilities/workerRequests");
+const { getAllApps } = require("@budibase/backend-core/db");
 const CouchDB = require("../../../db");
 const { loadHandlebarsFile, NODE_MODULES_PATH, TOP_LEVEL_PATH, } = require("../../../utilities/fileSystem");
 const env = require("../../../environment");
@@ -43,13 +43,15 @@ function prepareUpload({ s3Key, bucket, metadata, file }) {
         };
     });
 }
-function checkForSelfHostedURL(ctx) {
+function getAppIdFromUrl(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        // the "appId" component of the URL may actually be a specific self hosted URL
+        // the "appId" component of the URL can be the id or the custom url
         let possibleAppUrl = `/${encodeURI(ctx.params.appId).toLowerCase()}`;
-        const apps = yield getDeployedApps();
-        if (apps[possibleAppUrl] && apps[possibleAppUrl].appId) {
-            return apps[possibleAppUrl].appId;
+        // search prod apps for a url that matches, exclude dev where id is always used
+        const apps = yield getAllApps(CouchDB, { dev: false });
+        const app = apps.filter(a => a.url && a.url.toLowerCase() === possibleAppUrl)[0];
+        if (app && app.appId) {
+            return app.appId;
         }
         else {
             return ctx.params.appId;
@@ -82,10 +84,7 @@ exports.uploadFile = function (ctx) {
 };
 exports.serveApp = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        let appId = ctx.params.appId;
-        if (env.SELF_HOSTED) {
-            appId = yield checkForSelfHostedURL(ctx);
-        }
+        let appId = yield getAppIdFromUrl(ctx);
         const App = require("./templates/BudibaseApp.svelte").default;
         const db = new CouchDB(appId, { skip_setup: true });
         const appInfo = yield db.get(DocumentTypes.APP_METADATA);

package/dist/api/controllers/user.js

@@ -155,6 +155,8 @@ exports.updateSelfMetadata = function (ctx) {
         ctx.request.body._id = ctx.user._id;
         // make sure no stale rev
         delete ctx.request.body._rev;
+        // make sure no csrf token
+        delete ctx.request.body.csrfToken;
         yield exports.updateMetadata(ctx);
     });
 };

package/dist/api/routes/index.js

@@ -21,7 +21,6 @@ const integrationRoutes = require("./integration");
 const permissionRoutes = require("./permission");
 const datasourceRoutes = require("./datasource");
 const queryRoutes = require("./query");
-const hostingRoutes = require("./hosting");
 const backupRoutes = require("./backup");
 const metadataRoutes = require("./metadata");
 const devRoutes = require("./dev");
@@ -46,7 +45,6 @@ exports.mainRoutes = [
     permissionRoutes,
     datasourceRoutes,
     queryRoutes,
-    hostingRoutes,
     backupRoutes,
     metadataRoutes,
     devRoutes,

package/dist/constants/index.js

@@ -67,6 +67,9 @@ exports.DataSourceOperation = {
     UPDATE_TABLE: "UPDATE_TABLE",
     DELETE_TABLE: "DELETE_TABLE",
 };
+exports.DatasourceAuthTypes = {
+    GOOGLE: "google",
+};
 exports.SortDirection = {
     ASCENDING: "ASCENDING",
     DESCENDING: "DESCENDING",

package/dist/definitions/datasource.js

@@ -49,6 +49,7 @@ var SourceNames;
     SourceNames["ARANGODB"] = "ARANGODB";
     SourceNames["REST"] = "REST";
     SourceNames["ORACLE"] = "ORACLE";
+    SourceNames["GOOGLE_SHEETS"] = "GOOGLE_SHEETS";
 })(SourceNames = exports.SourceNames || (exports.SourceNames = {}));
 var IncludeRelationships;
 (function (IncludeRelationships) {

package/dist/integrations/googlesheets.js

@@ -0,0 +1,340 @@
+"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 datasource_1 = require("../definitions/datasource");
+const google_auth_library_1 = require("google-auth-library");
+const utils_1 = require("./utils");
+const constants_1 = require("../constants");
+const google_spreadsheet_1 = require("google-spreadsheet");
+var GoogleSheetsModule;
+(function (GoogleSheetsModule) {
+    const { getGlobalDB } = require("@budibase/backend-core/tenancy");
+    const { getScopedConfig } = require("@budibase/backend-core/db");
+    const { Configs } = require("@budibase/backend-core/constants");
+    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",
+        datasource: {
+            spreadsheetId: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                required: true,
+            },
+        },
+        query: {
+            create: {
+                type: datasource_1.QueryTypes.FIELDS,
+                fields: {
+                    sheet: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                        required: true,
+                    },
+                    row: {
+                        type: datasource_1.QueryTypes.JSON,
+                        required: true,
+                    },
+                },
+            },
+            read: {
+                type: datasource_1.QueryTypes.FIELDS,
+                fields: {
+                    sheet: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                        required: true,
+                    },
+                },
+            },
+            update: {
+                type: datasource_1.QueryTypes.FIELDS,
+                fields: {
+                    sheet: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                        required: true,
+                    },
+                    rowIndex: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                        required: true,
+                    },
+                    row: {
+                        type: datasource_1.QueryTypes.JSON,
+                        required: true,
+                    },
+                },
+            },
+            delete: {
+                type: datasource_1.QueryTypes.FIELDS,
+                fields: {
+                    sheet: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                        required: true,
+                    },
+                    rowIndex: {
+                        type: datasource_1.DatasourceFieldTypes.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);
+        }
+        /**
+         * 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;
+        }
+        connect() {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Initialise oAuth client
+                    const db = getGlobalDB();
+                    const googleConfig = yield getScopedConfig(db, {
+                        type: Configs.GOOGLE,
+                    });
+                    const oauthClient = new google_auth_library_1.OAuth2Client({
+                        clientId: googleConfig.clientID,
+                        clientSecret: googleConfig.clientSecret,
+                    });
+                    oauthClient.credentials.access_token = this.config.auth.accessToken;
+                    oauthClient.credentials.refresh_token = this.config.auth.refreshToken;
+                    this.client.useOAuth2Client(oauthClient);
+                    yield this.client.loadInfo();
+                }
+                catch (err) {
+                    console.error("Error connecting to google sheets", err);
+                    throw err;
+                }
+            });
+        }
+        buildSchema(datasourceId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.connect();
+                const sheets = yield this.client.sheetsByIndex;
+                const tables = {};
+                for (let sheet of sheets) {
+                    // must fetch rows to determine schema
+                    yield sheet.getRows();
+                    // build schema
+                    const schema = {};
+                    // build schema from headers
+                    for (let header of sheet.headerValues) {
+                        schema[header] = {
+                            name: header,
+                            type: constants_1.FieldTypes.STRING,
+                        };
+                    }
+                    // create tables
+                    tables[sheet.title] = {
+                        _id: utils_1.buildExternalTableId(datasourceId, sheet.title),
+                        name: sheet.title,
+                        primary: ["rowNumber"],
+                        schema,
+                    };
+                }
+                this.tables = tables;
+            });
+        }
+        query(json) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const sheet = json.endpoint.entityId;
+                const handlers = {
+                    [constants_1.DataSourceOperation.CREATE]: () => this.create({ sheet, row: json.body }),
+                    [constants_1.DataSourceOperation.READ]: () => this.read({ sheet }),
+                    [constants_1.DataSourceOperation.UPDATE]: () => {
+                        var _a, _b, _c;
+                        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,
+                        });
+                    },
+                    [constants_1.DataSourceOperation.DELETE]: () => {
+                        var _a, _b, _c;
+                        return this.delete({
+                            // 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,
+                        });
+                    },
+                    [constants_1.DataSourceOperation.CREATE_TABLE]: () => { var _a; return this.createTable((_a = json === null || json === void 0 ? void 0 : json.table) === null || _a === void 0 ? void 0 : _a.name); },
+                    [constants_1.DataSourceOperation.UPDATE_TABLE]: () => this.updateTable(json.table),
+                    [constants_1.DataSourceOperation.DELETE_TABLE]: () => { var _a; return this.deleteTable((_a = json === null || json === void 0 ? void 0 : json.table) === null || _a === void 0 ? void 0 : _a.name); },
+                };
+                const internalQueryMethod = handlers[json.endpoint.operation];
+                return yield internalQueryMethod();
+            });
+        }
+        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* () {
+                try {
+                    yield this.connect();
+                    const sheet = yield this.client.addSheet({ title: name });
+                    return sheet;
+                }
+                catch (err) {
+                    console.error("Error creating new table in google sheets", err);
+                    throw err;
+                }
+            });
+        }
+        updateTable(table) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connect();
+                    const sheet = yield 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);
+                            }
+                        }
+                        yield sheet.setHeaderRow(headers);
+                    }
+                    else {
+                        let newField = Object.keys(table.schema).find(key => !sheet.headerValues.includes(key));
+                        yield sheet.setHeaderRow([...sheet.headerValues, newField]);
+                    }
+                }
+                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 = yield 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 = yield 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;
+                }
+            });
+        }
+        read(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connect();
+                    const sheet = yield this.client.sheetsByTitle[query.sheet];
+                    const rows = yield sheet.getRows();
+                    const headerValues = sheet.headerValues;
+                    const response = [];
+                    for (let row of rows) {
+                        response.push(this.buildRowObject(headerValues, row._rawData, row._rowNumber));
+                    }
+                    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 = yield this.client.sheetsByTitle[query.sheet];
+                    const rows = yield sheet.getRows();
+                    const row = rows[query.rowIndex];
+                    if (row) {
+                        const updateValues = 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 = yield 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.");
+                }
+            });
+        }
+    }
+    module.exports = {
+        schema: SCHEMA,
+        integration: GoogleSheetsIntegration,
+    };
+})(GoogleSheetsModule || (GoogleSheetsModule = {}));