@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/src/with-router.jsx

@@ -1,133 +1,11 @@
-import config from "./config.mjs"
-import escapeStringRegexp from "escape-string-regexp"
-import inflection from "inflection"
-import PropTypes from "prop-types"
 import React from "react"
-import shouldComponentUpdate from "set-state-compare/src/should-component-update"
+import useRouter from "./use-router"
 
-export default (WrapperComponent) => class WithRouter extends React.Component {
-  static propTypes = {
-    path: PropTypes.string,
-    routeDefinitions: PropTypes.object,
-    routes: PropTypes.object
-  }
+export default (WrapperComponent) => (props) => {
+  const {path, routes, routeDefinitions, ...restProps} = props
+  const {match} = useRouter({path, routes, routeDefinitions})
 
-  parsedRouteDefinitions = this.parseRouteDefinitions()
-
-  shouldComponentUpdate(nextProps, nextState) {
-    return shouldComponentUpdate(this, nextProps, nextState)
-  }
-
-  findRouteParams(routeDefinition) {
-    const result = []
-    const parts = routeDefinition.path.split("/")
-
-    for (const part of parts) {
-      if (part.match(/^:([a-z_]+)$/))
-        result.push(part)
-    }
-
-    return result
-  }
-
-  path() {
-    let path = this.props.path || window.location.pathname
-
-    path = path.replace(/[/]+$/, "")
-
-    return path
-  }
-
-  routeDefinitions() {
-    return this.props.routeDefinitions || config.getRouteDefinitions()
-  }
-
-  routes() {
-    return this.props.routes || config.getRoutes()
-  }
-
-  parseRouteDefinitions() {
-    const Locales = require("shared/locales").default
-    const routeDefinitions = this.routeDefinitions()
-    const routes = this.routes()
-    const regex = /:([A-z\d_]+)/
-    const parsedRouteDefinitions = []
-
-    for (const locale of Locales.availableLocales()) {
-      for (const routeDefinition of routeDefinitions.routes) {
-        const routePathName = `${inflection.camelize(routeDefinition.name, true)}Path`
-        const params = this.findRouteParams(routeDefinition)
-
-        params.push({locale})
-
-        if (!(routePathName in routes))
-          throw new Error(`${routePathName} not found in routes: ${Object.keys(routes, ", ")}`)
-
-        const routePath = routes[routePathName](...params).replace(/[/]+$/, "")
-        const groups = []
-        let pathRegexString = "^"
-
-        pathRegexString += escapeStringRegexp(routePath)
-
-        while (true) {
-          const match = pathRegexString.match(regex)
-
-          if (!match) break
-
-          const variableName = match[1]
-
-          groups.push(variableName)
-
-          pathRegexString = pathRegexString.replace(match[0], "([^/]+)")
-        }
-
-        pathRegexString += "$"
-
-        const pathRegex = new RegExp(pathRegexString)
-
-        parsedRouteDefinitions.push({groups, pathRegex, routeDefinition})
-      }
-    }
-
-    return parsedRouteDefinitions
-  }
-
-  findMatchingRoute() {
-    const path = this.path()
-
-    for (const parsedRouteDefinition of this.parsedRouteDefinitions) {
-      const match = path.match(parsedRouteDefinition.pathRegex)
-      let matched, params
-
-      if (match) {
-        matched = true
-        params = {}
-
-        for (const groupKey in parsedRouteDefinition.groups) {
-          const groupName = parsedRouteDefinition.groups[groupKey]
-
-          params[groupName] = match[Number(groupKey) + 1]
-        }
-      }
-
-      if (path == "" && parsedRouteDefinition.routeDefinition.path == "/") matched = true
-      if (matched) {
-        return {params, parsedRouteDefinition}
-      }
-    }
-  }
-
-  render() {
-    const {path, routes, routeDefinitions, ...restProps} = this.props
-    const matchingRoute = this.findMatchingRoute()
-    const params = matchingRoute?.params || {}
-    const match = {
-      matchingRoute,
-      params
-    }
-
-    return (
-      <WrapperComponent match={match} {...restProps} />
-    )
-  }
+  return (
+    <WrapperComponent match={match} {...restProps} />
+  )
 }

package/__tests__/base-model.test.js

@@ -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.js

@@ -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.js

@@ -1,26 +0,0 @@
-jest.mock("@rails/actioncable", () => ({
-  createConsumer: () => ({})
-}))
-import CableSubscriptionPool from "../src/cable-subscription-pool.mjs"
-
-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.js

@@ -1,34 +0,0 @@
-import CanCan from "../src/can-can.mjs"
-import {jest} from "@jest/globals"
-
-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 () => {
-      import Services from "../src/services.mjs"
-      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.js

@@ -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.js

@@ -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.js

@@ -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")
-  })
-})