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

package/src/query/QueryFilters.js

@@ -0,0 +1,66 @@
+import Registry from './Registry.js'
+export const QueryFilters = new Registry()
+
+QueryFilters.register({
+  'text': {
+    parameters: {
+      operator: {
+        type: 'string'
+      },
+      text: {
+        type: 'string'
+      }
+    },
+
+    handler(query, property, { operator, text }) {
+      if (text === undefined) {
+        text = operator
+        operator = 'contains'
+      }
+      const templates = {
+        'equals': text => text,
+        'contains': text => `%${text}%`,
+        'starts-with': text => `${text}%`,
+        'ends-with': text => `%${text}`
+      }
+      if (text) {
+        const operand = templates[operator]?.(text)
+        if (operand) {
+          if (query.isPostgreSQL()) {
+            query.where(property, 'ILIKE', operand)
+          } else {
+            query.whereRaw(
+              `LOWER(??) LIKE ?`,
+              [property, operand.toLowerCase()]
+            )
+          }
+        }
+      }
+    }
+  },
+
+  'date-range': {
+    parameters: {
+      from: {
+        type: 'datetime',
+        nullable: true
+      },
+      to: {
+        type: 'datetime',
+        nullable: true
+      }
+    },
+
+    handler(query, property, { from, to }) {
+      if (from && to) {
+        query.whereBetween(property, [new Date(from), new Date(to)])
+      } else if (from) {
+        query.where(property, '>=', new Date(from))
+      } else if (to) {
+        query.where(property, '<=', new Date(to))
+      } else {
+        // TODO: Can we get validation to catch the case where both are empty?
+      }
+    }
+  }
+})

package/src/query/QueryParameters.js

@@ -0,0 +1,79 @@
+import { isString, asArray } from '@ditojs/utils'
+import Registry from './Registry.js'
+import { ResponseError, QueryBuilderError } from '../errors/index.js'
+
+export const QueryParameters = new Registry()
+
+QueryParameters.register({
+  scope(query, key, value) {
+    // Use `applyScope()` instead of `withScope()`, so the scope applied here
+    // can clear earlier `withScope()` statements before `execute()` is run.
+    query.applyScope(...asArray(value))
+  },
+
+  filter(query, key, value) {
+    try {
+      query.applyFilter(
+        Object.fromEntries(
+          asArray(value).map(filter => {
+            const [, name, json] = filter.match(/^(\w+):(.*)$/)
+            return [name, JSON.parse(`[${json}]`)]
+          })
+        )
+      )
+    } catch (error) {
+      throw error instanceof ResponseError
+        ? error
+        : new QueryBuilderError(
+            `Invalid Query filter parameters: ${error.message}.`
+          )
+    }
+  },
+
+  range(query, key, value) {
+    if (value) {
+      const [from, to] = isString(value) ? value.split(/\s*,s*/) : value
+      const start = +from
+      const end = +to
+      if (isNaN(start) || isNaN(end) || end < start) {
+        throw new QueryBuilderError(`Invalid range: [${start}, ${end}].`)
+      }
+      query.range(start, end)
+    }
+  },
+
+  limit(query, key, value) {
+    query.limit(value)
+  },
+
+  offset(query, key, value) {
+    query.offset(value)
+  },
+
+  order(query, key, value) {
+    if (value) {
+      for (const entry of asArray(value)) {
+        const [propertyName, direction, nulls] = entry.trim().split(/\s+/)
+        if (direction && !['asc', 'desc'].includes(direction)) {
+          throw new QueryBuilderError(
+            `Invalid order direction: '${direction}'.`
+          )
+        }
+        if (nulls && !['first', 'last'].includes(nulls)) {
+          throw new QueryBuilderError(
+            `Invalid nulls order: '${null}'.`
+          )
+        }
+        const tableRef = query.tableRefFor(query.modelClass())
+        const columnName = `${tableRef}.${propertyName}`
+        if (nulls) {
+          query.orderBy(columnName, direction, nulls)
+        } else if (direction) {
+          query.orderBy(columnName, direction)
+        } else {
+          query.orderBy(columnName)
+        }
+      }
+    }
+  }
+})

package/src/query/Registry.js

@@ -0,0 +1,29 @@
+import { isObject } from '@ditojs/utils'
+
+export default class Registry {
+  #registry = Object.create(null)
+  #allowed = Object.create(null)
+
+  get(name) {
+    return this.#registry[name]
+  }
+
+  has(name) {
+    return name in this.#registry
+  }
+
+  register(name, handler) {
+    if (isObject(name)) {
+      for (const key in name) {
+        this.register(key, name[key])
+      }
+    } else {
+      this.#registry[name] = handler
+      this.#allowed[name] = true
+    }
+  }
+
+  getAllowed() {
+    return this.#allowed
+  }
+}

package/src/query/index.js

@@ -0,0 +1,3 @@
+export * from './QueryBuilder.js'
+export * from './QueryFilters.js'
+export * from './QueryParameters.js'

package/src/schema/formats/_empty.js

@@ -0,0 +1,4 @@
+export const empty = {
+  validate: value => !value,
+  message: 'needs to be empty'
+}

package/src/schema/formats/_required.js

@@ -0,0 +1,4 @@
+export const required = {
+  validate: value => value != null && value !== '',
+  message: 'is required'
+}

package/src/schema/formats/index.js

@@ -0,0 +1,2 @@
+export * from './_empty.js'
+export * from './_required.js'

package/src/schema/index.js

@@ -0,0 +1,5 @@
+export * as keywords from './keywords/index.js'
+export * as formats from './formats/index.js'
+export * as types from './types/index.js'
+export * from './schema.js'
+export * from './relations.js'

package/src/schema/keywords/_computed.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const computed = {
+  metaSchema: {
+    type: 'boolean'
+  }
+}

package/src/schema/keywords/_foreign.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const foreign = {
+  metaSchema: {
+    type: 'boolean'
+  }
+}

package/src/schema/keywords/_hidden.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const hidden = {
+  metaSchema: {
+    type: 'boolean'
+  }
+}

package/src/schema/keywords/_index.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const index = {
+  metaSchema: {
+    type: 'boolean'
+  }
+}

package/src/schema/keywords/_instanceof.js

@@ -0,0 +1,45 @@
+import { isString, isFunction, asArray } from '@ditojs/utils'
+
+export const _instanceof = {
+  metaSchema: {
+    anyOf: [
+      { type: 'string' },
+      {
+        type: 'array',
+        items: {
+          type: ['string', 'object']
+        }
+      }
+    ]
+  },
+
+  validate(schema, data) {
+    // Support instanceof for basic JS types and Dito.js models. If `this` is
+    // the validator's ctx (see passContext), then we can access the models and
+    // check.
+    const models = this?.app?.models
+    for (const type of asArray(schema)) {
+      const ctor = isString(type)
+        ? constructors[type] || models?.[type]
+        : isFunction(type)
+          ? type
+          : null
+      if (ctor && data instanceof ctor) {
+        return true
+      }
+    }
+    return false
+  }
+}
+
+const constructors = {
+  Object,
+  Array,
+  Function,
+  String,
+  Number,
+  Boolean,
+  Date,
+  RegExp,
+  Buffer
+}

package/src/schema/keywords/_primary.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const primary = {
+  metaSchema: {
+    type: 'boolean'
+  }
+}

package/src/schema/keywords/_range.js

@@ -0,0 +1,18 @@
+export const range = {
+  type: ['number', 'integer'],
+  metaSchema: {
+    type: 'array',
+    prefixItems: [
+      { type: 'number' },
+      { type: 'number' }
+    ],
+    minItems: 2,
+    items: false
+  },
+  macro(config) {
+    return {
+      minimum: config[0],
+      maximum: config[1]
+    }
+  }
+}

package/src/schema/keywords/_relate.js

@@ -0,0 +1,13 @@
+// This keyword is used to validate reference-only data in relations: { id: 1 }
+// See ../schema/relation.js for more details
+export const relate = {
+  silent: true,
+
+  metaSchema: {
+    type: 'string'
+  },
+
+  validate(schema, data) {
+    return this.app?.models[schema]?.isReference(data) || false
+  }
+}

package/src/schema/keywords/_specificType.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const specificType = {
+  metaSchema: {
+    type: 'string'
+  }
+}

package/src/schema/keywords/_unique.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const unique = {
+  metaSchema: {
+    type: ['boolean', 'string']
+  }
+}

package/src/schema/keywords/_unsigned.js

@@ -0,0 +1,7 @@
+// This keyword is there for meta-information and migration generation only.
+// It doesn't do any actual validation.
+export const unsigned = {
+  metaSchema: {
+    type: 'boolean'
+  }
+}

package/src/schema/keywords/_validate.js

@@ -0,0 +1,73 @@
+import Ajv from 'ajv/dist/2020.js'
+import { isNumber, isArray } from '@ditojs/utils'
+
+export const validate = {
+  metaSchema: {
+    instanceof: 'Function'
+  },
+  errors: 'full',
+
+  validate: function validate(func, data, parentSchema, dataCtx) {
+    // The validator's `ctx` as passed to Ajv with passContext as `this`:
+    const params = getParams(this, data, parentSchema, dataCtx)
+    try {
+      return func(params) ?? true
+    } catch (error) {
+      // In sync validation, we have to pass the errors back to Ajv through
+      // `validate.errors`.
+      validate.errors = getErrors(error, params)
+      return false
+    }
+  }
+}
+
+// This is the async version of the above, to handle async `validate()`
+// functions in schemas. See `Validator.processSchema()` for details.
+export const validateAsync = {
+  ...validate,
+  async: true,
+
+  async validate(func, data, parentSchema, dataCtx) {
+    // The validator's `ctx` as passed to Ajv with passContext as `this`:
+    const params = getParams(this, data, parentSchema, dataCtx)
+    try {
+      return (await func(params)) ?? true
+    } catch (error) {
+      // Async validate methods need to throw their errors.
+      throw new Ajv.ValidationError(getErrors(error, params))
+    }
+  }
+}
+
+function getParams(ctx, data, parentSchema, dataCtx) {
+  const { instancePath, parentData, parentDataProperty, rootData } = dataCtx
+  return {
+    data,
+    parentData,
+    rootData,
+    instancePath,
+    // NOTE: We rename parentDataProperty to parentKey / parentIndex:
+    [isNumber(parentDataProperty) ? 'parentIndex' : 'parentKey']:
+      parentDataProperty,
+    ctx,
+    app: ctx.app,
+    validator: ctx.validator,
+    options: ctx.options
+  }
+}
+
+function getErrors(error, { validator, instancePath }) {
+  const errors = isArray(error.errors)
+    ? // Ajv errors array:
+      error.errors
+    : // Convert string error message to errors array:
+      [
+        {
+          keyword: 'validate',
+          message: error.message || error.toString(),
+          params: {}
+        }
+      ]
+  // Return errors prefixed with the current instancePath:
+  return validator.prefixInstancePaths(errors, instancePath)
+}

package/src/schema/keywords/index.js

@@ -0,0 +1,12 @@
+export * from './_specificType.js'
+export * from './_primary.js'
+export * from './_foreign.js'
+export * from './_unique.js'
+export * from './_index.js'
+export * from './_computed.js'
+export * from './_hidden.js'
+export * from './_unsigned.js'
+export * from './_instanceof.js'
+export * from './_validate.js'
+export * from './_relate.js'
+export * from './_range.js'