@budibase/server 2.1.22-alpha.6 → 2.1.22-alpha.8

package/src/api/routes/tests/query.spec.js

@@ -4,16 +4,21 @@ jest.mock("node-fetch")
 
 // Mock isProdAppID to we can later mock the implementation and pretend we are
 // using prod app IDs
-const authDb = require("@budibase/backend-core/db")
-const { isProdAppID } = authDb
-const mockIsProdAppID = jest.fn(isProdAppID)
-authDb.isProdAppID = mockIsProdAppID
-
+jest.mock("@budibase/backend-core", () => {
+  const core = jest.requireActual("@budibase/backend-core")
+  return {
+    ...core,
+    db: {
+      ...core.db,
+      isProdAppID: jest.fn(),
+    }
+  }
+})
 const setup = require("./utilities")
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
 const { checkCacheForDynamicVariable } = require("../../../threads/utils")
 const { basicQuery, basicDatasource } = setup.structures
-const { events } = require("@budibase/backend-core")
+const { events, db: dbCore } = require("@budibase/backend-core")
 
 describe("/queries", () => {
   let request = setup.getRequest()
@@ -152,8 +157,8 @@ describe("/queries", () => {
 
     it("should remove sensitive info for prod apps", async () => {
       // Mock isProdAppID to pretend we are using a prod app
-      mockIsProdAppID.mockClear()
-      mockIsProdAppID.mockImplementation(() => true)
+      dbCore.isProdAppID.mockClear()
+      dbCore.isProdAppID.mockImplementation(() => true)
 
       const query = await config.createQuery()
       const res = await request
@@ -167,8 +172,8 @@ describe("/queries", () => {
       expect(res.body.schema).toBeDefined()
 
       // Reset isProdAppID mock
-      expect(mockIsProdAppID).toHaveBeenCalledTimes(1)
-      mockIsProdAppID.mockImplementation(isProdAppID)
+      expect(dbCore.isProdAppID).toHaveBeenCalledTimes(1)
+      dbCore.isProdAppID.mockImplementation(() => false)
     })
   })
 

package/src/api/routes/tests/role.spec.js

@@ -1,6 +1,6 @@
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
 const {
-  BUILTIN_PERMISSION_IDS,
+  BuiltinPermissionID,
 } = require("@budibase/backend-core/permissions")
 const setup = require("./utilities")
 const { basicRole } = setup.structures
@@ -76,18 +76,18 @@ describe("/roles", () => {
       const adminRole = res.body.find(r => r._id === BUILTIN_ROLE_IDS.ADMIN)
       expect(adminRole).toBeDefined()
       expect(adminRole.inherits).toEqual(BUILTIN_ROLE_IDS.POWER)
-      expect(adminRole.permissionId).toEqual(BUILTIN_PERMISSION_IDS.ADMIN)
+      expect(adminRole.permissionId).toEqual(BuiltinPermissionID.ADMIN)
 
       const powerUserRole = res.body.find(r => r._id === BUILTIN_ROLE_IDS.POWER)
       expect(powerUserRole).toBeDefined()
       expect(powerUserRole.inherits).toEqual(BUILTIN_ROLE_IDS.BASIC)
-      expect(powerUserRole.permissionId).toEqual(BUILTIN_PERMISSION_IDS.POWER)
+      expect(powerUserRole.permissionId).toEqual(BuiltinPermissionID.POWER)
 
       const customRoleFetched = res.body.find(r => r._id === customRole._id)
       expect(customRoleFetched).toBeDefined()
       expect(customRoleFetched.inherits).toEqual(BUILTIN_ROLE_IDS.BASIC)
       expect(customRoleFetched.permissionId).toEqual(
-        BUILTIN_PERMISSION_IDS.READ_ONLY
+        BuiltinPermissionID.READ_ONLY
       )
     })
 
@@ -109,7 +109,7 @@ describe("/roles", () => {
     it("should delete custom roles", async () => {
       const customRole = await config.createRole({
         name: "user",
-        permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY,
+        permissionId: BuiltinPermissionID.READ_ONLY,
         inherits: BUILTIN_ROLE_IDS.BASIC,
       })
       delete customRole._rev_tree

package/src/api/routes/tests/static.spec.js

@@ -46,7 +46,7 @@ describe("/static", () => {
 
     it("should serve the app by id", async () => {
       const headers = config.defaultHeaders()
-      delete headers[constants.Headers.APP_ID]
+      delete headers[constants.Header.APP_ID]
 
       const res = await request
         .get(`/${config.prodAppId}`)
@@ -58,7 +58,7 @@ describe("/static", () => {
 
     it("should serve the app by url", async () => {
       const headers = config.defaultHeaders()
-      delete headers[constants.Headers.APP_ID]
+      delete headers[constants.Header.APP_ID]
 
       const res = await request
         .get(`/app${config.prodApp.url}`)

package/src/api/routes/tests/table.spec.js

@@ -1,17 +1,18 @@
 const { checkBuilderEndpoint } = require("./utilities/TestFunctions")
-const { getAppDB } = require("@budibase/backend-core/context")
 const setup = require("./utilities")
 const { basicTable } = setup.structures
-const { events } = require("@budibase/backend-core")
+const { events, context } = require("@budibase/backend-core")
 
 describe("/tables", () => {
   let request = setup.getRequest()
   let config = setup.getConfig()
+  let appId
 
   afterAll(setup.afterAll)
 
   beforeEach(async () => {
-    await config.init()
+    const app = await config.init()
+    appId = app.appId
   })
 
   describe("create", () => {
@@ -199,38 +200,6 @@ describe("/tables", () => {
     })
   })
 
-  describe("indexing", () => {
-    it("should be able to create a table with indexes", async () => {
-      const db = getAppDB(config)
-      const indexCount = (await db.getIndexes()).total_rows
-      const table = basicTable()
-      table.indexes = ["name"]
-      const res = await request
-        .post(`/api/tables`)
-        .send(table)
-        .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
-        .expect(200)
-      expect(res.body._id).toBeDefined()
-      expect(res.body._rev).toBeDefined()
-      expect((await db.getIndexes()).total_rows).toEqual(indexCount + 1)
-      // update index to see what happens
-      table.indexes = ["name", "description"]
-      await request
-        .post(`/api/tables`)
-        .send({
-          ...table,
-          _id: res.body._id,
-          _rev: res.body._rev,
-        })
-        .set(config.defaultHeaders())
-        .expect('Content-Type', /json/)
-        .expect(200)
-      // shouldn't have created a new index
-      expect((await db.getIndexes()).total_rows).toEqual(indexCount + 1)
-    })
-  })
-
   describe("validate csv", () => {
     it("should be able to validate a CSV layout", async () => {
       const res = await request
@@ -249,6 +218,40 @@ describe("/tables", () => {
     })
   })
 
+  describe("indexing", () => {
+    it("should be able to create a table with indexes", async () => {
+      await context.doInAppContext(appId, async () => {
+        const db = context.getAppDB()
+        const indexCount = (await db.getIndexes()).total_rows
+        const table = basicTable()
+        table.indexes = ["name"]
+        const res = await request
+          .post(`/api/tables`)
+          .send(table)
+          .set(config.defaultHeaders())
+          .expect('Content-Type', /json/)
+          .expect(200)
+        expect(res.body._id).toBeDefined()
+        expect(res.body._rev).toBeDefined()
+        expect((await db.getIndexes()).total_rows).toEqual(indexCount + 1)
+        // update index to see what happens
+        table.indexes = ["name", "description"]
+        await request
+          .post(`/api/tables`)
+          .send({
+            ...table,
+            _id: res.body._id,
+            _rev: res.body._rev,
+          })
+          .set(config.defaultHeaders())
+          .expect('Content-Type', /json/)
+          .expect(200)
+        // shouldn't have created a new index
+        expect((await db.getIndexes()).total_rows).toEqual(indexCount + 1)
+      })
+    })
+  })
+
   describe("destroy", () => {
     let testTable
 

package/src/api/routes/user.js

@@ -2,8 +2,8 @@ const Router = require("@koa/router")
 const controller = require("../controllers/user")
 const authorized = require("../../middleware/authorized")
 const {
-  PermissionLevels,
-  PermissionTypes,
+  PermissionLevel,
+  PermissionType,
 } = require("@budibase/backend-core/permissions")
 
 const router = new Router()
@@ -11,42 +11,42 @@ const router = new Router()
 router
   .get(
     "/api/users/metadata",
-    authorized(PermissionTypes.USER, PermissionLevels.READ),
+    authorized(PermissionType.USER, PermissionLevel.READ),
     controller.fetchMetadata
   )
   .get(
     "/api/users/metadata/:id",
-    authorized(PermissionTypes.USER, PermissionLevels.READ),
+    authorized(PermissionType.USER, PermissionLevel.READ),
     controller.findMetadata
   )
   .put(
     "/api/users/metadata",
-    authorized(PermissionTypes.USER, PermissionLevels.WRITE),
+    authorized(PermissionType.USER, PermissionLevel.WRITE),
     controller.updateMetadata
   )
   .post(
     "/api/users/metadata/self",
-    authorized(PermissionTypes.USER, PermissionLevels.WRITE),
+    authorized(PermissionType.USER, PermissionLevel.WRITE),
     controller.updateSelfMetadata
   )
   .delete(
     "/api/users/metadata/:id",
-    authorized(PermissionTypes.USER, PermissionLevels.WRITE),
+    authorized(PermissionType.USER, PermissionLevel.WRITE),
     controller.destroyMetadata
   )
   .post(
     "/api/users/metadata/sync/:id",
-    authorized(PermissionTypes.USER, PermissionLevels.WRITE),
+    authorized(PermissionType.USER, PermissionLevel.WRITE),
     controller.syncUser
   )
   .post(
     "/api/users/flags",
-    authorized(PermissionTypes.USER, PermissionLevels.WRITE),
+    authorized(PermissionType.USER, PermissionLevel.WRITE),
     controller.setFlag
   )
   .get(
     "/api/users/flags",
-    authorized(PermissionTypes.USER, PermissionLevels.READ),
+    authorized(PermissionType.USER, PermissionLevel.READ),
     controller.getFlags
   )
 

package/src/api/routes/utils/validators.js

@@ -1,8 +1,8 @@
 const { joiValidator } = require("@budibase/backend-core/auth")
 const { DataSourceOperation } = require("../../../constants")
 const {
-  BUILTIN_PERMISSION_IDS,
-  PermissionLevels,
+  BuiltinPermissionID,
+  PermissionLevel,
 } = require("@budibase/backend-core/permissions")
 const { WebhookActionType } = require("@budibase/types")
 const Joi = require("joi")
@@ -133,14 +133,14 @@ exports.webhookValidator = () => {
 }
 
 exports.roleValidator = () => {
-  const permLevelArray = Object.values(PermissionLevels)
+  const permLevelArray = Object.values(PermissionLevel)
   // prettier-ignore
   return joiValidator.body(Joi.object({
     _id: OPTIONAL_STRING,
     _rev: OPTIONAL_STRING,
     name: Joi.string().required(),
     // this is the base permission ID (for now a built in)
-    permissionId: Joi.string().valid(...Object.values(BUILTIN_PERMISSION_IDS)).required(),
+    permissionId: Joi.string().valid(...Object.values(BuiltinPermissionID)).required(),
     permissions: Joi.object()
       .pattern(/.*/, [Joi.string().valid(...permLevelArray)])
       .optional(),
@@ -149,7 +149,7 @@ exports.roleValidator = () => {
 }
 
 exports.permissionValidator = () => {
-  const permLevelArray = Object.values(PermissionLevels)
+  const permLevelArray = Object.values(PermissionLevel)
   // prettier-ignore
   return joiValidator.params(Joi.object({
     level: Joi.string().valid(...permLevelArray).required(),

package/src/api/routes/view.js

@@ -5,8 +5,8 @@ const authorized = require("../../middleware/authorized")
 const { paramResource } = require("../../middleware/resourceId")
 const {
   BUILDER,
-  PermissionTypes,
-  PermissionLevels,
+  PermissionType,
+  PermissionLevel,
 } = require("@budibase/backend-core/permissions")
 
 const router = new Router()
@@ -16,7 +16,7 @@ router
   .get(
     "/api/views/:viewName",
     paramResource("viewName"),
-    authorized(PermissionTypes.VIEW, PermissionLevels.READ),
+    authorized(PermissionType.VIEW, PermissionLevel.READ),
     rowController.fetchView
   )
   .get("/api/views", authorized(BUILDER), viewController.fetch)

package/src/automations/tests/updateRow.spec.js

@@ -1,4 +1,3 @@
-const env = require("../../environment")
 const setup = require("./utilities")
 
 describe("test the update row action", () => {

package/src/automations/tests/utilities/index.js

@@ -1,6 +1,5 @@
 const TestConfig = require("../../../tests/utilities/TestConfiguration")
-const { TENANT_ID } = require("../../../tests/utilities/structures")
-const { doInTenant } = require("@budibase/backend-core/tenancy")
+const { context } = require("@budibase/backend-core")
 const actions = require("../../actions")
 const emitter = require("../../../events/index")
 const env = require("../../../environment")
@@ -33,7 +32,7 @@ exports.runInProd = async fn => {
 }
 
 exports.runStep = async function runStep(stepId, inputs) {
-  return doInTenant(TENANT_ID, async () => {
+  async function run() {
     let step = await actions.getAction(stepId)
     expect(step).toBeDefined()
     return step({
@@ -43,7 +42,14 @@ exports.runStep = async function runStep(stepId, inputs) {
       apiKey: exports.apiKey,
       emitter,
     })
-  })
+  }
+  if (config?.appId) {
+    return context.doInContext(config?.appId, async () => {
+      return run()
+    })
+  } else {
+    return run()
+  }
 }
 
 exports.apiKey = "test"

package/src/automations/utils.ts

@@ -4,15 +4,9 @@ import { automationQueue } from "./bullboard"
 import newid from "../db/newid"
 import { updateEntityMetadata } from "../utilities"
 import { MetadataTypes } from "../constants"
-import { getProdAppID, doWithDB } from "@budibase/backend-core/db"
+import { db as dbCore, context } from "@budibase/backend-core"
 import { getAutomationMetadataParams } from "../db/utils"
 import { cloneDeep } from "lodash/fp"
-import {
-  getAppDB,
-  getAppId,
-  getProdAppDB,
-} from "@budibase/backend-core/context"
-import { context } from "@budibase/backend-core"
 import { quotas } from "@budibase/pro"
 import { Automation, WebhookActionType } from "@budibase/types"
 import sdk from "../sdk"
@@ -102,7 +96,7 @@ export async function disableCronById(jobId: number | string) {
 }
 
 export async function clearMetadata() {
-  const db = getProdAppDB()
+  const db = context.getProdAppDB()
   const automationMetadata = (
     await db.allDocs(
       getAutomationMetadataParams({
@@ -157,7 +151,7 @@ export async function enableCronTrigger(appId: any, automation: Automation) {
     // can't use getAppDB here as this is likely to be called from dev app,
     // but this call could be for dev app or prod app, need to just use what
     // was passed in
-    await doWithDB(appId, async (db: any) => {
+    await dbCore.doWithDB(appId, async (db: any) => {
       const response = await db.put(automation)
       automation._id = response.id
       automation._rev = response.rev
@@ -175,7 +169,10 @@ export async function enableCronTrigger(appId: any, automation: Automation) {
  * written to DB (this does not write to DB as it would be wasteful to repeat).
  */
 export async function checkForWebhooks({ oldAuto, newAuto }: any) {
-  const appId = getAppId()
+  const appId = context.getAppId()
+  if (!appId) {
+    throw new Error("Unable to check webhooks - no app ID in context.")
+  }
   const oldTrigger = oldAuto ? oldAuto.definition.trigger : null
   const newTrigger = newAuto ? newAuto.definition.trigger : null
   const triggerChanged =
@@ -194,7 +191,7 @@ export async function checkForWebhooks({ oldAuto, newAuto }: any) {
     oldTrigger.webhookId
   ) {
     try {
-      let db = getAppDB()
+      let db = context.getAppDB()
       // need to get the webhook to get the rev
       const webhook = await db.get(oldTrigger.webhookId)
       // might be updating - reset the inputs to remove the URLs
@@ -224,7 +221,7 @@ export async function checkForWebhooks({ oldAuto, newAuto }: any) {
     // the app ID has to be development for this endpoint
     // it can only be used when building the app
     // but the trigger endpoint will always be used in production
-    const prodAppId = getProdAppID(appId)
+    const prodAppId = dbCore.getProdAppID(appId)
     newTrigger.inputs = {
       schemaUrl: `api/webhooks/schema/${appId}/${id}`,
       triggerUrl: `api/webhooks/trigger/${prodAppId}/${id}`,

package/src/db/inMemoryView.js

@@ -2,7 +2,7 @@ const newid = require("./newid")
 
 // bypass the main application db config
 // use in memory pouchdb directly
-const { getPouch, closeDB } = require("@budibase/backend-core/db")
+const { getPouch, closePouchDB } = require("@budibase/backend-core/db")
 const Pouch = getPouch({ inMemory: true })
 
 exports.runView = async (view, calculation, group, data) => {
@@ -44,6 +44,6 @@ exports.runView = async (view, calculation, group, data) => {
     return response
   } finally {
     await db.destroy()
-    await closeDB(db)
+    await closePouchDB(db)
   }
 }

package/src/db/tests/linkController.spec.js

@@ -1,15 +1,17 @@
 const TestConfig = require("../../tests/utilities/TestConfiguration")
 const { basicRow, basicLinkedRow, basicTable } = require("../../tests/utilities/structures")
 const LinkController = require("../linkedRows/LinkController")
+const { context } = require("@budibase/backend-core")
 const { RelationshipTypes } = require("../../constants")
 const { cloneDeep } = require("lodash/fp")
 
 describe("test the link controller", () => {
   let config = new TestConfig(false)
-  let table1, table2
+  let table1, table2, appId
 
   beforeEach(async () => {
-    await config.init()
+    const app = await config.init()
+    appId = app.appId
     const { _id } = await config.createTable()
     table2 = await config.createLinkedTable(RelationshipTypes.MANY_TO_MANY, ["link", "link2"])
     // update table after creating link
@@ -18,18 +20,20 @@ describe("test the link controller", () => {
 
   afterAll(config.end)
 
-  function createLinkController(table, row = null, oldTable = null) {
-    const linkConfig = {
-      tableId: table._id,
-      table,
-    }
-    if (row) {
-      linkConfig.row = row
-    }
-    if (oldTable) {
-      linkConfig.oldTable = oldTable
-    }
-    return new LinkController(linkConfig)
+  async function createLinkController(table, row = null, oldTable = null) {
+    return context.doInAppContext(appId, () => {
+      const linkConfig = {
+        tableId: table._id,
+        table,
+      }
+      if (row) {
+        linkConfig.row = row
+      }
+      if (oldTable) {
+        linkConfig.oldTable = oldTable
+      }
+      return new LinkController(linkConfig)
+    })
   }
 
   async function createLinkedRow(linkField = "link", t1 = table1, t2 = table2) {
@@ -38,16 +42,16 @@ describe("test the link controller", () => {
     return config.getRow(t1._id, _id)
   }
 
-  it("should be able to confirm if two table schemas are equal", () => {
-    const controller = createLinkController(table1)
+  it("should be able to confirm if two table schemas are equal", async () => {
+    const controller = await createLinkController(table1)
     let equal = controller.areLinkSchemasEqual(table2.schema.link, table2.schema.link)
     expect(equal).toEqual(true)
     equal = controller.areLinkSchemasEqual(table1.schema.link, table2.schema.link)
     expect(equal).toEqual(false)
   })
 
-  it("should be able to check the relationship types across two fields", () => {
-    const controller = createLinkController(table1)
+  it("should be able to check the relationship types across two fields", async () => {
+    const controller = await createLinkController(table1)
     // empty case
     let output = controller.handleRelationshipType({}, {})
     expect(output.linkedField.relationshipType).toEqual(RelationshipTypes.MANY_TO_MANY)
@@ -65,29 +69,33 @@ describe("test the link controller", () => {
 
   it("should be able to delete a row", async () => {
     const row = await createLinkedRow()
-    const controller = createLinkController(table1, row)
-    // get initial count
-    const beforeLinks = await controller.getRowLinkDocs(row._id)
-    await controller.rowDeleted()
-    let afterLinks = await controller.getRowLinkDocs(row._id)
-    expect(beforeLinks.length).toEqual(1)
-    expect(afterLinks.length).toEqual(0)
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      // get initial count
+      const beforeLinks = await controller.getRowLinkDocs(row._id)
+      await controller.rowDeleted()
+      let afterLinks = await controller.getRowLinkDocs(row._id)
+      expect(beforeLinks.length).toEqual(1)
+      expect(afterLinks.length).toEqual(0)
+    })
   })
 
   it("shouldn't throw an error when deleting a row with no links", async () => {
     const row = await config.createRow(basicRow(table1._id))
-    const controller = createLinkController(table1, row)
-    let error
-    try {
-      await controller.rowDeleted()
-    } catch (err) {
-      error = err
-    }
-    expect(error).toBeUndefined()
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      let error
+      try {
+        await controller.rowDeleted()
+      } catch (err) {
+        error = err
+      }
+      expect(error).toBeUndefined()
+    })
   })
 
-  it("should throw an error when validating a table which is invalid", () => {
-    const controller = createLinkController(table1)
+  it("should throw an error when validating a table which is invalid", async () => {
+    const controller = await createLinkController(table1)
     const copyTable = {
       ...table1
     }
@@ -110,32 +118,38 @@ describe("test the link controller", () => {
     const row = await createLinkedRow()
     // remove the link from the row
     row.link = []
-    const controller = createLinkController(table1, row)
-    await controller.rowSaved()
-    let links = await controller.getRowLinkDocs(row._id)
-    expect(links.length).toEqual(0)
+    const controller = await createLinkController(table1, row)
+    await context.doInAppContext(appId, async () => {
+      await controller.rowSaved()
+      let links = await controller.getRowLinkDocs(row._id)
+      expect(links.length).toEqual(0)
+    })
   })
 
   it("should be able to delete a table and have links deleted", async () => {
     await createLinkedRow()
-    const controller = createLinkController(table1)
-    let before = await controller.getTableLinkDocs()
-    await controller.tableDeleted()
-    let after = await controller.getTableLinkDocs()
-    expect(before.length).toEqual(1)
-    expect(after.length).toEqual(0)
+    const controller = await createLinkController(table1)
+    await context.doInAppContext(appId, async () => {
+      let before = await controller.getTableLinkDocs()
+      await controller.tableDeleted()
+      let after = await controller.getTableLinkDocs()
+      expect(before.length).toEqual(1)
+      expect(after.length).toEqual(0)
+    })
   })
 
   it("should be able to remove a linked field from a table", async () => {
     await createLinkedRow()
     await createLinkedRow("link2")
-    const controller = createLinkController(table1, null, table1)
-    let before = await controller.getTableLinkDocs()
-    await controller.removeFieldFromTable("link")
-    let after = await controller.getTableLinkDocs()
-    expect(before.length).toEqual(2)
-    // shouldn't delete the other field
-    expect(after.length).toEqual(1)
+    const controller = await createLinkController(table1, null, table1)
+    await context.doInAppContext(appId, async () => {
+      let before = await controller.getTableLinkDocs()
+      await controller.removeFieldFromTable("link")
+      let after = await controller.getTableLinkDocs()
+      expect(before.length).toEqual(2)
+      // shouldn't delete the other field
+      expect(after.length).toEqual(1)
+    })
   })
 
   it("should throw an error when overwriting a link column", async () => {
@@ -143,7 +157,7 @@ describe("test the link controller", () => {
     update.schema.link.relationshipType = RelationshipTypes.MANY_TO_ONE
     let error
     try {
-      const controller = createLinkController(update)
+      const controller = await createLinkController(update)
       await controller.tableSaved()
     } catch (err) {
       error = err
@@ -156,10 +170,12 @@ describe("test the link controller", () => {
     await createLinkedRow()
     const newTable = cloneDeep(table1)
     delete newTable.schema.link
-    const controller = createLinkController(newTable, null, table1)
-    await controller.tableUpdated()
-    const links = await controller.getTableLinkDocs()
-    expect(links.length).toEqual(0)
+    const controller = await createLinkController(newTable, null, table1)
+    await context.doInAppContext(appId, async () => {
+      await controller.tableUpdated()
+      const links = await controller.getTableLinkDocs()
+      expect(links.length).toEqual(0)
+    })
   })
 
   it("shouldn't allow one to many having many relationships against it", async () => {