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

package/src/models/RelationAccessor.js

@@ -0,0 +1,41 @@
+import { QueryBuilder } from '../query/index.js'
+
+export default class RelationAccessor {
+  constructor(relation, modelClass, model) {
+    this.relation = relation
+    this.name = relation.name
+    this.modelClass = modelClass
+    this.model = model
+  }
+
+  query(trx) {
+    return this.modelClass
+      ? this.modelClass.relatedQuery(this.name, trx)
+      : this.model.$relatedQuery(this.name, trx)
+  }
+
+  load(arg0, ...args) {
+    return this.modelClass
+      ? this.modelClass.loadRelated(arg0, this.name, ...args)
+      : this.model.$loadRelated(this.name, arg0, ...args)
+  }
+
+  /**
+   * Accessor to provide simplified access to the implicitly generated join
+   * model class, handling the passing on of  the knex instance, as well as
+   * the application of `QueryBuilder.mixin()`.
+   */
+  get joinModelClass() {
+    const { joinModelClass } = this.relation
+    // Result is already cached per knex by `this.relation.joinModelClass()`,
+    // so all that's left to do is apply `QueryBuilder.mixin()`,
+    // if there is no `joinModelClass.where()` yet:
+    if (joinModelClass && !('where' in joinModelClass)) {
+      QueryBuilder.mixin(joinModelClass)
+    }
+    return joinModelClass
+  }
+}
+
+// Expose a selection of QueryBuilder methods as instance methods on relations.
+QueryBuilder.mixin(RelationAccessor.prototype)

package/src/models/SessionModel.js

@@ -0,0 +1,4 @@
+import { SessionMixin } from '../mixins/index.js'
+import { Model } from './Model.js'
+
+export const SessionModel = SessionMixin(Model)

package/src/models/TimeStampedModel.js

@@ -0,0 +1,4 @@
+import { TimeStampedMixin } from '../mixins/index.js'
+import { Model } from './Model.js'
+
+export const TimeStampedModel = TimeStampedMixin(Model)

package/src/models/UserModel.js

@@ -0,0 +1,4 @@
+import { UserMixin } from '../mixins/index.js'
+import { Model } from './Model.js'
+
+export const UserModel = UserMixin(Model)

package/src/models/definitions/assets.js

@@ -0,0 +1,5 @@
+import { mergeReversedOrNull } from '../../utils/object.js'
+
+export default function assets(values) {
+  return mergeReversedOrNull(values)
+}

package/src/models/definitions/filters.js

@@ -0,0 +1,121 @@
+import { isObject, isFunction, deprecate } from '@ditojs/utils'
+import { processHandlerParameters } from '../../utils/handler.js'
+import { mergeReversed } from '../../utils/object.js'
+import { QueryFilters } from '../../query/index.js'
+
+export default function filters(values) {
+  const filters = {}
+  for (const [name, definition] of Object.entries(mergeReversed(values))) {
+    const filter = isFunction(definition)
+      ? definition
+      : isObject(definition)
+        ? convertFilterObject(name, definition)
+        : null
+    if (!filter) {
+      throw new Error(
+        `Invalid filter '${name}': Unrecognized definition: ${definition}.`
+      )
+    }
+    filters[name] = wrapWithValidation(filter, name, this.app)
+  }
+  return filters
+}
+
+function convertFilterObject(name, object) {
+  const addHandlerSettings = (handler, definition) => {
+    // Copy over parameters, returns and their validation options settings.
+    const {
+      parameters,
+      // TODO: `returns` was deprecated in May 2025 in favour of `response`.
+      // Remove this in 2026.
+      returns,
+      response = returns,
+      ...rest
+    } = definition
+    if (returns) {
+      deprecate(
+        'The `returns` property is deprecated in favour of `response`. ' +
+        'Update your handler definition to use `response` instead.'
+      )
+    }
+    processHandlerParameters(handler, 'parameters', parameters)
+    processHandlerParameters(handler, 'response', response)
+    return Object.assign(handler, rest)
+  }
+
+  const { handler, filter, properties } = object
+  if (handler) {
+    return addHandlerSettings(handler, object)
+  } else if (filter) {
+    // Convert QueryFilter to normal filter function.
+    const queryFilter = QueryFilters.get(filter)
+    if (!queryFilter) {
+      throw new Error(
+        `Invalid filter '${name}': Unknown filter type '${filter}'.`
+      )
+    }
+    // Support both object and function definitions.
+    const queryHandler = isObject(queryFilter)
+      ? queryFilter.handler
+      : queryFilter
+    const func = properties
+      ? (query, ...args) => {
+          // When the filter provides multiple properties, match them
+          // all, but combine the expressions with OR.
+          for (const property of properties) {
+            query.orWhere(query => queryHandler(query, property, ...args))
+          }
+        }
+      : (query, ...args) => {
+          queryHandler(query, name, ...args)
+        }
+    return addHandlerSettings(func, queryFilter)
+  }
+}
+
+function wrapWithValidation(filter, name, app) {
+  if (filter) {
+    // TODO: Implement `response` validation for filters too.
+    // TODO: Share additional coercion handling with
+    // `ControllerAction#coerceValue()`
+    const { parameters, options = {} } = filter
+    // If parameters are defined, wrap the function in a closure that
+    // performs parameter validation...
+    const dataName = 'query'
+    const validator = app.compileParametersValidator(parameters, {
+      ...options.parameters,
+      dataName
+    })
+    if (validator?.validate) {
+      return (query, ...args) => {
+        // Convert args to object for validation:
+        const object = {}
+        let index = 0
+        for (const { name } of validator.list) {
+          // Use dataName if no name is given, see:
+          // Application.compileParametersValidator()
+          object[name || dataName] = args[index++]
+        }
+        try {
+          validator.validate(object)
+        } catch (error) {
+          throw app.createValidationError({
+            type: 'FilterValidation',
+            message: `The provided data for query filter '${
+              name
+            }' is not valid`,
+            errors: app.validator.prefixInstancePaths(
+              error.errors,
+              `.${name}`
+            )
+          })
+        }
+        return validator.asObject
+          ? filter(query, object)
+          : filter(query, ...args)
+      }
+    }
+  }
+  // ...otherwise use the defined filter function unmodified.
+  return filter
+}

package/src/models/definitions/hooks.js

@@ -0,0 +1,8 @@
+import { mergeAsReversedArrays } from '../../utils/object.js'
+
+export default function hooks(values) {
+  // Use `mergeAsReversedArrays()` so that for each event there is an array
+  // of hooks in sequence from base class to sub class, so that the hooks
+  // from the base class are run first by `_emitStaticHook()`.
+  return mergeAsReversedArrays(values)
+}

package/src/models/definitions/index.js

@@ -0,0 +1,22 @@
+import options from './options.js'
+import properties from './properties.js'
+import relations from './relations.js'
+import schema from './schema.js'
+import scopes from './scopes.js'
+import filters from './filters.js'
+import modifiers from './modifiers.js'
+import assets from './assets.js'
+import hooks from './hooks.js'
+
+export default {
+  // Export options first, as other definitions may rely on them, e.g. UserMixin
+  options,
+  properties,
+  relations,
+  schema,
+  scopes,
+  filters,
+  modifiers,
+  assets,
+  hooks
+}

package/src/models/definitions/modifiers.js

@@ -0,0 +1,5 @@
+import { mergeReversed } from '../../utils/object.js'
+
+export default function modifiers(values) {
+  return mergeReversed(values)
+}

package/src/models/definitions/options.js

@@ -0,0 +1,5 @@
+import { mergeReversed } from '../../utils/object.js'
+
+export default function options(values) {
+  return mergeReversed(values)
+}

package/src/models/definitions/properties.js

@@ -0,0 +1,73 @@
+import { mergeReversed } from '../../utils/object.js'
+
+export default function properties(values) {
+  const properties = mergeReversed(values)
+  // Include auto-generated 'id' properties for models and relations.
+  const addIdProperty = (name, schema) => {
+    if (!(name in properties)) {
+      properties[name] = {
+        type: 'integer',
+        ...schema
+      }
+    }
+  }
+
+  for (const name of this.getIdPropertyArray()) {
+    addIdProperty(name, {
+      primary: true
+    })
+  }
+
+  const addRelationProperties = (relation, propName) => {
+    const modelClass = relation.ownerModelClass
+    const { nullable } = modelClass.definition.relations[relation.name]
+    for (const property of relation[propName].props) {
+      addIdProperty(property, {
+        unsigned: true,
+        foreign: true,
+        index: true,
+        ...(nullable && { nullable })
+      })
+    }
+  }
+
+  for (const relation of Object.values(this.getRelations())) {
+    addRelationProperties(relation, 'ownerProp')
+  }
+
+  for (const relation of this.getRelatedRelations()) {
+    addRelationProperties(relation, 'relatedProp')
+  }
+
+  // Support Objection's #id and #ref references on all models:
+  properties[this.uidProp] = {
+    type: 'string'
+  }
+  properties[this.uidRefProp] = {
+    type: 'string'
+  }
+
+  // Convert root-level short-forms, for easier properties handling in
+  // attributes and idColumn() & co:
+  // - `name: type` to `name: { type }`
+  // - `name: [...items]` to `name: { type: 'array', items }
+  // NOTE: Substitutions on all other levels happen in convertSchema()
+  const ids = []
+  const rest = []
+  for (const [name, property] of Object.entries(properties)) {
+    // Also sort properties by kind: primary id > foreign id > rest:
+    const entry = [name, property]
+    if (property.primary) {
+      ids.unshift(entry)
+    } else if (property.foreign) {
+      ids.push(entry)
+    } else {
+      rest.push(entry)
+    }
+  }
+  // Finally recompile a new properties object out of the sorted properties.
+  return [...ids, ...rest].reduce((merged, [name, property]) => {
+    merged[name] = property
+    return merged
+  }, {})
+}

package/src/models/definitions/relations.js

@@ -0,0 +1,5 @@
+import { mergeReversed } from '../../utils/object.js'
+
+export default function relations(values) {
+  return mergeReversed(values)
+}

package/src/models/definitions/schema.js

@@ -0,0 +1,5 @@
+import { mergeReversed } from '../../utils/object.js'
+
+export default function schema(values) {
+  return mergeReversed(values)
+}

package/src/models/definitions/scopes.js

@@ -0,0 +1,36 @@
+import { isObject, isFunction } from '@ditojs/utils'
+import { ModelError } from '../../errors/index.js'
+import { mergeReversed } from '../../utils/object.js'
+
+export default function scopes(values) {
+  const scopes = {}
+  // Use mergeAsReversedArrays() to keep lists of filters to be inherited per
+  // scope, so they can be called in sequence.
+  for (const [name, scope] of Object.entries(mergeReversed(values))) {
+    const func = isFunction(scope)
+      ? scope
+      : isObject(scope)
+        ? query => query.find(scope)
+        : null
+    if (!func) {
+      throw new Error(`Invalid scope '${name}': ${scope}.`)
+    }
+
+    const parentModelClass = Object.getPrototypeOf(this)
+
+    const applyParentScope = query => {
+      const parentScope = parentModelClass.getScope(name)
+      if (!parentScope) {
+        throw new ModelError(this, `Undefined parent scope: '${name}'`)
+      }
+      parentScope(query)
+      return query
+    }
+
+    scopes[name] = query => {
+      func(query, applyParentScope)
+      return query
+    }
+  }
+  return scopes
+}

package/src/models/index.js

@@ -0,0 +1,5 @@
+export * from './Model.js'
+export * from './AssetModel.js'
+export * from './SessionModel.js'
+export * from './TimeStampedModel.js'
+export * from './UserModel.js'