@feathersjs/schema 5.0.0-pre.28 → 5.0.0-pre.30

package/src/default-schemas.ts

@@ -0,0 +1,157 @@
+import { FromSchema } from 'json-schema-to-ts'
+
+export const authenticationSettingsSchema = {
+  type: 'object',
+  required: ['secret', 'entity', 'authStrategies'],
+  properties: {
+    secret: {
+      type: 'string',
+      description: 'The JWT signing secret'
+    },
+    entity: {
+      oneOf: [
+        {
+          type: 'null'
+        },
+        {
+          type: 'string'
+        }
+      ],
+      description: 'The name of the authentication entity (e.g. user)'
+    },
+    entityId: {
+      type: 'string',
+      description: 'The name of the authentication entity id property'
+    },
+    service: {
+      type: 'string',
+      description: 'The path of the entity service'
+    },
+    authStrategies: {
+      type: 'array',
+      items: { type: 'string' },
+      description: 'A list of authentication strategy names that are allowed to create JWT access tokens'
+    },
+    parseStrategies: {
+      type: 'array',
+      items: { type: 'string' },
+      description:
+        'A list of authentication strategy names that should parse HTTP headers for authentication information (defaults to `authStrategies`)'
+    },
+    jwtOptions: {
+      type: 'object'
+    },
+    jwt: {
+      type: 'object',
+      properties: {
+        header: {
+          type: 'string',
+          default: 'Authorization',
+          description: 'The HTTP header containing the JWT'
+        },
+        schemes: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'An array of schemes to support'
+        }
+      }
+    },
+    local: {
+      type: 'object',
+      required: ['usernameField', 'passwordField'],
+      properties: {
+        usernameField: {
+          type: 'string',
+          description: 'Name of the username field (e.g. `email`)'
+        },
+        passwordField: {
+          type: 'string',
+          description: 'Name of the password field (e.g. `password`)'
+        },
+        hashSize: {
+          type: 'number',
+          description: 'The BCrypt salt length'
+        },
+        errorMessage: {
+          type: 'string',
+          default: 'Invalid login',
+          description: 'The error message to return on errors'
+        },
+        entityUsernameField: {
+          type: 'string',
+          description:
+            'Name of the username field on the entity if authentication request data and entity field names are different'
+        },
+        entityPasswordField: {
+          type: 'string',
+          description:
+            'Name of the password field on the entity if authentication request data and entity field names are different'
+        }
+      }
+    },
+    oauth: {
+      type: 'object',
+      properties: {
+        redirect: {
+          type: 'string'
+        },
+        origins: {
+          type: 'array',
+          items: { type: 'string' }
+        },
+        defaults: {
+          type: 'object',
+          properties: {
+            key: { type: 'string' },
+            secret: { type: 'string' }
+          }
+        }
+      }
+    }
+  }
+} as const
+
+export type AuthenticationConfiguration = FromSchema<typeof authenticationSettingsSchema>
+
+export const sqlSettingsSchema = {
+  type: 'object',
+  properties: {
+    client: { type: 'string' },
+    connection: { type: 'string' }
+  }
+} as const
+
+/**
+ * Schema for properties that are available in a standard Feathers application.
+ */
+export const defaultAppSettings = {
+  authentication: authenticationSettingsSchema,
+  origins: {
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  },
+  paginate: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['default', 'max'],
+    properties: {
+      default: { type: 'number' },
+      max: { type: 'number' }
+    }
+  },
+  mongodb: { type: 'string' },
+  mysql: sqlSettingsSchema,
+  postgresql: sqlSettingsSchema,
+  sqlite: sqlSettingsSchema,
+  mssql: sqlSettingsSchema
+} as const
+
+export const defaultAppConfiguration = {
+  type: 'object',
+  additionalProperties: false,
+  properties: defaultAppSettings
+} as const
+
+export type DefaultAppConfiguration = FromSchema<typeof defaultAppConfiguration>

package/src/hooks/resolve.ts

@@ -170,6 +170,8 @@ export const resolveDispatch =
     })
   }
 
+export const resolveExternal = resolveDispatch
+
 export const resolveAll = <H extends HookContext>(map: ResolveAllSettings<H>) => {
   const middleware = []
 

package/src/hooks/validate.ts

@@ -1,14 +1,16 @@
 import { HookContext, NextFunction } from '@feathersjs/feathers'
-import { BadRequest } from '../../../errors/lib'
-import { Schema } from '../schema'
+import { BadRequest } from '@feathersjs/errors'
+import { Schema, Validator } from '../schema'
+import { DataValidatorMap } from '../json-schema'
 
-export const validateQuery =
-  <H extends HookContext>(schema: Schema<any>) =>
-  async (context: H, next?: NextFunction) => {
+export const validateQuery = <H extends HookContext>(schema: Schema<any> | Validator) => {
+  const validator: Validator = typeof schema === 'function' ? schema : schema.validate.bind(schema)
+
+  return async (context: H, next?: NextFunction) => {
     const data = context?.params?.query || {}
 
     try {
-      const query = await schema.validate(data)
+      const query = await validator(data)
 
       context.params = {
         ...context.params,
@@ -22,23 +24,30 @@ export const validateQuery =
       throw error.ajv ? new BadRequest(error.message, error.errors) : error
     }
   }
+}
 
-export const validateData =
-  <H extends HookContext>(schema: Schema<any>) =>
-  async (context: H, next?: NextFunction) => {
+export const validateData = <H extends HookContext>(schema: Schema<any> | DataValidatorMap) => {
+  return async (context: H, next?: NextFunction) => {
     const data = context.data
+    const validator =
+      typeof (schema as Schema<any>).validate === 'function'
+        ? (schema as Schema<any>).validate.bind(schema)
+        : (schema as any)[context.method]
 
-    try {
-      if (Array.isArray(data)) {
-        context.data = await Promise.all(data.map((current) => schema.validate(current)))
-      } else {
-        context.data = await schema.validate(data)
+    if (validator) {
+      try {
+        if (Array.isArray(data)) {
+          context.data = await Promise.all(data.map((current) => validator(current)))
+        } else {
+          context.data = await validator(data)
+        }
+      } catch (error: any) {
+        throw error.ajv ? new BadRequest(error.message, error.errors) : error
       }
-    } catch (error: any) {
-      throw error.ajv ? new BadRequest(error.message, error.errors) : error
     }
 
     if (typeof next === 'function') {
       return next()
     }
   }
+}

package/src/index.ts

@@ -1,9 +1,17 @@
+import addFormats, { FormatName, FormatOptions, FormatsPluginOptions } from 'ajv-formats'
 import { ResolverStatus } from './resolver'
 
+export type { FromSchema } from 'json-schema-to-ts'
+export { addFormats, FormatName, FormatOptions, FormatsPluginOptions }
+
 export * from './schema'
 export * from './resolver'
 export * from './hooks'
-export * from './query'
+export * from './json-schema'
+export * from './default-schemas'
+
+export * as hooks from './hooks'
+export * as jsonSchema from './json-schema'
 
 export type Infer<S extends { _type: any }> = S['_type']
 

package/src/json-schema.ts

@@ -0,0 +1,182 @@
+import { _ } from '@feathersjs/commons'
+import { JSONSchema } from 'json-schema-to-ts'
+import { TObject } from '@sinclair/typebox'
+import { JSONSchemaDefinition, Ajv, Validator } from './schema'
+
+export type DataSchemaMap = {
+  create: JSONSchemaDefinition | TObject
+  update?: JSONSchemaDefinition | TObject
+  patch?: JSONSchemaDefinition | TObject
+}
+
+export type DataValidatorMap = {
+  create: Validator
+  update: Validator
+  patch: Validator
+}
+
+/**
+ * Returns a compiled validation function for a schema and AJV validator instance.
+ *
+ * @param schema The JSON schema definition
+ * @param validator The AJV validation instance
+ * @returns A compiled validation function
+ */
+export const getValidator = <T = any, R = T>(
+  schema: JSONSchemaDefinition | TObject,
+  validator: Ajv
+): Validator<T, R> =>
+  validator.compile({
+    $async: true,
+    ...(schema as any)
+  }) as any as Validator<T, R>
+
+/**
+ * Returns compiled validation functions to validate data for the `create`, `update` and `patch`
+ * service methods. If not passed explicitly, the `update` validator will be the same as the `create`
+ * and `patch` will be the `create` validator with no required fields.
+ *
+ * @param def Either general JSON schema definition or a mapping of `create`, `update` and `patch`
+ * to their respecitve JSON schema
+ * @param validator The Ajv instance to use as the validator
+ * @returns A map of validator functions
+ */
+export const getDataValidator = (
+  def: JSONSchemaDefinition | TObject | DataSchemaMap,
+  validator: Ajv
+): DataValidatorMap => {
+  const schema = ((def as any).create ? def : { create: def }) as DataSchemaMap
+
+  return {
+    create: getValidator(schema.create, validator),
+    update: getValidator(
+      schema.update || {
+        ...(schema.create as any),
+        $id: `${schema.create.$id}Update`
+      },
+      validator
+    ),
+    patch: getValidator(
+      schema.patch || {
+        ...(schema.create as any),
+        $id: `${schema.create.$id}Patch`,
+        required: []
+      },
+      validator
+    )
+  }
+}
+
+export type PropertyQuery<D extends JSONSchema> = {
+  anyOf: [
+    D,
+    {
+      type: 'object'
+      additionalProperties: false
+      properties: {
+        $gt: D
+        $gte: D
+        $lt: D
+        $lte: D
+        $ne: D
+        $in: {
+          type: 'array'
+          items: D
+        }
+        $nin: {
+          type: 'array'
+          items: D
+        }
+      }
+    }
+  ]
+}
+
+/**
+ * Create a Feathers query syntax compatible JSON schema definition for a property definition.
+ *
+ * @param def The property definition (e.g. `{ type: 'string' }`)
+ * @returns A JSON schema definition for the Feathers query syntax for this property.
+ */
+export const queryProperty = <T extends JSONSchema>(def: T) => {
+  const definition = _.omit(def, 'default')
+  return {
+    anyOf: [
+      definition,
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          $gt: definition,
+          $gte: definition,
+          $lt: definition,
+          $lte: definition,
+          $ne: definition,
+          $in: {
+            type: 'array',
+            items: definition
+          },
+          $nin: {
+            type: 'array',
+            items: definition
+          }
+        }
+      }
+    ]
+  } as const
+}
+
+/**
+ * Creates Feathers a query syntax compatible JSON schema for multiple properties.
+ *
+ * @param definition A map of property definitions
+ * @returns The JSON schema definition for the Feathers query syntax for multiple properties
+ */
+export const queryProperties = <T extends { [key: string]: JSONSchema }>(definition: T) =>
+  Object.keys(definition).reduce((res, key) => {
+    const result = res as any
+
+    result[key] = queryProperty(definition[key])
+
+    return result
+  }, {} as { [K in keyof T]: PropertyQuery<T[K]> })
+
+/**
+ * Creates a JSON schema for the complete Feathers query syntax including `$limit`, $skip`
+ * and `$sort` and `$select` for the allowed properties.
+ *
+ * @param definition The property definitions to create the query syntax schema for
+ * @returns A JSON schema for the complete query syntax
+ */
+export const querySyntax = <T extends { [key: string]: any }>(definition: T) =>
+  ({
+    $limit: {
+      type: 'number',
+      minimum: 0
+    },
+    $skip: {
+      type: 'number',
+      minimum: 0
+    },
+    $sort: {
+      type: 'object',
+      properties: Object.keys(definition).reduce((res, key) => {
+        const result = res as any
+
+        result[key] = {
+          type: 'number',
+          enum: [1, -1]
+        }
+
+        return result
+      }, {} as { [K in keyof T]: { readonly type: 'number'; readonly enum: [1, -1] } })
+    },
+    $select: {
+      type: 'array',
+      items: {
+        type: 'string',
+        enum: Object.keys(definition) as any as (keyof T)[]
+      }
+    },
+    ...queryProperties(definition)
+  } as const)

package/src/resolver.ts

@@ -20,8 +20,18 @@ export type ResolverConverter<T, C> = (
 
 export interface ResolverConfig<T, C> {
   schema?: Schema<T>
+  /**
+   * @deprecated Use the `validateData` and `validateQuery` hooks explicitly instead
+   */
   validate?: 'before' | 'after' | false
+  /**
+   * The properties to resolve
+   */
   properties: PropertyResolverMap<T, C>
+  /**
+   * A converter function that is run before property resolvers
+   * to transform the initial data into a different format.
+   */
   converter?: ResolverConverter<T, C>
 }
 
@@ -37,6 +47,15 @@ export class Resolver<T, C> {
 
   constructor(public options: ResolverConfig<T, C>) {}
 
+  /**
+   * Resolve a single property
+   *
+   * @param name The name of the property
+   * @param data The current data
+   * @param context The current resolver context
+   * @param status The current resolver status
+   * @returns The resolver property
+   */
   async resolveProperty<D, K extends keyof T>(
     name: K,
     data: D,
@@ -122,6 +141,12 @@ export class Resolver<T, C> {
   }
 }
 
+/**
+ * Create a new resolver with `<DataType, ContextType>`.
+ *
+ * @param options The configuration for the returned resolver
+ * @returns A new resolver instance
+ */
 export function resolve<T, C>(options: ResolverConfig<T, C>) {
   return new Resolver<T, C>(options)
 }

package/src/schema.ts

@@ -3,14 +3,21 @@ import { FromSchema, JSONSchema } from 'json-schema-to-ts'
 import { BadRequest } from '@feathersjs/errors'
 
 export const DEFAULT_AJV = new Ajv({
-  coerceTypes: true
+  coerceTypes: true,
+  addUsedSchema: false
 })
 
 export { Ajv }
 
+/**
+ * A validation function that takes data and returns the (possibly coerced)
+ * data or throws a validation error.
+ */
+export type Validator<T = any, R = T> = (data: T) => Promise<R>
+
 export type JSONSchemaDefinition = JSONSchema & {
   $id: string
-  $async?: boolean
+  $async?: true
   properties?: { [key: string]: JSONSchema }
   required?: readonly string[]
 }

package/lib/query.d.ts

@@ -1,75 +0,0 @@
-import { JSONSchema } from 'json-schema-to-ts';
-export declare type PropertyQuery<D extends JSONSchema> = {
-    anyOf: [
-        D,
-        {
-            type: 'object';
-            additionalProperties: false;
-            properties: {
-                $gt: D;
-                $gte: D;
-                $lt: D;
-                $lte: D;
-                $ne: D;
-                $in: {
-                    type: 'array';
-                    items: D;
-                };
-                $nin: {
-                    type: 'array';
-                    items: D;
-                };
-            };
-        }
-    ];
-};
-export declare const queryProperty: <T extends import("json-schema-to-ts").JSONSchema7>(def: T) => {
-    readonly anyOf: readonly [any, {
-        readonly type: "object";
-        readonly additionalProperties: false;
-        readonly properties: {
-            readonly $gt: any;
-            readonly $gte: any;
-            readonly $lt: any;
-            readonly $lte: any;
-            readonly $ne: any;
-            readonly $in: {
-                readonly type: "array";
-                readonly items: any;
-            };
-            readonly $nin: {
-                readonly type: "array";
-                readonly items: any;
-            };
-        };
-    }];
-};
-export declare const queryProperties: <T extends {
-    [key: string]: import("json-schema-to-ts").JSONSchema7;
-}>(definition: T) => { [K in keyof T]: PropertyQuery<T[K]>; };
-export declare const querySyntax: <T extends {
-    [key: string]: any;
-}>(definition: T) => {
-    readonly $limit: {
-        readonly type: "number";
-        readonly minimum: 0;
-    };
-    readonly $skip: {
-        readonly type: "number";
-        readonly minimum: 0;
-    };
-    readonly $sort: {
-        readonly type: "object";
-        readonly properties: { [K in keyof T]: {
-            readonly type: 'number';
-            readonly enum: [1, -1];
-        }; };
-    };
-    readonly $select: {
-        readonly type: "array";
-        readonly items: {
-            readonly type: "string";
-            readonly enum: (keyof T)[];
-        };
-    };
-} & { [K_1 in keyof T]: PropertyQuery<T[K_1]>; };

package/lib/query.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.querySyntax = exports.queryProperties = exports.queryProperty = void 0;
-const commons_1 = require("@feathersjs/commons");
-const queryProperty = (def) => {
-    const definition = commons_1._.omit(def, 'default');
-    return {
-        anyOf: [
-            definition,
-            {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    $gt: definition,
-                    $gte: definition,
-                    $lt: definition,
-                    $lte: definition,
-                    $ne: definition,
-                    $in: {
-                        type: 'array',
-                        items: definition
-                    },
-                    $nin: {
-                        type: 'array',
-                        items: definition
-                    }
-                }
-            }
-        ]
-    };
-};
-exports.queryProperty = queryProperty;
-const queryProperties = (definition) => Object.keys(definition).reduce((res, key) => {
-    const result = res;
-    result[key] = (0, exports.queryProperty)(definition[key]);
-    return result;
-}, {});
-exports.queryProperties = queryProperties;
-const querySyntax = (definition) => ({
-    $limit: {
-        type: 'number',
-        minimum: 0
-    },
-    $skip: {
-        type: 'number',
-        minimum: 0
-    },
-    $sort: {
-        type: 'object',
-        properties: Object.keys(definition).reduce((res, key) => {
-            const result = res;
-            result[key] = {
-                type: 'number',
-                enum: [1, -1]
-            };
-            return result;
-        }, {})
-    },
-    $select: {
-        type: 'array',
-        items: {
-            type: 'string',
-            enum: Object.keys(definition)
-        }
-    },
-    ...(0, exports.queryProperties)(definition)
-});
-exports.querySyntax = querySyntax;
-//# sourceMappingURL=query.js.map

package/lib/query.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":";;;AAAA,iDAAuC;AA4BhC,MAAM,aAAa,GAAG,CAAuB,GAAM,EAAE,EAAE;IAC5D,MAAM,UAAU,GAAG,WAAC,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;IACzC,OAAO;QACL,KAAK,EAAE;YACL,UAAU;YACV;gBACE,IAAI,EAAE,QAAQ;gBACd,oBAAoB,EAAE,KAAK;gBAC3B,UAAU,EAAE;oBACV,GAAG,EAAE,UAAU;oBACf,IAAI,EAAE,UAAU;oBAChB,GAAG,EAAE,UAAU;oBACf,IAAI,EAAE,UAAU;oBAChB,GAAG,EAAE,UAAU;oBACf,GAAG,EAAE;wBACH,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE,UAAU;qBAClB;oBACD,IAAI,EAAE;wBACJ,IAAI,EAAE,OAAO;wBACb,KAAK,EAAE,UAAU;qBAClB;iBACF;aACF;SACF;KACO,CAAA;AACZ,CAAC,CAAA;AA1BY,QAAA,aAAa,iBA0BzB;AAEM,MAAM,eAAe,GAAG,CAA0C,UAAa,EAAE,EAAE,CACxF,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;IAC1C,MAAM,MAAM,GAAG,GAAU,CAAA;IAEzB,MAAM,CAAC,GAAG,CAAC,GAAG,IAAA,qBAAa,EAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAA;IAE5C,OAAO,MAAM,CAAA;AACf,CAAC,EAAE,EAA6C,CAAC,CAAA;AAPtC,QAAA,eAAe,mBAOuB;AAE5C,MAAM,WAAW,GAAG,CAAmC,UAAa,EAAE,EAAE,CAC7E,CAAC;IACC,MAAM,EAAE;QACN,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,CAAC;KACX;IACD,KAAK,EAAE;QACL,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,CAAC;KACX;IACD,KAAK,EAAE;QACL,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACtD,MAAM,MAAM,GAAG,GAAU,CAAA;YAEzB,MAAM,CAAC,GAAG,CAAC,GAAG;gBACZ,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;aACd,CAAA;YAED,OAAO,MAAM,CAAA;QACf,CAAC,EAAE,EAA6E,CAAC;KAClF;IACD,OAAO,EAAE;QACP,IAAI,EAAE,OAAO;QACb,KAAK,EAAE;YACL,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAuB;SACpD;KACF;IACD,GAAG,IAAA,uBAAe,EAAC,UAAU,CAAC;CACrB,CAAA,CAAA;AA/BA,QAAA,WAAW,eA+BX"}