@budibase/backend-core 2.9.19 → 2.9.20

package/tests/core/utilities/structures/accounts.ts

@@ -1,115 +0,0 @@
-import { generator, uuid, quotas } from "."
-import { generateGlobalUserID } from "../../../../src/docIds"
-import {
-  Account,
-  AccountSSOProvider,
-  AccountSSOProviderType,
-  AuthType,
-  CloudAccount,
-  Hosting,
-  SSOAccount,
-  CreateAccount,
-  CreatePassswordAccount,
-} from "@budibase/types"
-import sample from "lodash/sample"
-
-export const account = (partial: Partial<Account> = {}): Account => {
-  return {
-    accountId: uuid(),
-    tenantId: generator.word(),
-    email: generator.email(),
-    tenantName: generator.word(),
-    hosting: Hosting.SELF,
-    createdAt: Date.now(),
-    verified: true,
-    verificationSent: true,
-    tier: "FREE", // DEPRECATED
-    authType: AuthType.PASSWORD,
-    name: generator.name(),
-    size: "10+",
-    profession: "Software Engineer",
-    quotaUsage: quotas.usage(),
-    ...partial,
-  }
-}
-
-export function selfHostAccount() {
-  return account()
-}
-
-export const cloudAccount = (): CloudAccount => {
-  return {
-    ...account(),
-    hosting: Hosting.CLOUD,
-    budibaseUserId: generateGlobalUserID(),
-  }
-}
-
-function providerType(): AccountSSOProviderType {
-  return sample(Object.values(AccountSSOProviderType)) as AccountSSOProviderType
-}
-
-function provider(): AccountSSOProvider {
-  return sample(Object.values(AccountSSOProvider)) as AccountSSOProvider
-}
-
-export function ssoAccount(account: Account = cloudAccount()): SSOAccount {
-  return {
-    ...account,
-    authType: AuthType.SSO,
-    oauth2: {
-      accessToken: generator.string(),
-      refreshToken: generator.string(),
-    },
-    pictureUrl: generator.url(),
-    provider: provider(),
-    providerType: providerType(),
-    thirdPartyProfile: {},
-  }
-}
-
-export const cloudCreateAccount: CreatePassswordAccount = {
-  email: "cloud@budibase.com",
-  tenantId: "cloud",
-  hosting: Hosting.CLOUD,
-  authType: AuthType.PASSWORD,
-  password: "Password123!",
-  tenantName: "cloud",
-  name: "Budi Armstrong",
-  size: "10+",
-  profession: "Software Engineer",
-}
-
-export const cloudSSOCreateAccount: CreateAccount = {
-  email: "cloud-sso@budibase.com",
-  tenantId: "cloud-sso",
-  hosting: Hosting.CLOUD,
-  authType: AuthType.SSO,
-  tenantName: "cloudsso",
-  name: "Budi Armstrong",
-  size: "10+",
-  profession: "Software Engineer",
-}
-
-export const selfCreateAccount: CreatePassswordAccount = {
-  email: "self@budibase.com",
-  tenantId: "self",
-  hosting: Hosting.SELF,
-  authType: AuthType.PASSWORD,
-  password: "Password123!",
-  tenantName: "self",
-  name: "Budi Armstrong",
-  size: "10+",
-  profession: "Software Engineer",
-}
-
-export const selfSSOCreateAccount: CreateAccount = {
-  email: "self-sso@budibase.com",
-  tenantId: "self-sso",
-  hosting: Hosting.SELF,
-  authType: AuthType.SSO,
-  tenantName: "selfsso",
-  name: "Budi Armstrong",
-  size: "10+",
-  profession: "Software Engineer",
-}

package/tests/core/utilities/structures/apps.ts

@@ -1,21 +0,0 @@
-import { generator } from "."
-import { App } from "@budibase/types"
-import { DEFAULT_TENANT_ID, DocumentType } from "../../../../src/constants"
-
-export function app(id: string): App {
-  return {
-    _id: DocumentType.APP_METADATA,
-    appId: id,
-    type: "",
-    version: "0.0.1",
-    componentLibraries: [],
-    name: generator.name(),
-    url: `/custom-url`,
-    instance: {
-      _id: id,
-    },
-    tenantId: DEFAULT_TENANT_ID,
-    status: "",
-    template: undefined,
-  }
-}

package/tests/core/utilities/structures/common.ts

@@ -1,7 +0,0 @@
-import { v4 as uuid } from "uuid"
-
-export { v4 as uuid } from "uuid"
-
-export const email = () => {
-  return `${uuid()}@test.com`
-}

package/tests/core/utilities/structures/db.ts

@@ -1,12 +0,0 @@
-import { generator } from "./generator"
-import { newid } from "../../../../src/docIds/newid"
-
-export function id() {
-  return `db_${newid()}`
-}
-
-export function rev() {
-  return `${generator.character({
-    numeric: true,
-  })}-${generator.guid().replace(/-/, "")}`
-}

package/tests/core/utilities/structures/documents/index.ts

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

package/tests/core/utilities/structures/documents/platform/index.ts

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

package/tests/core/utilities/structures/documents/platform/installation.ts

@@ -1,12 +0,0 @@
-import { generator } from "../../generator"
-import { Installation } from "@budibase/types"
-import * as db from "../../db"
-
-export function install(): Installation {
-  return {
-    _id: "install",
-    _rev: db.rev(),
-    installId: generator.guid(),
-    version: generator.string(),
-  }
-}

package/tests/core/utilities/structures/generator.ts

@@ -1,2 +0,0 @@
-import Chance from "./Chance"
-export const generator = new Chance()

package/tests/core/utilities/structures/index.ts

@@ -1,15 +0,0 @@
-export * from "./common"
-export * as accounts from "./accounts"
-export * as apps from "./apps"
-export * as db from "./db"
-export * as docs from "./documents"
-export * as koa from "./koa"
-export * as licenses from "./licenses"
-export * as plugins from "./plugins"
-export * as sso from "./sso"
-export * as tenant from "./tenants"
-export * as users from "./users"
-export * as userGroups from "./userGroups"
-export { generator } from "./generator"
-export * as scim from "./scim"
-export * as quotas from "./quotas"

package/tests/core/utilities/structures/koa.ts

@@ -1,16 +0,0 @@
-import { createMockContext, createMockCookies } from "@shopify/jest-koa-mocks"
-import { BBContext } from "@budibase/types"
-
-export const newContext = (): BBContext => {
-  const ctx = createMockContext()
-  return {
-    ...ctx,
-    path: "/",
-    cookies: createMockCookies(),
-    request: {
-      ...ctx.request,
-      headers: {},
-      body: {},
-    },
-  }
-}

package/tests/core/utilities/structures/licenses.ts

@@ -1,167 +0,0 @@
-import {
-  Billing,
-  Customer,
-  Feature,
-  License,
-  OfflineIdentifier,
-  OfflineLicense,
-  PlanModel,
-  PlanType,
-  PriceDuration,
-  PurchasedPlan,
-  PurchasedPrice,
-  Quotas,
-  Subscription,
-} from "@budibase/types"
-import { generator } from "./generator"
-
-export function price(): PurchasedPrice {
-  return {
-    amount: 10000,
-    amountMonthly: 10000,
-    currency: "usd",
-    duration: PriceDuration.MONTHLY,
-    priceId: "price_123",
-    dayPasses: undefined,
-    isPerUser: true,
-  }
-}
-
-export const plan = (type: PlanType = PlanType.FREE): PurchasedPlan => {
-  return {
-    type,
-    usesInvoicing: false,
-    model: PlanModel.PER_USER,
-    price: type !== PlanType.FREE ? price() : undefined,
-  }
-}
-
-export function quotas(): Quotas {
-  return {
-    usage: {
-      monthly: {
-        queries: {
-          name: "Queries",
-          value: 1,
-          triggers: [],
-        },
-        automations: {
-          name: "Queries",
-          value: 1,
-          triggers: [],
-        },
-        dayPasses: {
-          name: "Queries",
-          value: 1,
-          triggers: [],
-        },
-      },
-      static: {
-        rows: {
-          name: "Rows",
-          value: 1,
-          triggers: [],
-        },
-        apps: {
-          name: "Apps",
-          value: 1,
-          triggers: [],
-        },
-        users: {
-          name: "Users",
-          value: 1,
-          triggers: [],
-        },
-        userGroups: {
-          name: "User Groups",
-          value: 1,
-          triggers: [],
-        },
-        plugins: {
-          name: "Plugins",
-          value: 1,
-          triggers: [],
-        },
-      },
-    },
-    constant: {
-      automationLogRetentionDays: {
-        name: "Automation Logs",
-        value: 1,
-        triggers: [],
-      },
-      appBackupRetentionDays: {
-        name: "Backups",
-        value: 1,
-        triggers: [],
-      },
-    },
-  }
-}
-
-export function billing(
-  opts: { customer?: Customer; subscription?: Subscription } = {}
-): Billing {
-  return {
-    customer: opts.customer || customer(),
-    subscription: opts.subscription || subscription(),
-  }
-}
-
-export function customer(): Customer {
-  return {
-    balance: 0,
-    currency: "usd",
-  }
-}
-
-export function subscription(): Subscription {
-  return {
-    amount: 10000,
-    cancelAt: undefined,
-    currency: "usd",
-    currentPeriodEnd: 0,
-    currentPeriodStart: 0,
-    downgradeAt: 0,
-    duration: PriceDuration.MONTHLY,
-    pastDueAt: undefined,
-    quantity: 0,
-    status: "active",
-  }
-}
-
-interface GenerateLicenseOpts {
-  quotas?: Quotas
-  plan?: PurchasedPlan
-  planType?: PlanType
-  features?: Feature[]
-  billing?: Billing
-}
-
-export const license = (opts: GenerateLicenseOpts = {}): License => {
-  return {
-    features: opts.features || [],
-    quotas: opts.quotas || quotas(),
-    plan: opts.plan || plan(opts.planType),
-    billing: opts.billing || billing(),
-  }
-}
-
-export function offlineLicense(opts: GenerateLicenseOpts = {}): OfflineLicense {
-  const base = license(opts)
-  return {
-    ...base,
-    expireAt: new Date().toISOString(),
-    identifier: offlineIdentifier(),
-  }
-}
-
-export function offlineIdentifier(
-  installId: string = generator.guid(),
-  tenantId: string = generator.guid()
-): OfflineIdentifier {
-  return {
-    installId,
-    tenantId,
-  }
-}

package/tests/core/utilities/structures/plugins.ts

@@ -1,19 +0,0 @@
-import { generator } from "."
-import { Plugin, PluginSource, PluginType } from "@budibase/types"
-
-export function plugin(): Plugin {
-  return {
-    description: generator.word(),
-    name: generator.word(),
-    version: "1.0.0",
-    source: PluginSource.FILE,
-    package: {
-      name: generator.word,
-    },
-    hash: generator.hash(),
-    schema: {
-      type: PluginType.DATASOURCE,
-    },
-    iconFileName: "icon.svg",
-  }
-}

package/tests/core/utilities/structures/quotas.ts

@@ -1,67 +0,0 @@
-import { MonthlyQuotaName, QuotaUsage } from "@budibase/types"
-
-export const usage = (): QuotaUsage => {
-  return {
-    _id: "usage_quota",
-    quotaReset: new Date().toISOString(),
-    apps: {
-      app_1: {
-        // @ts-ignore - the apps definition doesn't match up to actual usage
-        usageQuota: {
-          rows: 0,
-        },
-      },
-    },
-    monthly: {
-      "01-2023": {
-        automations: 0,
-        dayPasses: 0,
-        queries: 0,
-        triggers: {},
-        breakdown: {
-          rowQueries: {
-            parent: MonthlyQuotaName.QUERIES,
-            values: {
-              row_1: 0,
-              row_2: 0,
-            },
-          },
-          datasourceQueries: {
-            parent: MonthlyQuotaName.QUERIES,
-            values: {
-              ds_1: 0,
-              ds_2: 0,
-            },
-          },
-          automations: {
-            parent: MonthlyQuotaName.AUTOMATIONS,
-            values: {
-              auto_1: 0,
-              auto_2: 0,
-            },
-          },
-        },
-      },
-      "02-2023": {
-        automations: 0,
-        dayPasses: 0,
-        queries: 0,
-        triggers: {},
-      },
-      current: {
-        automations: 0,
-        dayPasses: 0,
-        queries: 0,
-        triggers: {},
-      },
-    },
-    usageQuota: {
-      apps: 0,
-      plugins: 0,
-      users: 0,
-      userGroups: 0,
-      rows: 0,
-      triggers: {},
-    },
-  }
-}

package/tests/core/utilities/structures/scim.ts

@@ -1,80 +0,0 @@
-import { ScimCreateGroupRequest, ScimCreateUserRequest } from "@budibase/types"
-import { uuid } from "./common"
-import { generator } from "./generator"
-
-interface CreateUserRequestFields {
-  externalId: string
-  email: string
-  firstName: string
-  lastName: string
-  username: string
-}
-
-export function createUserRequest(userData?: Partial<CreateUserRequestFields>) {
-  const defaultValues = {
-    externalId: uuid(),
-    email: generator.email(),
-    firstName: generator.first(),
-    lastName: generator.last(),
-    username: generator.name(),
-  }
-
-  const { externalId, email, firstName, lastName, username } = {
-    ...defaultValues,
-    ...userData,
-  }
-
-  let user: ScimCreateUserRequest = {
-    schemas: [
-      "urn:ietf:params:scim:schemas:core:2.0:User",
-      "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
-    ],
-    externalId,
-    userName: username,
-    active: true,
-    emails: [
-      {
-        primary: true,
-        type: "work",
-        value: email,
-      },
-    ],
-    meta: {
-      resourceType: "User",
-    },
-    roles: [],
-  }
-
-  if (firstName || lastName) {
-    user.name = {
-      formatted: [firstName, lastName].filter(s => s).join(" "),
-      familyName: lastName,
-      givenName: firstName,
-    }
-  }
-
-  return user
-}
-
-export function createGroupRequest(groupData?: {
-  externalId?: string
-  displayName?: string
-}) {
-  const { externalId = uuid(), displayName = generator.word() } =
-    groupData || {}
-
-  const group: ScimCreateGroupRequest = {
-    schemas: [
-      "urn:ietf:params:scim:schemas:core:2.0:Group",
-      "http://schemas.microsoft.com/2006/11/ResourceManagement/ADSCIM/2.0/Group",
-    ],
-    externalId: externalId,
-    displayName: displayName,
-    meta: {
-      resourceType: "Group",
-      created: new Date(),
-      lastModified: new Date(),
-    },
-  }
-  return group
-}

package/tests/core/utilities/structures/shared.ts

@@ -1,19 +0,0 @@
-import { User } from "@budibase/types"
-import { generator } from "./generator"
-import { uuid } from "./common"
-
-export const newEmail = () => {
-  return `${uuid()}@test.com`
-}
-
-export const user = (userProps?: any): User => {
-  return {
-    email: newEmail(),
-    password: "test",
-    roles: { app_test: "admin" },
-    firstName: generator.first(),
-    lastName: generator.last(),
-    pictureUrl: "http://test.com",
-    ...userProps,
-  }
-}

package/tests/core/utilities/structures/sso.ts

@@ -1,119 +0,0 @@
-import {
-  ConfigType,
-  GoogleConfig,
-  GoogleInnerConfig,
-  JwtClaims,
-  OAuth2,
-  OIDCInnerConfig,
-  OIDCWellKnownConfig,
-  SSOAuthDetails,
-  SSOProfile,
-  SSOProviderType,
-  User,
-} from "@budibase/types"
-import { generator } from "./generator"
-import { email, uuid } from "./common"
-import * as shared from "./shared"
-import { user } from "./shared"
-import sample from "lodash/sample"
-
-export function OAuth(): OAuth2 {
-  return {
-    refreshToken: generator.string(),
-    accessToken: generator.string(),
-  }
-}
-
-export function authDetails(userDoc?: User): SSOAuthDetails {
-  if (!userDoc) {
-    userDoc = user()
-  }
-
-  const userId = userDoc._id || uuid()
-  const provider = generator.string()
-
-  const profile = ssoProfile(userDoc)
-  profile.provider = provider
-  profile.id = userId
-
-  return {
-    email: userDoc.email,
-    oauth2: OAuth(),
-    profile,
-    provider,
-    providerType: providerType(),
-    userId,
-  }
-}
-
-export function providerType(): SSOProviderType {
-  return sample(Object.values(SSOProviderType)) as SSOProviderType
-}
-
-export function ssoProfile(user?: User): SSOProfile {
-  if (!user) {
-    user = shared.user()
-  }
-  return {
-    id: user._id!,
-    name: {
-      givenName: user.firstName,
-      familyName: user.lastName,
-    },
-    _json: {
-      email: user.email,
-      picture: "http://test.com",
-    },
-    provider: generator.string(),
-  }
-}
-
-// OIDC
-
-export function oidcConfig(): OIDCInnerConfig {
-  return {
-    uuid: uuid(),
-    activated: true,
-    logo: "",
-    name: generator.string(),
-    configUrl: "http://someconfigurl",
-    clientID: generator.string(),
-    clientSecret: generator.string(),
-    scopes: [],
-  }
-}
-
-// response from .well-known/openid-configuration
-export function oidcWellKnownConfig(): OIDCWellKnownConfig {
-  return {
-    issuer: generator.string(),
-    authorization_endpoint: generator.url(),
-    token_endpoint: generator.url(),
-    userinfo_endpoint: generator.url(),
-  }
-}
-
-export function jwtClaims(): JwtClaims {
-  return {
-    email: email(),
-    preferred_username: email(),
-  }
-}
-
-// GOOGLE
-
-export function googleConfig(): GoogleInnerConfig {
-  return {
-    activated: true,
-    clientID: generator.string(),
-    clientSecret: generator.string(),
-  }
-}
-
-export function googleConfigDoc(): GoogleConfig {
-  return {
-    _id: "config_google",
-    type: ConfigType.GOOGLE,
-    config: googleConfig(),
-  }
-}

package/tests/core/utilities/structures/tenants.ts

@@ -1,5 +0,0 @@
-import { newid } from "../../../../src/docIds/newid"
-
-export function id() {
-  return `tenant-${newid()}`
-}