@kaspernj/api-maker 1.0.2011 → 1.0.2013

package/src/event-listener.jsx

@@ -1,38 +0,0 @@
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import React from "react"
-
-export default class ApiMakerEventListener extends React.PureComponent {
-  static callEvent (target, eventName, args = []) {
-    let event = document.createEvent("Event")
-    event.initEvent(eventName, false, true)
-    target.dispatchEvent(event, args)
-  }
-
-  static propTypes = propTypesExact({
-    event: PropTypes.string.isRequired,
-    onCalled: PropTypes.func.isRequired,
-    target: PropTypes.object.isRequired
-  })
-
-  constructor (props) {
-    super(props)
-    this.onCalled = this.onCalled.bind(this)
-  }
-
-  componentDidMount () {
-    this.props.target.addEventListener(this.props.event, this.onCalled)
-  }
-
-  componentWillUnmount () {
-    this.props.target.removeEventListener(this.props.event, this.onCalled)
-  }
-
-  onCalled (...args) {
-    this.props.onCalled.apply(null, args)
-  }
-
-  render () {
-    return null
-  }
-}

package/src/event-updated.jsx

@@ -1,74 +0,0 @@
-import debounce from "debounce"
-import ModelEvents from "./model-events.mjs"
-import PropTypes from "prop-types"
-import propTypesExact from "prop-types-exact"
-import React from "react"
-
-export default class ApiMakerEventUpdated extends React.PureComponent {
-  static defaultProps = {
-    active: true
-  }
-
-  static propTypes = propTypesExact({
-    active: PropTypes.bool.isRequired,
-    debounce: PropTypes.oneOfType([
-      PropTypes.bool,
-      PropTypes.number
-    ]),
-    model: PropTypes.object.isRequired,
-    onConnected: PropTypes.func,
-    onUpdated: PropTypes.func.isRequired
-  })
-
-  componentDidMount () {
-    this.connect()
-  }
-
-  componentWillUnmount () {
-    if (this.connectUpdated) {
-      this.connectUpdated.unsubscribe()
-    }
-
-    if (this.onConnectedListener) {
-      this.connectUpdated.events.removeListener("connected", this.props.onConnected)
-    }
-  }
-
-  connect () {
-    const {model, onConnected} = this.props
-
-    this.connectUpdated = ModelEvents.connectUpdated(model, this.onUpdated)
-
-    if (onConnected) {
-      this.onConnectedListener = this.connectUpdated.events.addListener("connected", this.props.onConnected)
-    }
-  }
-
-  debounce () {
-    if (!this.debounceInstance) {
-      if (typeof this.props.debounce == "number") {
-        this.debounceInstance = debounce(this.props.onUpdated, this.props.debounce)
-      } else {
-        this.debounceInstance = debounce(this.props.onUpdated)
-      }
-    }
-
-    return this.debounceInstance
-  }
-
-  onUpdated = (...args) => {
-    if (!this.props.active) {
-      return
-    }
-
-    if (this.props.debounce) {
-      this.debounce()(...args)
-    } else {
-      this.props.onUpdated(...args)
-    }
-  }
-
-  render () {
-    return null
-  }
-}

package/src/logger.mjs

@@ -1,25 +0,0 @@
-const shared = {}
-
-export default class ApiMakerLogger {
-  static current () {
-    if (!shared.apiMakerLogger) {
-      shared.apiMakerLogger = new ApiMakerLogger()
-      // shared.apiMakerLogger.setDebug(true)
-    }
-
-    return shared.apiMakerLogger
-  }
-
-  static log (message) {
-    ApiMakerLogger.current().log(message)
-  }
-
-  log (message) {
-    if (this.debug)
-      console.log("ApiMaker", message)
-  }
-
-  setDebug (value) {
-    this.debug = value
-  }
-}

package/src/model-class-require.mjs

@@ -1,10 +0,0 @@
-import {digg} from "diggerize"
-import inflection from "inflection"
-import * as models from "@kaspernj/api-maker/src/models.mjs.erb"
-
-export default (modelName) => {
-  const requireName = inflection.camelize(modelName)
-  const ModelClass = digg(models, requireName)
-
-  return ModelClass
-}

package/src/model-load-wrapper.jsx

@@ -1,116 +0,0 @@
-import EventUpdated from "./event-updated"
-import Params from "./params.mjs"
-import PropTypes from "prop-types"
-import React from "react"
-import withQueryParams from "on-location-changed/src/with-query-params"
-
-export default (WrappedComponent, ModelClass, args = {}) => {
-  class ModelLoadWrapper extends React.PureComponent {
-    static propTypes = {
-      queryParams: PropTypes.object
-    }
-
-    camelizedLower = ModelClass.modelName().camelizedLower()
-    paramsVariableName = `${ModelClass.modelName().paramKey()}_id`
-
-    state = {
-      model: undefined,
-      modelId: this.getModelId(),
-      notFound: undefined
-    }
-
-    componentDidMount() {
-      this.loadModel()
-    }
-
-    componentDidUpdate() {
-      const newModelId = this.getModelId()
-
-      // The model ID was changed in the URL and a different model should be loaded
-      if (newModelId != this.state.modelId) {
-        this.setState({model: undefined, modelId: newModelId})
-        this.loadExistingModel()
-      }
-    }
-
-    loadModel = async () => {
-      if (args.newIfNoId && !this.getModelId()) {
-        return await this.loadNewModel()
-      } else if (!args.optional || this.getModelId()) {
-        return await this.loadExistingModel()
-      }
-    }
-
-    getModelId() {
-      if (args.loadByQueryParam)
-        return args.loadByQueryParam({props: this.props})
-
-      return this.props.match.params[this.paramsVariableName] || this.props.match.params.id
-    }
-
-    loadExistingModel = async () => {
-      const modelId = this.getModelId()
-      const query = await ModelClass.ransack({id_eq: modelId})
-
-      if (args.abilities) query.abilities(args.abilities)
-      if (args.preload) query.preload(args.preload)
-      if (args.select) query.select(args.select)
-
-      const model = await query.first()
-
-      this.setState({
-        model,
-        notFound: !model
-      })
-    }
-
-    async loadNewModel() {
-      const params = Params.parse()
-      const paramKey = ModelClass.modelName().paramKey()
-      const modelDataFromParams = params[paramKey] || {}
-
-      let defaults = {}
-
-      if (args.newIfNoId?.defaults) {
-        defaults = await args.newIfNoId.defaults()
-      }
-
-      const modelData = Object.assign(defaults, args.newAttributes, modelDataFromParams)
-      const model = new ModelClass({
-        isNewRecord: true,
-        data: {a: modelData}
-      })
-
-      this.setState({model})
-    }
-
-    render() {
-      const {onUpdated, reloadModel} = digs(this, "onUpdated", "reloadModel")
-      const {model, modelId, notFound} = digs(this.state, "model", "modelId", "notFound")
-      const wrappedComponentProps = {}
-
-      wrappedComponentProps[this.camelizedLower] = model
-      wrappedComponentProps[`${this.camelizedLower}Id`] = modelId
-      wrappedComponentProps[`${this.camelizedLower}NotFound`] = notFound
-
-      return (
-        <>
-          {args.events &&
-            <EventEmitterListener event="reloadModel" events={args.events} onCalled={reloadModel} />
-          }
-          {model && args.eventUpdated &&
-            <EventUpdated model={model} onUpdated={onUpdated} />
-          }
-          <WrappedComponent {...wrappedComponentProps} {...this.props} />
-        </>
-      )
-    }
-
-    reloadModel = () => this.loadModel()
-    onUpdated = this.loadExistingModel
-  }
-
-  if (args.loadByQueryParam) return withQueryParams(ModelLoadWrapper)
-
-  return ModelLoadWrapper
-}

package/src/result.mjs

@@ -1,29 +0,0 @@
-export default class ApiMakerResult {
-  constructor (data) {
-    this.data = data
-  }
-
-  currentPage () {
-    return this.data.response.meta.currentPage
-  }
-
-  models () {
-    return this.data.models
-  }
-
-  modelClass () {
-    return this.data.collection.modelClass()
-  }
-
-  perPage () {
-    return this.data.response.meta.perPage
-  }
-
-  totalCount () {
-    return this.data.response.meta.totalCount
-  }
-
-  totalPages () {
-    return this.data.response.meta.totalPages
-  }
-}

package/src/session-status-updater.mjs

@@ -1,116 +0,0 @@
-import Devise from "./devise.mjs"
-import inflection from "inflection"
-import wakeEvent from "wake-event"
-
-export default class ApiMakerSessionStatusUpdater {
-  static current () {
-    if (!globalThis.apiMakerSessionStatusUpdater)
-      globalThis.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater()
-
-    return globalThis.apiMakerSessionStatusUpdater
-  }
-
-  constructor (args = {}) {
-    this.debugging = args.debug || false
-    this.events = {}
-    this.timeout = args.timeout || 600000
-
-    this.connectOnlineEvent()
-    this.connectWakeEvent()
-  }
-
-  connectOnlineEvent () {
-    window.addEventListener("online", () => this.updateSessionStatus(), false)
-  }
-
-  connectWakeEvent () {
-    wakeEvent(() => this.updateSessionStatus())
-  }
-
-  debug (message) {
-    if (this.debugging)
-      console.log(`ApiMakerSessionStatusUpdater: ${message}`)
-  }
-
-  async sessionStatus () {
-    return new Promise((resolve) => {
-      const xhr = new XMLHttpRequest()
-      xhr.open("POST", "/api_maker/session_statuses", true)
-      xhr.onload = () => {
-        const response = JSON.parse(xhr.responseText)
-        resolve(response)
-      }
-      xhr.send()
-    })
-  }
-
-  onSignedOut (callback) {
-    this.addEvent("onSignedOut", callback)
-  }
-
-  startTimeout () {
-    this.debug("startTimeout")
-
-    if (this.updateTimeout)
-      clearTimeout(this.updateTimeout)
-
-    this.updateTimeout = setTimeout(
-      () => {
-        this.startTimeout()
-        this.updateSessionStatus()
-      },
-      this.timeout
-    )
-  }
-
-  stopTimeout () {
-    if (this.updateTimeout)
-      clearTimeout(this.updateTimeout)
-  }
-
-  async updateSessionStatus () {
-    this.debug("updateSessionStatus")
-
-    const result = await this.sessionStatus()
-
-    this.debug(`Result: ${JSON.stringify(result, null, 2)}`)
-    this.updateMetaElementsFromResult(result)
-    this.updateUserSessionsFromResult(result)
-  }
-
-  updateMetaElementsFromResult (result) {
-    this.debug("updateMetaElementsFromResult")
-    const csrfTokenElement = document.querySelector("meta[name='csrf-token']")
-
-    if (csrfTokenElement) {
-      this.debug(`Changing token from "${csrfTokenElement.getAttribute("content")}" to "${result.csrf_token}"`)
-      csrfTokenElement.setAttribute("content", result.csrf_token)
-    } else {
-      this.debug("csrf token element couldn't be found")
-    }
-  }
-
-  updateUserSessionsFromResult (result) {
-    for (const scopeName in result.scopes) {
-      this.updateUserSessionScopeFromResult(scopeName, result.scopes[scopeName])
-    }
-  }
-
-  updateUserSessionScopeFromResult (scopeName, scope) {
-    const deviseIsSignedInMethodName = `is${inflection.camelize(scopeName)}SignedIn`
-
-    if (!(deviseIsSignedInMethodName in Devise)) {
-      throw new Error(`No such method in Devise: ${deviseIsSignedInMethodName}`)
-    }
-
-    const currentlySignedIn = Devise[deviseIsSignedInMethodName]()
-    const signedInOnBackend = scope.signed_in
-
-    if (currentlySignedIn && !signedInOnBackend) {
-      this.debug(`${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)
-
-      Devise.setSignedOut({scope: scopeName})
-      Devise.callSignOutEvent({scope: scopeName})
-    }
-  }
-}

package/webpack.config.js

@@ -1,15 +0,0 @@
-module.exports = {
-  mode: "production",
-  module: {
-    rules: [
-      {
-        exclude: /node_modules/,
-        test: /\.(js|jsx)$/,
-        use: "babel-loader"
-      }
-    ]
-  },
-  resolve: {
-    extensions: [".js", ".jsx"]
-  }
-}