@budibase/server 1.0.46-alpha.2 → 1.0.46-alpha.6

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 = {}));

package/dist/integrations/index.js

@@ -10,6 +10,7 @@ const airtable = require("./airtable");
 const mysql = require("./mysql");
 const arangodb = require("./arangodb");
 const rest = require("./rest");
+const googlesheets = require("./googlesheets");
 const { SourceNames } = require("../definitions/datasource");
 const DEFINITIONS = {
     [SourceNames.POSTGRES]: postgres.schema,
@@ -23,6 +24,7 @@ const DEFINITIONS = {
     [SourceNames.MYSQL]: mysql.schema,
     [SourceNames.ARANGODB]: arangodb.schema,
     [SourceNames.REST]: rest.schema,
+    [SourceNames.GOOGLE_SHEETS]: googlesheets.schema,
 };
 const INTEGRATIONS = {
     [SourceNames.POSTGRES]: postgres.integration,
@@ -36,6 +38,7 @@ const INTEGRATIONS = {
     [SourceNames.MYSQL]: mysql.integration,
     [SourceNames.ARANGODB]: arangodb.integration,
     [SourceNames.REST]: rest.integration,
+    [SourceNames.GOOGLE_SHEETS]: googlesheets.integration,
 };
 // optionally add oracle integration if the oracle binary can be installed
 if (!(process.arch === "arm64" && process.platform === "darwin")) {

package/dist/integrations/utils.js

@@ -153,7 +153,9 @@ exports.isIsoDateString = isIsoDateString;
  * @param tableIds The IDs of the tables which currently exist.
  */
 function shouldCopyRelationship(column, tableIds) {
-    return column.type === constants_1.FieldTypes.LINK && column.tableId && tableIds.includes(column.tableId);
+    return (column.type === constants_1.FieldTypes.LINK &&
+        column.tableId &&
+        tableIds.includes(column.tableId));
 }
 /**
  * Similar function to the shouldCopyRelationship function, but instead this looks for options and boolean
@@ -164,8 +166,9 @@ function shouldCopyRelationship(column, tableIds) {
  * @param fetchedColumn The fetched column to check for the type in the external database.
  */
 function shouldCopySpecialColumn(column, fetchedColumn) {
-    return column.type === constants_1.FieldTypes.OPTIONS ||
-        ((!fetchedColumn || fetchedColumn.type === constants_1.FieldTypes.NUMBER) && column.type === constants_1.FieldTypes.BOOLEAN);
+    return (column.type === constants_1.FieldTypes.OPTIONS ||
+        ((!fetchedColumn || fetchedColumn.type === constants_1.FieldTypes.NUMBER) &&
+            column.type === constants_1.FieldTypes.BOOLEAN));
 }
 /**
  * Looks for columns which need to be copied over into the new table definitions, like relationships

package/dist/middleware/currentapp.js

@@ -49,15 +49,6 @@ module.exports = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         !isWebhookEndpoint(ctx) &&
         (!ctx.user || !ctx.user.builder || !ctx.user.builder.global)) {
         clearCookie(ctx, Cookies.CurrentApp);
-        // have to set the return url on the server side as client side is not available
-        setCookie(ctx, ctx.url, Cookies.RETURN_URL, {
-            // don't sign so the browser can easily read
-            sign: false,
-            // use the request domain to match how ui handles the return url cookie.
-            // it's important we don't use the shared domain here as the builder
-            // can't delete from it without awareness of the domain.
-            requestDomain: true,
-        });
         return ctx.redirect("/");
     }
     let appId, roleId = BUILTIN_ROLE_IDS.PUBLIC;

package/dist/middleware/usageQuota.js

@@ -10,11 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 const CouchDB = require("../db");
 const usageQuota = require("../utilities/usageQuota");
-const env = require("../environment");
-const { getTenantId } = require("@budibase/backend-core/tenancy");
+const { getUniqueRows } = require("../utilities/usageQuota/rows");
 const { isExternalTable, isRowId: isExternalRowId, } = require("../integrations/utils");
-// tenants without limits
-const EXCLUDED_TENANTS = ["bb", "default", "bbtest", "bbstaging"];
+const migration = require("../migrations/usageQuotas");
 // currently only counting new writes and deletes
 const METHOD_MAP = {
     POST: 1,
@@ -22,13 +20,13 @@ const METHOD_MAP = {
 };
 const DOMAIN_MAP = {
     rows: usageQuota.Properties.ROW,
-    upload: usageQuota.Properties.UPLOAD,
-    views: usageQuota.Properties.VIEW,
-    users: usageQuota.Properties.USER,
+    // upload: usageQuota.Properties.UPLOAD,            // doesn't work yet
+    // views: usageQuota.Properties.VIEW,               // doesn't work yet
+    // users: usageQuota.Properties.USER,               // doesn't work yet
     applications: usageQuota.Properties.APPS,
     // this will not be updated by endpoint calls
     // instead it will be updated by triggerInfo
-    automationRuns: usageQuota.Properties.AUTOMATION,
+    // automationRuns: usageQuota.Properties.AUTOMATION, // doesn't work yet
 };
 function getProperty(url) {
     for (let domain of Object.keys(DOMAIN_MAP)) {
@@ -38,9 +36,7 @@ function getProperty(url) {
     }
 }
 module.exports = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
-    const tenantId = getTenantId();
-    // if in development or a self hosted cloud usage quotas should not be executed
-    if (env.isDev() || env.SELF_HOSTED || EXCLUDED_TENANTS.includes(tenantId)) {
+    if (!usageQuota.useQuotas()) {
         return next();
     }
     let usage = METHOD_MAP[ctx.req.method];
@@ -78,10 +74,83 @@ module.exports = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         usage = files.map(file => file.size).reduce((total, size) => total + size);
     }
     try {
-        yield usageQuota.update(property, usage);
-        return next();
+        yield migration.run();
+        yield performRequest(ctx, next, property, usage);
     }
     catch (err) {
         ctx.throw(400, err);
     }
 });
+const performRequest = (ctx, next, property, usage) => __awaiter(void 0, void 0, void 0, function* () {
+    const usageContext = {
+        skipNext: false,
+        skipUsage: false,
+        [usageQuota.Properties.APPS]: {},
+    };
+    if (usage === -1) {
+        if (PRE_DELETE[property]) {
+            yield PRE_DELETE[property](ctx, usageContext);
+        }
+    }
+    else {
+        if (PRE_CREATE[property]) {
+            yield PRE_CREATE[property](ctx, usageContext);
+        }
+    }
+    // run the request
+    if (!usageContext.skipNext) {
+        yield usageQuota.update(property, usage, { dryRun: true });
+        yield next();
+    }
+    if (usage === -1) {
+        if (POST_DELETE[property]) {
+            yield POST_DELETE[property](ctx, usageContext);
+        }
+    }
+    else {
+        if (POST_CREATE[property]) {
+            yield POST_CREATE[property](ctx, usageContext);
+        }
+    }
+    // update the usage
+    if (!usageContext.skipUsage) {
+        yield usageQuota.update(property, usage);
+    }
+});
+const appPreDelete = (ctx, usageContext) => __awaiter(void 0, void 0, void 0, function* () {
+    if (ctx.query.unpublish) {
+        // don't run usage decrement for unpublish
+        usageContext.skipUsage = true;
+        return;
+    }
+    // store the row count to delete
+    const rows = yield getUniqueRows([ctx.appId]);
+    if (rows.length) {
+        usageContext[usageQuota.Properties.APPS] = { rowCount: rows.length };
+    }
+});
+const appPostDelete = (ctx, usageContext) => __awaiter(void 0, void 0, void 0, function* () {
+    // delete the app rows from usage
+    const rowCount = usageContext[usageQuota.Properties.APPS].rowCount;
+    if (rowCount) {
+        yield usageQuota.update(usageQuota.Properties.ROW, -rowCount);
+    }
+});
+const appPostCreate = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    // app import & template creation
+    if (ctx.request.body.useTemplate === "true") {
+        const rows = yield getUniqueRows([ctx.response.body.appId]);
+        const rowCount = rows ? rows.length : 0;
+        yield usageQuota.update(usageQuota.Properties.ROW, rowCount);
+    }
+});
+const PRE_DELETE = {
+    [usageQuota.Properties.APPS]: appPreDelete,
+};
+const POST_DELETE = {
+    [usageQuota.Properties.APPS]: appPostDelete,
+};
+const PRE_CREATE = {};
+const POST_CREATE = {
+    [usageQuota.Properties.APPS]: appPostCreate,
+};

package/dist/migrations/usageQuotas/index.js

@@ -0,0 +1,24 @@
+"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());
+    });
+};
+const { MIGRATIONS, MIGRATION_DBS, migrateIfRequired, } = require("@budibase/backend-core/migrations");
+const { useQuotas } = require("../../utilities/usageQuota");
+const syncApps = require("./syncApps");
+const syncRows = require("./syncRows");
+exports.run = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (!useQuotas()) {
+        return;
+    }
+    // Jan 2022
+    yield migrateIfRequired(MIGRATION_DBS.GLOBAL_DB, MIGRATIONS.QUOTAS_1, () => __awaiter(void 0, void 0, void 0, function* () {
+        yield syncApps.run();
+        yield syncRows.run();
+    }));
+});

package/dist/migrations/usageQuotas/syncApps.js

@@ -0,0 +1,26 @@
+"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());
+    });
+};
+const { getGlobalDB, getTenantId } = require("@budibase/backend-core/tenancy");
+const { getAllApps } = require("@budibase/backend-core/db");
+const CouchDB = require("../../db");
+const { getUsageQuotaDoc } = require("../../utilities/usageQuota");
+exports.run = () => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getGlobalDB();
+    // get app count
+    const devApps = yield getAllApps(CouchDB, { dev: true });
+    const appCount = devApps ? devApps.length : 0;
+    // sync app count
+    const tenantId = getTenantId();
+    console.log(`[Tenant: ${tenantId}] Syncing app count: ${appCount}`);
+    const usageDoc = yield getUsageQuotaDoc(db);
+    usageDoc.usageQuota.apps = appCount;
+    yield db.put(usageDoc);
+});

package/dist/migrations/usageQuotas/syncRows.js

@@ -0,0 +1,29 @@
+"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());
+    });
+};
+const { getGlobalDB, getTenantId } = require("@budibase/backend-core/tenancy");
+const { getAllApps } = require("@budibase/backend-core/db");
+const CouchDB = require("../../db");
+const { getUsageQuotaDoc } = require("../../utilities/usageQuota");
+const { getUniqueRows } = require("../../utilities/usageQuota/rows");
+exports.run = () => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getGlobalDB();
+    // get all rows in all apps
+    const allApps = yield getAllApps(CouchDB, { all: true });
+    const appIds = allApps ? allApps.map(app => app.appId) : [];
+    const rows = yield getUniqueRows(appIds);
+    const rowCount = rows ? rows.length : 0;
+    // sync row count
+    const tenantId = getTenantId();
+    console.log(`[Tenant: ${tenantId}] Syncing row count: ${rowCount}`);
+    const usageDoc = yield getUsageQuotaDoc(db);
+    usageDoc.usageQuota.rows = rowCount;
+    yield db.put(usageDoc);
+});

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "1.0.46-alpha.1",
+    "version": "1.0.46-alpha.5",
     "description": "Budibase Web Server",
     "main": "src/index.ts",
     "repository": {
@@ -70,9 +70,9 @@
     "license": "GPL-3.0",
     "dependencies": {
         "@apidevtools/swagger-parser": "^10.0.3",
-        "@budibase/backend-core": "^1.0.46-alpha.1",
-        "@budibase/client": "^1.0.46-alpha.1",
-        "@budibase/string-templates": "^1.0.46-alpha.1",
+        "@budibase/backend-core": "^1.0.46-alpha.5",
+        "@budibase/client": "^1.0.46-alpha.5",
+        "@budibase/string-templates": "^1.0.46-alpha.5",
         "@bull-board/api": "^3.7.0",
         "@bull-board/koa": "^3.7.0",
         "@elastic/elasticsearch": "7.10.0",
@@ -92,6 +92,8 @@
         "fix-path": "3.0.0",
         "form-data": "^4.0.0",
         "fs-extra": "8.1.0",
+        "google-auth-library": "^7.11.0",
+        "google-spreadsheet": "^3.2.0",
         "jimp": "0.16.1",
         "joi": "17.2.1",
         "js-yaml": "^4.1.0",
@@ -110,7 +112,7 @@
         "mongodb": "3.6.3",
         "mssql": "6.2.3",
         "mysql2": "^2.3.1",
-        "node-fetch": "2.6.0",
+        "node-fetch": "2.6.7",
         "open": "^8.4.0",
         "pg": "8.5.1",
         "pino-pretty": "4.0.0",
@@ -139,6 +141,7 @@
         "@jest/test-sequencer": "^24.8.0",
         "@types/apidoc": "^0.50.0",
         "@types/bull": "^3.15.1",
+        "@types/google-spreadsheet": "^3.1.5",
         "@types/jest": "^26.0.23",
         "@types/koa": "^2.13.3",
         "@types/koa-router": "^7.4.2",