@budibase/backend-core 2.9.19 → 2.9.21-alpha.0

package/src/security/tests/sessions.spec.ts

@@ -1,12 +0,0 @@
-import * as sessions from "../sessions"
-
-describe("sessions", () => {
-  describe("getSessionsForUser", () => {
-    it("returns empty when user is undefined", async () => {
-      // @ts-ignore - allow the undefined to be passed
-      const results = await sessions.getSessionsForUser(undefined)
-
-      expect(results).toStrictEqual([])
-    })
-  })
-})

package/src/tenancy/db.ts

@@ -1,6 +0,0 @@
-import { getDB } from "../db/db"
-import { getGlobalDBName } from "../context"
-
-export function getTenantDB(tenantId: string) {
-  return getDB(getGlobalDBName(tenantId))
-}

package/src/tenancy/index.ts

@@ -1,2 +0,0 @@
-export * from "./db"
-export * from "./tenancy"

package/src/tenancy/tenancy.ts

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

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

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

package/src/timers/timers.ts

@@ -1,22 +0,0 @@
-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 = []
-}