api_maker 0.0.1

data/lib/api_maker/javascript/models-response-reader.js

@@ -0,0 +1,43 @@
+import Included from "./included"
+
+const inflection = require("inflection")
+
+export default class ModelsResponseReader {
+  static first(response) {
+    return ModelsResponseReader.collection(response)[0]
+  }
+
+  static collection(response) {
+    var reader = new ModelsResponseReader({response: response})
+    return reader.models()
+  }
+
+  constructor(args) {
+    this.response = args.response
+  }
+
+  models() {
+    var included = new Included(this.response)
+    var models = []
+
+    for(var modelType in this.response.data) {
+      var modelClassName = inflection.singularize(modelType)
+      var modelClass = require(`api-maker/models/${modelClassName}`).default
+      var collectionName = inflection.dasherize(modelClass.modelClassData().collectionName)
+
+      for(var modelId of this.response.data[modelType]) {
+        var modelData = this.response.included[collectionName][modelId]
+
+        if (!modelData)
+          throw new Error(`Couldn't find model data for ${collectionName}(${modelId})`)
+
+        var model = new modelClass({data: modelData, isNewRecord: false, response: this.response})
+
+        model._readIncludedRelationships(included)
+        models.push(model)
+      }
+    }
+
+    return models
+  }
+}

data/lib/api_maker/javascript/paginate.jsx

@@ -0,0 +1,128 @@
+import { Link } from "react-router-dom"
+import qs from "qs"
+import React from "react"
+
+export default class extends React.Component {
+  isPageActiveClass(pageNumber) {
+    if (this.props.result.currentPage() == pageNumber)
+      return "active"
+  }
+
+  pages() {
+    var currentPage = this.props.result.currentPage()
+    var pages = []
+    var totalPages = this.props.result.totalPages()
+    var pagesFrom = currentPage - 5
+    var pagesTo = currentPage + 5
+
+    if (pagesFrom < 1)
+      pagesFrom = 1
+
+    if (pagesTo > totalPages)
+      pagesTo = totalPages
+
+    for(var i = pagesFrom; i <= pagesTo; i++) {
+      pages.push(i)
+    }
+
+    return pages
+  }
+
+  pagePath(pageNumber) {
+    var pageKey = this.props.result.data.collection.queryArgs.pageKey
+    if (!pageKey)
+      pageKey = "page"
+
+    var currentParams = qs.parse(window.location.search.substr(1))
+    currentParams[pageKey] = pageNumber
+    var newParams = qs.stringify(currentParams)
+    var newPath = `${location.pathname}?${newParams}`
+
+    return newPath
+  }
+
+  previousPagePath() {
+    var previousPage
+
+    if (this.props.result.currentPage() > 1) {
+      previousPage = this.props.result.currentPage() - 1
+    } else {
+      previousPage = this.props.result.currentPage()
+    }
+
+    return this.pagePath(previousPage)
+  }
+
+  nextPagePath() {
+    var nextPage
+
+    if (this.props.result.currentPage() < this.props.result.totalPages()) {
+      nextPage = this.props.result.currentPage() + 1
+    } else {
+      nextPage = this.props.result.currentPage()
+    }
+
+    return this.pagePath(nextPage)
+  }
+
+  showBackwardsDots() {
+    var currentPage = this.props.result.currentPage()
+
+    return (currentPage - 5 > 1)
+  }
+
+  showForwardsDots() {
+    var currentPage = this.props.result.currentPage()
+    var totalPages = this.props.result.totalPages()
+
+    return (currentPage + 5 < totalPages)
+  }
+
+  render() {
+    return (
+      <ul className="pagination">
+        <li className={`page-item ${this.props.result.currentPage() <= 1 ? "disabled" : ""}`} key="page-first">
+          <Link className="page-link" to={this.pagePath(1)}>
+            ⇤
+          </Link>
+        </li>
+        <li className={`page-item ${this.props.result.currentPage() <= 1 ? "disabled" : ""}`} key="page-previous">
+          <Link className="page-link" to={this.previousPagePath()}>
+            ←
+          </Link>
+        </li>
+        {this.showBackwardsDots() &&
+          <li className="page-item">
+            <a className="page-link disabled" href="#">
+              &hellip;
+            </a>
+          </li>
+        }
+        {this.pages().map(page =>
+          <li className={`page-item ${this.isPageActiveClass(page)}`} key={`page-${page}`}>
+            <Link className="page-link" to={this.pagePath(page)}>
+              {page}
+            </Link>
+          </li>
+        )}
+        {this.showForwardsDots() &&
+          <li className="page-item">
+            <a className="page-link disabled" href="#">
+              &hellip;
+            </a>
+          </li>
+        }
+        <li className={`page-item ${this.props.result.currentPage() >= this.props.result.totalPages() ? "disabled" : ""}`} key="page-next">
+          <Link className="page-link" to={this.nextPagePath()}>
+            →
+          </Link>
+        </li>
+        <li className={`page-item ${this.props.result.currentPage() >= this.props.result.totalPages() ? "disabled" : ""}`} key="page-last">
+          <Link className="page-link" to={this.pagePath(this.props.result.totalPages())}>
+            ⇥
+          </Link>
+        </li>
+      </ul>
+    )
+  }
+}

data/lib/api_maker/javascript/params.js

@@ -0,0 +1,68 @@
+import formSerialize from "form-serialize"
+import KeyValueStore from "api-maker/key-value-store"
+import merge from "merge"
+import qs from "qs"
+
+export default class Params {
+  static parse() {
+    return qs.parse(window.location.search.substr(1))
+  }
+
+  static change(given) {
+    return merge.recursive(true, Params.parse(), given)
+  }
+
+  static changeParams(given) {
+    var params = Params.change(given)
+    var newParams = qs.stringify(params)
+    var newPath = `${location.pathname}?${newParams}`
+
+    AppHistory.push(newPath)
+  }
+
+  static async getCachedParams(paramName, args = {}) {
+    var oldQuery = await KeyValueStore.get(paramName)
+    var params = Params.parse()
+
+    if (params && paramName in params) {
+      return params[paramName]
+    } else if (oldQuery) {
+      return oldQuery
+    } else {
+      return args.default || {}
+    }
+  }
+
+  static async setCachedParams(paramName, qParams) {
+    return await KeyValueStore.set(paramName, qParams)
+  }
+
+  static serializeForm(form) {
+    var hash = formSerialize(form, {empty: true, hash: true})
+    return Params.setUndefined(hash)
+  }
+
+  // This is used to set all empty values to 'undefined' which makes qs removed those elements from the query string
+  static setUndefined(given) {
+    if (Array.isArray(given)) {
+      if (given.length == 0)
+        return undefined
+
+      return given.map(givenI => Params.setUndefined(givenI))
+    } else if (typeof given === "object") {
+      if (Object.keys(given).length == 0)
+        return undefined
+
+      var newGiven = {}
+      for(var key in given) {
+        newGiven[key] = Params.setUndefined(given[key])
+      }
+
+      return newGiven
+    } else if (given === "") {
+      return undefined
+    } else {
+      return given
+    }
+  }
+}

data/lib/api_maker/javascript/resource-route.jsx

@@ -0,0 +1,75 @@
+const inflection = require("inflection")
+
+export default class ResourceRoute {
+  constructor(args) {
+    this.args = args.args
+    this.parsedContext = args.parsedContext
+    this.route = args.route
+  }
+
+  routes() {
+    if (this.args.locales) {
+      return this.withLocale()
+    } else {
+      return this.withoutLocale()
+    }
+  }
+
+  findRouteParams(route) {
+    var result = []
+    var parts = route.path.split("/")
+
+    for(var part of parts) {
+      if (part.match(/^:([a-z_]+)$/))
+        result.push(part)
+    }
+
+    return result
+  }
+
+  requireComponent() {
+    var requireResult = this.parsedContext[`components/${this.route.component}.jsx`]
+
+    if (!requireResult)
+      var requireResult = this.parsedContext[`components/${this.route.component}/index.jsx`]
+
+    if (!requireResult)
+      throw new Error(`No such require: ${this.route.component}`)
+
+    return requireResult.default
+  }
+
+  withLocale() {
+    var component = this.requireComponent()
+    var Locales = require("shared/locales").default
+    var Path = require("shared/path").default
+    var routes = []
+
+    for(var locale of Locales.availableLocales()) {
+      var path = Path.localized(inflection.camelize(this.route.name, true), this.findRouteParams(this.route), {locale: locale})
+
+      routes.push({
+        path: path,
+        component: component
+      })
+    }
+
+    return routes
+  }
+
+  withoutLocale() {
+    var routePathName = inflection.camelize(this.route.name, true)
+    var routePathMethod = Routes[`${routePathName}Path`]
+
+    if (!routePathMethod)
+      throw new Error(`No such route could be found: ${routePathName}`)
+
+    var path = routePathMethod.apply(null, this.findRouteParams(this.route))
+    var component = this.requireComponent()
+
+    return [{
+      path: path,
+      component: component
+    }]
+  }
+}

data/lib/api_maker/javascript/resource-routes.jsx

@@ -0,0 +1,36 @@
+import React from "react" // This fixes an issue with the Baristo project where it needed it to be loaded
+import ResourceRoute from "./resource-route"
+import { Route } from "react-router-dom"
+
+export default class ApiMakerResourceRoutes {
+  static readRoutes(args = {}) {
+    if (!args.routes)
+      throw new Error("Please pass 'routes' to this method")
+
+    var parsedContext = ApiMakerResourceRoutes.parseContext(args)
+    var routesJson = args.routes
+    var routes = []
+
+    for(var route of routesJson.routes) {
+      var resourceRoute = new ResourceRoute({args, parsedContext, route})
+
+      for(var newRoute of resourceRoute.routes()) {
+        routes.push(
+          <Route exact key={`route-${newRoute.path}`} path={newRoute.path} component={newRoute.component} />
+        )
+      }
+    }
+
+    return routes
+  }
+
+  static parseContext(args) {
+    var result = {}
+    args.context.keys().forEach(key => {
+      var newKey = `${args.path}/${key.substring(2, key.length)}`
+      result[newKey] = args.context(key)
+    })
+
+    return result
+  }
+}

data/lib/api_maker/javascript/result.js

@@ -0,0 +1,25 @@
+export default class Result {
+  constructor(data) {
+    this.data = data
+  }
+
+  currentPage() {
+    return this.data.response.meta.currentPage
+  }
+
+  models() {
+    return this.data.models
+  }
+
+  modelClass() {
+    return this.data.collection.modelClass()
+  }
+
+  totalCount() {
+    return this.data.response.meta.totalCount
+  }
+
+  totalPages() {
+    return this.data.response.meta.totalPages
+  }
+}

data/lib/api_maker/javascript/session-status-updater.js

@@ -0,0 +1,113 @@
+import Devise from "./devise"
+
+var inflection = require("inflection")
+var wakeEvent = require("wake-event")
+
+export default class ApiMakerSessionStatusUpdater {
+  static current() {
+    if (!window.apiMakerSessionStatusUpdater)
+      window.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater()
+
+    return window.apiMakerSessionStatusUpdater
+  }
+
+  constructor(args = {}) {
+    this.debugging = args.debug || false
+    this.events = {}
+    this.timeout = args.timeout || 600000
+
+    this.connectOnlineEvent()
+    this.connectWakeEvent()
+  }
+
+  connectOnlineEvent() {
+    window.addEventListener("online", () => { this.updateSessionStatus() }, false)
+  }
+
+  connectWakeEvent() {
+    wakeEvent(() => { this.updateSessionStatus() })
+  }
+
+  debug(message) {
+    if (this.debugging)
+      console.log(`ApiMakerSessionStatusUpdater: ${message}`)
+  }
+
+  sessionStatus() {
+    return new Promise(resolve => {
+      var xhr = new XMLHttpRequest()
+      xhr.open("POST", "/api_maker/session_statuses", true)
+      xhr.onload = () => {
+        var response = JSON.parse(xhr.responseText)
+        resolve(response)
+      }
+      xhr.send()
+    })
+  }
+
+  onSignedOut(callback) {
+    this.addEvent("onSignedOut", callback)
+  }
+
+  startTimeout() {
+    this.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() {
+    this.debug("updateSessionStatus")
+
+    this.sessionStatus().then(result => {
+      this.debug(`Result: ${JSON.stringify(result, null, 2)}`)
+      this.updateMetaElementsFromResult(result)
+      this.updateUserSessionsFromResult(result)
+    })
+  }
+
+  updateMetaElementsFromResult(result) {
+    this.debug("updateMetaElementsFromResult")
+    var csrfTokenElement = document.querySelector("meta[name='csrf-token']")
+
+    if (csrfTokenElement) {
+      this.debug(`Changing token from "${csrfTokenElement.getAttribute("content")}" to "${result.csrf_token}"`)
+      csrfTokenElement.setAttribute("content", result.csrf_token)
+    } else {
+      this.debug("csrf token element couldn't be found")
+    }
+  }
+
+  updateUserSessionsFromResult(result) {
+    for(var scopeName in result.scopes) {
+      this.updateUserSessionScopeFromResult(scopeName, result.scopes[scopeName])
+    }
+  }
+
+  updateUserSessionScopeFromResult(scopeName, scope) {
+    var deviseMethodName = `current${inflection.camelize(scopeName)}`
+    var deviseIsSignedInMethodName = `is${inflection.camelize(scopeName)}SignedIn`
+    var currentlySignedIn = Devise[deviseIsSignedInMethodName]()
+    var signedInOnBackend = scope.signed_in
+
+    if (currentlySignedIn && !signedInOnBackend) {
+      this.debug(`${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)
+
+      Devise.setSignedOut({scope: scopeName})
+      Devise.callSignOutEvent({scope: scopeName})
+    }
+  }
+}