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

package/src/middleware/tests/builder.spec.ts

@@ -1,180 +0,0 @@
-import adminOnly from "../adminOnly"
-import builderOnly from "../builderOnly"
-import builderOrAdmin from "../builderOrAdmin"
-import { structures } from "../../../tests"
-import { ContextUser, ServiceType } from "@budibase/types"
-import { doInAppContext } from "../../context"
-import env from "../../environment"
-env._set("SERVICE_TYPE", ServiceType.APPS)
-
-const appId = "app_aaa"
-const basicUser = structures.users.user()
-const adminUser = structures.users.adminUser()
-const adminOnlyUser = structures.users.adminOnlyUser()
-const builderUser = structures.users.builderUser()
-const appBuilderUser = structures.users.appBuilderUser(appId)
-
-function buildUserCtx(user: ContextUser) {
-  return {
-    internal: false,
-    user,
-    throw: jest.fn(),
-  } as any
-}
-
-function passed(throwFn: jest.Func, nextFn: jest.Func) {
-  expect(throwFn).not.toBeCalled()
-  expect(nextFn).toBeCalled()
-}
-
-function threw(throwFn: jest.Func) {
-  // cant check next, the throw function doesn't actually throw - so it still continues
-  expect(throwFn).toBeCalled()
-}
-
-describe("adminOnly middleware", () => {
-  it("should allow admin user", () => {
-    const ctx = buildUserCtx(adminUser),
-      next = jest.fn()
-    adminOnly(ctx, next)
-    passed(ctx.throw, next)
-  })
-
-  it("should not allow basic user", () => {
-    const ctx = buildUserCtx(basicUser),
-      next = jest.fn()
-    adminOnly(ctx, next)
-    threw(ctx.throw)
-  })
-
-  it("should not allow builder user", () => {
-    const ctx = buildUserCtx(builderUser),
-      next = jest.fn()
-    adminOnly(ctx, next)
-    threw(ctx.throw)
-  })
-})
-
-describe("builderOnly middleware", () => {
-  it("should allow builder user", () => {
-    const ctx = buildUserCtx(builderUser),
-      next = jest.fn()
-    builderOnly(ctx, next)
-    passed(ctx.throw, next)
-  })
-
-  it("should allow app builder user", () => {
-    const ctx = buildUserCtx(appBuilderUser),
-      next = jest.fn()
-    doInAppContext(appId, () => {
-      builderOnly(ctx, next)
-    })
-    passed(ctx.throw, next)
-  })
-
-  it("should allow admin and builder user", () => {
-    const ctx = buildUserCtx(adminUser),
-      next = jest.fn()
-    builderOnly(ctx, next)
-    passed(ctx.throw, next)
-  })
-
-  it("should not allow admin user", () => {
-    const ctx = buildUserCtx(adminOnlyUser),
-      next = jest.fn()
-    builderOnly(ctx, next)
-    threw(ctx.throw)
-  })
-
-  it("should not allow app builder user to different app", () => {
-    const ctx = buildUserCtx(appBuilderUser),
-      next = jest.fn()
-    doInAppContext("app_bbb", () => {
-      builderOnly(ctx, next)
-    })
-    threw(ctx.throw)
-  })
-
-  it("should not allow basic user", () => {
-    const ctx = buildUserCtx(basicUser),
-      next = jest.fn()
-    builderOnly(ctx, next)
-    threw(ctx.throw)
-  })
-})
-
-describe("builderOrAdmin middleware", () => {
-  it("should allow builder user", () => {
-    const ctx = buildUserCtx(builderUser),
-      next = jest.fn()
-    builderOrAdmin(ctx, next)
-    passed(ctx.throw, next)
-  })
-
-  it("should allow builder and admin user", () => {
-    const ctx = buildUserCtx(adminUser),
-      next = jest.fn()
-    builderOrAdmin(ctx, next)
-    passed(ctx.throw, next)
-  })
-
-  it("should allow admin user", () => {
-    const ctx = buildUserCtx(adminOnlyUser),
-      next = jest.fn()
-    builderOrAdmin(ctx, next)
-    passed(ctx.throw, next)
-  })
-
-  it("should allow app builder user", () => {
-    const ctx = buildUserCtx(appBuilderUser),
-      next = jest.fn()
-    doInAppContext(appId, () => {
-      builderOrAdmin(ctx, next)
-    })
-    passed(ctx.throw, next)
-  })
-
-  it("should not allow basic user", () => {
-    const ctx = buildUserCtx(basicUser),
-      next = jest.fn()
-    builderOrAdmin(ctx, next)
-    threw(ctx.throw)
-  })
-})
-
-describe("check service difference", () => {
-  it("should not allow without app ID in apps", () => {
-    env._set("SERVICE_TYPE", ServiceType.APPS)
-    const appId = "app_a"
-    const ctx = buildUserCtx({
-      ...basicUser,
-      builder: {
-        apps: [appId],
-      },
-    })
-    const next = jest.fn()
-    doInAppContext(appId, () => {
-      builderOnly(ctx, next)
-    })
-    passed(ctx.throw, next)
-    doInAppContext("app_b", () => {
-      builderOnly(ctx, next)
-    })
-    threw(ctx.throw)
-  })
-
-  it("should allow without app ID in worker", () => {
-    env._set("SERVICE_TYPE", ServiceType.WORKER)
-    const ctx = buildUserCtx({
-      ...basicUser,
-      builder: {
-        apps: ["app_a"],
-      },
-    })
-    const next = jest.fn()
-    doInAppContext("app_b", () => {
-      builderOnly(ctx, next)
-    })
-    passed(ctx.throw, next)
-  })
-})

package/src/middleware/tests/matchers.spec.ts

@@ -1,134 +0,0 @@
-import * as matchers from "../matchers"
-import { structures } from "../../../tests"
-
-describe("matchers", () => {
-  it("matches by path and method", () => {
-    const pattern = [
-      {
-        route: "/api/tests",
-        method: "POST",
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/tests"
-    ctx.request.method = "POST"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(true)
-  })
-
-  it("wildcards path", () => {
-    const pattern = [
-      {
-        route: "/api/tests",
-        method: "POST",
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/tests/id/something/else"
-    ctx.request.method = "POST"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(true)
-  })
-
-  it("doesn't wildcard path with strict", () => {
-    const pattern = [
-      {
-        route: "/api/tests",
-        method: "POST",
-        strict: true,
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/tests/id/something/else"
-    ctx.request.method = "POST"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(false)
-  })
-
-  it("matches with param", () => {
-    const pattern = [
-      {
-        route: "/api/tests/:testId",
-        method: "GET",
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/tests/id"
-    ctx.request.method = "GET"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(true)
-  })
-
-  // TODO: Support the below behaviour
-  // Strict does not work when a param is present
-  // it("matches with param with strict", () => {
-  //   const pattern = [{
-  //     route: "/api/tests/:testId",
-  //     method: "GET",
-  //     strict: true
-  //   }]
-  //   const ctx = structures.koa.newContext()
-  //   ctx.request.url = "/api/tests/id"
-  //   ctx.request.method = "GET"
-  //
-  //   const built = matchers.buildMatcherRegex(pattern)
-  //
-  //   expect(!!matchers.matches(ctx, built)).toBe(true)
-  // })
-
-  it("doesn't match by path", () => {
-    const pattern = [
-      {
-        route: "/api/tests",
-        method: "POST",
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/unknown"
-    ctx.request.method = "POST"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(false)
-  })
-
-  it("doesn't match by method", () => {
-    const pattern = [
-      {
-        route: "/api/tests",
-        method: "POST",
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/tests"
-    ctx.request.method = "GET"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(false)
-  })
-
-  it("matches by path and wildcard method", () => {
-    const pattern = [
-      {
-        route: "/api/tests",
-        method: "ALL",
-      },
-    ]
-    const ctx = structures.koa.newContext()
-    ctx.request.url = "/api/tests"
-    ctx.request.method = "GET"
-
-    const built = matchers.buildMatcherRegex(pattern)
-
-    expect(!!matchers.matches(ctx, built)).toBe(true)
-  })
-})

package/src/migrations/definitions.ts

@@ -1,40 +0,0 @@
-import {
-  MigrationType,
-  MigrationName,
-  MigrationDefinition,
-} from "@budibase/types"
-
-export const DEFINITIONS: MigrationDefinition[] = [
-  {
-    type: MigrationType.GLOBAL,
-    name: MigrationName.USER_EMAIL_VIEW_CASING,
-  },
-  {
-    type: MigrationType.GLOBAL,
-    name: MigrationName.SYNC_QUOTAS,
-  },
-  {
-    type: MigrationType.APP,
-    name: MigrationName.APP_URLS,
-  },
-  {
-    type: MigrationType.APP,
-    name: MigrationName.EVENT_APP_BACKFILL,
-  },
-  {
-    type: MigrationType.APP,
-    name: MigrationName.TABLE_SETTINGS_LINKS_TO_ACTIONS,
-  },
-  {
-    type: MigrationType.GLOBAL,
-    name: MigrationName.EVENT_GLOBAL_BACKFILL,
-  },
-  {
-    type: MigrationType.INSTALLATION,
-    name: MigrationName.EVENT_INSTALLATION_BACKFILL,
-  },
-  {
-    type: MigrationType.GLOBAL,
-    name: MigrationName.GLOBAL_INFO_SYNC_USERS,
-  },
-]

package/src/migrations/index.ts

@@ -1,2 +0,0 @@
-export * from "./migrations"
-export * from "./definitions"

package/src/migrations/migrations.ts

@@ -1,191 +0,0 @@
-import { DEFAULT_TENANT_ID } from "../constants"
-import {
-  DocumentType,
-  StaticDatabases,
-  getAllApps,
-  getGlobalDBName,
-  getDB,
-} from "../db"
-import environment from "../environment"
-import * as platform from "../platform"
-import * as context from "../context"
-import { DEFINITIONS } from "."
-import {
-  Migration,
-  MigrationOptions,
-  MigrationType,
-  MigrationNoOpOptions,
-  App,
-} from "@budibase/types"
-
-export const getMigrationsDoc = async (db: any) => {
-  // get the migrations doc
-  try {
-    return await db.get(DocumentType.MIGRATIONS)
-  } catch (err: any) {
-    if (err.status && err.status === 404) {
-      return { _id: DocumentType.MIGRATIONS }
-    } else {
-      console.error(err)
-      throw err
-    }
-  }
-}
-
-export const backPopulateMigrations = async (opts: MigrationNoOpOptions) => {
-  // filter migrations to the type and populate a no-op migration
-  const migrations: Migration[] = DEFINITIONS.filter(
-    def => def.type === opts.type
-  ).map(d => ({ ...d, fn: () => {} }))
-  await runMigrations(migrations, { noOp: opts })
-}
-
-export const runMigration = async (
-  migration: Migration,
-  options: MigrationOptions = {}
-) => {
-  const migrationType = migration.type
-  let tenantId: string | undefined
-  if (migrationType !== MigrationType.INSTALLATION) {
-    tenantId = context.getTenantId()
-  }
-  const migrationName = migration.name
-  const silent = migration.silent
-
-  const log = (message: string) => {
-    if (!silent) {
-      console.log(message)
-    }
-  }
-
-  // get the db to store the migration in
-  let dbNames: string[]
-  if (migrationType === MigrationType.GLOBAL) {
-    dbNames = [getGlobalDBName()]
-  } else if (migrationType === MigrationType.APP) {
-    if (options.noOp) {
-      if (!options.noOp.appId) {
-        throw new Error("appId is required for noOp app migration")
-      }
-      dbNames = [options.noOp.appId]
-    } else {
-      const apps = (await getAllApps(migration.appOpts)) as App[]
-      dbNames = apps.map(app => app.appId)
-    }
-  } else if (migrationType === MigrationType.INSTALLATION) {
-    dbNames = [StaticDatabases.PLATFORM_INFO.name]
-  } else {
-    throw new Error(`Unrecognised migration type [${migrationType}]`)
-  }
-
-  const length = dbNames.length
-  let count = 0
-
-  // run the migration against each db
-  for (const dbName of dbNames) {
-    count++
-    const lengthStatement = length > 1 ? `[${count}/${length}]` : ""
-
-    const db = getDB(dbName)
-
-    try {
-      const doc = await getMigrationsDoc(db)
-
-      // the migration has already been run
-      if (doc[migrationName]) {
-        // check for force
-        if (
-          options.force &&
-          options.force[migrationType] &&
-          options.force[migrationType].includes(migrationName)
-        ) {
-          log(`[Migration: ${migrationName}] [DB: ${dbName}] Forcing`)
-        } else {
-          // no force, exit
-          return
-        }
-      }
-
-      // check if the migration is not a no-op
-      if (!options.noOp) {
-        log(
-          `[Migration: ${migrationName}] [DB: ${dbName}] Running ${lengthStatement}`
-        )
-
-        if (migration.preventRetry) {
-          // eagerly set the completion date
-          // so that we never run this migration twice even upon failure
-          doc[migrationName] = Date.now()
-          const response = await db.put(doc)
-          doc._rev = response.rev
-        }
-
-        // run the migration
-        if (migrationType === MigrationType.APP) {
-          await context.doInAppContext(db.name, async () => {
-            await migration.fn(db)
-          })
-        } else {
-          await migration.fn(db)
-        }
-
-        log(`[Migration: ${migrationName}] [DB: ${dbName}] Complete`)
-      }
-
-      // mark as complete
-      doc[migrationName] = Date.now()
-      await db.put(doc)
-    } catch (err) {
-      console.error(
-        `[Migration: ${migrationName}] [DB: ${dbName}] Error: `,
-        err
-      )
-      throw err
-    }
-  }
-}
-
-export const runMigrations = async (
-  migrations: Migration[],
-  options: MigrationOptions = {}
-) => {
-  let tenantIds
-
-  if (environment.MULTI_TENANCY) {
-    if (options.noOp) {
-      tenantIds = [options.noOp.tenantId]
-    } else if (!options.tenantIds || !options.tenantIds.length) {
-      // run for all tenants
-      tenantIds = await platform.tenants.getTenantIds()
-    } else {
-      tenantIds = options.tenantIds
-    }
-  } else {
-    // single tenancy
-    tenantIds = [DEFAULT_TENANT_ID]
-  }
-
-  if (tenantIds.length > 1) {
-    console.log(`Checking migrations for ${tenantIds.length} tenants`)
-  } else {
-    console.log("Checking migrations")
-  }
-
-  let count = 0
-  // for all tenants
-  for (const tenantId of tenantIds) {
-    count++
-    if (tenantIds.length > 1) {
-      console.log(`Progress [${count}/${tenantIds.length}]`)
-    }
-    // for all migrations
-    for (const migration of migrations) {
-      // run the migration
-      await context.doInTenant(
-        tenantId,
-        async () => await runMigration(migration, options)
-      )
-    }
-  }
-  console.log("Migrations complete")
-}

package/src/migrations/tests/__snapshots__/migrations.spec.ts.snap

@@ -1,11 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`migrations should match snapshot 1`] = `
-{
-  "_id": "migrations",
-  "_rev": "1-2f64479842a0513aa8b97f356b0b9127",
-  "createdAt": "2020-01-01T00:00:00.000Z",
-  "test": 1577836800000,
-  "updatedAt": "2020-01-01T00:00:00.000Z",
-}
-`;

package/src/migrations/tests/migrations.spec.ts

@@ -1,64 +0,0 @@
-import { testEnv, DBTestConfiguration } from "../../../tests/extra"
-import * as migrations from "../index"
-import * as context from "../../context"
-import { MigrationType } from "@budibase/types"
-
-testEnv.multiTenant()
-
-describe("migrations", () => {
-  const config = new DBTestConfiguration()
-
-  const migrationFunction = jest.fn()
-
-  const MIGRATIONS = [
-    {
-      type: MigrationType.GLOBAL,
-      name: "test" as any,
-      fn: migrationFunction,
-    },
-  ]
-
-  beforeEach(() => {
-    config.newTenant()
-  })
-
-  afterEach(async () => {
-    jest.clearAllMocks()
-  })
-
-  const migrate = () => {
-    return migrations.runMigrations(MIGRATIONS, {
-      tenantIds: [config.tenantId],
-    })
-  }
-
-  it("should run a new migration", async () => {
-    await config.doInTenant(async () => {
-      await migrate()
-      expect(migrationFunction).toHaveBeenCalled()
-      const db = context.getGlobalDB()
-      const doc = await migrations.getMigrationsDoc(db)
-      expect(doc.test).toBeDefined()
-    })
-  })
-
-  it("should match snapshot", async () => {
-    await config.doInTenant(async () => {
-      await migrate()
-      const doc = await migrations.getMigrationsDoc(context.getGlobalDB())
-      expect(doc).toMatchSnapshot()
-    })
-  })
-
-  it("should skip a previously run migration", async () => {
-    await config.doInTenant(async () => {
-      const db = context.getGlobalDB()
-      await migrate()
-      const previousDoc = await migrations.getMigrationsDoc(db)
-      await migrate()
-      const currentDoc = await migrations.getMigrationsDoc(db)
-      expect(migrationFunction).toHaveBeenCalledTimes(1)
-      expect(currentDoc.test).toBe(previousDoc.test)
-    })
-  })
-})

package/src/objectStore/buckets/app.ts

@@ -1,40 +0,0 @@
-import env from "../../environment"
-import * as objectStore from "../objectStore"
-import * as cloudfront from "../cloudfront"
-
-/**
- * In production the client library is stored in the object store, however in development
- * we use the symlinked version produced by lerna, located in node modules. We link to this
- * via a specific endpoint (under /api/assets/client).
- * @param {string} appId In production we need the appId to look up the correct bucket, as the
- * version of the client lib may differ between apps.
- * @param {string} version The version to retrieve.
- * @return {string} The URL to be inserted into appPackage response or server rendered
- * app index file.
- */
-export const clientLibraryUrl = (appId: string, version: string) => {
-  if (env.isProd()) {
-    let file = `${objectStore.sanitizeKey(appId)}/budibase-client.js`
-    if (env.CLOUDFRONT_CDN) {
-      // append app version to bust the cache
-      if (version) {
-        file += `?v=${version}`
-      }
-      // don't need to use presigned for client with cloudfront
-      // file is public
-      return cloudfront.getUrl(file)
-    } else {
-      return objectStore.getPresignedUrl(env.APPS_BUCKET_NAME, file)
-    }
-  } else {
-    return `/api/assets/client`
-  }
-}
-
-export const getAppFileUrl = (s3Key: string) => {
-  if (env.CLOUDFRONT_CDN) {
-    return cloudfront.getPresignedUrl(s3Key)
-  } else {
-    return objectStore.getPresignedUrl(env.APPS_BUCKET_NAME, s3Key)
-  }
-}

package/src/objectStore/buckets/global.ts

@@ -1,29 +0,0 @@
-import env from "../../environment"
-import * as context from "../../context"
-import * as objectStore from "../objectStore"
-import * as cloudfront from "../cloudfront"
-
-// URLs
-
-export const getGlobalFileUrl = (type: string, name: string, etag?: string) => {
-  let file = getGlobalFileS3Key(type, name)
-  if (env.CLOUDFRONT_CDN) {
-    if (etag) {
-      file = `${file}?etag=${etag}`
-    }
-    return cloudfront.getPresignedUrl(file)
-  } else {
-    return objectStore.getPresignedUrl(env.GLOBAL_BUCKET_NAME, file)
-  }
-}
-
-// KEYS
-
-export const getGlobalFileS3Key = (type: string, name: string) => {
-  let file = `${type}/${name}`
-  if (env.MULTI_TENANCY) {
-    const tenantId = context.getTenantId()
-    file = `${tenantId}/${file}`
-  }
-  return file
-}

package/src/objectStore/buckets/index.ts

@@ -1,3 +0,0 @@
-export * from "./app"
-export * from "./global"
-export * from "./plugins"