@kaspernj/api-maker 1.0.2053 → 1.0.2054

package/src/routes.js

@@ -1,58 +0,0 @@
-import {digg} from "diggerize"
-import * as inflection from "inflection"
-
-export default class ApiMakerRoutes {
-  constructor ({jsRoutes, locale, routeDefinitions}) {
-    if (!jsRoutes) throw new Error("'jsRoutes' wasn't given")
-
-    this.jsRoutes = jsRoutes
-    this.routeDefinitions = routeDefinitions
-
-    for (const routeDefinition of digg(this, "routeDefinitions", "routes")) {
-      let testRouteNamePath, testRouteNameUrl
-
-      const routeNamePath = inflection.camelize(`${digg(routeDefinition, "name")}_path`, true)
-      const routeNameUrl = inflection.camelize(`${digg(routeDefinition, "name")}_url`, true)
-
-      if (locale) {
-        testRouteNamePath = inflection.camelize(`${digg(routeDefinition, "name")}_${locale}_path`, true)
-        testRouteNameUrl = inflection.camelize(`${digg(routeDefinition, "name")}_${locale}_url`, true)
-      } else {
-        testRouteNamePath = inflection.camelize(`${digg(routeDefinition, "name")}_path`, true)
-        testRouteNameUrl = inflection.camelize(`${digg(routeDefinition, "name")}_url`, true)
-      }
-
-      if (!(testRouteNamePath in this.jsRoutes)) {
-        throw new Error(`No such path in JS routes: ${testRouteNamePath}: ${Object.keys(this.jsRoutes).join(", ")}`)
-      }
-
-      this[routeNamePath] = (...args) => {
-        let routeNamePathToUse
-
-        if (locale) {
-          routeNamePathToUse = inflection.camelize(`${digg(routeDefinition, "name")}_${I18n.locale}_path`, true)
-        } else {
-          routeNamePathToUse = routeNamePath
-        }
-
-        return this.jsRoutes[routeNamePathToUse](...args)
-      }
-
-      if (!(testRouteNameUrl in this.jsRoutes)) {
-        throw new Error(`No such URL in JS routes: ${testRouteNameUrl}: ${Object.keys(this.jsRoutes).join(", ")}`)
-      }
-
-      this[routeNameUrl] = (...args) => {
-        let routeNameUrlToUse
-
-        if (locale) {
-          routeNameUrlToUse = inflection.camelize(`${digg(routeDefinition, "name")}_${I18n.locale}_url`, true)
-        } else {
-          routeNameUrlToUse = routeNameUrl
-        }
-
-        return this.jsRoutes[routeNameUrlToUse](...args)
-      }
-    }
-  }
-}

package/src/run-last.js

@@ -1,39 +0,0 @@
-export default class RunLast {
-  constructor(callback) {
-    if (!callback) throw new Error("Empty callback given")
-
-    this.callback = callback
-  }
-
-  // Try to batch calls to backend while waiting for the event-queue-call to clear any other jobs before the request and reset on every flush call
-  // If only waiting a single time, then other event-queue-jobs might be before us and queue other jobs that might queue calls to the backend
-  queue() {
-    this.flushTriggerCount = 0
-    this.clearTimeout()
-    this.flushTrigger()
-  }
-
-  flushTrigger = () => {
-    if (this.flushTriggerCount >= 10) {
-      this.run()
-    } else {
-      this.flushTriggerCount++
-      this.flushTriggerQueue()
-    }
-  }
-
-  flushTriggerQueue() {
-    this.flushTimeout = setTimeout(this.flushTrigger, 0)
-  }
-
-  clearTimeout() {
-    if (this.flushTimeout) {
-      clearTimeout(this.flushTimeout)
-    }
-  }
-
-  run() {
-    this.clearTimeout()
-    this.callback()
-  }
-}

package/src/serializer.js

@@ -1,76 +0,0 @@
-import {digg} from "diggerize"
-
-export default class Serializer {
-  static serialize (arg) {
-    const serialize = new Serializer(arg)
-
-    return serialize.serialize()
-  }
-
-  constructor (arg) {
-    this.arg = arg
-  }
-
-  serialize () {
-    return this.serializeArgument(this.arg)
-  }
-
-  serializeArgument (arg) {
-    if (typeof arg == "object" && arg && arg.constructor.apiMakerType == "BaseModel") {
-      return {
-        api_maker_type: "model",
-        model_class_name: digg(arg.modelClassData(), "name"),
-        model_id: arg.id()
-      }
-    } else if (typeof arg == "function" && arg.apiMakerType == "BaseModel") {
-      return {
-        api_maker_type: "resource",
-        name: digg(arg.modelClassData(), "name")
-      }
-    } else if (arg instanceof Date) {
-      let offsetNumber = parseInt((arg.getTimezoneOffset() / 60) * 100, 10)
-
-      offsetNumber = -offsetNumber
-
-      let offset = `${offsetNumber}`
-
-      while (offset.length < 4) {
-        offset = `0${offset}`
-      }
-
-      return {
-        api_maker_type: "datetime",
-        value: `${arg.getFullYear()}-${arg.getMonth() + 1}-${arg.getDate()} ${arg.getHours()}:${arg.getMinutes()}:${arg.getSeconds()}+${offset}`
-      }
-    } else if (Array.isArray(arg)) {
-      return this.serializeArray(arg)
-    } else if (typeof arg == "object" && arg && arg.constructor && arg.constructor.apiMakerType == "Collection") {
-      return {
-        api_maker_type: "collection",
-        value: this.serializeObject(arg)
-      }
-    } else if (typeof arg == "object" && arg !== null && arg.constructor.name == "Object") {
-      return this.serializeObject(arg)
-    } else {
-      return arg
-    }
-  }
-
-  serializeArray (arg) {
-    return arg.map((value) => this.serializeArgument(value))
-  }
-
-  serializeObject (arg) {
-    const newObject = {}
-
-    for (const key in arg) {
-      const value = arg[key]
-      const newValue = this.serializeArgument(value)
-      const newKey = this.serializeArgument(key)
-
-      newObject[newKey] = newValue
-    }
-
-    return newObject
-  }
-}

package/src/services.js

@@ -1,23 +0,0 @@
-import CommandsPool from "./commands-pool"
-
-const shared = {}
-
-export default class ApiMakerServices {
-  static current () {
-    if (!shared.currentApiMakerService) shared.currentApiMakerService = new ApiMakerServices()
-
-    return shared.currentApiMakerService
-  }
-
-  sendRequest (serviceName, args) {
-    return CommandsPool.addCommand({
-      args: {
-        service_args: args,
-        service_name: serviceName
-      },
-      command: "services",
-      collectionName: "calls",
-      type: "service"
-    })
-  }
-}

package/src/session-status-updater.js

@@ -1,172 +0,0 @@
-import config from "./config"
-import Devise from "./devise"
-import * as inflection from "inflection"
-import Logger from "./logger"
-import wakeEvent from "wake-event"
-
-const logger = new Logger({name: "ApiMaker / SessionStatusUpdater"})
-const shared = {}
-
-// logger.setDebug(true)
-
-export default class ApiMakerSessionStatusUpdater {
-  static current(args) {
-    if (!shared.apiMakerSessionStatusUpdater) {
-      shared.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater(args)
-    }
-
-    return shared.apiMakerSessionStatusUpdater
-  }
-
-  constructor(args = {}) {
-    this.events = {}
-    this.timeout = args.timeout || 600000
-
-    if ("useMetaElement" in args) {
-      this.useMetaElement = args.useMetaElement
-    } else if (typeof document != "undefined") {
-      this.useMetaElement = true
-    } else {
-      this.useMetaElement = false
-    }
-
-    if (typeof window != "undefined") {
-      this.connectOnlineEvent()
-    }
-
-    this.connectWakeEvent()
-  }
-
-  connectOnlineEvent() {
-    window.addEventListener("online", this.updateSessionStatus, false)
-  }
-
-  connectWakeEvent() {
-    wakeEvent(this.updateSessionStatus)
-  }
-
-  async getCsrfToken() {
-    if (this.csrfToken) {
-      logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`)
-
-      return this.csrfToken
-    }
-
-    if (this.useMetaElement) {
-      const csrfTokenElement = document.querySelector("meta[name='csrf-token']")
-
-      if (csrfTokenElement) {
-        logger.debug(() => `Get CSRF token from meta element: ${csrfTokenElement.getAttribute("content")}`)
-
-        this.csrfToken = csrfTokenElement.getAttribute("content")
-
-        return this.csrfToken
-      }
-    }
-
-    logger.debug("Updating session status because no CSRF token set yet")
-    await this.updateSessionStatus()
-
-    if (this.csrfToken) {
-      logger.debug(() => `Returning CSRF token after updating session status: ${this.csrfToken}`)
-
-      return this.csrfToken
-    }
-
-    throw new Error("CSRF token hasn't been set")
-  }
-
-  sessionStatus() {
-    return new Promise((resolve) => {
-      const host = config.getHost()
-      let requestPath = ""
-
-      if (host) requestPath += host
-
-      requestPath += "/api_maker/session_statuses"
-
-      const xhr = new XMLHttpRequest()
-      xhr.open("POST", requestPath, true)
-      xhr.onload = () => {
-        const response = JSON.parse(xhr.responseText)
-        resolve(response)
-      }
-      xhr.send()
-    })
-  }
-
-  onSignedOut(callback) {
-    this.addEvent("onSignedOut", callback)
-  }
-
-  startTimeout() {
-    logger.debug("startTimeout")
-
-    if (this.updateTimeout)
-      clearTimeout(this.updateTimeout)
-
-    this.updateTimeout = setTimeout(
-      () => {
-        this.startTimeout()
-        this.updateSessionStatus()
-      },
-      this.timeout
-    )
-  }
-
-  stopTimeout() {
-    if (this.updateTimeout)
-      clearTimeout(this.updateTimeout)
-  }
-
-  updateSessionStatus = async () => {
-    logger.debug("updateSessionStatus")
-
-    const result = await this.sessionStatus()
-
-    logger.debug(() => `Result: ${JSON.stringify(result, null, 2)}`)
-    this.updateMetaElementsFromResult(result)
-    this.updateUserSessionsFromResult(result)
-  }
-
-  updateMetaElementsFromResult(result) {
-    logger.debug("updateMetaElementsFromResult")
-
-    this.csrfToken = result.csrf_token
-
-    if (this.useMetaElement) {
-      const csrfTokenElement = document.querySelector("meta[name='csrf-token']")
-
-      if (csrfTokenElement) {
-        logger.debug(() => `Changing token from "${csrfTokenElement.getAttribute("content")}" to "${result.csrf_token}"`)
-        csrfTokenElement.setAttribute("content", result.csrf_token)
-      } else {
-        logger.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) {
-      logger.debug(() => `${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)
-
-      Devise.setSignedOut({scope: scopeName})
-      Devise.callSignOutEvent({scope: scopeName})
-    }
-  }
-}

package/src/source-maps-loader.js

@@ -1,203 +0,0 @@
-import * as stackTraceParser from "stacktrace-parser"
-import Logger from "./logger"
-import {SourceMapConsumer} from "source-map"
-import uniqunize from "uniqunize"
-
-// Sometimes this needs to be called and sometimes not
-if (SourceMapConsumer.initialize) {
-  SourceMapConsumer.initialize({
-    "lib/mappings.wasm": "https://unpkg.com/source-map@0.7.4/lib/mappings.wasm"
-  })
-}
-
-const logger = new Logger({name: "ApiMaker / SourceMapsLoader"})
-
-export default class SourceMapsLoader {
-  constructor() {
-    this.isLoadingSourceMaps = false
-    this.sourceMaps = []
-    this.srcLoaded = {}
-  }
-
-  loadSourceMapsForScriptTags(callback) {
-    this.loadSourceMapsForScriptTagsCallback = callback
-  }
-
-  sourceMapForSource(callback) {
-    this.sourceMapForSourceCallback = callback
-  }
-
-  async loadSourceMaps(error) {
-    if (!error) throw new Error("No error was given to SourceMapsLoader#loadSourceMaps")
-
-    this.isLoadingSourceMaps = true
-
-    try {
-      const promises = []
-      const sources = this.getSources(error)
-
-      for(const source of sources) {
-        if (source.originalUrl && !this.srcLoaded[source.originalUrl]) {
-          this.srcLoaded[source.originalUrl] = true
-
-          const promise = this.loadSourceMapForSource(source)
-          promises.push(promise)
-        }
-      }
-
-      await Promise.all(promises)
-    } finally {
-      this.isLoadingSourceMaps = false
-    }
-  }
-
-  getSources(error) {
-    let sources = this.getSourcesFromScripts()
-
-    if (error) sources = sources.concat(this.getSourcesFromError(error))
-
-    return uniqunize(sources, (source) => source.originalUrl)
-  }
-
-  getSourcesFromError(error) {
-    const stack = stackTraceParser.parse(error.stack)
-    const sources = []
-
-    for (const trace of stack) {
-      const file = trace.file
-
-      if (file != "\u003Canonymous>") {
-        const sourceMapUrl = this.getMapURL({src: file})
-
-        if (sourceMapUrl) {
-          logger.debug(() => `Found source map from error: ${sourceMapUrl}`)
-
-          sources.push({originalUrl: file, sourceMapUrl})
-        } else {
-          logger.debug(() => `Coudn't get source map from: ${file}`)
-        }
-      }
-    }
-
-    return sources
-  }
-
-  getSourcesFromScripts() {
-    const scripts = document.querySelectorAll("script")
-    const sources = []
-
-    for (const script of scripts) {
-      const sourceMapUrl = this.getMapURL({script, src: script.src})
-
-      if (sourceMapUrl) {
-        logger.debug(() => `Found source map from script: ${sourceMapUrl}`)
-        sources.push({originalUrl: script.src, sourceMapUrl})
-      }
-    }
-
-    return sources
-  }
-
-  getMapURL({script, src}) {
-    const url = this.loadUrl(src)
-    const originalUrl = `${url.origin}${url.pathname}`
-
-    if (this.sourceMapForSourceCallback) {
-      // Use custom callback to resolve which map-file to download
-      return this.sourceMapForSourceCallback({originalUrl, script, src, url})
-    } else if (this.includeMapURL(src)) {
-      // Default to original URL with '.map' appended
-      return `${originalUrl}.map`
-    }
-  }
-
-  includeMapURL = (src) => src.includes("/packs/")
-
-  async loadSourceMapForSource({originalUrl, sourceMapUrl}) {
-    const xhr = new XMLHttpRequest()
-
-    xhr.open("GET", sourceMapUrl, true)
-
-    try {
-      await this.loadXhr(xhr, sourceMapUrl)
-    } catch (error) {
-      console.log(`Couldn't load source map from: ${sourceMapUrl}: ${xhr.responseText}`)
-
-      return
-    }
-
-    const consumer = await new SourceMapConsumer(xhr.responseText)
-
-    if (consumer) {
-      this.sourceMaps.push({consumer, originalUrl})
-    }
-  }
-
-  loadUrl(url) {
-    const parser = document.createElement("a")
-
-    parser.href = url
-
-    return parser
-  }
-
-  loadXhr(xhr, url) {
-    return new Promise((resolve, reject) => {
-      xhr.onload = () => {
-        if (xhr.status == 200) {
-          resolve()
-        } else {
-          reject(new Error(`HTTP request failed with ${xhr.status} for ${url}`))
-        }
-      }
-      xhr.send()
-    })
-  }
-
-  parseStackTrace(stackTrace) {
-    return this.getStackTraceData(stackTrace)
-      .map((traceData) => `at ${traceData.methodName} (${traceData.fileString})`)
-  }
-
-  getStackTraceData(stackTrace) {
-    const stack = stackTraceParser.parse(stackTrace)
-    const newSourceMap = []
-
-    for (const trace of stack) {
-      const sourceMapData = this.sourceMaps.find((sourceMapData) => sourceMapData.originalUrl == trace.file)
-
-      let filePath, fileString, original
-
-      if (sourceMapData) {
-        original = sourceMapData.consumer.originalPositionFor({
-          line: trace.lineNumber,
-          column: trace.column
-        })
-      }
-
-      if (original && original.source) {
-        filePath = original.source.replace(/^webpack:\/\/(app|)\//, "")
-        fileString = `${filePath}:${original.line}`
-
-        if (original.column) {
-          fileString += `:${original.column}`
-        }
-      } else {
-        filePath = trace.file
-        fileString = `${filePath}:${trace.lineNumber}`
-
-        if (trace.column) {
-          fileString += `:${trace.column}`
-        }
-      }
-
-      newSourceMap.push({
-        filePath,
-        fileString,
-        methodName: trace.methodName
-      })
-    }
-
-    return newSourceMap
-  }
-}

package/src/super-admin/config-reader.jsx

@@ -1,93 +0,0 @@
-import {digg, digs} from "diggerize"
-import * as inflection from "inflection"
-
-const modelConfigRequireContext = require.context("super-admin/model-configs", true, /.jsx$/)
-
-export default class ApiMakerSuperAdminConfigReader {
-  static forModel(modelClass) {
-    const modelNameCamelized = digg(modelClass.modelClassData(), "nameDasherized")
-    let modelConfig
-
-    try {
-      modelConfig = modelConfigRequireContext(`./${modelNameCamelized}.jsx`).default
-    } catch (error) {
-      if (error.message.includes("Cannot find module")) {
-        console.debug(`No model-config for ${modelClass.modelClassData().name}`)
-      } else {
-        throw error
-      }
-    }
-
-    return new ApiMakerSuperAdminConfigReader(modelClass, modelConfig)
-  }
-
-  constructor(modelClass, modelConfig) {
-    this.modelClass = modelClass
-    this.modelConfig = modelConfig
-  }
-
-  attributesToShow() {
-    const {modelConfig} = digs(this, "modelConfig")
-
-    if (modelConfig?.show?.attributesToShow) {
-      return modelConfig.show.attributesToShow()
-    }
-
-    return this.defaultAttributesToShow()
-  }
-
-  defaultAttributesToShow() {
-    const attributesToShow = []
-    const {columns} = this.defaultTableColumns()
-
-    for (const column of columns) {
-      attributesToShow.push(digg(column, "attribute"))
-    }
-
-    return attributesToShow
-  }
-
-  tableColumns() {
-    const {modelConfig} = digs(this, "modelConfig")
-
-    if (modelConfig?.table?.columns) {
-      return {
-        columns: modelConfig.table.columns()
-      }
-    } else {
-      return this.defaultTableColumns()
-    }
-  }
-
-  defaultTableColumns() {
-    const {modelClass} = digs(this, "modelClass")
-    const attributes = modelClass.attributes()
-    const columns = []
-    const select = {}
-    const modelClassSelect = []
-
-    select[modelClass.modelClassData().name] = modelClassSelect
-
-    for (const attribute of attributes) {
-      if (!attribute.isSelectedByDefault() && attribute.name() != "name") {
-        continue
-      }
-
-      const camelizedName = inflection.camelize(attribute.name(), true)
-      const column = {
-        attribute: camelizedName
-      }
-
-      if (attribute.isColumn()) {
-        column.sortKey = camelizedName
-      } else if (attribute.isTranslated()) {
-        column.sortKey = `currentTranslation${camelizedName}`
-      }
-
-      modelClassSelect.push(camelizedName)
-      columns.push(column)
-    }
-
-    return {columns, select}
-  }
-}