@budibase/worker 3.23.23 → 3.23.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "3.23.23",
+  "version": "3.23.24",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -109,5 +109,5 @@
       }
     }
   },
-  "gitHead": "e04af85aab2242716869fa9a8f62cd99f8d5e0da"
+  "gitHead": "083c01f79a93ea8819c45370178ded6909dd2ef4"
 }

package/src/api/controllers/system/tenants.ts

@@ -1,4 +1,5 @@
 import { GetTenantInfoResponse, UserCtx } from "@budibase/types"
+import { LockRequest, LockReason } from "@budibase/types"
 import * as tenantSdk from "../../../sdk/tenants"
 
 export async function destroy(ctx: UserCtx<void, void>) {
@@ -18,6 +19,34 @@ export async function destroy(ctx: UserCtx<void, void>) {
   }
 }
 
+export async function lock(ctx: UserCtx<LockRequest, void>) {
+  if (!ctx.internal) {
+    ctx.throw(403, "Only internal user can lock a tenant")
+  }
+
+  const { reason } = ctx.request.body
+  if (reason !== undefined && !Object.values(LockReason).includes(reason)) {
+    ctx.throw(
+      400,
+      `Invalid lock reason. Valid values: ${Object.values(LockReason).join(", ")}`
+    )
+  }
+
+  const tenantId = ctx.params.tenantId
+
+  try {
+    if (reason) {
+      await tenantSdk.lockTenant(tenantId, reason)
+    } else {
+      await tenantSdk.unlockTenant(tenantId)
+    }
+    ctx.status = 204
+  } catch (err) {
+    ctx.log.error(err)
+    throw err
+  }
+}
+
 export async function info(ctx: UserCtx<void, GetTenantInfoResponse>) {
   ctx.body = await tenantSdk.tenantInfo(ctx.params.tenantId)
 }

package/src/api/routes/system/tenants.ts

@@ -2,3 +2,4 @@ import * as controller from "../../controllers/system/tenants"
 import { adminRoutes } from "../endpointGroups"
 
 adminRoutes.delete("/api/system/tenants/:tenantId", controller.destroy)
+adminRoutes.put("/api/system/tenants/:tenantId/lock", controller.lock)

package/src/api/routes/system/tests/tenants.spec.ts

@@ -1,5 +1,13 @@
 import { TestConfiguration } from "../../../../tests"
 import { tenancy } from "@budibase/backend-core"
+import { LockReason } from "@budibase/types"
+import * as tenantSdk from "../../../../sdk/tenants"
+
+jest.mock("../../../../sdk/tenants", () => ({
+  lockTenant: jest.fn(),
+  unlockTenant: jest.fn(),
+  deleteTenant: jest.fn(),
+}))
 
 describe("/api/global/tenants", () => {
   const config = new TestConfiguration()
@@ -58,4 +66,85 @@ describe("/api/global/tenants", () => {
       expect(res.body).toEqual(config.adminOnlyResponse())
     })
   })
+
+  describe("PUT /api/system/tenants/:tenantId/lock", () => {
+    it("allows locking tenant with valid reason", async () => {
+      const user = await config.createTenant()
+
+      await config.api.tenants.lock(
+        user.tenantId,
+        {
+          reason: LockReason.FREE_TIER,
+        },
+        {
+          headers: config.internalAPIHeaders(),
+        }
+      )
+
+      expect(tenantSdk.lockTenant).toHaveBeenCalledWith(
+        user.tenantId,
+        LockReason.FREE_TIER
+      )
+      expect(tenantSdk.unlockTenant).not.toHaveBeenCalled()
+    })
+
+    it("unlocks tenant when no reason provided", async () => {
+      const user = await config.createTenant()
+
+      await config.api.tenants.lock(
+        user.tenantId,
+        {},
+        {
+          headers: config.internalAPIHeaders(),
+        }
+      )
+
+      expect(tenantSdk.unlockTenant).toHaveBeenCalledWith(user.tenantId)
+      expect(tenantSdk.lockTenant).not.toHaveBeenCalled()
+    })
+
+    it("rejects invalid lock reason", async () => {
+      const user = await config.createTenant()
+
+      const status = 400
+      const res = await config.api.tenants.lock(
+        user.tenantId,
+        {
+          reason: "invalid_reason" as any,
+        },
+        {
+          status,
+          headers: config.internalAPIHeaders(),
+        }
+      )
+
+      expect(res.body.message).toContain("Invalid lock reason. Valid values:")
+      expect(res.body.message).toContain(LockReason.FREE_TIER)
+      expect(tenantSdk.lockTenant).not.toHaveBeenCalled()
+      expect(tenantSdk.unlockTenant).not.toHaveBeenCalled()
+    })
+
+    it("rejects non-internal user", async () => {
+      const user = await config.createTenant()
+
+      const status = 403
+      const res = await config.api.tenants.lock(
+        user.tenantId,
+        {
+          reason: LockReason.FREE_TIER,
+        },
+        {
+          status,
+          headers: config.authHeaders(user),
+        }
+      )
+
+      expect(res.body).toEqual({
+        message: "Only internal user can lock a tenant",
+        status,
+      })
+      expect(tenantSdk.lockTenant).not.toHaveBeenCalled()
+      expect(tenantSdk.unlockTenant).not.toHaveBeenCalled()
+    })
+  })
 })

package/src/sdk/tenants/tenants.ts

@@ -1,5 +1,11 @@
-import { db as dbCore, platform, tenancy } from "@budibase/backend-core"
+import {
+  configs,
+  db as dbCore,
+  platform,
+  tenancy,
+} from "@budibase/backend-core"
 import { quotas } from "@budibase/pro"
+import { ConfigType, LockReason, SettingsConfig } from "@budibase/types"
 
 export async function deleteTenant(tenantId: string) {
   await quotas.bustCache()
@@ -8,6 +14,28 @@ export async function deleteTenant(tenantId: string) {
   await removeGlobalDB(tenantId)
 }
 
+export async function lockTenant(tenantId: string, lockReason: LockReason) {
+  return await setLock(tenantId, lockReason)
+}
+
+export async function unlockTenant(tenantId: string) {
+  return await setLock(tenantId)
+}
+
+async function setLock(tenantId: string, lockReason?: LockReason) {
+  const db = tenancy.getTenantDB(tenantId)
+  const settingsConfig = await db.tryGet<SettingsConfig>(
+    configs.generateConfigID(ConfigType.SETTINGS)
+  )
+  if (!settingsConfig?.config) {
+    throw new Error(
+      `Cannot lock. Settings config not found for tenant ${tenantId}`
+    )
+  }
+  settingsConfig.config.lockedBy = lockReason
+  await db.put(settingsConfig)
+}
+
 async function removeGlobalDB(tenantId: string) {
   try {
     const db = tenancy.getTenantDB(tenantId)

package/src/sdk/tenants/tests/tenants.spec.ts

@@ -0,0 +1,162 @@
+import { structures } from "../../../tests"
+import { lockTenant, unlockTenant } from "../tenants"
+import { configs, tenancy } from "@budibase/backend-core"
+import { LockReason, ConfigType, SettingsConfig } from "@budibase/types"
+
+// Mock the backend-core modules
+jest.mock("@budibase/backend-core", () => {
+  const actual = jest.requireActual("@budibase/backend-core")
+  return {
+    ...actual,
+    tenancy: {
+      ...actual.tenancy,
+      getTenantDB: jest.fn(),
+      getGlobalDBName: jest.fn(),
+    },
+    configs: {
+      ...actual.configs,
+      generateConfigID: jest.fn(),
+    },
+    db: {
+      ...actual.db,
+      getAllWorkspaces: jest.fn(),
+      getDB: jest.fn(),
+      dbExists: jest.fn(),
+      getGlobalUserParams: jest.fn(),
+    },
+    platform: {
+      ...actual.platform,
+      getPlatformDB: jest.fn(),
+    },
+  }
+})
+
+// Mock the pro module
+jest.mock("@budibase/pro", () => ({
+  quotas: {
+    bustCache: jest.fn(),
+  },
+  constants: {
+    licenses: {
+      CLOUD_FREE_LICENSE: "CLOUD_FREE_LICENSE",
+      UNLIMITED_LICENSE: "UNLIMITED_LICENSE",
+    },
+  },
+  licensing: {
+    cache: {
+      getCachedLicense: jest.fn(),
+    },
+  },
+}))
+
+const mockDb = {
+  put: jest.fn(),
+  tryGet: jest.fn(),
+}
+
+const mockedTenancy = jest.mocked(tenancy)
+const mockedConfigs = jest.mocked(configs)
+
+describe("tenants", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    // Setup mock database
+    mockedTenancy.getTenantDB.mockReturnValue(mockDb as any)
+    // Setup mock config ID generation
+    mockedConfigs.generateConfigID.mockReturnValue("config_settings")
+  })
+
+  describe("lockTenant", () => {
+    it("should lock tenant with provided reason", async () => {
+      const tenantId = structures.tenant.id()
+      const lockReason = LockReason.FREE_TIER
+
+      const settingsConfig: SettingsConfig = {
+        _id: "config_settings",
+        type: ConfigType.SETTINGS,
+        config: {},
+      }
+
+      mockDb.tryGet.mockResolvedValue(settingsConfig)
+
+      await lockTenant(tenantId, lockReason)
+
+      expect(mockDb.tryGet).toHaveBeenCalledWith(
+        configs.generateConfigID(ConfigType.SETTINGS)
+      )
+      expect(mockDb.put).toHaveBeenCalledWith({
+        ...settingsConfig,
+        config: {
+          ...settingsConfig.config,
+          lockedBy: lockReason,
+        },
+      })
+    })
+
+    it("should throw error when settings config not found", async () => {
+      const tenantId = structures.tenant.id()
+      const lockReason = LockReason.FREE_TIER
+
+      mockDb.tryGet.mockResolvedValue(null)
+
+      await expect(lockTenant(tenantId, lockReason)).rejects.toThrow(
+        `Cannot lock. Settings config not found for tenant ${tenantId}`
+      )
+    })
+
+    it("should throw error when settings config has no config property", async () => {
+      const tenantId = structures.tenant.id()
+      const lockReason = LockReason.FREE_TIER
+
+      const settingsConfig = {
+        _id: "config_settings",
+        type: ConfigType.SETTINGS,
+      }
+
+      mockDb.tryGet.mockResolvedValue(settingsConfig)
+
+      await expect(lockTenant(tenantId, lockReason)).rejects.toThrow(
+        `Cannot lock. Settings config not found for tenant ${tenantId}`
+      )
+    })
+  })
+
+  describe("unlockTenant", () => {
+    it("should unlock tenant by removing lock reason", async () => {
+      const tenantId = structures.tenant.id()
+
+      const settingsConfig: SettingsConfig = {
+        _id: "config_settings",
+        type: ConfigType.SETTINGS,
+        config: {
+          lockedBy: LockReason.FREE_TIER,
+        },
+      }
+
+      mockDb.tryGet.mockResolvedValue(settingsConfig)
+
+      await unlockTenant(tenantId)
+
+      expect(mockDb.tryGet).toHaveBeenCalledWith(
+        configs.generateConfigID(ConfigType.SETTINGS)
+      )
+      expect(mockDb.put).toHaveBeenCalledWith({
+        ...settingsConfig,
+        config: {
+          ...settingsConfig.config,
+          lockedBy: undefined,
+        },
+      })
+    })
+
+    it("should throw error when settings config not found", async () => {
+      const tenantId = structures.tenant.id()
+
+      mockDb.tryGet.mockResolvedValue(null)
+
+      await expect(unlockTenant(tenantId)).rejects.toThrow(
+        `Cannot lock. Settings config not found for tenant ${tenantId}`
+      )
+    })
+  })
+})

package/src/tests/api/tenants.ts

@@ -1,5 +1,6 @@
 import TestConfiguration from "../TestConfiguration"
 import { TestAPI, TestAPIOpts } from "./base"
+import { LockRequest } from "@budibase/types"
 
 export class TenantAPI extends TestAPI {
   config: TestConfiguration
@@ -14,4 +15,12 @@ export class TenantAPI extends TestAPI {
       .set(opts?.headers)
       .expect(opts?.status ? opts.status : 204)
   }
+
+  lock = (tenantId: string, body: LockRequest, opts?: TestAPIOpts) => {
+    return this.request
+      .put(`/api/system/tenants/${tenantId}/lock`)
+      .send(body)
+      .set(opts?.headers)
+      .expect(opts?.status ? opts.status : 204)
+  }
 }