@kalisio/kdk 2.4.0 → 2.5.1

package/core/api/services/index.js

@@ -2,6 +2,8 @@ import _ from 'lodash'
 import path from 'path'
 import makeDebug from 'debug'
 import { fileURLToPath } from 'url'
+import mongodb from 'mongodb'
+const { ObjectID } = mongodb
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const modelsPath = path.join(__dirname, '..', 'models')
@@ -9,17 +11,40 @@ const servicesPath = path.join(__dirname, '..', 'services')
 
 const debug = makeDebug('kdk:core:services')
 
-export function createTagService (options = {}) {
+export function getServiceNameAndContext (servicePath) {
   const app = this
-  return app.createService('tags', Object.assign({
-    servicesPath,
-    modelsPath
-  }, options))
+  // Get name from service path without api prefix
+  let name = servicePath.replace(app.get('apiPath').substring(1) + '/', '')
+  // Then without context if any
+  const lastSlash = name.lastIndexOf('/')
+  const contextId = (lastSlash >= 0 ? name.substring(0, lastSlash) : '')
+  if (contextId && ObjectID.isValid(contextId)) {
+    name = name.replace(contextId + '/', '')
+    return { name, contextId }
+  } else {
+    return { name }
+  }
 }
 
-export function removeTagService (options = {}) {
+export function decorateDistributedService (service) {
   const app = this
-  return app.removeService(app.getService('tags', options.context))
+  // Remote service are registered according to their path, ie with API prefix (but without trailing /)
+  const remoteService = app.service(service.path)
+  const { name, contextId } = getServiceNameAndContext.call(app, service.path)
+  remoteService.name = name
+  remoteService.context = contextId
+  // As remote services have no context, from the internal point of view path = name
+  // Unfortunately this property is already set and used by feathers-distributed and should not be altered
+  // remoteService.path = name
+  remoteService.app = app
+  remoteService.getPath = function (withApiPrefix) {
+    const path = (contextId ? contextId + '/' + name : name)
+    return (withApiPrefix ? app.get('apiPath') + '/' + path : path)
+  }
+  remoteService.getContextId = function () {
+    return contextId
+  }
+  return remoteService
 }
 
 export function createStorageService (options = {}) {
@@ -64,48 +89,17 @@ export function removeDatabasesService (options = {}) {
   return app.removeService(app.getService('databases', options.context))
 }
 
-export async function createOrganisationService (options = {}) {
-  const app = this
-
-  // Create services to manage MongoDB databases, organisations, etc.
-  await createDatabasesService.call(app)
-  const orgsService = await app.createService('organisations', { modelsPath, servicesPath })
-
-  // Replication management
-  const usersService = app.getService('users')
-  const authorisationsService = app.getService('authorisations')
-  // Ensure permissions are correctly distributed when replicated
-  usersService.on('patched', user => {
-    // Patching profile should not trigger abilities update since
-    // it is a perspective and permissions are not available in this case
-    // Updating abilities in this case will result in loosing permissions for orgs/groups as none are available
-    if (_.has(user, 'organisations') || _.has(user, 'groups')) authorisationsService.updateAbilities(user)
-  })
-  // Ensure org services are correctly distributed when replicated
-  orgsService.on('created', organisation => {
-    // Check if already done (initiator)
-    const orgMembersService = app.getService('members', organisation)
-    if (!orgMembersService) {
-      // Jump from infos/stats to real DB object
-      const db = app.db.client.db(organisation._id.toString())
-      orgsService.createOrganisationServices(organisation, db)
-    }
-  })
-  orgsService.on('removed', organisation => {
-    // Check if already done (initiator)
-    const orgMembersService = app.getService('members', organisation)
-    if (!orgMembersService) return
-    orgsService.removeOrganisationServices(organisation)
-  })
-  return orgsService
-}
-
 export default async function () {
   const app = this
 
   const authConfig = app.get('authentication')
   if (authConfig) {
-    await app.createService('users', { modelsPath, servicesPath })
+    await app.createService('users', {
+      modelsPath,
+      servicesPath,
+      methods: ['create', 'get', 'find', 'update', 'patch', 'remove', 'logout'],
+      events: ['logout']
+    })
     debug('\'users\' service created')
     await app.createService('account', {
       servicesPath,
@@ -137,12 +131,6 @@ export default async function () {
     debug('\'messages\' service created')
   }
 
-  const orgConfig = app.get('organisations')
-  if (orgConfig) {
-    await createOrganisationService.call(app)
-    debug('\'organisations\' service created')
-  }
-
   const mailerConfig = app.get('mailer')
   if (mailerConfig) {
     await app.createService('mailer', { servicesPath })

package/core/api/services/messages/messages.hooks.js

@@ -1,13 +1,14 @@
-import fuzzySearch from 'feathers-mongodb-fuzzy-search'
 import commonHooks from 'feathers-hooks-common'
-import { diacriticSearch } from '../../hooks/index.js'
+import fuzzySearch from 'feathers-mongodb-fuzzy-search'
+import { diacriticSearch, marshallComparisonQuery } from '../../hooks/index.js'
 
 export default {
   before: {
     all: [],
     find: [
       fuzzySearch({ fields: ['title', 'body', 'author'] }),
-      diacriticSearch()
+      diacriticSearch(),
+      marshallComparisonQuery
     ],
     get: [],
     create: [commonHooks.setNow('createdAt')],

package/core/api/services/users/users.service.js

@@ -0,0 +1,5 @@
+export default {
+	logout (user) {
+		this.emit('logout', user)
+	}
+}

package/core/client/api.js

@@ -6,21 +6,42 @@ import jwtdecode from 'jwt-decode'
 import feathers from '@feathersjs/client'
 import { io } from 'socket.io-client'
 import reactive from 'feathers-reactive/dist/feathers-reactive.js'
+import createOfflineService from '@kalisio/feathers-localforage'
 import configuration from 'config'
 import { permissions } from '../common/index.js'
 import { Store } from './store.js'
+import { LocalCache } from './local-cache.js'
 import { Events } from './events.js'
+import * as hooks from './hooks/index.js'
+import { makeServiceSnapshot } from '../common/utils.js'
 
-// Setup log level
-if (_.get(configuration, 'logs.level')) {
-  logger.setLevel(_.get(configuration, 'logs.level'), false)
-} else {
-  logger.setLevel('info')
-}
+// Disable default feathers behavior of re-authenticating on disconnect
+feathers.authentication.AuthenticationClient.prototype.handleSocket = () => {}
 
-export function createClient (config) {
+export async function createClient (config) {
+  // Setup log level
+  if (_.get(configuration, 'logs.level')) {
+    logger.setLevel(_.get(configuration, 'logs.level'), false)
+  } else {
+    logger.setLevel('info')
+  }
   // Initiate the client
   const api = feathers()
+  // Initialize connection state/listeners
+  api.isDisconnected = !navigator.onLine
+  addEventListener('online', () => {
+    api.isDisconnected = false
+    Events.emit('navigator-reconnected', api)
+  })
+  addEventListener('offline', () => {
+    api.isDisconnected = true
+    Events.emit('navigator-disconnected', api)
+  })
+  // This can force to use offline services it they exist even if connected
+  api.useLocalFirst = config.useLocalFirst
+  api.setLocalFirstEnabled = function (enabled) {
+    api.useLocalFirst = enabled
+  }
 
   // Matchers that can be added to customize route guards
   let matchers = []
@@ -55,87 +76,148 @@ export function createClient (config) {
   api.matcher = siftMatcher
 
   // This avoid managing the API path before each service name
-  // If a context is not given it will be retrieved from the store if any and used for contextual services
   api.getServicePath = function (name, context, withApiPrefix = true) {
-    const options = _.get(api.serviceOptions, name, {})
-    let path
-    // For non-contextual services path is always the name
-    if (!options.context) {
-      path = name
-    } else {
+    // Defaults to global service path on "nil" context
+    let path = name
+    if (!_.isEmpty(context)) {
       // Context is given as string ID or object ?
       if (typeof context === 'string') {
-        if (context) path = context + '/' + name
-        // Force global context on empty string
-        else path = name
-      } else if (typeof context === 'object') {
-        if (context && context._id) path = context._id + '/' + name
-        // Force global context on empty object
-        else path = name
-      } else {
-        // Otherwise test for current context as service is registered as contextual
-        const context = Store.get('context')
-        if (context) {
-          path = api.getServicePath(name, context, false)
-        } else {
-          // Because it could also be registered as global with the same name fallback
-          path = name
-        }
+        // 'global' keyword is to get the global service
+        if (context !== 'global') path = context + '/' + name
+      } else if (context._id) {
+        path = context._id + '/' + name
       }
     }
-
     if (withApiPrefix) {
       path = config.apiPath + '/' + path
     }
+    // Take care that feathers strip slashes
+    if (path.startsWith('/')) path = path.substr(1)
     return path
   }
-  api.getService = function (name, context) {
-    const path = api.getServicePath(name, context)
-    const service = api.service(path)
-    if (!service) {
-      throw new Error('Cannot retrieve service ' + name + ' for context ' + (typeof context === 'object' ? context._id : context))
+  // If no context is given the current from the store will be retrieved (if any)
+  // and the associated contextual service returned (if any)
+  api.getServiceInstance = function (name, context, options = {}) {
+    // Depending on the create option we don't directly use service() here
+    // as it will automatically create a new service wrapper even if it does not exist
+    let service
+    // If a context is given use it
+    if (!_.isEmpty(context)) {
+      const servicePath = api.getServicePath(name, context)
+      service = (options.create ? api.service(servicePath) : api.services[servicePath])
+    } else { // Otherwise check for a potential current context to be used
+      const currentContext = Store.get('context')
+      const contextualPath = api.getServicePath(name, currentContext)
+      const contextualService = api.services[contextualPath]
+      const globalPath = api.getServicePath(name)
+      const globalService = api.services[globalPath]
+      // If one of the service do exist use it, contextual one first
+      service = contextualService || globalService
+      // Otherwise as a fallback create a new global service as we don't really know if context should apply,
+      // if so the app should declare it upfront
+      if (!service && options.create) {
+        service = api.service(globalPath)
+      }
     }
-    // Store the path on first call
-    if (!service.path) service.path = path
     return service
   }
-  // Used to register an existing backend service with its options
-  api.declareService = function (name, options = {}) {
-    if (!_.has(api.serviceOptions, name)) _.set(api.serviceOptions, name, options)
+  // Check if an online, ie "standard", version of a service is available
+  api.getOnlineService = function (name, context, options = {}) {
+    return api.getServiceInstance(name, context, Object.assign({ create: true }, options))
   }
-  api.getServiceOptions = function (name) {
-    return _.get(api.serviceOptions, name)
+  // Check if an offline version of a service is available
+  api.getOfflineService = function (name, context, options = {}) {
+    return api.getServiceInstance(`${name}-offline`, context, Object.assign({ create: false }, options))
+  }
+  api.getService = function (name, context, options = {}) {
+    let service
+    // When offline try to use offline service version if any
+    if (api.isDisconnected || api.useLocalFirst) {
+      service = api.getOfflineService(name, context, options)
+      // In local first mode we allow to use remote service if offline one doesn't exist
+      if (!service && !api.useLocalFirst) {
+        // Do not throw as a lot of components expect services to be available at initialization, eg
+        // api.getService('xxx').on('event', () => ...)
+        // In this case we simply warn and return the wrapper to the online service.
+        // However, it is up to the application to make sure of not using such components when offline
+        // throw new Error('Cannot retrieve offline service ' + name + ' for context ' + (typeof context === 'object' ? context._id : context))
+        logger.warn('[KDK] Cannot retrieve offline service ' + name + ' for context ' + (typeof context === 'object' ? context._id : context))
+      }
+    }
+    if (!service) {
+      service = api.getOnlineService(name, context, options)
+      if (!service) {
+        throw new Error('Cannot retrieve service ' + name + ' for context ' + (typeof context === 'object' ? context._id : context))
+      }
+    }
+    return service
   }
   // Used to create a frontend only service with its options
   api.createService = function (name, options = {}) {
-    let servicePath = options.path || name
-    let contextId
-    if (options.context) {
-      contextId = (typeof options.context === 'object' ? options.context._id : options.context)
-      servicePath = contextId + '/' + servicePath
-    }
-    servicePath = config.apiPath + '/' + servicePath
-    if (servicePath.startsWith('/')) servicePath = servicePath.substr(1)
-    api.declareService(name, options)
+    const servicePath = api.getServicePath(name, options.context)
+    // Service object/constructor fucntion provided ?
     let service = options.service
     // If we get a function try to call it assuming it will return the service object
     if (typeof service === 'function') {
       service = service(name, api, options)
     }
-    // Need to register services with custom methods
-    if (options.methods) {
-      api.use(servicePath, service || api.transporter.service(servicePath), {
-        methods: options.methods
-      })
-    } else {
-      api.use(servicePath, service)
-    }
+    // Otherwise initialize a default wrapper
+    if (!service) service = api.transporter.service(servicePath)
+    // Register service up-front (required for custom methods)
+    api.use(servicePath, service, options)
     service = api.service(servicePath)
     if (options.hooks) service.hooks(options.hooks)
     if (options.context) service.context = options.context
+    service.path = servicePath
     return service
   }
-  // Helper fonctions to access/alter config used at creation time
+  // Used to create a frontend only service to be used in offline mode
+  // based on an online service name, will snapshot service data by default
+  api.createOfflineService = async function (serviceName, options = {}) {
+    const offlineServiceName = `${serviceName}-offline`
+    let offlineService = api.getOfflineService(serviceName)
+
+    if (!offlineService) {
+      // Pass options not used internally for offline management as service options and store it along with service
+      const serviceOptions = _.omit(options, ['hooks', 'snapshot', 'clear', 'baseQuery', 'baseQueries', 'dataPath'])
+      const services = await LocalCache.getItem('services') || {}
+      _.set(services, serviceName, serviceOptions)
+      await LocalCache.setItem('services', services)
+      offlineService = api.createService(offlineServiceName, {
+        service: createOfflineService({
+          id: '_id',
+          name: 'offline_services',
+          storeName: serviceName,
+          multi: true,
+          storage: ['IndexedDB'],
+          // FIXME: this should not be hard-coded as it depends on the service
+          // For now we set it at the max value but if a component
+          // does not explicitly set the limit it will get a lot of data
+          paginate: { default: 5000, max: 5000 }
+        }),
+        // Set required default hooks
+        hooks: _.defaultsDeep(_.get(options, 'hooks'), {
+          before: {
+            all: [hooks.ensureSerializable, hooks.removeServerSideParameters],
+            create: [hooks.generateId]
+          }
+        }),
+        ...serviceOptions
+      })
+    }
+
+    if (_.get(options, 'snapshot', true)) {
+      const service = api.getOnlineService(serviceName)
+      await makeServiceSnapshot(service, Object.assign({ offlineService }, options))
+    }
+
+    return offlineService
+  }
+  api.removeService = function (name, context) {
+    const path = api.getServicePath(name, context)
+    api.unuse(path)
+  }
+  // Helper functions to access/alter config used at creation time
   api.getConfig = function (path) {
     return (path ? _.get(config, path) : config)
   }
@@ -171,9 +253,9 @@ export function createClient (config) {
     if (_.has(resource, 'abilities')) resource = undefined
 
     const abilities = (hasUser ? _.get(user, 'abilities') : Store.get('user.abilities'))
-    logger.debug('Check for abilities ', operation, service, context, resource, abilities)
+    logger.debug('[KDK] Check for abilities ', operation, service, context, resource, abilities)
     if (!abilities) {
-      logger.debug('Access denied without abilities')
+      logger.debug('[KDK] Access denied without abilities')
       return false
     }
     let result
@@ -183,7 +265,7 @@ export function createClient (config) {
       const path = api.getServicePath(service, context, false)
       result = permissions.hasServiceAbilities(abilities, path)
       if (!result) {
-        logger.debug('Access to service path ' + path + ' denied')
+        logger.debug('[KDK] Access to service path ' + path + ' denied')
         return false
       } else if (operation === 'service') {
         // When we only check for service-level access return
@@ -195,9 +277,9 @@ export function createClient (config) {
       result = abilities.can(operation)
     }
     if (!result) {
-      logger.debug('Access to resource denied')
+      logger.debug('[KDK] Access to resource denied')
     } else {
-      logger.debug('Access to resource granted')
+      logger.debug('[KDK] Access to resource granted')
     }
     return result
   }
@@ -215,6 +297,21 @@ export function createClient (config) {
     api.configure(api.transporter)
     // Retrieve our specific errors on rate-limiting
     api.socket.on('rate-limit', (error) => Events.emit('error', error))
+    // Disable default socketio behavior of buffering messages when disconnected
+    // Also keep track of connection state with the server
+    api.socket.io.on('reconnect', async () => {
+      api.isDisconnected = false
+      api.socket.sendBuffer = []
+      // Re-authenticate on reconnect
+      await api.reAuthenticate(true)
+      Events.emit('websocket-reconnected', api)
+      logger.info('[KDK] Socket has been reconnected')
+    })
+    api.socket.io.on('reconnect_error', () => {
+      api.isDisconnected = true
+      Events.emit('websocket-disconnected', api)
+      logger.error(new Error('[KDK] Socket has been disconnected'))
+    })
   }
   api.configure(feathers.authentication({
     storage: window.localStorage,
@@ -243,8 +340,6 @@ export function createClient (config) {
   if (_.get(config, 'renewJwt', true)) {
     api.on('login', api.renewJwtOnExpiration)
   }
-  // Object used to store configuration options for services
-  api.serviceOptions = {}
   // Override Feathers configure that do not manage async operations,
   // here we also simply call the function given as parameter but await for it
   api.configure = async function (fn) {
@@ -255,16 +350,32 @@ export function createClient (config) {
   // Define domain in config if not forced
   if (!api.getConfig('domain')) api.setConfig('domain', window.location.origin)
 
+  // It appears that navigator.onLine is not reliable so that
+  // we perform an actual request to the domain in order to ensure we are online.
+  // We avoid CORS errors with a request to your own origin.
+  // We also add a random query parameter to prevent cached responses.
+  if (!api.isDisconnected) {
+    try {
+      const url = new URL(api.getConfig('domain'))
+      url.searchParams.set('random', Math.random().toFixed(18).substring(2, 18))
+      await window.fetch(url.toString(), { method: 'HEAD' })
+    } catch (error) {
+      api.isDisconnected = true
+      Events.emit('navigator-disconnected', api)
+      logger.warn(`[KDK] Cannot request target domain ${api.getConfig('domain')}, setting state to offline`, error)
+    }
+  }
+
   return api
 }
 
 // We don't create a default client based on app configuration here
 // as we don't know when the file will be imported first,
 // eg it might be imported before another one updating the config.
-// It is up to the application to instanciate the client when required.
+// It is up to the application to instantiate the client when required.
 export let api
-export function initializeApi (fn) {
-  api = createClient(configuration)
+export async function initializeApi (fn) {
+  api = await createClient(configuration)
   if (fn) fn.call(api, configuration)
   return api
 }

package/core/client/broadcaster.js

@@ -0,0 +1,20 @@
+import _ from 'lodash'
+import logger from 'loglevel'
+import config from 'config'
+
+export const Broadcaster = {
+  initialize () {
+    this.channelName = _.get(config, 'appSlug', _.kebabCase(_.get(config, 'appName', 'kdk')))
+    this.channel = new BroadcastChannel(this.channelName)
+    logger.debug(`[KDK] Broadcaster initialized with channel '${this.channelName}'`)
+  },
+  getChannelName () {
+    return this.channelName
+  },
+  getChannel () {
+    return this.channel
+  },
+  post (message) {
+    this.channel.postMessage(message)
+  }
+}

package/core/client/capabilities.js

@@ -1,26 +1,36 @@
 import _ from 'lodash'
 import logger from 'loglevel'
 import config from 'config'
+import { LocalCache } from './local-cache.js'
 import { api } from './api.js'
 import { Store } from './store.js'
 
 // Export singleton
 export const Capabilities = {
   async initialize () {
-    const capabilities = await window.fetch(api.getConfig('domain') + _.get(config, 'apiPath') + '/capabilities')
-    const content = await capabilities.json()
-    logger.debug('[KDK] Fetched capabilities:', content)
-    this.content = content
+    // If browser has detected an offline state then go for cached data
+    if (api.isDisconnected || api.useLocalFirst) {
+      this.content = await LocalCache.getItem('capabilities')
+    }
+    if (!this.content) {
+      // Otherwise try to fetch capabilities from server
+      const capabilities = await window.fetch(api.getConfig('domain') + _.get(config, 'apiPath') + '/capabilities')
+      this.content = await capabilities.json()
+      // Store latest capabilities data for offline mode
+      await LocalCache.setItem('capabilities', this.content)
+    }
+    logger.debug('[KDK] Capabilities initialized with content:', this.content)
+    if (!this.content) return
     // Backend might override some defaults in client config
-    _.forOwn(_.pick(content, ['gateway']), (value, key) => {
+    _.forOwn(_.pick(this.content, ['gateway']), (value, key) => {
       api.setConfig(key, value)
     })
     // Used to ensure backward compatibility
-    Store.set('capabilities.api', content)
+    Store.set('capabilities.api', this.content)
     Store.set('capabilities.client', _.pick(config, ['version', 'buildNumber']))
   },
   get (key, defaultValue) {
-    if (!this.content) logger.error(new Error('Capabilities must be initialized first'))
+    if (!this.content) logger.error(new Error('[KDK] Capabilities must be initialized first'))
     else return _.get(this.content, key, defaultValue)
   }
 }