@radio-garden/ditojs-server 2.85.2-0.5067ad799

package/src/graph/graph.js

@@ -0,0 +1,258 @@
+import { isObject, isArray, asArray, mapConcurrently } from '@ditojs/utils'
+import { QueryBuilder } from '../query/index.js'
+import { collectExpressionPaths, expressionPathToString } from './expression.js'
+
+// Similar to Objection's private `modelClass.ensureModel(model)`:
+export function ensureModel(modelClass, model, options) {
+  return !model
+    ? null
+    : model instanceof modelClass
+      ? parseRelationsIntoModelInstances(model, model, options)
+      : modelClass.fromJson(model, options)
+}
+
+// Similar to Objection's private `modelClass.ensureModelArray(data)`:
+export function ensureModelArray(modelClass, data, options) {
+  return data
+    ? asArray(data).map(model => ensureModel(modelClass, model, options))
+    : []
+}
+
+function parseRelationsIntoModelInstances(model, json, options = {}) {
+  if (!options.cache) {
+    options = { ...options, cache: new Map() }
+  }
+  options.cache.set(json, model)
+
+  for (const relationName of model.constructor.getRelationNames()) {
+    const jsonRelation = json[relationName]
+    if (jsonRelation !== undefined) {
+      const relation = model.constructor.getRelation(relationName)
+      const parsedRelation = parseRelation(jsonRelation, relation, options)
+      if (parsedRelation !== jsonRelation) {
+        model[relation.name] = parsedRelation
+      }
+    }
+  }
+
+  return model
+}
+
+function parseRelation(json, relation, options) {
+  return isArray(json)
+    ? parseRelationArray(json, relation, options)
+    : parseRelationObject(json, relation, options)
+}
+
+function parseRelationArray(json, relation, options) {
+  const models = new Array(json.length)
+  let changed = false
+  for (let i = 0, l = json.length; i < l; i++) {
+    const model = parseRelationObject(json[i], relation, options)
+    changed ||= model !== json[i]
+    models[i] = model
+  }
+  return changed ? models : json
+}
+
+function parseRelationObject(json, relation, options) {
+  if (isObject(json)) {
+    const modelClass = relation.relatedModelClass
+    let model = options.cache.get(json)
+    if (model === undefined) {
+      if (json instanceof modelClass) {
+        model = parseRelationsIntoModelInstances(json, json, options)
+      } else {
+        model = modelClass.fromJson(json, options)
+      }
+    }
+    return model
+  }
+  return json
+}
+
+export function walkGraph(data, callback, path = []) {
+  if (isObject(data) || isArray(data)) {
+    for (const [key, value] of Object.entries(data)) {
+      const dataPath = [...path, key]
+      callback(value, dataPath, data, key)
+      walkGraph(value, callback, dataPath)
+    }
+  }
+}
+
+export function filterGraph(rootModelClass, modelGraph, expr) {
+  expr = QueryBuilder.parseRelationExpression(expr)
+  const models = ensureModelArray(rootModelClass, modelGraph, {
+    skipValidation: true
+  })
+  for (const model of models) {
+    if (model) {
+      const relations = model.constructor.getRelations()
+      for (const key of Object.keys(model)) {
+        const relation = relations[key]
+        if (relation) {
+          const child = expr[key]
+          if (child) {
+            // Allowed relation, keep filtering recursively:
+            filterGraph(
+              relation.relatedModelClass,
+              model[key],
+              child
+            )
+          } else {
+            // Disallowed relation, delete:
+            delete model[key]
+          }
+        }
+      }
+    }
+  }
+  return modelGraph
+}
+
+export async function populateGraph(rootModelClass, graph, expr, trx) {
+  // TODO: Optimize the scenario where an item that isn't a leaf is a
+  // reference and has multiple sub-paths to be populated. We may need to
+  // move away from graph path handling and directly process the expression
+  // tree, composing paths to the current place on the fly, and process data
+  // with addToGroup(). Then use the sub-tree as graph expression when
+  // encountering references (needs toString() for caching also?)
+  // TODO: Better idea: First cache groups by the path up to their location in
+  // the graph, and collect modify + graph expressions there for references
+  // that are not leaves. Then use the resulting nodes to create new groups by
+  // model name / modify / graph expressions.
+  expr = QueryBuilder.parseRelationExpression(expr)
+  // Convert the relation expression to an array of paths, that themselves
+  // 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] = {
+          modelClass,
+          modify,
+          relation,
+          expr,
+          targets: [],
+          ids: [],
+          modelsById: {}
+        })
+      )
+      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
+    const modelClasses = []
+    let lastModify
+    for (const entry of path) {
+      modelClasses.push(modelClass)
+      modelClass = modelClass.getRelation(entry.relation).relatedModelClass
+      lastModify = entry.modify
+    }
+    for (const model of asArray(graph)) {
+      if (model) {
+        let items = asArray(model)
+        // Collect all graph items described by the current relation path in
+        // one loop:
+        for (let i = 0, l = path.length; i < l; i++) {
+          if (items.length === 0) break
+          const { relation } = path[i]
+          const modelClass = modelClasses[i]
+          items = items.reduce((items, item) => {
+            item = ensureModel(modelClass, item, { skipValidation: true })
+            let add = false
+            const isReference = modelClass.isReference(item)
+            if (isReference) {
+              // Detected a reference item that isn't a leaf: We need to
+              // eager-load the rest of the path, and respect modify settings.
+              add = true
+            } else {
+              const value = item[relation]
+              // Add the models of this relation to items, so they can be
+              // filtered further in the next iteration of this loop.
+              if (value != null) {
+                items.push(...asArray(value))
+              } else if (value === undefined) {
+                // If the full relation is missing try eager-loading it.
+                // NOTE: Values of `null` are respected here, not loaded again.
+                add = true
+              }
+            }
+            if (add) {
+              // `path[i].modify` is the current relation's modify expression,
+              // get the parent one for `modelClass`:
+              const modify = i > 0 ? path[i - 1].modify : null
+              const expr = expressionPathToString(path, i)
+              addToGroup(item, modelClass, isReference, modify, relation, expr)
+            }
+            return items
+          }, [])
+        }
+        // Add all encountered leaf-references to groups to be loaded.
+        for (const item of items) {
+          // Only load leafs that are references.
+          if (modelClass.isReference(item)) {
+            addToGroup(item, modelClass, true, lastModify)
+          }
+        }
+      }
+    }
+  }
+
+  const groups = Object.values(grouped).filter(({ ids }) => ids.length > 0)
+  if (groups.length > 0) {
+    // Load all found models by ids asynchronously, within provided transaction.
+    // NOTE: Using the same transaction means that all involved tables need to
+    // be in the same database.
+    await mapConcurrently(
+      groups,
+      async ({ modelClass, modify, expr, ids, modelsById }) => {
+        const query = modelClass.query(trx).findByIds(ids).modify(modify)
+        if (expr) {
+          // TODO: Make algorithm configurable through options.
+          query.withGraph(expr)
+        }
+        const models = await query
+        // Fill the group.modelsById lookup:
+        for (const model of models) {
+          modelsById[model.$id()] = model
+        }
+      }
+    )
+
+    // Finally populate the targets with the loaded models.
+    for (const { targets, modelsById, relation } of groups) {
+      for (const { item, isReference } of targets) {
+        const model = modelsById[item.$id()]
+        if (model) {
+          if (isReference) {
+            // Copy over the full item.
+            Object.assign(item, model)
+          } else {
+            // Just copy the eager-loaded relation.
+            item[relation] = model[relation]
+          }
+        }
+      }
+    }
+  }
+
+  return graph
+}

package/src/graph/index.js

@@ -0,0 +1,3 @@
+export * from './DitoGraphProcessor.js'
+export * from './graph.js'
+export * from './expression.js'

package/src/index.js

@@ -0,0 +1,9 @@
+export * from './app/index.js'
+export * from './query/index.js'
+export * from './schema/index.js'
+export * from './errors/index.js'
+export * from './mixins/index.js'
+export * from './models/index.js'
+export * from './controllers/index.js'
+export * from './services/index.js'
+export * from './storage/index.js'

package/src/lib/EventEmitter.js

@@ -0,0 +1,66 @@
+import EventEmitter2 from 'eventemitter2'
+import { isPlainObject, isString, isArray, asArray } from '@ditojs/utils'
+
+export class EventEmitter extends EventEmitter2 {
+  // Method for classes that use `EventEmitter.mixin()` to setup the emitter.
+  _configureEmitter(events, options) {
+    EventEmitter2.call(this, {
+      delimiter: ':',
+      maxListeners: 0,
+      ...options
+    })
+    for (const key in events) {
+      for (const part of key.split(',')) {
+        const event = part.trim()
+        for (const callback of asArray(events[key])) {
+          this.on(event, callback)
+        }
+      }
+    }
+  }
+
+  emit(event, ...args) {
+    // Always use async version to emit events: It will perform the same as
+    // the normal one when the methods aren't actually async.
+    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)
+    } else if (isArray(event)) {
+      for (const ev of event) {
+        super[method](ev, callback)
+      }
+    } else if (isPlainObject(event)) {
+      for (const key in event) {
+        super[method](key, event[key])
+      }
+    }
+    return this
+  }
+
+  static mixin(target) {
+    Object.defineProperties(target, properties)
+  }
+}
+
+const {
+  constructor, // Don't extract constructor, but everything else
+  ...properties
+} = {
+  ...Object.getOwnPropertyDescriptors(EventEmitter2.prototype),
+  ...Object.getOwnPropertyDescriptors(EventEmitter.prototype)
+}

package/src/lib/KnexHelper.js

@@ -0,0 +1,30 @@
+export class KnexHelper {
+  getDialect() {
+    return this.knex()?.client?.dialect || null
+  }
+
+  isPostgreSQL() {
+    return this.getDialect() === 'postgresql'
+  }
+
+  isMySQL() {
+    return this.getDialect() === 'mysql'
+  }
+
+  isSQLite() {
+    return this.getDialect() === 'sqlite3'
+  }
+
+  isMsSQL() {
+    return this.getDialect() === 'mssql'
+  }
+
+  static mixin(target) {
+    Object.defineProperties(target, properties)
+  }
+}
+
+const {
+  constructor, // Don't extract constructor, but everything else
+  ...properties
+} = Object.getOwnPropertyDescriptors(KnexHelper.prototype)

package/src/lib/index.js

@@ -0,0 +1,2 @@
+export * from './EventEmitter.js'
+export * from './KnexHelper.js'

package/src/middleware/attachLogger.js

@@ -0,0 +1,8 @@
+import { nanoid } from 'nanoid'
+
+export function attachLogger(logger) {
+  return (ctx, next) => {
+    ctx.logger = logger.child({ requestId: nanoid(6) })
+    return next()
+  }
+}

package/src/middleware/createTransaction.js

@@ -0,0 +1,33 @@
+import { transaction } from 'objection'
+import { emitAsync } from '../utils/emitter.js'
+
+export function createTransaction() {
+  return async (ctx, next) => {
+    const { route } = ctx
+    if (route.transacted) {
+      const trx = await transaction.start(
+        route.controller.modelClass ||
+        ctx.app.knex
+      )
+      ctx.transaction = trx
+      // Knex doesn't offer a mechanism for code dealing with transactions to
+      // be notified when the transaction is rolled back. So add support for
+      // 'commit' and 'rollback' events here:
+      try {
+        await next()
+        await trx.commit()
+        await emitAsync(trx, 'commit')
+      } catch (err) {
+        await trx.rollback()
+        await emitAsync(trx, 'rollback', err)
+        throw err
+      } finally {
+        delete ctx.transaction
+      }
+    } else {
+      // TODO: Consider setting `ctx.transaction = ctx.app.knex`, just like
+      // Objection does in static hooks so `transaction is alway set.
+      await next()
+    }
+  }
+}

package/src/middleware/extendContext.js

@@ -0,0 +1,10 @@
+export function extendContext() {
+  return (ctx, next) => {
+    ctx.extend = function (object) {
+      // Create a copy of this context that inherits from the real one, but
+      // overrides some properties with the ones from the passed `object`.
+      return Object.setPrototypeOf(object, this)
+    }
+    return next()
+  }
+}

package/src/middleware/findRoute.js

@@ -0,0 +1,20 @@
+export function findRoute(router) {
+  return (ctx, next) => {
+    const result = router.find(ctx.method, ctx.path)
+    // We use `result.handler` as returned from the router to store the route
+    // object for matched routes. If none is found, set `ctx.route = result`,
+    // for `{ status, allowed }`.
+    const route = result.handler ? { ...result.handler } : result
+    ctx.route = route
+    // NOTE: The name for `ctx.params` was inherited from `koa-router`
+    ctx.params = result.params || {}
+    const { controller, action } = route
+    if (controller) {
+      ctx.controller = controller
+    }
+    if (action) {
+      ctx.action = action
+    }
+    return next()
+  }
+}

package/src/middleware/handleConnectMiddleware.js

@@ -0,0 +1,99 @@
+import { PassThrough } from 'stream'
+import { isString, isArray, isObject } from '@ditojs/utils'
+
+export function handleConnectMiddleware(middleware, {
+  expandMountPath = false
+}) {
+  return (ctx, next) => {
+    return new Promise(resolve => {
+      let body = null
+
+      const res = {
+        locals: ctx.state,
+
+        get statusCode() {
+          return ctx.status
+        },
+
+        set statusCode(status) {
+          ctx.status = status
+        },
+
+        getHeader(field) {
+          // console.log('getHeader', ...arguments)
+          return ctx.get(field)
+        },
+
+        setHeader(field, value) {
+          // console.log('setHeader', ...arguments)
+          ctx.set(field, value)
+        },
+
+        appendHeader(field, value) {
+          // console.log('appendHeader', ...arguments)
+          ctx.append(field, value)
+        },
+
+        writeHead(status, message, headers) {
+          // console.log('writeHead', ...arguments)
+          ctx.status = status
+          if (isString(message)) {
+            ctx.body = message
+          } else {
+            headers = message
+          }
+          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
+                },
+                []
+              )
+            )
+          }
+          if (isObject(headers)) {
+            ctx.set(headers)
+          }
+        },
+
+        write(...args) {
+          // console.log('write', ...arguments)
+          if (!body) {
+            body = new PassThrough()
+            ctx.body = body
+          }
+          body.write(...args)
+        },
+
+        end(body) {
+          // console.log('end', body?.substring?.(0, 256))
+          if (body !== undefined) {
+            ctx.body = body
+          }
+          resolve()
+        }
+      }
+
+      if (expandMountPath && ctx.mountPath) {
+        // Create an inheriting `ctx` object with the expanded `ctx.path`,
+        // without actually modifying the original `ctx` object.
+        ctx = Object.create(ctx, {
+          path: {
+            value: ctx.mountPath + ctx.path
+          }
+        })
+      }
+      middleware(ctx.req, res, next)
+    })
+  }
+}

package/src/middleware/handleError.js

@@ -0,0 +1,29 @@
+import { ResponseError } from '../errors/index.js'
+
+export function handleError() {
+  return async (ctx, next) => {
+    try {
+      await next()
+    } catch (err) {
+      ctx.body = undefined
+      ctx.status = err.status || 500
+      // If the browser accepts json, return a JSON representation of the
+      // 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.'
+              }
+      } else {
+        // TODO: Consider handling html and xml responses also, see:
+        // https://github.com/strongloop/strong-error-handler/blob/master/lib/send-html.js
+        // https://github.com/strongloop/strong-error-handler/blob/master/lib/send-xml.js
+        // https://github.com/strongloop/strong-error-handler/blob/master/views/default-error.ejs
+      }
+      ctx.app.emit('error', err, ctx)
+    }
+  }
+}

package/src/middleware/handleRoute.js

@@ -0,0 +1,23 @@
+export function handleRoute() {
+  return async (ctx, next) => {
+    const { middleware } = ctx.route
+    if (middleware) {
+      await middleware(ctx, next)
+    } else {
+      // No route was found. See if the remaining middleware does something with
+      // this request. If not, return the errors as received from the router:
+      try {
+        await next()
+      } finally {
+        if (ctx.body === undefined && ctx.status === 404) {
+          ctx.status = ctx.route.status || 404
+          // Only retrieve `allowed` now, because it involves calling a getter
+          // and some internal processing:
+          if (ctx.status !== 404 && ctx.route.allowed) {
+            ctx.set('Allow', ctx.route.allowed.join(', '))
+          }
+        }
+      }
+    }
+  }
+}

package/src/middleware/handleSession.js

@@ -0,0 +1,77 @@
+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.
+    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)
+    }
+  }