Refined arch

.meteor/packages

@@ -20,8 +20,8 @@ shell-server@0.5.0            # Server-side component of the `meteor shell` comm
 # Basic tools
 leaonline:errors
 leaonline:utils
-leaonline:interfaces
 leaonline:corelib
+leaonline:service-registry
 
 # collections
 aldeed:collection2

.meteor/versions

@@ -58,10 +58,10 @@ leaonline:corelib@1.0.0
 leaonline:ddp-login@1.0.4
 leaonline:errors@1.0.0
 leaonline:files-collection-factory@1.0.0
-leaonline:interfaces@1.0.0
 leaonline:method-factory@1.0.0
 leaonline:oauth-lea@1.0.2
 leaonline:ratelimit-factory@1.0.0
+leaonline:service-registry@1.0.0
 leaonline:utils@1.0.0
 livedata@1.0.18
 localstorage@1.2.0

client/main.js

@@ -5,6 +5,7 @@ import '../imports/startup/client/language'
 
 // startup routines
 import '../imports/startup/client/routes'
+import '../imports/startup/client/reloadRoute'
 import '../imports/startup/client/apps'
 import '../imports/startup/client/fontawesome'
 import '../imports/startup/client/bootstrap'

imports/api/apps/Apps.js

@@ -1,11 +1,6 @@
-/* global localStorage */
-import { Meteor } from 'meteor/meteor'
-import { Tracker } from 'meteor/tracker'
-import { DDP } from 'meteor/ddp-client'
-import { ReactiveDict } from 'meteor/reactive-dict'
-import { i18n } from '../i18n/I18n'
-import { BackendConfig } from '../config/BackendConfig'
 import { onServer } from '../../utils/arch'
+import { getConfigTypeOptions } from '../config/getConfigTypeOptions'
+import { getFormTypeOptions } from '../../ui/forms/getFormTypeOptions'
 
 export const Apps = {
   name: 'apps',
@@ -14,180 +9,87 @@ export const Apps = {
   debug: false
 }
 
-const _apps = new ReactiveDict()
-const _connections = {}
-const _trackers = {}
+// Note, that the schema is normalized to map one context to one document.
+// Registering an app may result in multiple context documents at once.
 
-function connect (name, url) {
-  if (!_connections[name]) {
-    _connections[name] = DDP.connect(url)
-  }
-  return _connections[name]
-}
-
-function updateStatus (name, status) {
-  const app = _apps.get(name)
-  if (!app) {
-    throw new Error(`[Apps] expected app by name ${name}`)
-  }
-  app.status = status
-  _apps.set(name, app)
-}
-
-function updateLogin (name, userId) {
-  const app = _apps.get(name)
-  app.login = { successful: !!userId }
-  _apps.set(name, app)
-}
-
-function updateConfig (name, config) {
-  const app = _apps.get(name)
-  app.config = config
-  _apps.set(name, app)
-}
-
-function log (...args) {
-  if (Apps.debug && Meteor.isDevelopment) {
-    console.info('[Apps]', ...args)
-  }
-}
-
-function track (name, connection, ddpLogin) {
-  const url = connection._stream.rawUrl
-  _trackers[name] = Tracker.autorun(() => {
-    // skip this computation if there is
-    // currently no logged in backend user
-    if (Meteor.status().connected && !Meteor.user() && !Meteor.userId()) {
-      // clear localStorage entries from previous
-      // login results to avoid follow-up 403 errors
-      localStorage.removeItem(`${url}/lea/userId`)
-      localStorage.removeItem(`${url}/lea/loginToken`)
-      localStorage.removeItem(`${url}/lea/loginTokenExpires`)
-      // logout connection if still connected
-      if (connection.userId()) {
-        connection.call('logout')
-      }
-      return
+Apps.schema = {
+  // name of the app that registered to the backend
+  name: {
+    type: String,
+    autoform: {
+      disabled: true
     }
+  },
 
-    // always update status to
-    // trigger reactive Template updates
-    const status = connection.status()
-    updateStatus(name, status)
-
-    // also skip if we are not yet connected
-    if (!status.connected) {
-      log(url, 'not yet connected -> skip')
-      return
+  // name of the context that has been registered
+  context: {
+    type: String,
+    autoform: {
+      disabled: true
     }
-
-    // skip if we have not explcitly enabled the DDP login
-    if (!ddpLogin) {
-      return
+  },
+
+  // edit log / history flag
+  useHistory: {
+    type: Boolean,
+    defaultValue: true
+  },
+
+  // comments flag
+  useComments: {
+    type: Boolean,
+    defaultValue: true
+  },
+
+  // flag if we want to track links to this context
+  useDependencyTracking: {
+    type: Boolean,
+    defaultValue: true
+  },
+
+  // which template to use as main template for overview
+  template: {
+    type: String,
+    autoform: {
+      options: getConfigTypeOptions
     }
+  },
 
-    // update userId and skip,
-    // if we are already logged-in
-    const userId = connection.userId()
-    const loggingIn = connection._loggingIn
-    updateLogin(name, userId)
-    if (userId || loggingIn) return
-
-    log(url, 'get credentials')
-    connection._loggingIn = true
-    Apps.methods.getServiceCredentials.call((err, credentials) => {
-      if (err || !credentials) {
-        connection._loggingIn = false
-        console.error(err)
-        log(url, 'no credentials received, skip login')
-        return
-      }
-      log(url, 'init login')
-      const options = { accessToken: credentials.accessToken, debug: Apps.debug }
-      DDP.loginWithLea(connection, options, (err, res) => {
-        connection._loggingIn = false
-        if (err) {
-          return console.error(err)
-        } else {
-          log(url, 'logged in with token', !!res)
-          configure(name)
-        }
-      })
-    })
-  })
-}
+  // define fields-specific settings
+  fields: Array,
+  'fields.$': Object,
 
-const configure = function (name) {
-  const app = Apps.get(name)
-  const { url } = app
-  const { connection } = app
-  const lang = i18n.getLocale()
-
-  connection.call(BackendConfig.methods.get.name, { lang }, (err, config) => {
-    log(url, 'backend config received', config)
-    if (err) return console.error(err)
-    if (config) {
-      BackendConfig.parse(config)
-      BackendConfig.parent(name, config)
-      i18n.add(lang, config.lang)
-      updateConfig(name, config)
-      BackendConfig.children(name, config)
-      hostLoaded(name, null, true)
+  // field name / key (not label)
+  'fields.$.name': {
+    type: String,
+    autoform: {
+      disabled: true
     }
-  })
-}
+  },
 
-const callbacks = new Map()
+  // may it appear in lists
+  'fields.$.inList': Boolean,
 
-Apps.onHostLoaded = function (name, cb) {
-  const hostCbs = callbacks.get(name) || []
-  hostCbs.push(cb)
-  callbacks.set(name, hostCbs)
-}
+  // may it appear in summaries and previews
+  'fields.$.inSummary': Boolean,
 
-function hostLoaded (name, err, res) {
-  const loadedCbs = callbacks.get(name)
-  if (!loadedCbs || loadedCbs.length === 0) {
-    return
-  }
+  'fields.$.inForm': Boolean,
 
-  loadedCbs.forEach(cb => {
-    setTimeout(() => cb(err, res), 0)
-  })
-
-  loadedCbs.length = 0
-}
-
-Apps.register = function ({ name, label, url, icon, ddpConnect, ddpLogin }) {
-  const app = _apps.set(name, { name, label, url, icon, ddpConnect, ddpLogin })
-  if (ddpConnect) {
-    const connection = connect(name, url)
-    track(name, connection, ddpLogin)
-  }
-  return app
-}
-
-Apps.get = function (name) {
-  const app = _apps.get(name)
-  const connection = _connections[name]
-  return Object.assign({}, app, { connection })
-}
-
-Apps.connection = function (name) {
-  return _connections[name]
-}
-
-Apps.all = function () {
-  const all = _apps.all()
-  return all && Object.values(all)
+  // is there a specific autoform formType to use
+  'fields.$.form': {
+    type: String,
+    optional: true,
+    autoform: {
+      options: getFormTypeOptions
+    }
+  },
 }
 
 Apps.methods = {}
 
 Apps.methods.getServiceCredentials = {
   name: 'apps.methods.getServiceCredentials',
   schema: {},
-  isPublic: true, // fixme,
   numRequests: 5,
   timeInterval: 500,
   run: onServer(function () {
@@ -198,3 +100,33 @@ Apps.methods.getServiceCredentials = {
     Meteor.call(Apps.methods.getServiceCredentials.name, cb)
   }
 }
+
+Apps.methods.updateSettings = {
+  name: 'apps.methods.updateSettings',
+  schema: Apps.schema,
+  numRequests: 1,
+  timeInterval: 1000,
+  run: onServer(function (settingsDoc) {
+    const existingDocId = Apps.collection().findOne({ name: settingsDoc.name, context: settingsDoc.context })
+    if (existingDocId) {
+      return Apps.collection().update(existingDocId, { $set: settingsDoc })
+    } else {
+      return Apps.collection().insert(settingsDoc)
+    }
+  })
+}
+
+Apps.publications = {}
+
+Apps.publications.getByNames = {
+  name: 'apps.publications.getByNames',
+  schema: {
+    names: Array,
+    'names.$': String
+  },
+  numRequests: 5,
+  timeInterval: 500,
+  run: onServer(function ({ names = [] }) {
+    return Apps.collection().find({ name: { $in: names } })
+  }),
+}