@budibase/backend-core 3.2.5 → 3.2.7

package/src/platform/tenants.ts

@@ -1,101 +0,0 @@
-import { StaticDatabases } from "../constants"
-import { getPlatformDB } from "./platformDb"
-import { LockName, LockOptions, LockType, Tenants } from "@budibase/types"
-import * as locks from "../redis/redlockImpl"
-
-const TENANT_DOC = StaticDatabases.PLATFORM_INFO.docs.tenants
-
-export const tenacyLockOptions: LockOptions = {
-  type: LockType.DEFAULT,
-  name: LockName.UPDATE_TENANTS_DOC,
-  ttl: 10 * 1000, // auto expire after 10 seconds
-  systemLock: true,
-}
-
-// READ
-
-export async function getTenantIds(): Promise<string[]> {
-  const tenants = await getTenants()
-  return tenants.tenantIds
-}
-
-async function getTenants(): Promise<Tenants> {
-  const db = getPlatformDB()
-  let tenants: Tenants
-
-  try {
-    tenants = await db.get(TENANT_DOC)
-  } catch (e: any) {
-    // doesn't exist yet - create
-    if (e.status === 404) {
-      tenants = await createTenantsDoc()
-    } else {
-      throw e
-    }
-  }
-
-  return tenants
-}
-
-export async function exists(tenantId: string) {
-  const tenants = await getTenants()
-  return tenants.tenantIds.indexOf(tenantId) !== -1
-}
-
-// CREATE / UPDATE
-
-function newTenantsDoc(): Tenants {
-  return {
-    _id: TENANT_DOC,
-    tenantIds: [],
-  }
-}
-
-async function createTenantsDoc(): Promise<Tenants> {
-  const db = getPlatformDB()
-  let tenants = newTenantsDoc()
-
-  try {
-    const response = await db.put(tenants)
-    tenants._rev = response.rev
-  } catch (e: any) {
-    // don't throw 409 is doc has already been created
-    if (e.status === 409) {
-      return db.get(TENANT_DOC)
-    }
-    throw e
-  }
-
-  return tenants
-}
-
-export async function addTenant(tenantId: string) {
-  const db = getPlatformDB()
-
-  // use a lock as tenant creation is conflict prone
-  await locks.doWithLock(tenacyLockOptions, async () => {
-    const tenants = await getTenants()
-
-    // write the new tenant if it doesn't already exist
-    if (tenants.tenantIds.indexOf(tenantId) === -1) {
-      tenants.tenantIds.push(tenantId)
-      await db.put(tenants)
-    }
-  })
-}
-
-// DELETE
-
-export async function removeTenant(tenantId: string) {
-  try {
-    await locks.doWithLock(tenacyLockOptions, async () => {
-      const db = getPlatformDB()
-      const tenants = await getTenants()
-      tenants.tenantIds = tenants.tenantIds.filter(id => id !== tenantId)
-      await db.put(tenants)
-    })
-  } catch (err) {
-    console.error(`Error removing tenant ${tenantId} from info db`, err)
-    throw err
-  }
-}

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

@@ -1,26 +0,0 @@
-import { structures } from "../../../tests"
-import { DBTestConfiguration } from "../../../tests/extra"
-import * as tenants from "../tenants"
-
-describe("tenants", () => {
-  new DBTestConfiguration()
-
-  describe("addTenant", () => {
-    it("concurrently adds multiple tenants safely", async () => {
-      const tenant1 = structures.tenant.id()
-      const tenant2 = structures.tenant.id()
-      const tenant3 = structures.tenant.id()
-
-      await Promise.all([
-        tenants.addTenant(tenant1),
-        tenants.addTenant(tenant2),
-        tenants.addTenant(tenant3),
-      ])
-
-      const tenantIds = await tenants.getTenantIds()
-      expect(tenantIds.includes(tenant1)).toBe(true)
-      expect(tenantIds.includes(tenant2)).toBe(true)
-      expect(tenantIds.includes(tenant3)).toBe(true)
-    })
-  })
-})

package/src/platform/users.ts

@@ -1,129 +0,0 @@
-import { getPlatformDB } from "./platformDb"
-import { DEFAULT_TENANT_ID } from "../constants"
-import env from "../environment"
-import {
-  PlatformUser,
-  PlatformUserByEmail,
-  PlatformUserById,
-  PlatformUserBySsoId,
-  User,
-} from "@budibase/types"
-
-// READ
-
-export async function lookupTenantId(userId: string) {
-  if (!env.MULTI_TENANCY) {
-    return DEFAULT_TENANT_ID
-  }
-
-  const user = await getUserDoc(userId)
-  return user.tenantId
-}
-
-export async function getUserDoc(emailOrId: string): Promise<PlatformUser> {
-  const db = getPlatformDB()
-  return db.get(emailOrId)
-}
-
-export async function updateUserDoc(platformUser: PlatformUserById) {
-  const db = getPlatformDB()
-  await db.put(platformUser)
-}
-
-// CREATE
-
-function newUserIdDoc(id: string, tenantId: string): PlatformUserById {
-  return {
-    _id: id,
-    tenantId,
-  }
-}
-
-function newUserEmailDoc(
-  userId: string,
-  email: string,
-  tenantId: string
-): PlatformUserByEmail {
-  return {
-    _id: email,
-    userId,
-    tenantId,
-  }
-}
-
-function newUserSsoIdDoc(
-  ssoId: string,
-  email: string,
-  userId: string,
-  tenantId: string
-): PlatformUserBySsoId {
-  return {
-    _id: ssoId,
-    userId,
-    email,
-    tenantId,
-  }
-}
-
-/**
- * Add a new user id or email doc if it doesn't exist.
- */
-async function addUserDoc(emailOrId: string, newDocFn: () => PlatformUser) {
-  const db = getPlatformDB()
-  let user: PlatformUser
-
-  try {
-    await db.get(emailOrId)
-  } catch (e: any) {
-    if (e.status === 404) {
-      user = newDocFn()
-      await db.put(user)
-    } else {
-      throw e
-    }
-  }
-}
-
-export async function addSsoUser(
-  ssoId: string,
-  email: string,
-  userId: string,
-  tenantId: string
-) {
-  return addUserDoc(ssoId, () =>
-    newUserSsoIdDoc(ssoId, email, userId, tenantId)
-  )
-}
-
-export async function addUser(
-  tenantId: string,
-  userId: string,
-  email: string,
-  ssoId?: string
-) {
-  const promises = [
-    addUserDoc(userId, () => newUserIdDoc(userId, tenantId)),
-    addUserDoc(email, () => newUserEmailDoc(userId, email, tenantId)),
-  ]
-
-  if (ssoId) {
-    promises.push(addSsoUser(ssoId, email, userId, tenantId))
-  }
-
-  await Promise.all(promises)
-}
-
-// DELETE
-
-export async function removeUser(user: User) {
-  const db = getPlatformDB()
-  const keys = [user._id!, user.email]
-  const userDocs = await db.allDocs<User>({
-    keys,
-    include_docs: true,
-  })
-  await db.bulkRemove(
-    userDocs.rows.map(row => row.doc!),
-    { silenceErrors: true }
-  )
-}

package/src/plugin/index.ts

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

package/src/plugin/tests/validation.spec.ts

@@ -1,209 +0,0 @@
-import { validate } from "../utils"
-import fetch from "node-fetch"
-import { PluginType } from "@budibase/types"
-import nock from "nock"
-
-const automationLink = `http://example.com/automation/schema.json`
-const componentLink = `http://example.com/component/schema.json`
-const datasourceLink = `http://example.com/datasource/schema.json`
-
-function mockDatasourceSchema() {
-  nock("http://example.com")
-    .get("/datasource/schema.json")
-    .reply(200, {
-      type: "datasource",
-      metadata: {},
-      schema: {
-        docs: "https://docs.budibase.com",
-        friendlyName: "Basic HTTP",
-        type: "API",
-        description: "Performs a basic HTTP calls to a URL",
-        datasource: {
-          url: {
-            type: "string",
-            required: true,
-          },
-          cookie: {
-            type: "string",
-            required: false,
-          },
-        },
-        query: {
-          create: {
-            type: "json",
-          },
-          read: {
-            type: "fields",
-            fields: {
-              queryString: {
-                display: "Query string",
-                type: "string",
-                required: false,
-              },
-            },
-          },
-          update: {
-            type: "json",
-          },
-          delete: {
-            type: "fields",
-            fields: {
-              id: {
-                type: "string",
-                required: true,
-              },
-            },
-          },
-        },
-      },
-    })
-}
-
-function mockAutomationSchema() {
-  nock("http://example.com")
-    .get("/automation/schema.json")
-    .reply(200, {
-      type: "automation",
-      metadata: {},
-      schema: {
-        name: "{{ name }}",
-        tagline: "{{ description }}",
-        icon: "Actions",
-        description: "{{ description }}",
-        type: "action",
-        stepId: "{{ name }}",
-        inputs: {
-          text: "",
-        },
-        schema: {
-          inputs: {
-            properties: {
-              text: {
-                type: "string",
-                title: "Log",
-              },
-            },
-            required: ["text"],
-          },
-          outputs: {
-            properties: {
-              success: {
-                type: "boolean",
-                description: "Whether the action was successful",
-              },
-              message: {
-                type: "string",
-                description: "What was output",
-              },
-            },
-            required: ["success", "message"],
-          },
-        },
-      },
-    })
-}
-
-function mockComponentSchema() {
-  nock("http://example.com")
-    .get("/component/schema.json")
-    .reply(200, {
-      type: "component",
-      metadata: {},
-      schema: {
-        name: "{{ name }}",
-        friendlyName: "{{ name }}",
-        description: "{{ description }}",
-        icon: "Text",
-        settings: [
-          {
-            type: "text",
-            key: "text",
-            label: "Text",
-          },
-        ],
-      },
-    })
-}
-
-async function getSchema(link: string) {
-  const response = await fetch(link)
-  if (response.status > 300) {
-    return
-  }
-  const text = await response.text()
-  return JSON.parse(text)
-}
-
-async function runTest(opts: { link?: string; schema?: any }) {
-  let error
-  try {
-    let schema = opts.schema
-    if (opts.link) {
-      schema = await getSchema(opts.link)
-    }
-    validate(schema)
-  } catch (err) {
-    error = err
-  }
-  return error
-}
-
-describe("plugin validation", () => {
-  beforeEach(() => {
-    nock.cleanAll()
-    mockAutomationSchema()
-    mockComponentSchema()
-    mockDatasourceSchema()
-  })
-
-  describe("it should be able to validate an automation schema", () => {
-    it("should return automation skeleton schema is valid", async () => {
-      const error = await runTest({ link: automationLink })
-      expect(error).toBeUndefined()
-    })
-
-    it("should fail given invalid automation schema", async () => {
-      const error = await runTest({
-        schema: {
-          type: PluginType.AUTOMATION,
-          schema: {},
-        },
-      })
-      expect(error).toBeDefined()
-    })
-  })
-
-  describe("it should be able to validate a component schema", () => {
-    it("should return component skeleton schema is valid", async () => {
-      const error = await runTest({ link: componentLink })
-      expect(error).toBeUndefined()
-    })
-
-    it("should fail given invalid component schema", async () => {
-      const error = await runTest({
-        schema: {
-          type: PluginType.COMPONENT,
-          schema: {},
-        },
-      })
-      expect(error).toBeDefined()
-    })
-  })
-
-  describe("it should be able to validate a datasource schema", () => {
-    it("should return datasource skeleton schema is valid", async () => {
-      const error = await runTest({ link: datasourceLink })
-      expect(error).toBeUndefined()
-    })
-
-    it("should fail given invalid datasource schema", async () => {
-      const error = await runTest({
-        schema: {
-          type: PluginType.DATASOURCE,
-          schema: {},
-        },
-      })
-      expect(error).toBeDefined()
-    })
-  })
-})

package/src/plugin/utils.ts

@@ -1,175 +0,0 @@
-import {
-  DatasourceFieldType,
-  QueryType,
-  PluginType,
-  AutomationStepType,
-  AutomationStepIdArray,
-  AutomationIOType,
-  AutomationCustomIOType,
-  DatasourceFeature,
-} from "@budibase/types"
-import joi from "joi"
-
-const DATASOURCE_TYPES = [
-  "Relational",
-  "Non-relational",
-  "Spreadsheet",
-  "Object store",
-  "Graph",
-  "API",
-]
-
-function runJoi(validator: joi.Schema, schema: any) {
-  const { error } = validator.validate(schema)
-  if (error) {
-    throw error
-  }
-}
-
-function validateComponent(schema: any) {
-  const validator = joi.object({
-    type: joi.string().allow(PluginType.COMPONENT).required(),
-    metadata: joi.object().unknown(true).required(),
-    hash: joi.string().optional(),
-    version: joi.string().optional(),
-    schema: joi
-      .object({
-        name: joi.string().required(),
-        settings: joi.array().items(joi.object().unknown(true)).required(),
-      })
-      .unknown(true),
-  })
-  runJoi(validator, schema)
-}
-
-function validateDatasource(schema: any) {
-  const fieldValidator = joi.object({
-    type: joi
-      .string()
-      .allow(...Object.values(DatasourceFieldType))
-      .required(),
-    required: joi.boolean().required(),
-    default: joi.any(),
-    display: joi.string(),
-  })
-
-  const queryValidator = joi
-    .object({
-      type: joi.string().allow(...Object.values(QueryType)),
-      readable: joi.boolean(),
-      fields: joi.object().pattern(joi.string(), fieldValidator),
-    })
-    .required()
-
-  const validator = joi.object({
-    type: joi.string().allow(PluginType.DATASOURCE).required(),
-    metadata: joi.object().unknown(true).required(),
-    hash: joi.string().optional(),
-    version: joi.string().optional(),
-    schema: joi.object({
-      docs: joi.string(),
-      plus: joi.boolean().optional(),
-      isSQL: joi.boolean().optional(),
-      auth: joi
-        .object({
-          type: joi.string().required(),
-        })
-        .optional(),
-      features: joi
-        .object(
-          Object.fromEntries(
-            Object.values(DatasourceFeature).map(key => [
-              key,
-              joi.boolean().optional(),
-            ])
-          )
-        )
-        .optional(),
-      relationships: joi.boolean().optional(),
-      description: joi.string().required(),
-      friendlyName: joi.string().required(),
-      type: joi.string().allow(...DATASOURCE_TYPES),
-      datasource: joi.object().pattern(joi.string(), fieldValidator).required(),
-      query: joi
-        .object()
-        .pattern(joi.string(), queryValidator)
-        .unknown(true)
-        .required(),
-      extra: joi.object().pattern(
-        joi.string(),
-        joi.object({
-          type: joi.string().required(),
-          displayName: joi.string().required(),
-          required: joi.boolean(),
-          data: joi.object(),
-        })
-      ),
-    }),
-  })
-  runJoi(validator, schema)
-}
-
-function validateAutomation(schema: any) {
-  const basePropsValidator = joi.object().pattern(joi.string(), {
-    type: joi
-      .string()
-      .allow(...Object.values(AutomationIOType))
-      .required(),
-    customType: joi.string().allow(...Object.values(AutomationCustomIOType)),
-    title: joi.string(),
-    description: joi.string(),
-    enum: joi.array().items(joi.string()),
-    pretty: joi.array().items(joi.string()),
-  })
-  const stepSchemaValidator = joi
-    .object({
-      properties: basePropsValidator,
-      required: joi.array().items(joi.string()),
-    })
-    .concat(basePropsValidator)
-    .required()
-  const validator = joi.object({
-    type: joi.string().allow(PluginType.AUTOMATION).required(),
-    metadata: joi.object().unknown(true).required(),
-    hash: joi.string().optional(),
-    version: joi.string().optional(),
-    schema: joi.object({
-      name: joi.string().required(),
-      tagline: joi.string().required(),
-      icon: joi.string().required(),
-      description: joi.string().required(),
-      type: joi
-        .string()
-        .allow(AutomationStepType.ACTION, AutomationStepType.LOGIC)
-        .required(),
-      stepId: joi
-        .string()
-        .disallow(...AutomationStepIdArray)
-        .required(),
-      inputs: joi.object().optional(),
-      schema: joi
-        .object({
-          inputs: stepSchemaValidator,
-          outputs: stepSchemaValidator,
-        })
-        .required(),
-    }),
-  })
-  runJoi(validator, schema)
-}
-
-export function validate(schema: any) {
-  switch (schema?.type) {
-    case PluginType.COMPONENT:
-      validateComponent(schema)
-      break
-    case PluginType.DATASOURCE:
-      validateDatasource(schema)
-      break
-    case PluginType.AUTOMATION:
-      validateAutomation(schema)
-      break
-    default:
-      throw new Error(`Unknown plugin type - check schema.json: ${schema.type}`)
-  }
-}

package/src/queue/constants.ts

@@ -1,8 +0,0 @@
-export enum JobQueue {
-  AUTOMATION = "automationQueue",
-  APP_BACKUP = "appBackupQueue",
-  AUDIT_LOG = "auditLogQueue",
-  SYSTEM_EVENT_QUEUE = "systemEventQueue",
-  APP_MIGRATION = "appMigration",
-  DOC_WRITETHROUGH_QUEUE = "docWritethroughQueue",
-}