@budibase/backend-core 3.2.4 → 3.2.6

package/src/features/tests/features.spec.ts

@@ -1,267 +0,0 @@
-import { IdentityContext, IdentityType } from "@budibase/types"
-import { Flag, FlagSet, FlagValues, init, shutdown } from "../"
-import * as context from "../../context"
-import environment, { withEnv } from "../../environment"
-import nodeFetch from "node-fetch"
-import nock from "nock"
-import * as crypto from "crypto"
-
-const schema = {
-  TEST_BOOLEAN: Flag.boolean(false),
-  TEST_STRING: Flag.string("default value"),
-  TEST_NUMBER: Flag.number(0),
-  TEST_BOOLEAN_DEFAULT_TRUE: Flag.boolean(true),
-}
-const flags = new FlagSet(schema)
-
-interface TestCase {
-  it: string
-  identity?: Partial<IdentityContext>
-  environmentFlags?: string
-  posthogFlags?: PostHogFlags
-  expected?: Partial<FlagValues<typeof schema>>
-  errorMessage?: string | RegExp
-}
-
-interface PostHogFlags {
-  featureFlags?: Record<string, boolean>
-  featureFlagPayloads?: Record<string, string>
-}
-
-function mockPosthogFlags(
-  flags: PostHogFlags,
-  opts?: { token?: string; distinct_id?: string }
-) {
-  const { token = "test", distinct_id = "us_1234" } = opts || {}
-  nock("https://us.i.posthog.com")
-    .post("/decide/?v=3", body => {
-      return body.token === token && body.distinct_id === distinct_id
-    })
-    .reply(200, flags)
-    .persist()
-}
-
-describe("feature flags", () => {
-  beforeEach(() => {
-    nock.cleanAll()
-  })
-
-  it.each<TestCase>([
-    {
-      it: "should should find a simple boolean flag in the environment",
-      environmentFlags: "default:TEST_BOOLEAN",
-      expected: { TEST_BOOLEAN: true },
-    },
-    {
-      it: "should should find a simple netgative boolean flag in the environment",
-      environmentFlags: "default:!TEST_BOOLEAN",
-      expected: { TEST_BOOLEAN: false },
-    },
-    {
-      it: "should should match stars in the environment",
-      environmentFlags: "*:TEST_BOOLEAN",
-      expected: { TEST_BOOLEAN: true },
-    },
-    {
-      it: "should not match a different tenant's flags",
-      environmentFlags: "otherTenant:TEST_BOOLEAN",
-      expected: { TEST_BOOLEAN: false },
-    },
-    {
-      it: "should return the defaults when no flags are set",
-      expected: flags.defaults(),
-    },
-    {
-      it: "should ignore unknown feature flags",
-      environmentFlags: "default:TEST_BOOLEAN,default:FOO",
-      expected: { TEST_BOOLEAN: true },
-    },
-    {
-      it: "should be able to read boolean flags from PostHog",
-      posthogFlags: {
-        featureFlags: { TEST_BOOLEAN: true },
-      },
-      expected: { TEST_BOOLEAN: true },
-    },
-    {
-      it: "should be able to read string flags from PostHog",
-      posthogFlags: {
-        featureFlags: { TEST_STRING: true },
-        featureFlagPayloads: { TEST_STRING: "test" },
-      },
-      expected: { TEST_STRING: "test" },
-    },
-    {
-      it: "should be able to read numeric flags from PostHog",
-      posthogFlags: {
-        featureFlags: { TEST_NUMBER: true },
-        featureFlagPayloads: { TEST_NUMBER: "123" },
-      },
-      expected: { TEST_NUMBER: 123 },
-    },
-    {
-      it: "should not be able to override a negative environment flag from PostHog",
-      environmentFlags: "default:!TEST_BOOLEAN",
-      posthogFlags: {
-        featureFlags: { TEST_BOOLEAN: true },
-      },
-      expected: { TEST_BOOLEAN: false },
-    },
-    {
-      it: "should not be able to override a positive environment flag from PostHog",
-      environmentFlags: "default:TEST_BOOLEAN",
-      posthogFlags: {
-        featureFlags: {
-          TEST_BOOLEAN: false,
-        },
-      },
-      expected: { TEST_BOOLEAN: true },
-    },
-    {
-      it: "should not error on unrecognised PostHog flag",
-      posthogFlags: {
-        featureFlags: { UNDEFINED: true },
-      },
-      expected: flags.defaults(),
-    },
-    {
-      it: "should be possible to override a default true flag to false",
-      environmentFlags: "default:!TEST_BOOLEAN_DEFAULT_TRUE",
-      expected: { TEST_BOOLEAN_DEFAULT_TRUE: false },
-    },
-  ])(
-    "$it",
-    async ({
-      identity,
-      environmentFlags,
-      posthogFlags,
-      expected,
-      errorMessage,
-    }) => {
-      const env: Partial<typeof environment> = {
-        TENANT_FEATURE_FLAGS: environmentFlags,
-        SELF_HOSTED: false,
-        POSTHOG_FEATURE_FLAGS_ENABLED: "true",
-      }
-
-      if (posthogFlags) {
-        mockPosthogFlags(posthogFlags)
-        env.POSTHOG_TOKEN = "test"
-        env.POSTHOG_API_HOST = "https://us.i.posthog.com"
-      }
-
-      await withEnv(env, async () => {
-        // We need to pass in node-fetch here otherwise nock won't get used
-        // because posthog-node uses axios under the hood.
-        init({
-          fetch: (url, opts) => {
-            return nodeFetch(url, opts)
-          },
-        })
-
-        const fullIdentity: IdentityContext = {
-          _id: "us_1234",
-          tenantId: "default",
-          type: IdentityType.USER,
-          email: "test@example.com",
-          firstName: "Test",
-          lastName: "User",
-          ...identity,
-        }
-
-        await context.doInIdentityContext(fullIdentity, async () => {
-          if (errorMessage) {
-            await expect(flags.fetch()).rejects.toThrow(errorMessage)
-          } else if (expected) {
-            const values = await flags.fetch()
-            expect(values).toMatchObject(expected)
-
-            for (const [key, expectedValue] of Object.entries(expected)) {
-              const value = await flags.get(key as keyof typeof schema)
-              expect(value).toBe(expectedValue)
-            }
-          } else {
-            throw new Error("No expected value")
-          }
-        })
-
-        shutdown()
-      })
-    }
-  )
-
-  it("should not error if PostHog is down", async () => {
-    const identity: IdentityContext = {
-      _id: "us_1234",
-      tenantId: "default",
-      type: IdentityType.USER,
-      email: "test@example.com",
-      firstName: "Test",
-      lastName: "User",
-    }
-
-    // We need to pass in node-fetch here otherwise nock won't get used
-    // because posthog-node uses axios under the hood.
-    init({
-      fetch: (url, opts) => {
-        return nodeFetch(url, opts)
-      },
-    })
-
-    nock("https://us.i.posthog.com")
-      .post("/decide/?v=3", body => {
-        return body.token === "test" && body.distinct_id === "us_1234"
-      })
-      .reply(503)
-      .persist()
-
-    await withEnv(
-      { POSTHOG_TOKEN: "test", POSTHOG_API_HOST: "https://us.i.posthog.com" },
-      async () => {
-        await context.doInIdentityContext(identity, async () => {
-          await flags.fetch()
-        })
-      }
-    )
-  })
-
-  it("should still get flags when user is logged out", async () => {
-    const env: Partial<typeof environment> = {
-      SELF_HOSTED: false,
-      POSTHOG_FEATURE_FLAGS_ENABLED: "true",
-      POSTHOG_API_HOST: "https://us.i.posthog.com",
-      POSTHOG_TOKEN: "test",
-    }
-
-    const ip = "127.0.0.1"
-    const hashedIp = crypto.createHash("sha512").update(ip).digest("hex")
-
-    await withEnv(env, async () => {
-      mockPosthogFlags(
-        {
-          featureFlags: { TEST_BOOLEAN: true },
-        },
-        {
-          distinct_id: hashedIp,
-        }
-      )
-
-      // We need to pass in node-fetch here otherwise nock won't get used
-      // because posthog-node uses axios under the hood.
-      init({
-        fetch: (url, opts) => {
-          return nodeFetch(url, opts)
-        },
-      })
-
-      await context.doInIPContext(ip, async () => {
-        await context.doInTenant("default", async () => {
-          const result = await flags.fetch()
-          expect(result.TEST_BOOLEAN).toBe(true)
-        })
-      })
-
-      shutdown()
-    })
-  })
-})

package/src/features/tests/utils.ts

@@ -1,64 +0,0 @@
-import { FeatureFlags, parseEnvFlags } from ".."
-import { setEnv } from "../../environment"
-
-function getCurrentFlags(): Record<string, Record<string, boolean>> {
-  const result: Record<string, Record<string, boolean>> = {}
-  for (const { tenantId, key, value } of parseEnvFlags(
-    process.env.TENANT_FEATURE_FLAGS || ""
-  )) {
-    const tenantFlags = result[tenantId] || {}
-    // Don't allow overwriting specifically false flags, to match the beheaviour
-    // of FlagSet.
-    if (tenantFlags[key] === false) {
-      continue
-    }
-    tenantFlags[key] = value
-    result[tenantId] = tenantFlags
-  }
-  return result
-}
-
-function buildFlagString(
-  flags: Record<string, Record<string, boolean>>
-): string {
-  const parts: string[] = []
-  for (const [tenantId, tenantFlags] of Object.entries(flags)) {
-    for (const [key, value] of Object.entries(tenantFlags)) {
-      if (value === false) {
-        parts.push(`${tenantId}:!${key}`)
-      } else {
-        parts.push(`${tenantId}:${key}`)
-      }
-    }
-  }
-  return parts.join(",")
-}
-
-export function setFeatureFlags(
-  tenantId: string,
-  flags: Partial<FeatureFlags>
-): () => void {
-  const current = getCurrentFlags()
-  for (const [key, value] of Object.entries(flags)) {
-    const tenantFlags = current[tenantId] || {}
-    tenantFlags[key] = value
-    current[tenantId] = tenantFlags
-  }
-  const flagString = buildFlagString(current)
-  return setEnv({ TENANT_FEATURE_FLAGS: flagString })
-}
-
-export function withFeatureFlags<T>(
-  tenantId: string,
-  flags: Partial<FeatureFlags>,
-  f: () => T
-) {
-  const cleanup = setFeatureFlags(tenantId, flags)
-  const result = f()
-  if (result instanceof Promise) {
-    return result.finally(cleanup)
-  } else {
-    cleanup()
-    return result
-  }
-}

package/src/helpers.ts

@@ -1,9 +0,0 @@
-/**
- * Makes sure that a URL has the correct number of slashes, while maintaining the
- * http(s):// double slashes.
- * @param url The URL to test and remove any extra double slashes.
- * @return The updated url.
- */
-export function checkSlashesInUrl(url: string) {
-  return url.replace(/(https?:\/\/)|(\/)+/g, "$1$2")
-}

package/src/index.ts

@@ -1,59 +0,0 @@
-export * as configs from "./configs"
-export * as events from "./events"
-export * as migrations from "./migrations"
-export * as users from "./users"
-export * as userUtils from "./users/utils"
-export * as roles from "./security/roles"
-export * as permissions from "./security/permissions"
-export * as accounts from "./accounts"
-export * as installation from "./installation"
-export * as features from "./features"
-export * as sessions from "./security/sessions"
-export * as platform from "./platform"
-export * as auth from "./auth"
-export * as constants from "./constants"
-export * as logging from "./logging"
-export * as middleware from "./middleware"
-export * as plugins from "./plugin"
-export * as encryption from "./security/encryption"
-export * as queue from "./queue"
-export * as db from "./db"
-export * as context from "./context"
-export * as cache from "./cache"
-export * as objectStore from "./objectStore"
-export * as redis from "./redis"
-export { Client as RedisClient } from "./redis"
-export * as locks from "./redis/redlockImpl"
-export * as utils from "./utils"
-export * as errors from "./errors"
-export * as timers from "./timers"
-export { default as env, withEnv, setEnv } from "./environment"
-export * as blacklist from "./blacklist"
-export * as docUpdates from "./docUpdates"
-export * from "./utils/Duration"
-export * as docIds from "./docIds"
-export * as security from "./security"
-export * as sql from "./sql"
-// Add context to tenancy for backwards compatibility
-// only do this for external usages to prevent internal
-// circular dependencies
-import * as context from "./context"
-import * as _tenancy from "./tenancy"
-
-export const tenancy = {
-  ..._tenancy,
-  ...context,
-}
-
-// expose error classes directly
-export * from "./errors"
-
-// expose constants directly
-export * from "./constants"
-
-// expose package init function
-import * as db from "./db"
-
-export const init = (opts: any = {}) => {
-  db.init(opts.db)
-}

package/src/installation.ts

@@ -1,115 +0,0 @@
-import { newid } from "./utils"
-import * as events from "./events"
-import { StaticDatabases, doWithDB } from "./db"
-import { Installation, IdentityType, Database } from "@budibase/types"
-import * as context from "./context"
-import semver from "semver"
-import { bustCache, withCache, TTL, CacheKey } from "./cache/generic"
-import environment from "./environment"
-import { logAlert } from "./logging"
-
-export const getInstall = async (): Promise<Installation> => {
-  return withCache(CacheKey.INSTALLATION, TTL.ONE_DAY, getInstallFromDB, {
-    useTenancy: false,
-  })
-}
-async function createInstallDoc(platformDb: Database) {
-  const install: Installation = {
-    _id: StaticDatabases.PLATFORM_INFO.docs.install,
-    installId: newid(),
-    version: environment.VERSION,
-  }
-  try {
-    const resp = await platformDb.put(install)
-    install._rev = resp.rev
-    return install
-  } catch (err: any) {
-    if (err.status === 409) {
-      return getInstallFromDB()
-    } else {
-      throw err
-    }
-  }
-}
-
-export const getInstallFromDB = async (): Promise<Installation> => {
-  return doWithDB(
-    StaticDatabases.PLATFORM_INFO.name,
-    async (platformDb: any) => {
-      let install: Installation
-      try {
-        install = await platformDb.get(
-          StaticDatabases.PLATFORM_INFO.docs.install
-        )
-      } catch (e: any) {
-        if (e.status === 404) {
-          install = await createInstallDoc(platformDb)
-        } else {
-          throw e
-        }
-      }
-      return install
-    }
-  )
-}
-
-const updateVersion = async (version: string): Promise<boolean> => {
-  try {
-    await doWithDB(
-      StaticDatabases.PLATFORM_INFO.name,
-      async (platformDb: any) => {
-        const install = await getInstall()
-        install.version = version
-        await platformDb.put(install)
-        await bustCache(CacheKey.INSTALLATION)
-      }
-    )
-  } catch (e: any) {
-    if (e.status === 409) {
-      // do nothing - version has already been updated
-      // likely in clustered environment
-      return false
-    }
-    throw e
-  }
-  return true
-}
-
-export const checkInstallVersion = async (): Promise<void> => {
-  const install = await getInstall()
-
-  const currentVersion = install.version
-  const newVersion = environment.VERSION
-
-  try {
-    if (currentVersion !== newVersion) {
-      const isUpgrade = semver.gt(newVersion, currentVersion)
-      const isDowngrade = semver.lt(newVersion, currentVersion)
-
-      const success = await updateVersion(newVersion)
-
-      if (success) {
-        await context.doInIdentityContext(
-          {
-            _id: install.installId,
-            type: IdentityType.INSTALLATION,
-          },
-          async () => {
-            if (isUpgrade) {
-              await events.installation.upgraded(currentVersion, newVersion)
-            } else if (isDowngrade) {
-              await events.installation.downgraded(currentVersion, newVersion)
-            }
-          }
-        )
-        await events.identification.identifyInstallationGroup(install.installId)
-      }
-    }
-  } catch (err: any) {
-    if (err?.message?.includes("Invalid Version")) {
-      logAlert(`Invalid version "${newVersion}" - is it semver?`)
-    } else {
-      logAlert("Failed to retrieve version", err)
-    }
-  }
-}

package/src/logging/alerts.ts

@@ -1,26 +0,0 @@
-const NonErrors = ["AccountError"]
-
-function isSuppressed(e?: any) {
-  return e && e["suppressAlert"]
-}
-
-export function logAlert(message: string, e?: any) {
-  if (e && NonErrors.includes(e.name) && isSuppressed(e)) {
-    return
-  }
-  console.error(`bb-alert: ${message}`, e)
-}
-
-export function logAlertWithInfo(
-  message: string,
-  db: string,
-  id: string,
-  error: any
-) {
-  message = `${message} - db: ${db} - doc: ${id} - error: `
-  logAlert(message, error)
-}
-
-export function logWarn(message: string, e?: any) {
-  console.warn(`bb-warn: ${message}`, e)
-}

package/src/logging/correlation/correlation.ts

@@ -1,15 +0,0 @@
-import { Header } from "../../constants"
-
-const correlator = require("correlation-id")
-
-export const setHeader = (headers: Record<string, string>) => {
-  const correlationId = correlator.getId()
-  if (!correlationId) {
-    return
-  }
-  headers[Header.CORRELATION_ID] = correlationId
-}
-
-export function getId() {
-  return correlator.getId()
-}

package/src/logging/correlation/index.ts

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

package/src/logging/correlation/middleware.ts

@@ -1,18 +0,0 @@
-import { Header } from "../../constants"
-import { v4 as uuid } from "uuid"
-
-const correlator = require("correlation-id")
-
-const correlation = (ctx: any, next: any) => {
-  // use the provided correlation id header if present
-  let correlationId = ctx.headers[Header.CORRELATION_ID]
-  if (!correlationId) {
-    correlationId = uuid()
-  }
-
-  return correlator.withId(correlationId, () => {
-    return next()
-  })
-}
-
-export default correlation

package/src/logging/index.ts

@@ -1,4 +0,0 @@
-export * as correlation from "./correlation/correlation"
-export { logger } from "./pino/logger"
-export * from "./alerts"
-export * as system from "./system"