@kaspernj/api-maker 1.0.446 → 1.0.448

package/__tests__/base-model.test.mjs

@@ -1,71 +0,0 @@
-import BaseModel from "../src/base-model.mjs"
-import CustomError from "../src/custom-error.mjs"
-import {jest} from "@jest/globals"
-import {JSDOM} from "jsdom"
-import ValidationError from "../src/validation-error.mjs"
-import User from "./support/user.mjs"
-
-jest.mock("@rails/actioncable", () => ({
-  createConsumer: () => ({})
-}))
-
-const {window} = new JSDOM()
-const document = window.document
-
-describe("BaseModel", () => {
-  describe("identifierKey", () => {
-    it("returns the id when persisted", () => {
-      const user = new User({a: {id: 5}})
-
-      expect(user.identifierKey()).toEqual(5)
-    })
-
-    it("returns the unique key when new record", () => {
-      const user = new User({isNewRecord: true})
-
-      user.uniqueKey = () => 45
-
-      expect(user.identifierKey()).toEqual(45)
-    })
-  })
-
-  describe("update", () => {
-    it("aborts if no changes", async () => {
-      const model = new BaseModel()
-
-      // This will fail because of missing setup if it doesn't abort.
-      const response = await model.update({})
-
-      // There will be extra objects in the hash if it actually calls the backend.
-      expect(response).toEqual({model})
-    })
-  })
-
-  describe("parseValidationErrors", () => {
-    const error = new CustomError("Some validation error", {
-      response: {
-        validation_errors: []
-      }
-    })
-    const form = document.createElement("form")
-    const model = new BaseModel()
-    const dispatchEventSpy = jest.spyOn(form, "dispatchEvent").mockImplementation(() => "asd")
-    const newCustomEventSpy = jest.spyOn(BaseModel, "newCustomEvent").mockImplementation(() => "asd")
-
-    it("throws the validation errors if no options are given", () => {
-      expect(() => BaseModel.parseValidationErrors({error, model})).toThrow(ValidationError)
-    })
-
-    it("throws the validation errors and dispatches an event to the form", () => {
-      expect(() => BaseModel.parseValidationErrors({error, model, options: {form}})).toThrow(ValidationError)
-      expect(dispatchEventSpy).toHaveBeenCalled()
-      expect(newCustomEventSpy).toHaveBeenCalled()
-    })
-
-    it("doesnt throw validation errors if disabled", () => {
-      BaseModel.parseValidationErrors({error, model, options: {throwValidationError: false}})
-      expect(dispatchEventSpy).toHaveBeenCalled()
-      expect(newCustomEventSpy).toHaveBeenCalled()
-    })
-  })
-})

package/__tests__/cable-connection-pool.test.mjs

@@ -1,227 +0,0 @@
-import CableConnectionPool from "../src/cable-connection-pool.mjs"
-import CableSubscriptionPool from "../src/cable-subscription-pool.mjs"
-import {digg} from "diggerize"
-import {jest} from "@jest/globals"
-
-jest.mock("@rails/actioncable", () => ({
-  createConsumer: () => ({})
-}))
-
-describe("CableConnectionPool", () => {
-  describe("connectCreated", () => {
-    it("creates a new create event and connects", () => {
-      const cableConnectionPool = new CableConnectionPool()
-
-      cableConnectionPool.scheduleConnectUpcoming = function () {
-        const subscriptionData = this.upcomingSubscriptionData
-        const subscriptions = this.upcomingSubscriptions
-
-        this.upcomingSubscriptionData = {}
-        this.upcomingSubscriptions = {}
-
-        const cableSubscriptionPool = {subscriptionData, subscriptions}
-
-        this.cableSubscriptionPools.push(cableSubscriptionPool)
-      }
-      cableConnectionPool.cableSubscriptionPools = []
-      cableConnectionPool.connectCreated("Contact", () => console.log("Callback"))
-
-      expect(cableConnectionPool.cableSubscriptionPools.length).toEqual(1)
-
-      const newCableSubscriptionPool = digg(cableConnectionPool, "cableSubscriptionPools", 0)
-      const subscriptions = digg(newCableSubscriptionPool, "subscriptions", "Contact", "creates")
-
-      expect(subscriptions.length).toEqual(1)
-    })
-  })
-
-  describe("connectDestroyed", () => {
-    it("creates a new destroy event and connects", () => {
-      const cableConnectionPool = new CableConnectionPool()
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      cableSubscriptionPool.subscriptions = {
-        Contact: {
-          updates: {
-            modelId: []
-          }
-        }
-      }
-
-      cableConnectionPool.scheduleConnectUpcoming = function () {
-        const subscriptionData = this.upcomingSubscriptionData
-        const subscriptions = this.upcomingSubscriptions
-
-        this.upcomingSubscriptionData = {}
-        this.upcomingSubscriptions = {}
-
-        const cableSubscriptionPool = {subscriptionData, subscriptions}
-
-        this.cableSubscriptionPools.push(cableSubscriptionPool)
-      }
-      cableConnectionPool.cableSubscriptionPools = [cableSubscriptionPool]
-      cableConnectionPool.connectDestroyed("Contact", "modelId", () => { })
-
-      expect(cableConnectionPool.cableSubscriptionPools.length).toEqual(2)
-
-      const newCableSubscriptionPool = cableConnectionPool.cableSubscriptionPools[1]
-      const subscriptions = digg(newCableSubscriptionPool, "subscriptions", "Contact", "destroys", "modelId")
-
-      expect(subscriptions.length).toEqual(1)
-    })
-
-    it("connects to an existing destroy event", () => {
-      let connectedUnsubscribeEvent = false
-
-      const cableConnectionPool = new CableConnectionPool()
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      cableSubscriptionPool.connected = true
-      cableSubscriptionPool.connectUnsubscriptionForSubscription = function () {
-        connectedUnsubscribeEvent = true
-      }
-      cableSubscriptionPool.subscriptions = {
-        Contact: {
-          destroys: {
-            modelId: []
-          }
-        }
-      }
-
-      cableConnectionPool.connectUpcoming = () => console.log("connectUpcoming")
-      cableConnectionPool.cableSubscriptionPools = [cableSubscriptionPool]
-      cableConnectionPool.connectDestroyed("Contact", "modelId", () => { })
-
-      const subscriptions = digg(cableSubscriptionPool, "subscriptions", "Contact", "destroys", "modelId")
-
-      expect(subscriptions.length).toEqual(1)
-      expect(connectedUnsubscribeEvent).toEqual(true)
-    })
-
-    it("doesnt connect to an existing destroy event that is disconnected", () => {
-      const cableConnectionPool = new CableConnectionPool()
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      cableSubscriptionPool.subscriptions = {
-        Contact: {
-          destroys: {
-            modelId: []
-          }
-        }
-      }
-
-      cableConnectionPool.connected = false
-      cableConnectionPool.connectUpcoming = function () {
-        const subscriptionData = this.upcomingSubscriptionData
-        const subscriptions = this.upcomingSubscriptions
-
-        this.upcomingSubscriptionData = {}
-        this.upcomingSubscriptions = {}
-
-        const cableSubscriptionPool = {subscriptionData, subscriptions}
-
-        this.cableSubscriptionPools.push(cableSubscriptionPool)
-      }
-      cableConnectionPool.cableSubscriptionPools = [cableSubscriptionPool]
-      cableConnectionPool.scheduleConnectUpcoming = () => cableConnectionPool.connectUpcoming()
-      cableConnectionPool.connectDestroyed("Contact", "modelId", () => { })
-
-      const subscriptions = digg(cableSubscriptionPool, "subscriptions", "Contact", "destroys", "modelId")
-
-      expect(subscriptions.length).toEqual(0)
-      expect(cableConnectionPool.cableSubscriptionPools.length).toEqual(2)
-    })
-  })
-
-  describe("connectUpdate", () => {
-    it("creates a new update event and connects", () => {
-      const cableConnectionPool = new CableConnectionPool()
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      cableSubscriptionPool.subscriptions = {
-        Contact: {
-          destroys: {
-            modelId: []
-          }
-        }
-      }
-
-      cableConnectionPool.scheduleConnectUpcoming = function () {
-        const subscriptionData = this.upcomingSubscriptionData
-        const subscriptions = this.upcomingSubscriptions
-
-        this.upcomingSubscriptionData = {}
-        this.upcomingSubscriptions = {}
-
-        const cableSubscriptionPool = {subscriptionData, subscriptions}
-
-        this.cableSubscriptionPools.push(cableSubscriptionPool)
-      }
-      cableConnectionPool.cableSubscriptionPools = [cableSubscriptionPool]
-      cableConnectionPool.connectUpdate("Contact", "modelId", () => console.log("Update callback"))
-
-      expect(cableConnectionPool.cableSubscriptionPools.length).toEqual(2)
-
-      const newCableSubscriptionPool = cableConnectionPool.cableSubscriptionPools[1]
-      const subscriptions = digg(newCableSubscriptionPool, "subscriptions", "Contact", "updates", "modelId")
-
-      expect(subscriptions.length).toEqual(1)
-    })
-
-    it("connects to an existing update event", () => {
-      let connectedUnsubscribeEvent = false
-
-      const cableConnectionPool = new CableConnectionPool()
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      cableSubscriptionPool.connected = true
-      cableSubscriptionPool.connectUnsubscriptionForSubscription = function () {
-        connectedUnsubscribeEvent = true
-      }
-      cableSubscriptionPool.subscriptions = {
-        Contact: {
-          updates: {
-            modelId: []
-          }
-        }
-      }
-
-      cableConnectionPool.connectUpcoming = () => console.log("connectUpcoming")
-      cableConnectionPool.cableSubscriptionPools = [cableSubscriptionPool]
-      cableConnectionPool.connectUpdate("Contact", "modelId", () => { })
-
-      const subscriptions = digg(cableSubscriptionPool, "subscriptions", "Contact", "updates", "modelId")
-
-      expect(subscriptions.length).toEqual(1)
-      expect(connectedUnsubscribeEvent).toEqual(true)
-    })
-
-    it("connects to an existing update event if the model ID is truthy like 1 is", () => {
-      let connectedUnsubscribeEvent = false
-
-      const cableConnectionPool = new CableConnectionPool()
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      cableSubscriptionPool.connected = true
-      cableSubscriptionPool.connectUnsubscriptionForSubscription = function () {
-        connectedUnsubscribeEvent = true
-      }
-      cableSubscriptionPool.subscriptions = {
-        Contact: {
-          updates: {
-            1: []
-          }
-        }
-      }
-
-      cableConnectionPool.connectUpcoming = () => console.log("connectUpcoming")
-      cableConnectionPool.cableSubscriptionPools = [cableSubscriptionPool]
-      cableConnectionPool.connectUpdate("Contact", 1, () => console.log("Update callback called"))
-
-      const subscriptions = digg(cableSubscriptionPool, "subscriptions", "Contact", "updates", 1)
-
-      expect(subscriptions.length).toEqual(1)
-      expect(connectedUnsubscribeEvent).toEqual(true)
-    })
-  })
-})

package/__tests__/cable-subscription-pool.test.mjs

@@ -1,27 +0,0 @@
-import CableSubscriptionPool from "../src/cable-subscription-pool.mjs"
-
-jest.mock("@rails/actioncable", () => ({
-  createConsumer: () => ({})
-}))
-
-describe("CableSubscriptionPool", () => {
-  describe("onUnsubscribe", () => {
-    it("unsubscribes from ActionCable", () => {
-      const cableSubscriptionPool = new CableSubscriptionPool()
-
-      let unsubscribeCalled = false
-
-      cableSubscriptionPool.activeSubscriptions = 1
-      cableSubscriptionPool.subscription = {
-        unsubscribe: () => {
-          unsubscribeCalled = true
-        }
-      }
-      cableSubscriptionPool.onUnsubscribe()
-
-      expect(unsubscribeCalled).toEqual(true)
-      expect(cableSubscriptionPool.activeSubscriptions).toEqual(0)
-      expect(cableSubscriptionPool.isConnected()).toEqual(false)
-    })
-  })
-})

package/__tests__/can-can.test.mjs

@@ -1,34 +0,0 @@
-import CanCan from "../src/can-can.mjs"
-import {jest} from "@jest/globals"
-import Services from "../src/services.mjs"
-
-jest.mock("../src/services.mjs")
-
-describe("CanCan", () => {
-  const canCan = CanCan.current()
-
-  describe("resetAbilities", () => {
-    test("that reset abilities and load abilities not have concurrency issues", async () => {
-      const mockedCurrent = jest.fn().mockReturnValue({
-        sendRequest: async () => ({abilities: ["loaded"]})
-      })
-      Services.current = mockedCurrent
-
-      const loadAbilitiesPromise = canCan.loadAbilities([["user", ["read"]]])
-      const resetPromise = canCan.resetAbilities()
-
-      await Promise.all([loadAbilitiesPromise, resetPromise])
-
-      expect(canCan.abilities).toEqual([])
-    })
-
-    it("dispatches an event", async () => {
-      const eventListener = jest.fn()
-      canCan.events.addListener("onResetAbilities", eventListener)
-
-      await canCan.resetAbilities()
-
-      expect(eventListener).toHaveBeenCalled()
-    })
-  })
-})

package/__tests__/collection.test.mjs

@@ -1,51 +0,0 @@
-import Collection from "../src/collection.mjs"
-
-describe("Collection", () => {
-  describe("count", () => {
-    it("is able to clone the collection and merge count into it without manipulating the original given query", () => {
-      let collection = new Collection({}, {})
-
-      collection.ransack({name_cont: "Kasper"})
-
-      let countCollection = collection.clone()._merge({count: true})
-
-      expect(collection.queryArgs).toEqual({ransack: {name_cont: "Kasper"}})
-      expect(countCollection.queryArgs).toEqual({count: true, ransack: {name_cont: "Kasper"}})
-    })
-  })
-
-  describe("ransack", () => {
-    it("handles undefined arguments", () => {
-      // This can happen if someone does something like this and users_q isn't set:
-      // query.ransack(params.users_q)
-
-      let collection = new Collection({}, {ransack: {id_eq: 5}})
-
-      collection.ransack(undefined)
-
-      expect(collection.queryArgs).toEqual({ransack: {id_eq: 5}})
-    })
-
-    it("handles sorts of different types", () => {
-      let collection = new Collection({}, {})
-
-      collection = collection.ransack({s: "created_at"})
-      expect(collection.queryArgs.ransack.s).toEqual("created_at")
-
-      collection = collection.ransack({s: ["id", "name"]})
-      expect(collection.queryArgs.ransack.s).toEqual(["created_at", "id", "name"])
-    })
-  })
-
-  describe("selectColumns", () => {
-    it("adds selected columns to the query", () => {
-      let collection = new Collection({}, {})
-
-      collection = collection.selectColumns({User: ["id"]})
-      expect(collection.queryArgs.selectColumns).toEqual({user: ["id"]})
-
-      collection = collection.selectColumns({User: ["email"]})
-      expect(collection.queryArgs.selectColumns).toEqual({user: ["id", "email"]})
-    })
-  })
-})

package/__tests__/custom-error.test.mjs

@@ -1,13 +0,0 @@
-import CustomError from "../src/custom-error.mjs"
-
-describe("CustomError", () => {
-  it("handles when response is a string", () => {
-    const xhr = {status: 401}
-    const response = "An error happened"
-    const customError = new CustomError(`Request failed with code: ${xhr.status}`, {response, xhr})
-
-    expect(customError.message).toEqual("Request failed with code: 401")
-    expect(customError.errorMessages()).toEqual(undefined)
-    expect(customError.errorTypes()).toEqual(undefined)
-  })
-})

package/__tests__/model-name.test.mjs

@@ -1,34 +0,0 @@
-import I18nOnSteroids from "i18n-on-steroids"
-import ModelName from "../src/model-name.mjs"
-
-const i18n = new I18nOnSteroids()
-
-const initializeI18n = () => {
-  i18n.scanObject({
-    da: {
-      activerecord: {
-        models: {
-          user: {
-            one: "Bruger",
-            other: "Brugere"
-          }
-        }
-      }
-    }
-  })
-  i18n.setLocale("da")
-}
-
-describe("ModelName", () => {
-  beforeEach(() => {
-    initializeI18n()
-  })
-
-  test("human", () => {
-    const modelClassData = {i18nKey: "user"}
-    const modelName = new ModelName({i18n, modelClassData})
-
-    expect(modelName.human()).toEqual("Bruger")
-    expect(modelName.human({count: 2})).toEqual("Brugere")
-  })
-})

package/__tests__/model-prop-type.test.mjs

@@ -1,113 +0,0 @@
-import ModelPropType from "../src/model-prop-type.mjs"
-import Task from "./support/task.mjs"
-import User from "./support/user.mjs"
-
-describe("ModelPropType", () => {
-  describe("ofModel", () => {
-    it("validates model class successfully", () => {
-      const user = new User({})
-      const validator = ModelPropType.ofModel(User).isRequired
-      const validation = validator({user}, "user")
-
-      expect(validation).toBeUndefined()
-    })
-
-    it("validates model class unsuccessfully", () => {
-      const task = new Task()
-      const validator = ModelPropType.ofModel(User).isRequired
-      const validation = validator({user: task}, "user")
-
-      expect(validation).toEqual(new Error("Expected user to be of type User but it wasn't: Task"))
-    })
-  })
-
-  describe("withLoadedAbilities", () => {
-    it("validates required attributes successfully", () => {
-      const user = new User({a: {id: 5}, b: {destroy: false, edit: true}})
-      const validator = ModelPropType.ofModel(User).withLoadedAbilities(["destroy", "edit"]).isRequired
-      const validation = validator({user}, "user")
-
-      expect(validation).toBeUndefined()
-    })
-
-    it("validates required attributes unsuccessfully", () => {
-      const user = new User({a: {id: 5}, b: {edit: true}})
-      const validator = ModelPropType.ofModel(User).withLoadedAbilities(["destroy", "edit"]).isRequired
-      const validation = validator({user}, "user")
-
-      expect(validation).toEqual(new Error("The ability destroy was required to be loaded in user of the User type but it wasn't"))
-    })
-  })
-
-  describe("withLoadedAssociation", () => {
-    it("validates association is loaded overall successfully", () => {
-      const task = new Task()
-      const user = new User({r: {tasks: [task]}})
-
-      const validator = ModelPropType
-        .ofModel(User)
-        .withLoadedAssociation("tasks")
-        .previous()
-        .isRequired
-
-      const validation = validator({user}, "user")
-
-      expect(validation).toBeUndefined()
-    })
-
-    it("validates association is loaded overall unsuccessfully", () => {
-      const user = new User({r: {}})
-
-      const validator = ModelPropType
-        .ofModel(User)
-        .withLoadedAssociation("tasks")
-        .previous()
-        .isRequired
-
-      const validation = validator({user}, "user")
-
-      expect(validation).toEqual(new Error("The association tasks was required to be loaded in user of the User type but it wasn't"))
-    })
-
-    it("validates attributes on nested associations", () => {
-      const task = new Task({a: {id: 4, name: "Test task"}})
-      const user = new User({r: {tasks: [task]}})
-
-      const validator = ModelPropType.ofModel(User)
-        .withLoadedAssociation("tasks")
-          .withLoadedAttributes(["id", "name", "updatedAt"])
-          .previous()
-        .isRequired
-
-      const validation = validator({user}, "user")
-
-      expect(validation).toEqual(new Error("The attribute updatedAt was required to be loaded in user.tasks of the Task type but it wasn't"))
-    })
-  })
-
-  describe("withLoadedAttributes", () => {
-    it("validates required attributes successfully", () => {
-      const user = new User({a: {id: 5, name: "Donald Duck"}})
-      const validator = ModelPropType.ofModel(User).withLoadedAttributes(["id", "name"]).isRequired
-      const validation = validator({user}, "user")
-
-      expect(validation).toBeUndefined()
-    })
-
-    it("validates required attributes unsuccessfully", () => {
-      const user = new User({a: {id: 5}})
-      const validator = ModelPropType.ofModel(User).withLoadedAttributes(["id", "name"]).isRequired
-      const validation = validator({user}, "user")
-
-      expect(validation).toEqual(new Error("The attribute name was required to be loaded in user of the User type but it wasn't"))
-    })
-
-    it("ignores if the model is a new record", () => {
-      const user = new User({isNewRecord: true})
-      const validator = ModelPropType.ofModel(User).withLoadedAttributes(["id", "name"]).isRequired
-      const validation = validator({user}, "user")
-
-      expect(validation).toBeUndefined()
-    })
-  })
-})

package/__tests__/params.test.mjs

@@ -1,40 +0,0 @@
-import Params from "../src/params.mjs"
-
-describe("Params", () => {
-  describe("change", () => {
-    it("changes the params", () => {
-      delete global.location
-
-      global.location = {
-        search: "?q[name_cont]=kasper"
-      }
-
-      const result = Params.change({q: {s: "name asc"}})
-
-      expect(result).toEqual({
-        q: {
-          name_cont: "kasper",
-          s: "name asc"
-        }
-      })
-    })
-  })
-
-  describe("parse", () => {
-    it("parses the current path", () => {
-      delete global.location
-
-      global.location = {
-        search: "?q[name_cont]=kasper"
-      }
-
-      const result = Params.parse()
-
-      expect(result).toEqual({
-        q: {
-          name_cont: "kasper"
-        }
-      })
-    })
-  })
-})