api_maker 0.0.1

data/lib/api_maker/javascript/sort-link.jsx

@@ -0,0 +1,88 @@
+import { Link } from "react-router-dom"
+import qs from "qs"
+import React from "react"
+
+const inflection = require("inflection")
+
+export default class extends React.Component {
+  constructor(props) {
+    super(props)
+
+    var searchKey = this.props.query.queryArgs.searchKey
+    if (!searchKey)
+      searchKey = "q"
+
+    this.state = {searchKey: searchKey}
+  }
+
+  attribute() {
+    return inflection.underscore(this.props.attribute)
+  }
+
+  href() {
+    var currentParams = qs.parse(window.location.search.substr(1))
+
+    if (!currentParams[this.state.searchKey])
+      currentParams[this.state.searchKey] = {}
+
+    currentParams[this.state.searchKey]["s"] = `${this.attribute()} ${this.sortMode()}`
+
+    var newParams = qs.stringify(currentParams)
+    var newPath = `${location.pathname}?${newParams}`
+
+    return newPath
+  }
+
+  isSortedByAttribute() {
+    if (this.props.query.queryArgs.ransack && this.props.query.queryArgs.ransack.s == this.attribute())
+      return true
+
+    if (this.props.query.queryArgs.ransack && this.props.query.queryArgs.ransack.s == `${this.attribute()} asc`)
+      return true
+
+    return false
+  }
+
+  render() {
+    var LinkComponent = this.linkComponent()
+    var { attribute, className, linkComponent, query, title, ...other } = this.props
+
+    return (
+      <LinkComponent {...other} className={this.className()} data-attribute={attribute} data-sort-mode={this.sortMode()} to={this.href()}>
+        {this.title()}
+      </LinkComponent>
+    )
+  }
+
+  className() {
+    var classNames = ["component-api-maker-bootstrap-sort-link"]
+
+    if (this.props.className)
+      classNames.push(this.props.className)
+
+    return classNames.join(" ")
+  }
+
+  linkComponent() {
+    if (this.props.linkComponent) {
+      return this.props.linkComponent
+    } else {
+      return Link
+    }
+  }
+
+  sortMode() {
+    if (this.isSortedByAttribute()) {
+      return "desc"
+    } else {
+      return "asc"
+    }
+  }
+
+  title() {
+    if (this.props.title)
+      return this.props.title
+
+    return this.props.query.modelClass().humanAttributeName(this.props.attribute)
+  }
+}

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

@@ -0,0 +1,60 @@
+import PropTypes from "prop-types"
+import PropTypesExact from "prop-types-exact"
+import React from "react"
+
+export default class ApiMakerUpdatedAttribute extends React.Component {
+  static propTypes = PropTypesExact({
+    attribute: PropTypes.string,
+    model: PropTypes.object.isRequired,
+    onValue: PropTypes.func
+  })
+
+  constructor(props) {
+    super(props)
+    this.state = {
+      model: this.props.model
+    }
+  }
+
+  componentDidMount() {
+    this.setAttribute()
+    this.connect()
+  }
+
+  componentWillUnmount() {
+    this.connectUpdated.unsubscribe()
+  }
+
+  connect() {
+    this.connectUpdated = this.props.model.connectUpdated(args =>
+      this.setState(
+        {model: args.model},
+        () => this.setAttribute()
+      )
+    )
+  }
+
+  setAttribute() {
+    var newValue
+
+    if (this.props.onValue) {
+      newValue = this.props.onValue.apply(null, [{model: this.state.model}])
+    } else {
+      if (!this.state.model[this.props.attribute])
+        throw new Error(`No such method: ${this.state.model.modelClassData().name}#${this.props.attribute}()`)
+
+      newValue = this.state.model[this.props.attribute].apply(this.state.model)
+    }
+
+    this.setState({
+      value: newValue
+    })
+  }
+
+  render() {
+    if (this.state.value === undefined)
+      return ""
+
+    return this.state.value
+  }
+}

data/lib/api_maker/loader.rb

@@ -0,0 +1,14 @@
+class ApiMaker::Loader
+  def self.load_everything
+    return if @loaded
+
+    @loaded = true
+
+    resources_dir = Rails.root.join("app", "api_maker", "resources")
+    files = Dir.glob("#{resources_dir}/**/*.rb")
+
+    files.each do |file|
+      require file
+    end
+  end
+end

data/lib/api_maker/memory_storage.rb

@@ -0,0 +1,65 @@
+class ApiMaker::MemoryStorage
+  attr_reader :model_class_for_data, :storage
+
+  def self.current
+    @current ||= ApiMaker::MemoryStorage.new
+  end
+
+  def initialize
+    @model_class_for_data = {}
+    @storage = {}
+  end
+
+  def storage_for(klass, mode)
+    @storage.dig(klass, mode) || {}
+  end
+
+  def add(klass, mode, data, args = {})
+    @storage[klass] ||= {}
+    @storage[klass][mode] ||= {}
+    @storage[klass][mode][data] = {data: data, args: args} unless @storage[klass][mode].key?(data)
+  end
+
+  def load_all_resources
+    resources_path = Rails.root.join("app", "api_maker", "resources")
+
+    Dir.foreach(resources_path) do |file|
+      match = file.match(/\A((.+)_resource)\.rb\Z/)
+      next unless match
+
+      resource_name = match[1]
+      resource_class_name = "Resources::#{resource_name.camelize}"
+
+      # Load the resource by constantizing it to support auto loading
+      resource_class_name.safe_constantize
+    end
+
+    @resources_loaded = true
+  end
+
+  def resources_loaded?
+    @resources_loaded
+  end
+
+  def model_class_for(resource:, klass:)
+    model_class_for_data[klass.name] = resource.name
+  end
+
+  def resource_for_model(model_class)
+    class_name = resource_name_for_model(model_class)
+    resource_class = class_name.safe_constantize
+
+    if !resource_class && !resources_loaded?
+      load_all_resources # Some resources with custom model class won't have been loaded at this point
+      return resource_for_model(model_class)
+    end
+
+    raise "Resource couldn't be found from model: #{model_class}" unless resource_class
+
+    resource_class
+  end
+
+  def resource_name_for_model(model_class)
+    model_class_for_data[model_class.name] || "Resources::#{model_class.name.gsub("::", "")}Resource"
+  end
+end

data/lib/api_maker/model_extensions.rb

@@ -0,0 +1,96 @@
+module ApiMaker::ModelExtensions
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def api_maker_broadcast_creates
+      after_commit on: :create do |model| # rubocop:disable Style/SymbolProc
+        model.api_maker_broadcast_create
+      end
+    end
+
+    def api_maker_broadcast_create_channel_name
+      @api_maker_broadcast_create_channel_name ||= "api_maker_creates_#{api_maker_resource.short_name}"
+    end
+
+    def api_maker_broadcast_updates
+      after_commit on: :update do |model| # rubocop:disable Style/SymbolProc
+        model.api_maker_broadcast_update
+      end
+    end
+
+    def api_maker_broadcast_destroys
+      after_commit on: :destroy do |model| # rubocop:disable Style/SymbolProc
+        model.api_maker_broadcast_destroy
+      end
+    end
+
+    def api_maker_resource
+      @api_maker_resource ||= ApiMaker::MemoryStorage.current.resource_for_model(self)
+    end
+  end
+
+  def api_maker_event(event_name, args = {})
+    channel_name = api_maker_event_channel_name(event_name)
+    serializer = ApiMaker::Serializer.new(model: self)
+    data_to_broadcast = ApiMaker::ResultParser.parse(
+      args: args,
+      event_name: event_name,
+      model_id: id,
+      model_type: serializer.resource.collection_name,
+      type: :event
+    )
+    ActionCable.server.broadcast(channel_name, data_to_broadcast)
+  end
+
+  def api_maker_event_channel_name(event_name)
+    "api_maker_events_#{api_maker_resource.short_name}_#{id}_#{event_name}"
+  end
+
+  def api_maker_broadcast_create
+    serializer = ApiMaker::Serializer.new(model: self)
+    data_to_broadcast = ApiMaker::ResultParser.parse(
+      model: self,
+      model_class_name: self.class.name,
+      model_id: id,
+      model_type: serializer.resource.collection_name,
+      type: :create
+    )
+    ActionCable.server.broadcast(self.class.api_maker_broadcast_create_channel_name, data_to_broadcast)
+  end
+
+  def api_maker_broadcast_destroy
+    serializer = ApiMaker::Serializer.new(model: self)
+    data_to_broadcast = ApiMaker::ResultParser.parse(
+      model: self,
+      model_id: id,
+      model_type: serializer.resource.collection_name,
+      type: :destroy
+    )
+    ActionCable.server.broadcast(api_maker_broadcast_destroy_channel_name, data_to_broadcast)
+  end
+
+  def api_maker_broadcast_destroy_channel_name
+    @api_maker_broadcast_destroy_channel_name ||= "api_maker_destroys_#{api_maker_resource.short_name}_#{id}"
+  end
+
+  def api_maker_broadcast_update
+    serializer = ApiMaker::Serializer.new(model: self)
+    data_to_broadcast = ApiMaker::ResultParser.parse(
+      model: self,
+      model_id: id,
+      model_type: serializer.resource.collection_name,
+      type: :update
+    )
+    ActionCable.server.broadcast(api_maker_broadcast_update_channel_name, data_to_broadcast)
+  end
+
+  def api_maker_broadcast_update_channel_name
+    @api_maker_broadcast_update_channel_name ||= "api_maker_updates_#{api_maker_resource.short_name}_#{id}"
+  end
+
+  def api_maker_resource
+    @api_maker_resource ||= self.class.api_maker_resource
+  end
+end

data/lib/api_maker/permitted_params_argument.rb

@@ -0,0 +1,12 @@
+class ApiMaker::PermittedParamsArgument
+  attr_reader :command, :model
+
+  def initialize(command:, model:)
+    @command = command
+    @model = model
+  end
+
+  def params
+    command.args
+  end
+end

data/lib/api_maker/preloader.rb

@@ -0,0 +1,91 @@
+class ApiMaker::Preloader
+  def initialize(ability: nil, args: nil, collection:, data:, include_param:, records:, select:)
+    @ability = ability
+    @args = args
+    @collection = collection
+    @data = data
+    @include_param = include_param
+    @records = records
+    @select = select
+  end
+
+  def fill_data
+    parsed = ApiMaker::RelationshipIncluder.parse(@include_param)
+    return unless parsed
+
+    parsed.each do |key, value|
+      next unless key
+
+      reflection = @collection.model.reflections[key]
+      raise "Unknown reflection: #{@collection.model.name}##{key}" unless reflection
+
+      fill_empty_relationships_for_key(reflection, key)
+      preload_class = preload_class_for_key(reflection)
+
+      preload_result = ApiMaker::Configuration.profile("Preloading #{reflection.klass.name} with #{preload_class.name}") do
+        preload_class.new(
+          ability: @ability,
+          args: @args,
+          collection: @collection,
+          data: @data,
+          records: @records,
+          reflection: reflection,
+          select: @select
+        ).preload
+      end
+
+      next if value.blank? || preload_result.fetch(:collection).empty?
+
+      ApiMaker::Preloader.new(
+        ability: @ability,
+        args: @args,
+        data: @data,
+        collection: preload_result.fetch(:collection),
+        include_param: value,
+        records: @data.fetch(:included),
+        select: @select
+      ).fill_data
+    end
+  end
+
+private
+
+  def fill_empty_relationships_for_key(reflection, key)
+    if @records.is_a?(Hash)
+      collection_name = ApiMaker::MemoryStorage.current.resource_for_model(reflection.active_record).collection_name
+      records_to_set = @records.fetch(collection_name).values
+    else
+      records_to_set = @records.select { |record| record.model.class == reflection.active_record }
+    end
+
+    case reflection.macro
+    when :has_many
+      records_to_set.each do |model|
+        model.relationships[key.to_sym] ||= []
+      end
+    when :belongs_to
+      records_to_set.each do |model|
+        model.relationships[key.to_sym] ||= nil
+      end
+    when :has_one
+      records_to_set.each do |model|
+        model.relationships[key.to_sym] ||= nil
+      end
+    else
+      raise "Unknown macro: #{reflection.macro}"
+    end
+  end
+
+  def preload_class_for_key(reflection)
+    case reflection.macro
+    when :has_many
+      ApiMaker::PreloaderHasMany
+    when :belongs_to
+      ApiMaker::PreloaderBelongsTo
+    when :has_one
+      ApiMaker::PreloaderHasOne
+    else
+      raise "Unknown macro: #{reflection.macro}"
+    end
+  end
+end

data/lib/api_maker/preloader_belongs_to.rb

@@ -0,0 +1,58 @@
+class ApiMaker::PreloaderBelongsTo
+  def initialize(ability:, args:, data:, collection:, records:, reflection:, select:)
+    @ability = ability
+    @args = args
+    @data = data
+    @collection = collection
+    @reflection = reflection
+    @reflection_name = @reflection.name
+    @records = records
+    @select = select
+  end
+
+  def preload
+    models.each do |model|
+      records_for_model(model).each do |record|
+        record.relationships[@reflection_name] = model.id
+      end
+
+      serializer = ApiMaker::Serializer.new(ability: @ability, args: @args, model: model, select: @select&.dig(model.class))
+      collection_name = serializer.resource.collection_name
+
+      @data.fetch(:included)[collection_name] ||= {}
+      @data.fetch(:included).fetch(collection_name)[model.id] ||= serializer
+    end
+
+    {collection: models}
+  end
+
+private
+
+  def collection_name
+    @collection_name = ApiMaker::MemoryStorage.current.resource_for_model(@reflection.active_record).collection_name
+  end
+
+  def model_class
+    @model_class ||= @reflection.klass
+  end
+
+  def models
+    @models ||= begin
+      models = @reflection.klass.where(look_up_key => @collection.map(&@reflection.foreign_key.to_sym).uniq)
+      models = models.accessible_by(@ability) if @ability
+      models.load
+      models
+    end
+  end
+
+  def look_up_key
+    @look_up_key ||= @reflection.options[:primary_key] || @reflection.klass.primary_key
+  end
+
+  def records_for_model(model)
+    @records
+      .fetch(collection_name)
+      .values
+      .select { |record| record.model.read_attribute(@reflection.foreign_key) == model.read_attribute(look_up_key) }
+  end
+end