api_maker 0.0.1

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

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

data/lib/api_maker/javascript/event-emitter-listener.jsx

@@ -0,0 +1,32 @@
+import EventEmitter from "events"
+import PropTypes from "prop-types"
+import React from "react"
+
+export default class ApiMakerEventEmitterListener extends React.Component {
+  static propTypes = {
+    events: PropTypes.instanceOf(EventEmitter).isRequired,
+    event: PropTypes.string.isRequired,
+    onCalled: PropTypes.func.isRequired
+  }
+
+  constructor(props) {
+    super(props)
+    this.onCalled = this.onCalled.bind(this)
+  }
+
+  componentDidMount() {
+    this.props.events.addListener(this.props.event, this.onCalled)
+  }
+
+  componentWillUnmount() {
+    this.props.events.removeListener(this.props.event, this.onCalled)
+  }
+
+  onCalled(...args) {
+    this.props.onCalled.apply(null, ...args)
+  }
+
+  render() {
+    return ""
+  }
+}

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

@@ -0,0 +1,41 @@
+import PropTypes from "prop-types"
+import PropTypesExact from "prop-types-exact"
+import React from "react"
+
+export default class ApiMakerEventListener extends React.Component {
+  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
+  })
+
+  constructor(props) {
+    super(props)
+    this.onCalled = this.onCalled.bind(this)
+
+    if (!this.props.target)
+      throw new Error("'target' was expected but not given")
+  }
+
+  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 ""
+  }
+}

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

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

data/lib/api_maker/javascript/form-data-to-object.js

@@ -0,0 +1,70 @@
+export default class FormDataToObject {
+  static toObject(formData) {
+    var formDataToObject = new FormDataToObject(formData)
+    return formDataToObject.toObject()
+  }
+
+  constructor(formData) {
+    this.formData = formData
+  }
+
+  toObject() {
+    var result = {}
+
+    for(var entry of this.formData.entries()) {
+      var key = entry[0]
+      var value = entry[1]
+
+      this.treatInitial(key, value, result)
+    }
+
+    return result
+  }
+
+  treatInitial(key, value, result) {
+    var firstMatch = key.match(/^(.+?)(\[([\s\S]+$))/)
+
+    if (firstMatch) {
+      var inputName = firstMatch[1]
+      var rest = firstMatch[2]
+
+      if (inputName in result) {
+        var newResult = result[inputName]
+      } else if (rest == "[]") {
+        var newResult = []
+        result[inputName] = newResult
+      } else {
+        var newResult = {}
+        result[inputName] = newResult
+      }
+
+      this.treatSecond(value, rest, newResult)
+    } else {
+      result[key] = value
+    }
+  }
+
+  treatSecond(value, rest, result) {
+    var secondMatch = rest.match(/^\[(.*?)\]([\s\S]*)$/)
+    var key = secondMatch[1]
+    var newRest = secondMatch[2]
+
+    if (rest == "[]") {
+      result.push(value)
+    } else if (newRest == "") {
+      result[key] = value
+    } else {
+      if (key in result) {
+        var newResult = result[key]
+      } else if (newRest == "[]") {
+        var newResult = []
+        result[key] = newResult
+      } else {
+        var newResult = {}
+        result[key] = newResult
+      }
+
+      this.treatSecond(value, newRest, newResult)
+    }
+  }
+}

data/lib/api_maker/javascript/included.js

@@ -0,0 +1,39 @@
+const inflection = require("inflection")
+
+export default class ApiMakerIncluded {
+  constructor(response) {
+    this.response = response
+    this.loadIncludedModels()
+  }
+
+  loadIncludedModels() {
+    this.included = {}
+
+    for(var includedType in this.response.included) {
+      for(var includedId in this.response.included[includedType]) {
+        var includedData = this.response.included[includedType][includedId]
+        var modelClassName = inflection.dasherize(inflection.singularize(includedType))
+        var modelClass = require(`api-maker/models/${modelClassName}`).default
+        var model = new modelClass({data: includedData, isNewRecord: false})
+
+        if (!this.included[includedType])
+          this.included[includedType] = {}
+
+        this.included[includedType][includedId] = model
+      }
+    }
+
+    for(var modelType in this.included) {
+      for(var modelId in this.included[modelType]) {
+        this.included[modelType][modelId]._readIncludedRelationships(this)
+      }
+    }
+  }
+
+  getModel(type, id) {
+    if (!this.included[type] || !this.included[type][id])
+      throw new Error(`Could not find a ${type} by that ID: ${id}`)
+
+    return this.included[type][id]
+  }
+}

data/lib/api_maker/javascript/key-value-store.js

@@ -0,0 +1,47 @@
+import Dexie from "dexie"
+
+export default class KeyValueStore {
+  static current() {
+    if (!window.currentKeyValueStore)
+      window.currentKeyValueStore = new KeyValueStore()
+
+    return window.currentKeyValueStore
+  }
+
+  static async get(key) {
+    return await KeyValueStore.current().get(key)
+  }
+
+  static async set(key, value) {
+    return await KeyValueStore.current().set(key, value)
+  }
+
+  constructor() {
+    this.database = new Dexie("KeyValueStoreDatabase")
+    this.database.version(1).stores({
+      keyValues: "++id, key, value"
+    })
+  }
+
+  async get(key) {
+    var row = await this.database.keyValues.where("key").equals(key).first()
+
+    if (row)
+      return row.value
+  }
+
+  async set(key, value) {
+    var row = await this.database.keyValues.where("key").equals(key).first()
+
+    if (row) {
+      await this.database.keyValues.update(row.id, {value: value})
+    } else {
+      await this.database.keyValues.add({
+        key: key,
+        value: value
+      })
+    }
+
+    return true
+  }
+}

data/lib/api_maker/javascript/logger.js

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

data/lib/api_maker/javascript/model-name.js

@@ -0,0 +1,21 @@
+export default class ModelName {
+  constructor(data) {
+    this.data = data
+  }
+
+  human(args) {
+    if (!args)
+      args = {count: 1}
+
+    var countKey
+
+    if (args.count > 1 || args.count < 0) {
+      countKey = "other"
+    } else {
+      countKey = "one"
+    }
+
+    var key = `activerecord.models.${this.data.modelClassData.i18nKey}.${countKey}`
+    return I18n.t(key)
+  }
+}

data/lib/api_maker/javascript/model-template.js.erb

@@ -0,0 +1,110 @@
+import BaseModel from "../base-model"
+import Collection from "../collection"
+
+export default class <%= model.name.gsub("::", "") %> extends BaseModel {
+  static modelClassData() {
+    return <%= {
+      attributes: attributes,
+      collectionKey: model.model_name.collection,
+      collectionName: resource.collection_name,
+      i18nKey: model.model_name.i18n_key,
+      name: resource.short_name,
+      pluralName: model.model_name.plural,
+      relationships: reflections_for_model_class_data,
+      paramKey: model.model_name.param_key,
+      path: "/api_maker/#{model.model_name.route_key}",
+      primaryKey: model.primary_key
+    }.to_json %>
+  }
+
+  <% reflections.each do |reflection| %>
+    <% if reflection.macro == :belongs_to %>
+      <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
+        let id = this.<%= ApiMaker::JsMethodNamerService.execute!(name: reflection.foreign_key) %>()
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return this._loadBelongsToReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("ransack" => {"#{reflection.options[:primary_key] || reflection.klass.primary_key}_eq" => "{{id}}"}) %>)
+      }
+
+      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return this._readBelongsToReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>)
+      }
+    <% elsif reflection.macro == :has_many %>
+      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
+        let id = this.<%= ApiMaker::JsMethodNamerService.execute!(name: reflection.options[:primary_key] || reflection.active_record.primary_key) %>()
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return new Collection(<%= api_maker_json(reflection_has_many_parameters(reflection)) %>, <%= api_maker_json(reflection_has_many_parameters_query(reflection)) %>)
+      }
+    <% elsif reflection.macro == :has_one && reflection.options[:through] %>
+      <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
+        let id = this.<%= reflection.active_record.primary_key %>()
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return this._loadHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("params": {"through" => {"model" => model.model_name, "id" => "{{id}}", "reflection" => reflection.name}}) %>)
+      }
+
+      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return this._readHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>)
+      }
+    <% elsif reflection.macro == :has_one %>
+      <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
+        let id = this.<%= reflection.active_record.primary_key %>()
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return this._loadHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("ransack" => {"#{reflection.foreign_key}_eq" => "{{id}}"}) %>)
+      }
+
+      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
+        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        return this._readHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>)
+      }
+    <% end %>
+  <% end %>
+
+  <% attributes.each do |attribute_data| %>
+    <% methodName = ApiMaker::JsMethodNamerService.execute!(name: attribute_data.fetch(:name)) %>
+    <%= methodName %>() {
+      // <%= attribute_data.fetch(:type) %>
+      <% if attribute_data.fetch(:type) == :datetime || attribute_data.fetch(:type) == :date %>
+        return this._getAttributeDateTime("<%= attribute_data.fetch(:name) %>")
+      <% elsif attribute_data.fetch(:type) == :money %>
+        return this._getAttributeMoney("<%= attribute_data.fetch(:name) %>")
+      <% else %>
+        return this._getAttribute("<%= attribute_data.fetch(:name) %>")
+      <% end %>
+    }
+
+    <%= ApiMaker::JsMethodNamerService.execute!(name: "has_#{attribute_data.fetch(:name)}") %>() {
+      let value = this.<%= methodName %>()
+      return this._isPresent(value)
+    }
+  <% end %>
+
+  <% collection_commands.each do |collection_command, data| %>
+    static <%= ApiMaker::JsMethodNamerService.execute!(name: collection_command) %>(args, commandArgs = {}) {
+      return this._callCollectionCommand(
+        {
+          args: args,
+          command: "<%= collection_command %>",
+          collectionName: this.modelClassData().collectionName,
+          type: "collection"
+        },
+        commandArgs
+      )
+    }
+  <% end %>
+
+  <% member_commands.each do |member_command, data| %>
+    <%= ApiMaker::JsMethodNamerService.execute!(name: member_command) %>(args, commandArgs = {}) {
+      return this._callMemberCommand(
+        {
+          args: args,
+          command: "<%= member_command %>",
+          primaryKey: this._primaryKey(),
+          collectionName: this.modelClassData().collectionName,
+          type: "member"
+        },
+        commandArgs
+      )
+    }
+  <% end %>
+}