@kaspernj/api-maker 1.0.2053 → 1.0.2054

package/src/use-collection.js

@@ -1,280 +0,0 @@
-import debounce from "debounce"
-import {digg} from "diggerize"
-import * as inflection from "inflection"
-import ModelEvents from "./model-events"
-import {useCallback, useLayoutEffect, useMemo} from "react"
-import useCreatedEvent from "./use-created-event"
-import useShape from "set-state-compare/src/use-shape"
-import useQueryParams from "on-location-changed/build/use-query-params"
-
-const useCollection = (props, cacheKeys = []) => {
-  const {
-    abilities,
-    collection,
-    defaultParams,
-    groupBy,
-    ifCondition,
-    limit,
-    modelClass,
-    noRecordsAvailableContent = undefined,
-    noRecordsFoundContent = undefined,
-    onModelsLoaded,
-    pagination = false,
-    preloads = [],
-    queryMethod,
-    queryName: initialQueryName,
-    ransack,
-    select = {},
-    selectColumns,
-    ...restProps
-  } = props
-
-  if (Object.keys(restProps).length > 0) {
-    throw new Error(`Unknown props given to useCollection: ${Object.keys(restProps).join(", ")}`)
-  }
-
-  const s = useShape(props)
-  const queryName = initialQueryName || digg(modelClass.modelClassData(), "collectionKey")
-
-  s.meta.queryParams = useQueryParams()
-
-  const hasQParams = useCallback(() => {
-    if (s.s.queryQName in s.m.queryParams) return true
-
-    return false
-  }, [])
-
-  const qParams = useCallback(() => {
-    if (hasQParams()) return JSON.parse(digg(s.m.queryParams, s.s.queryQName))
-
-    return {}
-  }, [])
-
-  s.useStates({
-    models: undefined,
-    overallCount: undefined,
-    query: undefined,
-    queryName,
-    queryPerKey: `${queryName}_per`,
-    queryQName: `${queryName}_q`,
-    querySName: `${queryName}_s`,
-    queryPageName: `${queryName}_page`,
-    result: undefined,
-    searchParams: undefined,
-    showNoRecordsAvailableContent: false,
-    showNoRecordsFoundContent: false
-  })
-  s.useStates({
-    qParams: () => qParams()
-  })
-
-  let modelIdsCacheString
-
-  if (s.s.models === undefined) {
-    modelIdsCacheString = "models-undefined"
-  } else if (s.s.models.length === 0) {
-    modelIdsCacheString = "no-models"
-  } else {
-    modelIdsCacheString = s.s.models.map((model) => model.cacheKey())?.join("---")
-  }
-
-  const loadOverallCount = useCallback(async () => {
-    const baseQuery = s.p.collection || s.p.modelClass.all()
-    const overallCount = await baseQuery.count()
-
-    s.set({
-      overallCount,
-      showNoRecordsAvailableContent: showNoRecordsAvailableContent({overallCount}),
-      showNoRecordsFoundContent: showNoRecordsFoundContent({overallCount})
-    })
-  }, [])
-
-  const loadQParams = useCallback(() => {
-    const qParamsToSet = hasQParams() ? qParams() : Object.assign({}, s.props.defaultParams)
-    const searchParams = []
-
-    if (s.m.queryParams[s.s.querySName]) {
-      for (const rawSearchParam of s.m.queryParams[s.s.querySName]) {
-        const parsedSearchParam = JSON.parse(rawSearchParam)
-
-        searchParams.push(parsedSearchParam)
-      }
-    }
-
-    s.set({
-      qParams: qParamsToSet,
-      searchParams
-    })
-  }, [])
-
-  const loadModels = useCallback(async () => {
-    let query = s.props.collection?.clone() || s.p.modelClass.ransack()
-
-    if (s.props.pagination) {
-      const page = s.m.queryParams[s.s.queryPageName] || 1
-      let per = s.m.queryParams[s.s.queryPerKey] || 30
-
-      if (per == "all") {
-        per = 999_999_999
-      } else {
-        per = Number(per)
-      }
-
-      query.page(page).per(per)
-    }
-
-    if (s.props.groupBy) query = query.groupBy(...s.p.groupBy)
-
-    query = query
-      .ransack(s.s.qParams)
-      .search(s.s.searchParams)
-      .searchKey(s.s.queryQName)
-      .pageKey(s.s.queryPageName)
-      .perKey(s.s.queryPerKey)
-
-    if (s.props.abilities) query.abilities(s.p.abilities)
-    if (s.props.limit !== undefined) query.limit(s.p.limit)
-    if (s.props.preloads) query.preload(s.p.preloads)
-    if (s.props.ransack) query.ransack(s.props.ransack)
-    if (s.props.select) query.select(s.p.select)
-    if (s.props.selectColumns) query.selectColumns(s.p.selectColumns)
-
-    let result
-
-    if (s.props.queryMethod) {
-      result = await s.p.queryMethod({query})
-    } else {
-      result = await query.result()
-    }
-
-    const models = result.models()
-
-    if (s.props.onModelsLoaded) {
-      s.p.onModelsLoaded({
-        models,
-        qParams: s.s.qParams,
-        query,
-        result
-      })
-    }
-
-    s.set({
-      models: result.models(),
-      query,
-      result,
-      showNoRecordsAvailableContent: showNoRecordsAvailableContent({models}),
-      showNoRecordsFoundContent: showNoRecordsFoundContent({models})
-    })
-  }, [])
-
-  const loadModelsDebounce = useCallback(debounce(loadModels), [])
-  const onModelDestroyed = useCallback((args) => {
-    s.set({
-      models: s.s.models.filter((model) => model.id() != args.model.id())
-    })
-  }, [])
-
-  const onModelUpdated = useCallback((args) => {
-    const updatedModel = digg(args, "model")
-    const foundModel = s.s.models.find((model) => model.id() == updatedModel.id())
-
-    if (foundModel) loadModelsDebounce()
-  }, [])
-
-  const showNoRecordsAvailableContent = useCallback((args) => {
-    let models, overallCount
-
-    if (args.models !== undefined) {
-      models = args.models
-    } else if (s.s.models !== undefined) {
-      models = s.s.models
-    }
-
-    if (args.overallCount !== undefined) {
-      overallCount = args.overallCount
-    } else if (s.s.overallCount !== undefined) {
-      overallCount = s.s.overallCount
-    }
-
-    if (models === undefined || overallCount === undefined || s.p.noRecordsAvailableContent === undefined) return false
-    if (models.length === 0 && overallCount === 0 && s.p.noRecordsAvailableContent) return true
-  }, [])
-
-  const showNoRecordsFoundContent = useCallback((args) => {
-    let models, overallCount
-
-    if (args.models !== undefined) {
-      models = args.models
-    } else if (s.s.models !== undefined) {
-      models = s.s.models
-    }
-
-    if (args.overallCount !== undefined) {
-      overallCount = args.overallCount
-    } else if (s.s.overallCount !== undefined) {
-      overallCount = s.s.overallCount
-    }
-
-    if (models === undefined || s.props.noRecordsFoundContent === undefined) return false
-
-    // Dont show noRecordsAvailableContent together with noRecordsAvailableContent
-    if (models.length === 0 && overallCount === 0 && s.props.noRecordsAvailableContent) return false
-    if (models.length === 0 && s.props.noRecordsFoundContent) return true
-  }, [])
-
-  const onCreated = useCallback(() => {
-    loadModelsDebounce()
-  }, [])
-
-  useMemo(
-    () => {
-      if (!("ifCondition" in s.props) || s.props.ifCondition) {
-        loadQParams()
-        loadModels()
-      }
-    },
-    [
-      s.props.ifCondition,
-      s.m.queryParams[s.s.queryQName],
-      s.m.queryParams[s.s.queryPageName],
-      s.m.queryParams[s.s.queryPerKey],
-      s.m.queryParams[s.s.querySName],
-      collection
-    ].concat(cacheKeys)
-  )
-
-  useMemo(() => {
-    if (s.props.noRecordsAvailableContent) {
-      loadOverallCount()
-    }
-  }, [])
-
-  useCreatedEvent(s.p.modelClass, onCreated)
-
-  useLayoutEffect(() => {
-    const connections = []
-
-    if (s.s.models) {
-      for(const model of s.s.models) {
-        connections.push(ModelEvents.connectUpdated(model, onModelUpdated))
-        connections.push(ModelEvents.connectDestroyed(model, onModelDestroyed))
-      }
-    }
-
-    return () => {
-      for(const connection of connections) {
-        connection.unsubscribe()
-      }
-    }
-  }, [modelIdsCacheString])
-
-  const result = Object.assign({}, s.state)
-  const modelVariableName = inflection.pluralize(inflection.camelize(modelClass.modelClassData().name, true))
-
-  result.modelIdsCacheString = modelIdsCacheString
-  result[modelVariableName] = s.s.models
-
-  return result
-}
-
-export default useCollection

package/src/use-created-event.js

@@ -1,55 +0,0 @@
-import debounceFunction from "debounce"
-import ModelEvents from "./model-events"
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import {useCallback, useLayoutEffect} from "react"
-import useShape from "set-state-compare/src/use-shape"
-
-const ApiMakerUseCreatedEvent = (modelClass, onCreated, args = {}) => {
-  const {active = true, debounce} = args
-  const s = useShape({active, debounce, modelClass, onCreated})
-
-  const eventDebounce = useCallback(() => {
-    if (!s.meta.debounceInstance) {
-      if (typeof this.props.debounce == "number") {
-        s.meta.debounceInstance = debounceFunction(s.p.onCreated, s.p.debounce)
-      } else {
-        s.meta.debounceInstance = debounceFunction(s.p.onCreated)
-      }
-    }
-
-    return s.meta.debounceInstance
-  }, [])
-
-  const onCreatedCallback = useCallback((...args) => {
-    if (!s.p.active) {
-      return
-    }
-
-    if (s.p.debounce) {
-      eventDebounce()(...args)
-    } else {
-      s.p.onCreated(...args)
-    }
-  }, [])
-
-  useLayoutEffect(() => {
-    const connectCreated = ModelEvents.connectCreated(s.p.modelClass, (...args) => onCreatedCallback(...args))
-
-    return () => {
-      connectCreated.unsubscribe()
-    }
-  }, [])
-}
-
-ApiMakerUseCreatedEvent.propTypes = propTypesExact({
-  active: PropTypes.bool.isRequired,
-  debounce: PropTypes.oneOfType([
-    PropTypes.bool,
-    PropTypes.number
-  ]),
-  modelClass: PropTypes.func.isRequired,
-  onCreated: PropTypes.func.isRequired
-})
-
-export default ApiMakerUseCreatedEvent

package/src/use-current-user.js

@@ -1,133 +0,0 @@
-import React, {useCallback, useContext, useMemo} from "react"
-import Devise from "./devise"
-import {digg} from "diggerize"
-import EventEmitter from "events"
-import * as inflection from "inflection"
-import Logger from "./logger"
-import Services from "./services"
-import useEventEmitter from "./use-event-emitter"
-import useShape from "set-state-compare/src/use-shape"
-
-const events = new EventEmitter()
-const logger = new Logger({name: "ApiMaker / useCurrentUser"})
-
-logger.setDebug(false)
-
-const useCurrentUser = (props = {}) => {
-  const {scope = "user", withData, ...restProps} = props
-
-  if (Object.keys(restProps).length > 0) {
-    throw new Error(`Unknown props given to useCurrentUser: ${Object.keys(restProps).join(", ")}`)
-  }
-
-  const scopeInstance = Devise.getScope(scope)
-  const currentUserContext = useContext(scopeInstance.getContext())
-
-  if (withData) {
-    return currentUserContext
-  } else {
-    return currentUserContext.model
-  }
-}
-
-const WithCurrentUser = (props = {}) => {
-  const {children, scope = "user", ...restProps} = props
-
-  if (Object.keys(restProps).length > 0) {
-    throw new Error(`Unknown props given to WithCurrentUser: ${Object.keys(restProps).join(", ")}`)
-  }
-
-  const s = useShape(props)
-  const scopeName = `current${inflection.camelize(scope)}`
-  const scopeInstance = Devise.getScope(scope)
-  const ScopeContext = scopeInstance.getContext()
-
-  s.meta.scope = scope
-  s.meta.scopeName = scopeName
-
-  const loadCurrentUserFromRequest = useCallback(async () => {
-    const {scope} = s.m
-    const getArgsMethodName = `get${inflection.camelize(scope)}Args`
-    const args = Devise[getArgsMethodName]()
-
-    logger.debug(() => `Loading ${scope} with request`)
-
-    const result = await Services.current().sendRequest("Devise::Current", {query: args.query, scope})
-    const current = digg(result, "current")[0]
-
-    if (current) Devise.updateSession(current)
-
-    s.set({
-      result: {
-        loaded: true,
-        model: current
-      }
-    })
-
-    events.emit("currentUserLoaded", {current})
-  }, [])
-
-  const defaultCurrentUser = useCallback(() => {
-    const {scope, scopeName} = s.m
-    let current
-
-    if (Devise.current().hasCurrentScope(s.m.scope)) {
-      current = Devise.current().getCurrentScope(scope)
-
-      logger.debug(() => `Setting ${scope} from current scope: ${current?.id()}`)
-    } else if (Devise.current().hasGlobalCurrentScope(scope)) {
-      current = Devise[scopeName]()
-
-      logger.debug(() => `Setting ${scope} from global current scope: ${current?.id()}`)
-    }
-
-    if (current) {
-      events.emit("currentUserLoaded", {current})
-    }
-
-    return current
-  }, [])
-
-  s.useStates({
-    result: () => ({
-      loaded: false,
-      model: defaultCurrentUser()
-    })
-  })
-
-  const updateCurrentUser = useCallback(() => {
-    s.set({
-      result: {
-        loaded: true,
-        model: Devise[s.m.scopeName]()
-      }
-    })
-  }, [])
-
-  useMemo(() => {
-    if (!Devise.current().hasGlobalCurrentScope(s.m.scope) && !Devise.current().hasCurrentScope(s.m.scope)) {
-      logger.debug(() => `Devise hasn't got current scope ${s.m.scope} so loading from request`)
-      loadCurrentUserFromRequest()
-    }
-  }, [])
-
-  const onDeviseSignIn = useCallback(() => {
-    updateCurrentUser()
-  }, [])
-
-  const onDeviseSignOut = useCallback(() => {
-    updateCurrentUser()
-  }, [])
-
-  useEventEmitter(Devise.events(), "onDeviseSignIn", onDeviseSignIn)
-  useEventEmitter(Devise.events(), "onDeviseSignOut", onDeviseSignOut)
-
-  return (
-    <ScopeContext.Provider value={s.s.result}>
-      {children}
-    </ScopeContext.Provider>
-  )
-}
-
-export {events, WithCurrentUser}
-export default useCurrentUser

package/src/use-destroyed-event.js

@@ -1,60 +0,0 @@
-import {useCallback, useLayoutEffect, useMemo} from "react"
-import debounceFunction from "debounce"
-import ModelEvents from "./model-events"
-import useShape from "set-state-compare/src/use-shape"
-
-const apiMakerUseDestroyedEvent = (model, onDestroyed, props) => {
-  const {active = true, debounce, onConnected, ...restProps} = props || {}
-
-  if (Object.keys(restProps).length > 0) {
-    throw new Error(`Unknown props given to useDestroyedEvent: ${Object.keys(restProps).join(", ")}`)
-  }
-
-  const s = useShape({active, debounce, model, onDestroyed})
-
-  const debounceCallback = useMemo(() => {
-    if (typeof debounce == "number") {
-      return debounceFunction(s.p.onDestroyed, debounce)
-    } else {
-      return debounceFunction(s.p.onDestroyed)
-    }
-  }, [debounce])
-
-  s.updateMeta({debounceCallback})
-
-  const onDestroyedCallback = useCallback((...args) => {
-    if (!s.p.active) {
-      return
-    }
-
-    if (s.p.debounce) {
-      s.m.debounceCallback(...args)
-    } else {
-      s.p.onDestroyed(...args)
-    }
-  }, [])
-
-  useLayoutEffect(() => {
-    let connectDestroyed, onConnectedListener
-
-    if (model) {
-      connectDestroyed = ModelEvents.connectDestroyed(model, onDestroyedCallback)
-
-      if (onConnected) {
-        onConnectedListener = connectDestroyed.events.addListener("connected", onConnected)
-      }
-    }
-
-    return () => {
-      if (onConnectedListener) {
-        connectDestroyed.events.removeListener("connected", onConnected)
-      }
-
-      if (connectDestroyed) {
-        connectDestroyed.unsubscribe()
-      }
-    }
-  }, [model?.id()])
-}
-
-export default apiMakerUseDestroyedEvent

package/src/use-event-emitter.js

@@ -1,25 +0,0 @@
-import useEnvSense from "env-sense/src/use-env-sense"
-import {useEffect, useLayoutEffect, useMemo} from "react"
-
-const ApiMakerUseEventEmitter = (events, event, onCalled) => {
-  const {isServer} = useEnvSense()
-  const useWorkingEffect = isServer ? useEffect : useLayoutEffect
-
-  // useMemo to instantly connect
-  useMemo(() => {
-    if (events) {
-      events.addListener(event, onCalled)
-    }
-  }, [events, event, onCalled])
-
-  // useLayoutEffect to disconnect when unmounted or changed
-  useWorkingEffect(() => {
-    if (events) {
-      return () => {
-        events.removeListener(event, onCalled)
-      }
-    }
-  }, [events, event, onCalled])
-}
-
-export default ApiMakerUseEventEmitter

package/src/use-event-listener.js

@@ -1,23 +0,0 @@
-import useEnvSense from "env-sense/src/use-env-sense"
-import {useCallback, useEffect, useLayoutEffect} from "react"
-
-const ApiMakerUseEventListener = (target, event, onCalled) => {
-  const {isServer} = useEnvSense()
-  const useWorkingEffect = isServer ? useEffect : useLayoutEffect
-  const onCalledCallback = useCallback((...args) => {
-    onCalled.apply(null, args)
-  }, [target, event, onCalled])
-
-  useWorkingEffect(() => {
-    if (target) {
-      const eventListener = target.addEventListener(event, onCalledCallback)
-
-      return () => {
-        if (eventListener?.remove) eventListener.remove() // This is how its done in Expo + Jest.
-        if (target.removeEventListener) target.removeEventListener(event, onCalledCallback) // This is the "old" way in browsers.
-      }
-    }
-  }, [target, event, onCalled])
-}
-
-export default ApiMakerUseEventListener