@budibase/backend-core 2.9.40-alpha.6 → 2.10.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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