@ditojs/server 2.0.4 → 2.1.0

package/src/schema/relations.js

@@ -7,7 +7,12 @@ import {
   ManyToManyRelation
 } from 'objection'
 import {
-  isObject, isArray, isString, asArray, capitalize, camelize
+  isObject,
+  isArray,
+  isString,
+  asArray,
+  capitalize,
+  camelize
 } from '@ditojs/utils'
 import { RelationError } from '../errors/index.js'
 
@@ -45,14 +50,16 @@ class ModelReference {
       const modelClass = models[modelName]
       if (!modelClass && !allowUnknown) {
         throw new RelationError(
-          `Unknown model reference: ${ref}`)
+          `Unknown model reference: ${ref}`
+        )
       }
       if (!this.modelName) {
         this.modelName = modelName
         this.modelClass = modelClass
       } else if (this.modelName !== modelName) {
         throw new RelationError(
-          `Composite keys need to be defined on the same table: ${ref}`)
+          `Composite keys need to be defined on the same table: ${ref}`
+        )
       }
       this.propertyNames.push(propertyName)
     }
@@ -90,8 +97,10 @@ class ModelReference {
     const toName = toRef.modelName
     const toProperties = toRef.propertyNames
     if (fromProperties.length !== toProperties.length) {
-      throw new RelationError('Unable to create through join for ' +
-        `composite keys from '${this}' to '${toRef}'`)
+      throw new RelationError(
+        'Unable to create through join for ' +
+        `composite keys from '${this}' to '${toRef}'`
+      )
     }
     const from = []
     const to = []
@@ -106,7 +115,8 @@ class ModelReference {
         to.push(`${throughName}.${throughTo}`)
       } else {
         throw new RelationError(
-          `Unable to create through join from '${this}' to '${to}'`)
+          `Unable to create through join from '${this}' to '${to}'`
+        )
       }
     }
     return {
@@ -136,11 +146,18 @@ export function convertRelation(schema, models) {
   let {
     relation,
     // Dito.js-style relation description:
-    from, to, through, inverse, modify, scope,
+    from,
+    to,
+    through,
+    inverse,
+    modify,
+    scope,
     // Objection.js-style relation description (`modify` is shared)
-    join, filter,
+    join,
+    filter,
     // Pluck Dito.js-related properties that should not end up in `rest`:
-    nullable, owner,
+    nullable,
+    owner,
     ...rest
   } = schema || {}
   const relationClass = getRelationClass(relation)
@@ -178,16 +195,19 @@ export function convertRelation(schema, models) {
             through.from = throughFrom.toValue()
             through.to = throughTo.toValue()
           } else {
-            throw new RelationError('Both sides of the `through` definition ' +
-              'need to be on the same join model')
+            throw new RelationError(
+              'Both sides of the `through` definition ' +
+              'need to be on the same join model'
+            )
           }
         } else {
           // Assume the references are to a join table, and use the settings
           // unmodified.
         }
       } else {
-        throw new RelationError('The relation needs a `through.from` and ' +
-          '`through.to` definition')
+        throw new RelationError(
+          'The relation needs a `through.from` and ' + '`through.to` definition'
+        )
       }
     } else if (through) {
       throw new RelationError('Unsupported through join definition')
@@ -230,7 +250,8 @@ export function convertRelations(ownerModelClass, relations, models) {
       converted[name] = convertRelation(relation, models)
     } catch (err) {
       throw new RelationError(
-        `${ownerModelClass.name}.relations.${name}: ${(err.message || err)}`)
+        `${ownerModelClass.name}.relations.${name}: ${err.message || err}`
+      )
     }
   }
   return converted
@@ -261,15 +282,16 @@ export function addRelationSchemas(modelClass, properties) {
     }
     // Finally the model itself
     anyOf.push({ $ref })
-    const items = anyOf.length > 1
-      ? { anyOf }
-      : anyOf[0]
+    const items =
+      anyOf.length > 1
+        ? { anyOf }
+        : anyOf[0]
     properties[name] = isOneToOne
       ? items
       : {
-        type: 'array',
-        items
-      }
+          type: 'array',
+          items
+        }
   }
   return properties
 }

package/src/schema/relations.test.js

@@ -7,7 +7,9 @@ import {
 } from 'objection'
 import { Model } from '../models/index.js'
 import {
-  getRelationClass, convertRelation, addRelationSchemas
+  getRelationClass,
+  convertRelation,
+  addRelationSchemas
 } from './relations.js'
 
 describe('getRelationClass()', () => {
@@ -40,12 +42,17 @@ describe('convertRelation()', () => {
   const models = { ModelOne, ModelTwo }
 
   it('converts a belongs-to relation to Objection.js format', () => {
-    expect(convertRelation({
-      relation: 'belongs-to',
-      from: 'ModelOne.modelTwoId',
-      to: 'ModelTwo.id',
-      modify: 'myScope'
-    }, models)).toEqual({
+    expect(
+      convertRelation(
+        {
+          relation: 'belongs-to',
+          from: 'ModelOne.modelTwoId',
+          to: 'ModelTwo.id',
+          modify: 'myScope'
+        },
+        models
+      )
+    ).toEqual({
       relation: BelongsToOneRelation,
       modelClass: ModelTwo,
       join: {
@@ -57,12 +64,17 @@ describe('convertRelation()', () => {
   })
 
   it('converts a many-to-many relation to Objection.js format', () => {
-    expect(convertRelation({
-      relation: 'many-to-many',
-      from: 'ModelOne.id',
-      to: 'ModelTwo.id',
-      inverse: false
-    }, models)).toEqual({
+    expect(
+      convertRelation(
+        {
+          relation: 'many-to-many',
+          from: 'ModelOne.id',
+          to: 'ModelTwo.id',
+          inverse: false
+        },
+        models
+      )
+    ).toEqual({
       relation: ManyToManyRelation,
       modelClass: ModelTwo,
       join: {
@@ -77,12 +89,17 @@ describe('convertRelation()', () => {
   })
 
   it('converts an inverse many-to-many relation to Objection.js format', () => {
-    expect(convertRelation({
-      relation: 'many-to-many',
-      from: 'ModelTwo.id',
-      to: 'ModelOne.id',
-      inverse: true
-    }, models)).toEqual({
+    expect(
+      convertRelation(
+        {
+          relation: 'many-to-many',
+          from: 'ModelTwo.id',
+          to: 'ModelOne.id',
+          inverse: true
+        },
+        models
+      )
+    ).toEqual({
       relation: ManyToManyRelation,
       modelClass: ModelOne,
       join: {

package/src/services/Service.js

@@ -20,27 +20,21 @@ export class Service {
   }
 
   // @overridable
-  async initialize() {
-  }
+  async initialize() {}
 
   // @overridable
-  async start() {
-  }
+  async start() {}
 
   // @overridable
-  async stop() {
-  }
+  async stop() {}
 
-  // Only use this method to get a logger instance that is bound to the context,
-  // otherwise use the cached getter.
-  getLogger(ctx) {
-    const logger = ctx?.logger ?? this.app.logger
-    return logger.child({ name: this.#loggerName })
+  /** @deprecated Use `instance.logger` instead. */
+  getLogger() {
+    return this.logger
   }
 
   get logger() {
-    const value = this.getLogger()
-    Object.defineProperty(this, 'logger', { value })
-    return value
+    const logger = this.app.requestLocals.logger ?? this.app.logger
+    return logger.child({ name: this.#loggerName })
   }
 }

package/src/storage/S3Storage.js

@@ -63,9 +63,11 @@ export class S3Storage extends Storage {
               } else {
                 // 3. If that fails, keep collecting all chunks and determine
                 //    the mimetype using the full data.
-                stream.once('end', () => done(
-                  getFileTypeFromBuffer(data) || 'application/octet-stream'
-                ))
+                stream.once('end', () =>
+                  done(
+                    getFileTypeFromBuffer(data) || 'application/octet-stream'
+                  )
+                )
               }
             }
             data = data ? Buffer.concat([data, chunk]) : chunk

package/src/storage/Storage.js

@@ -27,12 +27,10 @@ export class Storage {
   }
 
   // @overridable
-  async setup() {
-  }
+  async setup() {}
 
   // @overridable
-  async initialize() {
-  }
+  async initialize() {}
 
   static register(storageClass) {
     const type = (
@@ -51,15 +49,18 @@ export class Storage {
     // Returns a storage that inherits from this.storage but overrides
     // _handleFile to pass on `config` to the call of `handleUpload()`
     return this.storage
-      ? Object.setPrototypeOf({
-        _handleFile: async (req, file, callback) => {
-          try {
-            callback(null, await this._handleUpload(req, file, config))
-          } catch (err) {
-            callback(err)
-          }
-        }
-      }, this.storage)
+      ? Object.setPrototypeOf(
+          {
+            _handleFile: async (req, file, callback) => {
+              try {
+                callback(null, await this._handleUpload(req, file, config))
+              } catch (err) {
+                callback(err)
+              }
+            }
+          },
+          this.storage
+        )
       : null
   }
 
@@ -169,7 +170,8 @@ export class Storage {
         // TODO: `config.readImageSize` was deprecated in favour of
         // `config.readDimensions` in March 2023. Remove in 1 year.
         config.readImageSize
-      ) && /^(image|video)\//.test(file.mimetype)
+      ) &&
+      /^(image|video)\//.test(file.mimetype)
     ) {
       return this._handleMediaFile(req, file)
     } else {

package/src/utils/function.js

@@ -6,9 +6,12 @@ export function describeFunction(func) {
   )
   if (match) {
     const body = match[5] === '{' ? '{ ... }' : '...'
-    return match[2] !== undefined ? `${match[1]}function (${match[2]}) ${body}`
-      : match[3] !== undefined ? `${match[1]}(${match[3]}) => ${body}`
-      : match[4] !== undefined ? `${match[1]}${match[4]} => ${body}`
-      : ''
+    return match[2] !== undefined
+      ? `${match[1]}function (${match[2]}) ${body}`
+      : match[3] !== undefined
+        ? `${match[1]}(${match[3]}) => ${body}`
+        : match[4] !== undefined
+          ? `${match[1]}${match[4]} => ${body}`
+          : ''
   }
 }

package/src/utils/function.test.js

@@ -2,12 +2,20 @@ import { describeFunction } from './function.js'
 
 describe('describeFunction()', () => {
   it('describes normal functions', () => {
-    expect(describeFunction(function(a, b, c) { return a + b + c }))
+    expect(
+      describeFunction(function (a, b, c) {
+        return a + b + c
+      })
+    )
       .toBe('function (a, b, c) { ... }')
   })
 
   it('describes lambdas with one param and a body', () => {
-    expect(describeFunction(a => { return a }))
+    expect(
+      describeFunction(a => {
+        return a
+      })
+    )
       .toBe('a => { ... }')
   })
 
@@ -17,7 +25,11 @@ describe('describeFunction()', () => {
   })
 
   it('describes lambdas with multiple params and a body', () => {
-    expect(describeFunction((a, b, c) => { return a + b + c }))
+    expect(
+      describeFunction((a, b, c) => {
+        return a + b + c
+      })
+    )
       .toBe('(a, b, c) => { ... }')
   })
 
@@ -27,12 +39,20 @@ describe('describeFunction()', () => {
   })
 
   it('describes async functions', () => {
-    expect(describeFunction(async function(a, b, c) { return a + b + c }))
+    expect(
+      describeFunction(async function (a, b, c) {
+        return a + b + c
+      })
+    )
       .toBe('async function (a, b, c) { ... }')
   })
 
   it('describes async lambdas with one param and a body', () => {
-    expect(describeFunction(async a => { return a }))
+    expect(
+      describeFunction(async a => {
+        return a
+      })
+    )
       .toBe('async a => { ... }')
   })
 
@@ -42,7 +62,11 @@ describe('describeFunction()', () => {
   })
 
   it('describes async lambdas with multiple params and a body', () => {
-    expect(describeFunction(async (a, b, c) => { return a + b + c }))
+    expect(
+      describeFunction(async (a, b, c) => {
+        return a + b + c
+      })
+    )
       .toBe('async (a, b, c) => { ... }')
   })
 

package/src/utils/object.test.js

@@ -1,5 +1,9 @@
 import {
-  getAllKeys, getOwnProperty, createLookup, mergeReversed, mergeAsReversedArrays
+  getAllKeys,
+  getOwnProperty,
+  createLookup,
+  mergeReversed,
+  mergeAsReversedArrays
 } from './object.js'
 
 const object = Object.create({ a: 1 })