@ditojs/server 2.0.4 → 2.1.0

package/src/graph/DitoGraphProcessor.js

@@ -76,9 +76,11 @@ export class DitoGraphProcessor {
             // since `relation.graphOptions` is across insert  / upsert & co.,
             // but not all of them use all options (insert defines less).
             for (const key in this.options) {
-              if (key in graphOptions &&
-                  graphOptions[key] !== this.options[key] &&
-                  !this.overrides[key]) {
+              if (
+                key in graphOptions &&
+                graphOptions[key] !== this.options[key] &&
+                !this.overrides[key]
+              ) {
                 this.numOverrides++
                 this.overrides[key] = []
               }
@@ -104,41 +106,45 @@ export class DitoGraphProcessor {
   processOverrides() {
     const expr = modelGraphToExpression(this.data)
 
-    const processExpression =
-      (expr, modelClass, relation, relationPath = '') => {
-        if (relation) {
-          const graphOptions = this.getGraphOptions(relation)
-          // Loop through all override options, figure out their settings for
-          // the current relation and build relation expression arrays for each
-          // override reflecting their nested settings in arrays of expressions.
-          for (const key in this.overrides) {
-            const option = graphOptions[key] ?? this.options[key]
-            if (option) {
-              this.overrides[key].push(relationPath)
-            }
-          }
-
-          // Also collect any many-to-many pivot table extra properties.
-          const extra = relation.through?.extra
-          if (extra?.length > 0) {
-            this.extras[relationPath] = extra
+    const processExpression = (
+      expr,
+      modelClass,
+      relation,
+      relationPath = ''
+    ) => {
+      if (relation) {
+        const graphOptions = this.getGraphOptions(relation)
+        // Loop through all override options, figure out their settings for
+        // the current relation and build relation expression arrays for each
+        // override reflecting their nested settings in arrays of expressions.
+        for (const key in this.overrides) {
+          const option = graphOptions[key] ?? this.options[key]
+          if (option) {
+            this.overrides[key].push(relationPath)
           }
         }
 
-        const { relations } = modelClass.definition
-        const relationInstances = modelClass.getRelations()
-        for (const key in expr) {
-          const childExpr = expr[key]
-          const { relatedModelClass } = relationInstances[key]
-          processExpression(
-            childExpr,
-            relatedModelClass,
-            relations[key],
-            appendPath(relationPath, '.', key)
-          )
+        // Also collect any many-to-many pivot table extra properties.
+        const extra = relation.through?.extra
+        if (extra?.length > 0) {
+          this.extras[relationPath] = extra
         }
       }
 
+      const { relations } = modelClass.definition
+      const relationInstances = modelClass.getRelations()
+      for (const key in expr) {
+        const childExpr = expr[key]
+        const { relatedModelClass } = relationInstances[key]
+        processExpression(
+          childExpr,
+          relatedModelClass,
+          relations[key],
+          appendPath(relationPath, '.', key)
+        )
+      }
+    }
+
     processExpression(expr, this.rootModelClass)
   }
 
@@ -147,9 +153,9 @@ export class DitoGraphProcessor {
     if (relationPath !== '') {
       const { relate } = this.overrides
       return relate
-        // See if the relate overrides contain this particular relation-Path
-        // and only remove and restore relation data if relate is to be used
-        ? relate.includes(relationPath)
+        ? // See if the relate overrides contain this particular relation-Path
+          // and only remove and restore relation data if relate is to be used
+          relate.includes(relationPath)
         : this.options.relate
     }
   }
@@ -189,11 +195,13 @@ export class DitoGraphProcessor {
         return copy
       } else if (isArray(data)) {
         // Potentially a has-many relation, so keep processing relates:
-        return data.map((entry, index) => this.processRelates(
-          entry,
-          relationPath,
-          appendPath(dataPath, '/', index)
-        ))
+        return data.map((entry, index) =>
+          this.processRelates(
+            entry,
+            relationPath,
+            appendPath(dataPath, '/', index)
+          )
+        )
       }
     }
     return data

package/src/graph/expression.js

@@ -26,14 +26,12 @@ export function collectExpressionPaths(expr) {
 
 export function expressionPathToString(path, start = 0) {
   return (start ? path.slice(start) : path)
-    .map(
-      ({ relation, alias, modify }) => {
-        const expr = alias ? `${relation} as ${alias}` : relation
-        return modify.length > 0
-          ? `${expr}(${modify.join(', ')})`
-          : expr
-      }
-    )
+    .map(({ relation, alias, modify }) => {
+      const expr = alias ? `${relation} as ${alias}` : relation
+      return modify.length > 0
+        ? `${expr}(${modify.join(', ')})`
+        : expr
+    })
     .join('.')
 }
 

package/src/graph/graph.js

@@ -127,13 +127,21 @@ export async function populateGraph(rootModelClass, graph, expr, trx) {
   // contain path entries with relation names and modify settings.
 
   const grouped = {}
-  const addToGroup =
-    (item, modelClass, isReference, modify, relation, expr) => {
-      const id = item.$id()
-      if (id != null) {
-        // Group models by model-name + modify + expr, for faster loading:
-        const key = `${modelClass.name}_${modify}_${expr || ''}`
-        const group = grouped[key] || (grouped[key] = {
+  const addToGroup = (
+    item,
+    modelClass,
+    isReference,
+    modify,
+    relation,
+    expr
+  ) => {
+    const id = item.$id()
+    if (id != null) {
+      // Group models by model-name + modify + expr, for faster loading:
+      const key = `${modelClass.name}_${modify}_${expr || ''}`
+      const group = (
+        grouped[key] ||
+        (grouped[key] = {
           modelClass,
           modify,
           relation,
@@ -142,11 +150,12 @@ export async function populateGraph(rootModelClass, graph, expr, trx) {
           ids: [],
           modelsById: {}
         })
-        group.targets.push({ item, isReference })
-        // Collect ids to be loaded for the targets.
-        group.ids.push(id)
-      }
+      )
+      group.targets.push({ item, isReference })
+      // Collect ids to be loaded for the targets.
+      group.ids.push(id)
     }
+  }
 
   for (const path of collectExpressionPaths(expr)) {
     let modelClass = rootModelClass

package/src/lib/EventEmitter.js

@@ -25,6 +25,18 @@ export class EventEmitter extends EventEmitter2 {
     return this.emitAsync(event, ...args)
   }
 
+  on(event, callback) {
+    return this._handle('on', event, callback)
+  }
+
+  off(event, callback) {
+    return this._handle('off', event, callback)
+  }
+
+  once(event, callback) {
+    return this._handle('once', event, callback)
+  }
+
   _handle(method, event, callback) {
     if (isString(event)) {
       super[method](event, callback)
@@ -40,18 +52,6 @@ export class EventEmitter extends EventEmitter2 {
     return this
   }
 
-  on(event, callback) {
-    return this._handle('on', event, callback)
-  }
-
-  off(event, callback) {
-    return this._handle('off', event, callback)
-  }
-
-  once(event, callback) {
-    return this._handle('once', event, callback)
-  }
-
   static mixin(target) {
     Object.defineProperties(target, properties)
   }

package/src/middleware/handleConnectMiddleware.js

@@ -39,16 +39,22 @@ export function handleConnectMiddleware(middleware, {
           }
           if (isArray(headers)) {
             // Convert raw headers array to object.
-            headers = Object.fromEntries(headers.reduce(
-              // Translate raw array to [field, value] tuples.
-              (entries, value, index) => {
-                if (index & 1) { // Odd: value
-                  entries[entries.length - 1].push(value)
-                } else { // Even: field
-                  entries.push([value])
-                }
-                return entries
-              }, []))
+            headers = Object.fromEntries(
+              headers.reduce(
+                // Translate raw array to [field, value] tuples.
+                (entries, value, index) => {
+                  if (index & 1) {
+                    // Odd: value
+                    entries[entries.length - 1].push(value)
+                  } else {
+                    // Even: field
+                    entries.push([value])
+                  }
+                  return entries
+                },
+                []
+              )
+            )
           }
           if (isObject(headers)) {
             ctx.set(headers)

package/src/middleware/handleError.js

@@ -11,11 +11,12 @@ export function handleError() {
       // error. But don't do so if the request actually went to js file.
       if (ctx.accepts('json') && !ctx.request.path.endsWith('.js')) {
         // Format error as JSON
-        ctx.body = err instanceof ResponseError
-          ? err.toJSON()
-          : {
-            message: err.message || 'An error has occurred.'
-          }
+        ctx.body =
+          err instanceof ResponseError
+            ? err.toJSON()
+            : {
+                message: err.message || 'An error has occurred.'
+              }
       } else {
         // TODO: Consider handling html and xml responses also, see:
         // https://github.com/strongloop/strong-error-handler/blob/master/lib/send-html.js

package/src/middleware/handleSession.js

@@ -0,0 +1,78 @@
+import session from 'koa-session'
+import compose from 'koa-compose'
+import { isString } from '@ditojs/utils'
+
+export function handleSession(app, {
+  modelClass,
+  autoCommit = true,
+  ...options
+} = {}) {
+  if (modelClass) {
+    // Create a ContextStore that resolved the specified model class,
+    // uses it to persist and retrieve the session, and automatically
+    // binds all db operations to `ctx.transaction`, if it is set.
+    // eslint-disable-next-line new-cap
+    options.ContextStore = createSessionStore(modelClass)
+  }
+  options.autoCommit = false
+  return compose([
+    session(options, app),
+    async (ctx, next) => {
+      // Get hold of `session` now, since it may not be available from the
+      // `ctx` if the session is destroyed.
+      const {
+        session,
+        route: { transacted }
+      } = ctx
+      try {
+        await next()
+        if (autoCommit && transacted) {
+          // When transacted, only commit when there are no errors. Otherwise,
+          // the commit will fail and the original error will be lost.
+          await session.commit()
+        }
+      } finally {
+        // When not transacted, keep the original behavior of always
+        // committing.
+        if (autoCommit && !transacted) {
+          await session.commit()
+        }
+      }
+    }
+  ])
+}
+
+const createSessionStore = modelClass =>
+  class SessionStore {
+    constructor(ctx) {
+      this.ctx = ctx
+      this.modelClass = isString(modelClass)
+        ? ctx.app.models[modelClass]
+        : modelClass
+      if (!this.modelClass) {
+        throw new Error(`Unable to find model class: '${modelClass}'`)
+      }
+    }
+
+    query() {
+      return this.modelClass.query(this.ctx.transaction)
+    }
+
+    async get(id) {
+      const session = await this.query().findById(id)
+      return session?.value || {}
+    }
+
+    async set(id, value) {
+      await this.query()
+        .findById(id)
+        .upsert({
+          ...this.modelClass.getReference(id),
+          value
+        })
+    }
+
+    async destroy(key) {
+      await this.query().deleteById(key)
+    }
+  }

package/src/middleware/handleUser.js

@@ -7,13 +7,13 @@ export function handleUser() {
     // on the user model:
     const { login, logout } = ctx
 
-    ctx.login = ctx.logIn = async function(user, options = {}) {
+    ctx.login = ctx.logIn = async function (user, options = {}) {
       await user.$emit('before:login', options)
       await login.call(this, user, options)
       await user.$emit('after:login', options)
     }
 
-    ctx.logout = ctx.logOut = async function(options = {}) {
+    ctx.logout = ctx.logOut = async function (options = {}) {
       const { user } = ctx.state
       await user?.$emit('before:logout', options)
       await logout.call(this, options)

package/src/middleware/index.js

@@ -4,5 +4,7 @@ export * from './findRoute.js'
 export * from './handleConnectMiddleware.js'
 export * from './handleError.js'
 export * from './handleRoute.js'
+export * from './handleSession.js'
 export * from './handleUser.js'
 export * from './logRequests.js'
+export * from './setupRequestStorage.js'

package/src/middleware/logRequests.js

@@ -5,9 +5,9 @@ import bytes from 'bytes'
 import pico from 'picocolors'
 import Counter from 'passthrough-counter'
 
-export function logRequests({ ignoreUrls } = {}) {
+export function logRequests({ ignoreUrlPattern } = {}) {
   return async (ctx, next) => {
-    if (ignoreUrls && ctx.req.url.match(ignoreUrls)) {
+    if (ignoreUrlPattern && ctx.req.url.match(ignoreUrlPattern)) {
       return next()
     }
     // request
@@ -72,7 +72,7 @@ function logResponse({ ctx, start, length, err }) {
   const logger = ctx.logger?.child({ name: 'http' })
   const level = err ? 'warn' : 'info'
   if (logger?.isLevelEnabled(level)) {
-  // Get the status code of the response
+    // Get the status code of the response
     const status = err
       ? err.status || 500
       : ctx.status || 404

package/src/middleware/setupRequestStorage.js

@@ -0,0 +1,14 @@
+export function setupRequestStorage(requestStorage) {
+  return (ctx, next) =>
+    requestStorage.run(
+      {
+        get transaction() {
+          return ctx.transaction
+        },
+        get logger() {
+          return ctx.logger
+        }
+      },
+      next
+    )
+}

package/src/mixins/AssetMixin.js

@@ -2,73 +2,77 @@ import { mixin } from '@ditojs/utils'
 import { TimeStampedMixin } from './TimeStampedMixin.js'
 
 // Asset models are always to be time-stamped:
-export const AssetMixin = mixin(Model => class extends TimeStampedMixin(Model) {
-  static properties = {
-    key: {
-      type: 'string',
-      required: true,
-      unique: true,
-      index: true
-    },
-
-    file: {
-      type: 'object',
-      // TODO: Support this on 'object':
-      // required: true
-      properties: {
-        // The unique key within the storage (uuid/v4 + file extension)
+export const AssetMixin = mixin(
+  Model =>
+    class extends TimeStampedMixin(Model) {
+      static properties = {
         key: {
           type: 'string',
-          required: true
+          required: true,
+          unique: true,
+          index: true
         },
-        // The original filename, and display name when file is shown
-        name: {
-          type: 'string',
-          required: true
+
+        file: {
+          type: 'object',
+          // TODO: Support this on 'object':
+          // required: true
+          properties: {
+            // The unique key within the storage (uuid/v4 + file extension)
+            key: {
+              type: 'string',
+              required: true
+            },
+            // The original filename, and display name when file is shown
+            name: {
+              type: 'string',
+              required: true
+            },
+            // The file's mime-type
+            type: {
+              type: 'string',
+              required: true
+            },
+            // The amount of bytes consumed by the file
+            size: {
+              type: 'integer',
+              required: true
+            },
+            // Use for storages configured for files to be publicly accessible:
+            url: {
+              type: 'string'
+            },
+            // These are only used when the storage defines
+            // `config.readDimensions`:
+            width: {
+              type: 'integer'
+            },
+            height: {
+              type: 'integer'
+            }
+          }
         },
-        // The file's mime-type
-        type: {
+
+        storage: {
           type: 'string',
           required: true
         },
-        // The amount of bytes consumed by the file
-        size: {
+
+        count: {
           type: 'integer',
-          required: true
-        },
-        // Use for storages configured for files to be publicly accessible:
-        url: {
-          type: 'string'
-        },
-        // These are only used when the storage defines `config.readDimensions`:
-        width: {
-          type: 'integer'
-        },
-        height: {
-          type: 'integer'
+          unsigned: true,
+          default: 0
         }
       }
-    },
-
-    storage: {
-      type: 'string',
-      required: true
-    },
 
-    count: {
-      type: 'integer',
-      unsigned: true,
-      default: 0
-    }
-  }
-
-  // @override
-  $parseJson(json) {
-    const { file, storage } = json
-    // Convert `AssetMixin#file` to an `AssetFile` instance:
-    if (file && storage) {
-      this.constructor.app.getStorage(storage)?.convertAssetFile(file)
+      // @override
+      $parseJson(json) {
+        const { file, storage } = json
+        // Convert `AssetMixin#file` to an `AssetFile` instance:
+        if (file && storage) {
+          this.constructor.app.getStorage(storage)?.convertAssetFile(file)
+        }
+        return json
+      }
     }
-    return json
-  }
-})
+)

package/src/mixins/SessionMixin.js

@@ -1,14 +1,17 @@
 import { mixin } from '@ditojs/utils'
 
-export const SessionMixin = mixin(Model => class extends Model {
-  static properties = {
-    id: {
-      type: 'string',
-      primary: true
-    },
+export const SessionMixin = mixin(
+  Model =>
+    class extends Model {
+      static properties = {
+        id: {
+          type: 'string',
+          primary: true
+        },
 
-    value: {
-      type: 'object'
+        value: {
+          type: 'object'
+        }
+      }
     }
-  }
-})
+)

package/src/mixins/TimeStampedMixin.js

@@ -1,37 +1,41 @@
 import { mixin } from '@ditojs/utils'
 
-export const TimeStampedMixin = mixin(Model => class extends Model {
-  static properties = {
-    createdAt: {
-      type: 'timestamp',
-      default: 'now()'
-    },
+export const TimeStampedMixin = mixin(
+  Model =>
+    class extends Model {
+      static properties = {
+        createdAt: {
+          type: 'timestamp',
+          default: 'now()'
+        },
 
-    updatedAt: {
-      type: 'timestamp',
-      default: 'now()'
-    }
-  }
-
-  static scopes = {
-    timeStamped: query => query
-      .select('createdAt', 'updatedAt')
-  }
+        updatedAt: {
+          type: 'timestamp',
+          default: 'now()'
+        }
+      }
 
-  static hooks = {
-    'before:insert'({ inputItems }) {
-      const now = new Date()
-      for (const item of inputItems) {
-        item.createdAt = now
-        item.updatedAt = now
+      static scopes = {
+        timeStamped: query =>
+          query
+            .select('createdAt', 'updatedAt')
       }
-    },
 
-    'before:update'({ inputItems }) {
-      const now = new Date()
-      for (const item of inputItems) {
-        item.updatedAt = now
+      static hooks = {
+        'before:insert'({ inputItems }) {
+          const now = new Date()
+          for (const item of inputItems) {
+            item.createdAt = now
+            item.updatedAt = now
+          }
+        },
+
+        'before:update'({ inputItems }) {
+          const now = new Date()
+          for (const item of inputItems) {
+            item.updatedAt = now
+          }
+        }
       }
     }
-  }
-})
+)