@kaspernj/api-maker 1.0.2052 → 1.0.2054

package/src/model-prop-type.js

@@ -1,124 +0,0 @@
-import {digg} from "diggerize"
-import Inflection from "inflection"
-
-export default class ApiMakerModelPropType {
-  static ofModel (modelClass) {
-    const modelPropTypeInstance = new ApiMakerModelPropType()
-
-    modelPropTypeInstance.withModelType(modelClass)
-
-    return modelPropTypeInstance
-  }
-
-  constructor () {
-    this.isNotRequired = this.isNotRequired.bind(this)
-    this.isRequired = this.isRequired.bind(this)
-    this._withLoadedAssociations = {}
-  }
-
-  isNotRequired (props, propName, _componentName) {
-    const model = props[propName]
-
-    if (model) {
-      return this.validate({model, propName})
-    }
-  }
-
-  isRequired (props, propName, _componentName) {
-    const model = props[propName]
-
-    if (!model) return new Error(`${propName} was required but not given`)
-
-    return this.validate({model, propName})
-  }
-
-  previous () {
-    if (!this._previousModelPropType) throw new Error("No previous model prop type set")
-
-    return this._previousModelPropType
-  }
-
-  setPreviousModelPropType (previousModelPropType) {
-    this._previousModelPropType = previousModelPropType
-  }
-
-  withModelType (modelClass) {
-    this._withModelType = modelClass
-  }
-
-  validate ({model, propName}) {
-    if (this._withModelType && this._withModelType.name != model.constructor.name)
-      return new Error(`Expected ${propName} to be of type ${this._withModelType.name} but it wasn't: ${model.constructor.name}`)
-
-    if (this._withLoadedAbilities) {
-      for (const abilityName of this._withLoadedAbilities) {
-        const underscoreAbilityName = Inflection.underscore(abilityName)
-
-        if (!(underscoreAbilityName in model.abilities))
-          return new Error(`The ability ${abilityName} was required to be loaded in ${propName} of the ${model.constructor.name} type but it wasn't`)
-      }
-    }
-
-    if (this._withLoadedAssociations) {
-      for (const associationName in this._withLoadedAssociations) {
-        const associationModelPropType = digg(this._withLoadedAssociations, associationName)
-        const underscoreAssociationName = Inflection.underscore(associationName)
-
-        if (!(underscoreAssociationName in model.relationshipsCache))
-          return new Error(`The association ${associationName} was required to be loaded in ${propName} of the ${model.constructor.name} type but it wasn't`)
-
-        const associationCache = digg(model.relationshipsCache, underscoreAssociationName)
-
-        // Find a model to run sub-model-prop-type-validations on
-        if (Array.isArray(associationCache)) {
-          for (const preloadedModel of associationCache) {
-            const validationResult = associationModelPropType.validate({
-              model: preloadedModel,
-              propName: `${propName}.${associationName}`
-            })
-
-            if (validationResult) return validationResult
-          }
-        } else if (associationCache) {
-          const validationResult = associationModelPropType.validate({
-            model: associationCache,
-            propName: `${propName}.${associationName}`
-          })
-
-          if (validationResult) return validationResult
-        }
-      }
-    }
-
-    if (this._withLoadedAttributes && model.isPersisted()) {
-      for (const attributeName of this._withLoadedAttributes) {
-        const underscoreAttributeName = Inflection.underscore(attributeName)
-
-        if (!(underscoreAttributeName in model.modelData)) {
-          return new Error(`The attribute ${attributeName} was required to be loaded in ${propName} of the ${model.constructor.name} type but it wasn't`)
-        }
-      }
-    }
-  }
-
-  withLoadedAbilities (arrayOfAbilities) {
-    this._withLoadedAbilities = arrayOfAbilities
-
-    return this
-  }
-
-  withLoadedAssociation (associationName) {
-    const associationModelPropType = new ApiMakerModelPropType()
-
-    associationModelPropType.setPreviousModelPropType(this)
-    this._withLoadedAssociations[associationName] = associationModelPropType
-
-    return associationModelPropType
-  }
-
-  withLoadedAttributes (arrayOfAttributes) {
-    this._withLoadedAttributes = arrayOfAttributes
-
-    return this
-  }
-}

package/src/model-recipes-loader.js

@@ -1,28 +0,0 @@
-import {digg, digs} from "diggerize"
-import ModelRecipesModelLoader from "./model-recipes-model-loader"
-
-export default class ModelRecipesLoader {
-  constructor ({recipes}) {
-    this.modelClasses = {}
-    this.recipes = recipes
-  }
-
-  getModelClass (name) {
-    return digg(this, "modelClasses", name)
-  }
-
-  load () {
-    const {recipes} = digs(this, "recipes")
-    const {models} = digs(recipes, "models")
-
-    for (const modelName in models) {
-      const modelRecipe = models[modelName]
-      const modelClassLoader = new ModelRecipesModelLoader({modelRecipe, modelRecipesLoader: this})
-      const modelClass = modelClassLoader.createClass()
-
-      this.modelClasses[modelName] = modelClass
-    }
-
-    return this.modelClasses
-  }
-}

package/src/model-recipes-model-loader.js

@@ -1,350 +0,0 @@
-import BaseModel from "./base-model"
-import Collection from "./collection"
-import {digg, digs} from "diggerize"
-import * as inflection from "inflection"
-
-export default class ApiMakerModelRecipesModelLoader {
-  constructor ({modelRecipe, modelRecipesLoader}) {
-    if (!modelRecipe) throw new Error("No 'modelRecipe' was given")
-
-    this.modelRecipesLoader = modelRecipesLoader
-    this.modelRecipe = modelRecipe
-  }
-
-  createClass () {
-    const {modelRecipe} = digs(this, "modelRecipe")
-    const {
-      attributes,
-      collection_commands: collectionCommands,
-      member_commands: memberCommands,
-      model_class_data: modelClassData,
-      relationships
-    } = digs(
-      modelRecipe,
-      "attributes",
-      "collection_commands",
-      "member_commands",
-      "model_class_data",
-      "relationships"
-    )
-    const {name: modelClassName} = digs(modelClassData, "name")
-    const ModelClass = class ApiMakerModel extends BaseModel { }
-
-    Object.defineProperty(ModelClass, "name", {writable: false, value: modelClassName})
-
-    ModelClass.prototype.constructor.modelClassData = () => modelClassData
-
-    this.addAttributeMethodsToModelClass(ModelClass, attributes)
-    this.addRelationshipsToModelClass(ModelClass, modelClassData, relationships)
-    this.addQueryCommandsToModelClass(ModelClass, collectionCommands)
-    this.addMemberCommandsToModelClass(ModelClass, memberCommands)
-
-    return ModelClass
-  }
-
-  addAttributeMethodsToModelClass (ModelClass, attributes) {
-    for (const attributeName in attributes) {
-      const attribute = attributes[attributeName]
-      const {name} = digs(attribute, "name")
-      const methodName = inflection.camelize(name, true)
-      const hasMethodName = inflection.camelize(`has_${name}`, true)
-
-      ModelClass.prototype[methodName] = function () {
-        return this.readAttributeUnderscore(attributeName)
-      }
-
-      ModelClass.prototype[hasMethodName] = function () {
-        const value = this[methodName]()
-
-        return this._isPresent(value)
-      }
-    }
-  }
-
-  addQueryCommandsToModelClass (ModelClass, collectionCommands) {
-    for (const collectionCommandName in collectionCommands) {
-      const methodName = inflection.camelize(collectionCommandName, true)
-
-      ModelClass[methodName] = function (args, commandArgs = {}) {
-        return this._callCollectionCommand(
-          {
-            args,
-            command: collectionCommandName,
-            collectionName: digg(this.modelClassData(), "collectionName"),
-            type: "collection"
-          },
-          commandArgs
-        )
-      }
-    }
-  }
-
-  addMemberCommandsToModelClass (ModelClass, memberCommands) {
-    for (const memberCommandName in memberCommands) {
-      const methodName = inflection.camelize(memberCommandName, true)
-
-      ModelClass.prototype[methodName] = function (args, commandArgs = {}) {
-        return this._callMemberCommand(
-          {
-            args,
-            command: memberCommandName,
-            primaryKey: this.primaryKey(),
-            collectionName: this.modelClassData().collectionName,
-            type: "member"
-          },
-          commandArgs
-        )
-      }
-    }
-  }
-
-  addRelationshipsToModelClass (ModelClass, modelClassData, relationships) {
-    const {modelRecipesLoader} = digs(this, "modelRecipesLoader")
-
-    for (const relationshipName in relationships) {
-      const relationship = relationships[relationshipName]
-      const {
-        active_record: {
-          name: activeRecordName,
-          primary_key: activeRecordPrimaryKey
-        },
-        class_name: className,
-        foreign_key: foreignKey,
-        klass: {primary_key: klassPrimaryKey},
-        options: {as: optionsAs, primary_key: optionsPrimaryKey, through: optionsThrough},
-        resource_name: resourceName,
-        type
-      } = digs(
-        relationship,
-        "active_record",
-        "class_name",
-        "foreign_key",
-        "klass",
-        "options",
-        "resource_name",
-        "type"
-      )
-      const loadMethodName = inflection.camelize(`load_${relationshipName}`, true)
-      const modelMethodName = inflection.camelize(relationshipName, true)
-
-      if (type == "belongs_to") {
-        this.defineBelongsToGetMethod({ModelClass, modelMethodName, relationshipName})
-        this.defineBelongsToLoadMethod({
-          foreignKey,
-          klassPrimaryKey,
-          loadMethodName,
-          ModelClass,
-          modelRecipesLoader,
-          optionsPrimaryKey,
-          relationshipName,
-          resourceName
-        })
-      } else if (type == "has_many") {
-        this.defineHasManyGetMethod({
-          activeRecordName,
-          className,
-          foreignKey,
-          ModelClass,
-          modelMethodName,
-          modelRecipesLoader,
-          optionsAs,
-          optionsPrimaryKey,
-          optionsThrough,
-          relationshipName,
-          resourceName
-        })
-        this.defineHasManyLoadMethod({foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, relationshipName, resourceName})
-      } else if (type == "has_one") {
-        this.defineHasOneGetMethd({ModelClass, modelMethodName, relationshipName})
-        this.defineHasOneLoadMethod({
-          activeRecordPrimaryKey,
-          foreignKey,
-          loadMethodName,
-          ModelClass,
-          modelClassData,
-          modelRecipesLoader,
-          optionsThrough,
-          relationshipName,
-          resourceName
-        })
-      } else {
-        throw new Error(`Unknown relationship type: ${type}`)
-      }
-    }
-  }
-
-  defineBelongsToGetMethod ({ModelClass, modelMethodName, relationshipName}) {
-    ModelClass.prototype[modelMethodName] = function () {
-      return this._readBelongsToReflection({reflectionName: relationshipName})
-    }
-  }
-
-  defineBelongsToLoadMethod ({foreignKey, klassPrimaryKey, ModelClass, modelRecipesLoader, loadMethodName, optionsPrimaryKey, relationshipName, resourceName}) {
-    ModelClass.prototype[loadMethodName] = function () {
-      const foreignKeyMethodName = inflection.camelize(foreignKey, true)
-
-      if (!(foreignKeyMethodName in this)) throw new Error(`Foreign key method wasn't defined: ${foreignKeyMethodName}`)
-
-      const id = this[foreignKeyMethodName]()
-      const modelClass = modelRecipesLoader.getModelClass(resourceName)
-      const ransack = {}
-      const ransackIdSearchKey = `${optionsPrimaryKey || klassPrimaryKey}_eq`
-
-      ransack[ransackIdSearchKey] = id
-
-      return this._loadBelongsToReflection(
-        {reflectionName: relationshipName, model: this, modelClass},
-        {ransack}
-      )
-    }
-  }
-
-  defineHasManyGetMethod ({
-    activeRecordName,
-    className,
-    foreignKey,
-    ModelClass,
-    modelMethodName,
-    modelRecipesLoader,
-    optionsAs,
-    optionsPrimaryKey,
-    optionsThrough,
-    relationshipName,
-    resourceName
-  }) {
-    ModelClass.prototype[modelMethodName] = function () {
-      const id = this.primaryKey()
-      const modelClass = modelRecipesLoader.getModelClass(resourceName)
-      const ransack = {}
-
-      ransack[`${foreignKey}_eq`] = id
-
-      const hasManyParameters = {
-        reflectionName: relationshipName,
-        model: this,
-        modelName: className,
-        modelClass
-      }
-
-      let queryParameters
-
-      if (optionsThrough) {
-        queryParameters = {
-          params: {
-            through: {
-              model: activeRecordName,
-              id: this.primaryKey(),
-              reflection: relationshipName
-            }
-          }
-        }
-      } else {
-        const ransack = {}
-        const primaryKeyColumnName = optionsPrimaryKey || digg(ModelClass.modelClassData(), "primaryKey")
-        const primaryKeyMethodName = inflection.camelize(primaryKeyColumnName, true)
-
-        if (!(primaryKeyMethodName in this)) throw new Error(`No such primary key method: ${primaryKeyMethodName}`)
-
-        ransack[`${foreignKey}_eq`] = this[primaryKeyMethodName]()
-
-        if (optionsAs) {
-          ransack[`${optionsAs}_type_eq`] = activeRecordName
-        }
-
-        queryParameters = {ransack}
-      }
-
-      return new Collection(hasManyParameters, queryParameters)
-    }
-  }
-
-  defineHasManyLoadMethod ({foreignKey, loadMethodName, ModelClass, modelClassData, modelRecipesLoader, optionsThrough, relationshipName, resourceName}) {
-    ModelClass.prototype[loadMethodName] = function () {
-      const id = this.primaryKey()
-      const modelClass = modelRecipesLoader.getModelClass(resourceName)
-
-      if (optionsThrough) {
-        const modelClassName = digg(modelClassData, "className")
-
-        return this._loadHasManyReflection(
-          {
-            reflectionName: relationshipName,
-            model: this,
-            modelClass
-          },
-          {
-            params: {
-              through: {
-                model: modelClassName,
-                id,
-                reflection: relationshipName
-              }
-            }
-          }
-        )
-      } else {
-        const ransack = {}
-
-        ransack[`${foreignKey}_eq`] = id
-
-        return this._loadHasManyReflection(
-          {
-            reflectionName: relationshipName,
-            model: this,
-            modelClass
-          },
-          {ransack}
-        )
-      }
-    }
-  }
-
-  defineHasOneGetMethd ({ModelClass, modelMethodName, relationshipName}) {
-    ModelClass.prototype[modelMethodName] = function () {
-      return this._readHasOneReflection({reflectionName: relationshipName})
-    }
-  }
-
-  defineHasOneLoadMethod ({
-    activeRecordPrimaryKey,
-    foreignKey,
-    loadMethodName,
-    ModelClass,
-    modelClassData,
-    modelRecipesLoader,
-    optionsThrough,
-    relationshipName,
-    resourceName
-  }) {
-    ModelClass.prototype[loadMethodName] = function () {
-      const primaryKeyMethodName = inflection.camelize(activeRecordPrimaryKey, true)
-
-      if (!(primaryKeyMethodName in this)) throw new Error(`Primary key method wasn't defined: ${primaryKeyMethodName}`)
-
-      const id = this[primaryKeyMethodName]()
-      const modelClass = modelRecipesLoader.getModelClass(resourceName)
-
-      if (optionsThrough) {
-        const modelClassName = digg(modelClassData, "className")
-
-        return this._loadHasOneReflection(
-          {reflectionName: relationshipName, model: this, modelClass},
-          {params: {through: {model: modelClassName, id, reflection: relationshipName}}}
-        )
-      } else {
-        const ransack = {}
-
-        ransack[`${foreignKey}_eq`] = id
-
-        return this._loadHasOneReflection(
-          {
-            reflectionName: relationshipName,
-            model: this,
-            modelClass
-          },
-          {ransack}
-        )
-      }
-    }
-  }
-}

package/src/models-response-reader.js

@@ -1,48 +0,0 @@
-import * as inflection from "inflection"
-import modelClassRequire from "./model-class-require"
-import Preloaded from "./preloaded"
-
-export default class ModelsResponseReader {
-  static first (response) {
-    return ModelsResponseReader.collection(response)[0]
-  }
-
-  static collection (response) {
-    const reader = new ModelsResponseReader({response})
-    return reader.models()
-  }
-
-  constructor (args) {
-    this.collection = args.collection
-    this.response = args.response
-  }
-
-  models () {
-    const preloaded = new Preloaded(this.response)
-    const models = []
-
-    for (const modelType in this.response.data) {
-      const modelClassName = inflection.classify(modelType)
-      const ModelClass = modelClassRequire(modelClassName)
-      const collectionName = ModelClass.modelClassData().collectionName
-
-      for (const modelId of this.response.data[modelType]) {
-        const modelData = this.response.preloaded[collectionName][modelId]
-
-        if (!modelData)
-          throw new Error(`Couldn't find model data for ${collectionName}(${modelId})`)
-
-        const model = new ModelClass({
-          collection: this.collection,
-          data: modelData,
-          isNewRecord: false
-        })
-
-        model._readPreloadedRelationships(preloaded)
-        models.push(model)
-      }
-    }
-
-    return models
-  }
-}

package/src/models.js

@@ -1,7 +0,0 @@
-import modelRecipes from "model-recipes.json"
-import ModelRecipesLoader from "./model-recipes-loader"
-
-const loader = new ModelRecipesLoader({recipes: modelRecipes})
-const result = loader.load()
-
-export default result

package/src/models.js.erb

@@ -1,19 +0,0 @@
-/* rails-erb-loader-dependencies api_maker/resources/ models/ */
-
-import {digg} from "diggerize"
-import ModelRecipesLoader from "@kaspernj/api-maker/build/model-recipes-loader"
-import modelRecipes from "./model-recipes.json"
-
-const loader = new ModelRecipesLoader({recipes: modelRecipes})
-const result = loader.load()
-
-<% model_class_names = [] %>
-<% ApiMaker::ModelClassesJavaScriptGeneratorService.new.resources.each do |resource| %>
-  <% model_class_names << resource.short_name %>
-
-  const <%= resource.short_name %>ModelClass = digg(result, "<%= resource.short_name %>")
-
-  class <%= resource.short_name %> extends <%= resource.short_name %>ModelClass {}
-<% end %>
-
-export {<%= model_class_names.join(", ") %>}

package/src/money-formatter.js

@@ -1,100 +0,0 @@
-import I18nOnSteroids from "i18n-on-steroids"
-import Money from "js-money"
-import formatNumber from "format-number"
-import replaceall from "replaceall"
-
-export default class MoneyFormatter {
-  static fromMoney (money, args = {}) {
-    return new MoneyFormatter(money, args)
-  }
-
-  static format (money, args = {}) {
-    return MoneyFormatter.fromMoney(money, args).toString()
-  }
-
-  static stringToFloat (moneyString) {
-    let unformatted = replaceall(I18nOnSteroids.getCurrent().t("number.currency.format.delimiter"), "", moneyString)
-
-    unformatted = replaceall(I18nOnSteroids.getCurrent().t("number.currency.format.separator"), ".", unformatted)
-    const float = parseFloat(unformatted)
-
-    return float
-  }
-
-  static amountFromMoney (money) {
-    if ("amount" in money) {
-      return parseFloat(money.amount)
-    } else if ("fractional" in money) {
-      return parseFloat(money.fractional)
-    }
-
-    throw new Error(`Couldn't figure out amount from: ${JSON.stringify(money, null, 2)}`)
-  }
-
-  static currencyFromMoney (money) {
-    let currencyString
-
-    if (typeof money.currency == "string") {
-      currencyString = money.currency
-    } else if (typeof money.currency.id == "string") {
-      currencyString = money.currency.id
-    } else if (typeof money.currency.iso_code == "string") {
-      currencyString = money.currency.iso_code
-    } else if (typeof money.currency.code == "string") {
-      currencyString = money.currency.code
-    } else {
-      throw new Error(`Couldn't figure out currency from: ${JSON.stringify(money, null, 2)}`)
-    }
-
-    const moneyCurrency = Money[currencyString.toUpperCase()]
-
-    if (!moneyCurrency) {
-      throw new Error(`Could not find currency ${JSON.stringify(money, null, 2)}`)
-    }
-
-    return moneyCurrency
-  }
-
-  static isMoney(value) {
-    if (value instanceof Money) return true
-
-    if (typeof value == "object" && value && Object.keys(value).length == 2 && "amount" in value && "currency" in value)
-      return true
-
-    return false
-  }
-
-  constructor (money, args = {}) {
-    this.args = args
-    this.money = money
-    this.amount = MoneyFormatter.amountFromMoney(money)
-    this.currency = MoneyFormatter.currencyFromMoney(money)
-  }
-
-  toString () {
-    const amount = (this.amount / 100).toFixed(this.decimalDigits())
-    const formatOptions = {
-      prefix: this.prefix(),
-      decimal: I18nOnSteroids.getCurrent().t("number.currency.format.separator"),
-      integerSeparator: I18nOnSteroids.getCurrent().t("number.currency.format.delimiter")
-    }
-
-    return formatNumber(formatOptions)(amount)
-  }
-
-  decimalDigits () {
-    if (this.args.decimals !== null) {
-      return this.args.decimals
-    }
-
-    return this.currency.decimal_digits
-  }
-
-  prefix () {
-    if (this.args.excludeCurrency) {
-      return ""
-    }
-
-    return `${this.currency.code} `
-  }
-}

package/src/not-loaded-error.js

@@ -1 +0,0 @@
-export default class NotLoadedError extends Error {}