@budibase/backend-core 2.9.40-alpha.6 → 2.10.1

package/src/tenancy/tenancy.ts

@@ -0,0 +1,140 @@
+import {
+  DEFAULT_TENANT_ID,
+  getTenantId,
+  getTenantIDFromAppID,
+  isMultiTenant,
+  getPlatformURL,
+} from "../context"
+import {
+  BBContext,
+  TenantResolutionStrategy,
+  GetTenantIdOptions,
+} from "@budibase/types"
+import { Header } from "../constants"
+
+export function addTenantToUrl(url: string) {
+  const tenantId = getTenantId()
+
+  if (isMultiTenant()) {
+    const char = url.indexOf("?") === -1 ? "?" : "&"
+    url += `${char}tenantId=${tenantId}`
+  }
+
+  return url
+}
+
+export const isUserInAppTenant = (appId: string, user?: any) => {
+  let userTenantId
+  if (user) {
+    userTenantId = user.tenantId || DEFAULT_TENANT_ID
+  } else {
+    userTenantId = getTenantId()
+  }
+  const tenantId = getTenantIDFromAppID(appId) || DEFAULT_TENANT_ID
+  return tenantId === userTenantId
+}
+
+const ALL_STRATEGIES = Object.values(TenantResolutionStrategy)
+
+export const getTenantIDFromCtx = (
+  ctx: BBContext,
+  opts: GetTenantIdOptions
+): string | null => {
+  // exit early if not multi-tenant
+  if (!isMultiTenant()) {
+    return DEFAULT_TENANT_ID
+  }
+
+  // opt defaults
+  if (opts.allowNoTenant === undefined) {
+    opts.allowNoTenant = false
+  }
+  if (!opts.includeStrategies) {
+    opts.includeStrategies = ALL_STRATEGIES
+  }
+  if (!opts.excludeStrategies) {
+    opts.excludeStrategies = []
+  }
+
+  const isAllowed = (strategy: TenantResolutionStrategy) => {
+    // excluded takes precedence
+    if (opts.excludeStrategies?.includes(strategy)) {
+      return false
+    }
+    if (opts.includeStrategies?.includes(strategy)) {
+      return true
+    }
+  }
+
+  // always use user first
+  if (isAllowed(TenantResolutionStrategy.USER)) {
+    const userTenantId = ctx.user?.tenantId
+    if (userTenantId) {
+      return userTenantId
+    }
+  }
+
+  // header
+  if (isAllowed(TenantResolutionStrategy.HEADER)) {
+    const headerTenantId = ctx.request.headers[Header.TENANT_ID]
+    if (headerTenantId) {
+      return headerTenantId as string
+    }
+  }
+
+  // query param
+  if (isAllowed(TenantResolutionStrategy.QUERY)) {
+    const queryTenantId = ctx.request.query.tenantId
+    if (queryTenantId) {
+      return queryTenantId as string
+    }
+  }
+
+  // subdomain
+  if (isAllowed(TenantResolutionStrategy.SUBDOMAIN)) {
+    // e.g. budibase.app or local.com:10000
+    const platformHost = new URL(getPlatformURL()).host.split(":")[0]
+    // e.g. tenant.budibase.app or tenant.local.com
+    const requestHost = ctx.host
+    // parse the tenant id from the difference
+    if (requestHost.includes(platformHost)) {
+      const tenantId = requestHost.substring(
+        0,
+        requestHost.indexOf(`.${platformHost}`)
+      )
+      if (tenantId) {
+        return tenantId
+      }
+    }
+  }
+
+  // path
+  if (isAllowed(TenantResolutionStrategy.PATH)) {
+    // params - have to parse manually due to koa-router not run yet
+    const match = ctx.matched.find(
+      (m: any) => !!m.paramNames.find((p: any) => p.name === "tenantId")
+    )
+
+    // get the raw path url - without any query params
+    const ctxUrl = ctx.originalUrl
+    let url
+    if (ctxUrl.includes("?")) {
+      url = ctxUrl.split("?")[0]
+    } else {
+      url = ctxUrl
+    }
+
+    if (match) {
+      const params = match.params(url, match.captures(url), {})
+      if (params.tenantId) {
+        return params.tenantId
+      }
+    }
+  }
+
+  if (!opts.allowNoTenant) {
+    ctx.throw(403, "Tenant id not set")
+  }
+
+  return null
+}

package/src/tenancy/tests/tenancy.spec.ts

@@ -0,0 +1,184 @@
+import { TenantResolutionStrategy } from "@budibase/types"
+import { addTenantToUrl, isUserInAppTenant, getTenantIDFromCtx } from "../"
+import { isMultiTenant, getTenantIDFromAppID } from "../../context"
+
+jest.mock("../../context", () => ({
+  getTenantId: jest.fn(() => "budibase"),
+  isMultiTenant: jest.fn(() => true),
+  getTenantIDFromAppID: jest.fn(),
+  getPlatformURL: jest.fn(() => "https://app.com"),
+  DEFAULT_TENANT_ID: "default",
+}))
+
+const mockedIsMultiTenant = isMultiTenant as jest.MockedFunction<
+  typeof isMultiTenant
+>
+const mockedGetTenantIDFromAppID = getTenantIDFromAppID as jest.MockedFunction<
+  typeof getTenantIDFromAppID
+>
+
+describe("addTenantToUrl", () => {
+  it("should append tenantId parameter to the URL", () => {
+    const url = "https://budibase.com"
+    const expectedUrl = "https://budibase.com?tenantId=budibase"
+    expect(addTenantToUrl(url)).toEqual(expectedUrl)
+  })
+
+  it("should append tenantId parameter to the URL query string", () => {
+    const url = "https://budibase.com?var=test"
+    const expectedUrl = "https://budibase.com?var=test&tenantId=budibase"
+    expect(addTenantToUrl(url)).toEqual(expectedUrl)
+  })
+
+  it("should not append tenantId parameter to the URL if isMultiTenant is false", () => {
+    mockedIsMultiTenant.mockImplementation(() => false)
+
+    const url = "https://budibase.com"
+    const expectedUrl = "https://budibase.com"
+    expect(addTenantToUrl(url)).toEqual(expectedUrl)
+  })
+})
+
+describe("isUserInAppTenant", () => {
+  mockedGetTenantIDFromAppID.mockImplementation(() => "budibase")
+  const mockUser = { tenantId: "budibase" }
+
+  it("returns true if user tenant ID matches app tenant ID", () => {
+    const appId = "app-budibase"
+    const result = isUserInAppTenant(appId, mockUser)
+    expect(result).toBe(true)
+  })
+
+  it("uses default tenant ID if user is not provided", () => {
+    const appId = "app-budibase"
+    const result = isUserInAppTenant(appId)
+    expect(result).toBe(true)
+  })
+
+  it("uses default tenant ID if app tenant ID is not found", () => {
+    const appId = "not-budibase-app"
+    const result = isUserInAppTenant(appId, mockUser)
+    expect(result).toBe(true)
+  })
+
+  it("returns false if user tenant ID does not match app tenant ID", () => {
+    const appId = "app-budibase"
+    mockedGetTenantIDFromAppID.mockImplementation(() => "not-budibase")
+    const result = isUserInAppTenant(appId, mockUser)
+    expect(result).toBe(false)
+  })
+})
+
+let mockOpts: any = {}
+function createCtx(opts: {
+  originalUrl?: string
+  headers?: Record<string, string>
+  qsTenantId?: string
+  userTenantId?: string
+  host?: string
+  path?: string
+}) {
+  const createdCtx: any = {
+    originalUrl: opts.originalUrl || "budibase.com",
+    matched: [{ name: "name" }],
+    throw: jest.fn(),
+    request: { headers: {} },
+  }
+  if (opts.headers) {
+    createdCtx.request.headers = opts.headers
+  }
+  if (opts.qsTenantId) {
+    createdCtx.request.query = { tenantId: opts.qsTenantId }
+  }
+  if (opts.userTenantId) {
+    createdCtx.user = { tenantId: opts.userTenantId }
+  }
+  if (opts.host) {
+    createdCtx.host = opts.host
+  }
+  if (opts.path) {
+    createdCtx.matched = [
+      {
+        paramNames: [{ name: "tenantId" }],
+        params: () => ({ tenantId: opts.path }),
+        captures: jest.fn(),
+      },
+    ]
+  }
+
+  return createdCtx as any
+}
+
+describe("getTenantIDFromCtx", () => {
+  describe("when tenant can be found", () => {
+    it("returns the tenant ID from the user object", () => {
+      mockedIsMultiTenant.mockImplementation(() => true)
+      const ctx = createCtx({ userTenantId: "budibase" })
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toEqual("budibase")
+    })
+
+    it("returns the tenant ID from the header", () => {
+      mockedIsMultiTenant.mockImplementation(() => true)
+      const ctx = createCtx({ headers: { "x-budibase-tenant-id": "budibase" } })
+      mockOpts = { includeStrategies: [TenantResolutionStrategy.HEADER] }
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toEqual("budibase")
+    })
+
+    it("returns the tenant ID from the query param", () => {
+      mockedIsMultiTenant.mockImplementation(() => true)
+      mockOpts = { includeStrategies: [TenantResolutionStrategy.QUERY] }
+      const ctx = createCtx({ qsTenantId: "budibase" })
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toEqual("budibase")
+    })
+
+    it("returns the tenant ID from the subdomain", () => {
+      mockedIsMultiTenant.mockImplementation(() => true)
+      const ctx = createCtx({ host: "bb.app.com" })
+      mockOpts = { includeStrategies: [TenantResolutionStrategy.SUBDOMAIN] }
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toEqual("bb")
+    })
+
+    it("returns the tenant ID from the path", () => {
+      mockedIsMultiTenant.mockImplementation(() => true)
+      const ctx = createCtx({ path: "bb" })
+      mockOpts = { includeStrategies: [TenantResolutionStrategy.PATH] }
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toEqual("bb")
+    })
+  })
+
+  describe("when tenant cannot be found", () => {
+    it("throws a 403 error if allowNoTenant is false", () => {
+      const ctx = createCtx({})
+      mockOpts = {
+        allowNoTenant: false,
+        excludeStrategies: [
+          TenantResolutionStrategy.QUERY,
+          TenantResolutionStrategy.SUBDOMAIN,
+          TenantResolutionStrategy.PATH,
+        ],
+      }
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toBeNull()
+      expect(ctx.throw).toBeCalledTimes(1)
+      expect(ctx.throw).toBeCalledWith(403, "Tenant id not set")
+    })
+
+    it("returns null if allowNoTenant is true", () => {
+      const ctx = createCtx({})
+      mockOpts = {
+        allowNoTenant: true,
+        excludeStrategies: [
+          TenantResolutionStrategy.QUERY,
+          TenantResolutionStrategy.SUBDOMAIN,
+          TenantResolutionStrategy.PATH,
+        ],
+      }
+      expect(getTenantIDFromCtx(ctx, mockOpts)).toBeNull()
+    })
+  })
+
+  it("returns the default tenant ID when isMultiTenant() returns false", () => {
+    mockedIsMultiTenant.mockImplementation(() => false)
+    const ctx = createCtx({})
+    expect(getTenantIDFromCtx(ctx, mockOpts)).toEqual("default")
+  })
+})

package/src/timers/index.ts

@@ -0,0 +1 @@
+export * from "./timers"

package/src/timers/timers.ts

@@ -0,0 +1,22 @@
+let intervals: NodeJS.Timeout[] = []
+
+export function set(callback: () => any, period: number) {
+  const interval = setInterval(callback, period)
+  intervals.push(interval)
+  return interval
+}
+
+export function clear(interval: NodeJS.Timeout) {
+  const idx = intervals.indexOf(interval)
+  if (idx !== -1) {
+    intervals.splice(idx, 1)
+  }
+  clearInterval(interval)
+}
+
+export function cleanup() {
+  for (let interval of intervals) {
+    clearInterval(interval)
+  }
+  intervals = []
+}