api_maker 0.0.1

data/lib/api_maker/javascript/commands-pool.js

@@ -0,0 +1,123 @@
+import Api from "./api"
+import CustomError from "./custom-error"
+import Deserializer from "./deserializer"
+import FormDataToObject from "./form-data-to-object"
+import objectToFormData from "object-to-formdata"
+
+export default class ApiMakerCommandsPool {
+  static addCommand(data, args = {}) {
+    if (args.instant) {
+      var pool = new ApiMakerCommandsPool()
+    } else {
+      var pool = ApiMakerCommandsPool.current()
+    }
+
+    var promiseResult = pool.addCommand(data)
+
+    if (args.instant) {
+      pool.flush()
+    } else {
+      pool.setFlushTimeout()
+    }
+
+    return promiseResult
+  }
+
+  static current() {
+    if (!window.currentApiMakerCommandsPool)
+      window.currentApiMakerCommandsPool = new ApiMakerCommandsPool()
+
+    return window.currentApiMakerCommandsPool
+  }
+
+  static flush() {
+    ApiMakerCommandsPool.current().flush()
+  }
+
+  constructor() {
+    this.pool = {}
+    this.poolData = {}
+    this.currentId = 1
+    this.globalRequestData = null
+  }
+
+  addCommand(data) {
+    return new Promise((resolve, reject) => {
+      var id = this.currentId
+      this.currentId += 1
+
+      var commandType = data.type
+      var commandName = data.command
+      var collectionName = data.collectionName
+
+      this.pool[id] = {resolve: resolve, reject: reject}
+
+      if (!this.poolData[commandType])
+        this.poolData[commandType] = {}
+
+      if (!this.poolData[commandType][collectionName])
+        this.poolData[commandType][collectionName] = {}
+
+      if (!this.poolData[commandType][collectionName][commandName])
+        this.poolData[commandType][collectionName][commandName] = {}
+
+      if (data.args instanceof FormData) {
+        var args = FormDataToObject.toObject(data.args)
+      } else {
+        var args = data.args
+      }
+
+      this.poolData[commandType][collectionName][commandName][id] = {
+        args: args,
+        primary_key: data.primaryKey,
+        id: id
+      }
+    })
+  }
+
+  async flush() {
+    if (Object.keys(this.pool) == 0)
+      return
+
+    this.clearTimeout()
+
+    var currentPool = this.pool
+    var currentPoolData = this.poolData
+
+    this.pool = {}
+    this.poolData = {}
+
+    var objectForFormData = {pool: currentPoolData}
+
+    if (this.globalRequestData)
+      objectForFormData.global = this.globalRequestData
+
+    var formData = objectToFormData(objectForFormData)
+    var url = `/api_maker/commands`
+    var response = await Api.requestLocal({path: url, method: "POST", rawData: formData})
+
+    for(var commandId in response.responses) {
+      var commandResponse = response.responses[commandId]
+      var commandResponseData = Deserializer.parse(commandResponse.data)
+      var commandData = currentPool[parseInt(commandId)]
+
+      if (commandResponse.type == "success") {
+        commandData.resolve(commandResponseData)
+      } else if (commandResponse.type == "error") {
+        commandData.reject(new CustomError("Command error", {response: commandResponseData}))
+      } else {
+        commandData.reject(new CustomError("Command failed", {response: commandResponseData}))
+      }
+    }
+  }
+
+  clearTimeout() {
+    if (this.flushTimeout)
+      clearTimeout(this.flushTimeout)
+  }
+
+  setFlushTimeout() {
+    this.clearTimeout()
+    this.flushTimeout = setTimeout(() => this.flush(), 0)
+  }
+}

data/lib/api_maker/javascript/custom-error.js

@@ -0,0 +1,14 @@
+export default class ApiMakerCustomError extends Error {
+  constructor(message, args = {}) {
+    if (args.response && args.response.errors)
+      message = `${message}: ${args.response.errors.join(". ")}`
+
+    super(message)
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, ApiMakerCustomError)
+
+    this.args = args
+  }
+}

data/lib/api_maker/javascript/deserializer.js

@@ -0,0 +1,35 @@
+import Money from "js-money"
+
+const inflection = require("inflection")
+
+export default class ApiMakerDeserializer {
+  static parse(object) {
+    if (Array.isArray(object)) {
+      return object.map(value => ApiMakerDeserializer.parse(value))
+    } else if (object && typeof object == "object") {
+      if (object.api_maker_type == "money") {
+        var cents = object.amount
+        var currency = object.currency
+
+        return Money.fromInteger(cents, currency)
+      } else if (object.api_maker_type == "model") {
+        var modelClassName = inflection.singularize(object.model_name)
+        var modelClass = require(`api-maker/models/${modelClassName}`).default
+        var model = new modelClass({data: object.serialized, isNewRecord: false})
+
+        return model
+      } else {
+        var newObject = {}
+
+        for(var key in object) {
+          var value = object[key]
+          newObject[key] = ApiMakerDeserializer.parse(value)
+        }
+
+        return newObject
+      }
+    } else {
+      return object
+    }
+  }
+}

data/lib/api_maker/javascript/devise.js.erb

@@ -0,0 +1,113 @@
+import Api from "./api"
+import CustomError from "./custom-error"
+import EventEmitter from "events"
+const inflection = require("inflection")
+
+export default class Devise {
+  static callSignOutEvent(args) {
+    Devise.events().emit("onDeviseSignOut", {args: args})
+  }
+
+  static current() {
+    if (!window.currentApiMakerDevise)
+      window.currentApiMakerDevise = new Devise()
+
+    return window.currentApiMakerDevise
+  }
+
+  static events() {
+    if (!window.apiMakerDeviseEvents)
+      window.apiMakerDeviseEvents = new EventEmitter()
+
+    return window.apiMakerDeviseEvents
+  }
+
+  <% Devise.mappings.each do |scope| %>
+    <%
+      klass = scope[1].class_name.safe_constantize
+      resource = ApiMaker::Serializer.resource_for(klass)
+    %>
+    <% if resource %>
+      static <%= ApiMaker::JsMethodNamerService.execute!(name: "is_#{scope[0]}_signed_in") %>() {
+        if (Devise.current().getCurrentScope("<%= scope[1].class_name %>"))
+          return true
+
+        return false
+      }
+
+      static current<%= scope[1].class_name %>() {
+        return Devise.current().getCurrentScope("<%= scope[1].class_name %>")
+      }
+    <% end %>
+  <% end %>
+
+  static async signIn(username, password, args = {}) {
+    if (!args.scope)
+      args.scope = "user"
+
+    var postData = {"username": username, "password": password, "args": args}
+    var response = await Api.post("/api_maker/devise/do_sign_in", postData)
+
+    if (response.success) {
+      var modelClass = require(`api-maker/models/${inflection.dasherize(args.scope)}`).default
+      var modelInstance = new modelClass(response.model_data)
+
+      Devise.updateSession(modelInstance)
+      Devise.events().emit("onDeviseSignIn", Object.assign({username: username}, args))
+
+      return {model: modelInstance, response: response}
+    } else {
+      throw new CustomError("Sign in failed", {response: response})
+    }
+  }
+
+  static updateSession(model) {
+    var scope = model.modelClassData().name
+    Devise.current().currents[scope] = model
+  }
+
+  static setSignedOut(args) {
+    Devise.current().currents[inflection.camelize(args.scope)] = null
+  }
+
+  static async signOut(args = {}) {
+    if (!args.scope)
+      args.scope = "user"
+
+    var postData = {"args": args}
+    var response = await Api.post("/api_maker/devise/do_sign_out", postData)
+
+    if (response.success) {
+      Devise.setSignedOut(args)
+      Devise.callSignOutEvent(args)
+      return response
+    } else {
+      throw new CustomError("Sign out failed", {response: response})
+    }
+  }
+
+  constructor() {
+    this.currents = {}
+  }
+
+  getCurrentScope(scope) {
+    if (!(scope in this.currents))
+      this.currents[scope] = this.loadCurrentScope(scope)
+
+    return this.currents[scope]
+  }
+
+  loadCurrentScope(scope) {
+    var apiMakerDataElement = document.querySelector(".api-maker-data")
+    var keyName = `current${inflection.camelize(scope)}`
+    var scopeData = apiMakerDataElement.dataset[keyName]
+
+    if (!scopeData)
+      return null
+
+    var modelClass = require(`api-maker/models/${inflection.dasherize(inflection.underscore(scope))}`).default
+    var modelInstance = new modelClass({data: JSON.parse(scopeData)})
+
+    return modelInstance
+  }
+}

data/lib/api_maker/javascript/error-logger.js

@@ -0,0 +1,119 @@
+import retrace from "retrace"
+
+export default class ErrorLogger {
+  constructor() {
+    this.errors = []
+  }
+
+  loadSourceMaps() {
+    return new Promise(resolve => {
+      var scripts = document.querySelectorAll("script")
+      var promises = []
+
+      for(var script of scripts) {
+        var src = script.getAttribute("src")
+        var type = script.getAttribute("type")
+
+        if (src && src.includes("/packs/") && (type == "text/javascript" || !type)) {
+          var promise = this.loadSourceMapForScript(script)
+          promises.push(promise)
+        }
+      }
+
+      Promise.all(promises).then(() => { resolve() })
+    })
+  }
+
+  loadSourceMapForScript(script) {
+    var src = script.getAttribute("src")
+    var url = this.loadUrl(src)
+    var originalUrl = `${url.origin}${url.pathname}`
+    var mapUrl = `${url.origin}${url.pathname}.map`
+
+    return new Promise(resolve => {
+      var xhr = new XMLHttpRequest()
+      xhr.open("GET", mapUrl, true)
+      xhr.onload = () => {
+        retrace.register(originalUrl, xhr.responseText)
+        resolve()
+      }
+      xhr.send()
+    })
+  }
+
+  loadUrl(url) {
+    var parser = document.createElement("a")
+    parser.href = url
+
+    return parser
+  }
+
+  enable() {
+    this.connectOnError()
+    this.connectUnhandledRejection()
+  }
+
+  getErrors() {
+    return this.errors
+  }
+
+  connectOnError() {
+    window.addEventListener("error", (event) => {
+      if (!this.isHandlingError) {
+        try {
+          this.isHandlingError = true
+          this.errors.push({
+            errorClass: event.error ? event.error.name : "No error class",
+            file: event.filename,
+            message: event.message || "Unknown error",
+            url: window.location.href,
+            line: event.lineno,
+            error: event.error
+          })
+        } finally {
+          this.isHandlingError = false
+        }
+      }
+    })
+  }
+
+  connectUnhandledRejection() {
+    window.addEventListener("unhandledrejection", (event, test) => {
+      if (!this.isHandlingError) {
+        this.isHandlingError = true
+
+        try {
+          if (event.reason.stack) {
+            retrace.map(event.reason.stack).then(mappedStackTrace => {
+              this.errors.push({
+                errorClass: "UnhandledRejection",
+                file: null,
+                message: event.reason.message || "Unhandled promise rejection",
+                url: window.location.href,
+                line: null,
+                backtrace: mappedStackTrace.split("\n")
+              })
+            })
+          } else {
+            this.errors.push({
+              errorClass: "UnhandledRejection",
+              file: null,
+              message: event.reason.message || "Unhandled promise rejection",
+              url: window.location.href,
+              line: null,
+              backtrace: null
+            })
+          }
+        } finally {
+          this.isHandlingError = false
+        }
+      }
+    })
+  }
+
+  testPromiseError() {
+    return new Promise(resolve => {
+      throw new Error("testPromiseError")
+    })
+  }
+}

data/lib/api_maker/javascript/event-connection.jsx

@@ -0,0 +1,24 @@
+import PropTypes from "prop-types"
+import PropTypesExact from "prop-types-exact"
+import React from "react"
+
+export default class ApiMakerEventConnection extends React.Component {
+  static propTypes = PropTypesExact({
+    model: PropTypes.object.isRequired,
+    event: PropTypes.string.isRequired,
+    onCall: PropTypes.func.isRequired
+  })
+
+  componentDidMount() {
+    this.subscription = this.props.model.connect(this.props.event, this.props.onCall)
+  }
+
+  componentWillUnmount() {
+    if (this.subscription)
+      this.subscription.unsubscribe()
+  }
+
+  render() {
+    return ""
+  }
+}

data/lib/api_maker/javascript/event-created.jsx

@@ -0,0 +1,26 @@
+import PropTypes from "prop-types"
+import PropTypesExact from "prop-types-exact"
+import React from "react"
+
+export default class ApiMakerEventCreated extends React.Component {
+  static propTypes = PropTypesExact({
+    modelClass: PropTypes.func.isRequired,
+    onCreated: PropTypes.func.isRequired
+  })
+
+  componentDidMount() {
+    this.connect()
+  }
+
+  componentWillUnmount() {
+    this.connectCreated.unsubscribe()
+  }
+
+  connect() {
+    this.connectCreated = this.props.modelClass.connectCreated(this.props.onCreated)
+  }
+
+  render() {
+    return ""
+  }
+}