@feathersjs/schema 5.0.0-pre.20 → 5.0.0-pre.23

package/src/hooks/resolve.ts

@@ -0,0 +1,191 @@
+import { HookContext, NextFunction } from '@feathersjs/feathers'
+import { compose } from '@feathersjs/hooks'
+import { Resolver, ResolverStatus } from '../resolver'
+
+const getContext = <H extends HookContext>(context: H) => {
+  return {
+    ...context,
+    params: {
+      ...context.params,
+      query: {}
+    }
+  }
+}
+
+const getData = <H extends HookContext>(context: H) => {
+  const isPaginated = context.method === 'find' && context.result.data
+  const data = isPaginated ? context.result.data : context.result
+
+  return { isPaginated, data }
+}
+
+const runResolvers = async <T, H extends HookContext>(
+  resolvers: Resolver<T, H>[],
+  data: any,
+  ctx: H,
+  status?: Partial<ResolverStatus<T, H>>
+) => {
+  let current: any = data
+
+  for (const resolver of resolvers) {
+    if (resolver && typeof resolver.resolve === 'function') {
+      current = await resolver.resolve(current, ctx, status)
+    }
+  }
+
+  return current as T
+}
+
+export type ResolverSetting<H extends HookContext> = Resolver<any, H> | Resolver<any, H>[]
+
+export type DataResolvers<H extends HookContext> = {
+  create: Resolver<any, H>
+  patch: Resolver<any, H>
+  update: Resolver<any, H>
+}
+
+export type ResolveAllSettings<H extends HookContext> = {
+  data?: DataResolvers<H>
+  query?: Resolver<any, H>
+  result?: Resolver<any, H>
+  dispatch?: Resolver<any, H>
+}
+
+export const DISPATCH = Symbol('@feathersjs/schema/dispatch')
+
+export const getDispatch = (value: any) =>
+  typeof value === 'object' && value !== null && value[DISPATCH] !== undefined ? value[DISPATCH] : value
+
+export const resolveQuery =
+  <T, H extends HookContext>(...resolvers: Resolver<T, H>[]) =>
+  async (context: H, next?: NextFunction) => {
+    const ctx = getContext(context)
+    const data = context?.params?.query || {}
+    const query = await runResolvers(resolvers, data, ctx)
+
+    context.params = {
+      ...context.params,
+      query
+    }
+
+    if (typeof next === 'function') {
+      return next()
+    }
+  }
+
+export const resolveData =
+  <H extends HookContext>(settings: DataResolvers<H> | Resolver<any, H>) =>
+  async (context: H, next?: NextFunction) => {
+    if (context.method === 'create' || context.method === 'patch' || context.method === 'update') {
+      const resolvers = settings instanceof Resolver ? [settings] : [settings[context.method]]
+      const ctx = getContext(context)
+      const data = context.data
+
+      const status = {
+        originalContext: context
+      }
+
+      if (Array.isArray(data)) {
+        context.data = await Promise.all(data.map((current) => runResolvers(resolvers, current, ctx, status)))
+      } else {
+        context.data = await runResolvers(resolvers, data, ctx, status)
+      }
+    }
+
+    if (typeof next === 'function') {
+      return next()
+    }
+  }
+
+export const resolveResult =
+  <T, H extends HookContext>(...resolvers: Resolver<T, H>[]) =>
+  async (context: H, next?: NextFunction) => {
+    if (typeof next === 'function') {
+      const { $resolve: properties, ...query } = context.params?.query || {}
+      const resolve = {
+        originalContext: context,
+        ...context.params.resolve,
+        properties
+      }
+
+      context.params = {
+        ...context.params,
+        resolve,
+        query
+      }
+
+      await next()
+    }
+
+    const ctx = getContext(context)
+    const status = context.params.resolve
+    const { isPaginated, data } = getData(context)
+
+    const result = Array.isArray(data)
+      ? await Promise.all(data.map(async (current) => runResolvers(resolvers, current, ctx, status)))
+      : await runResolvers(resolvers, data, ctx, status)
+
+    if (isPaginated) {
+      context.result.data = result
+    } else {
+      context.result = result
+    }
+  }
+
+export const resolveDispatch =
+  <T, H extends HookContext>(...resolvers: Resolver<T, H>[]) =>
+  async (context: H, next?: NextFunction) => {
+    if (typeof next === 'function') {
+      await next()
+    }
+
+    const ctx = getContext(context)
+    const status = context.params.resolve
+    const { isPaginated, data } = getData(context)
+    const resolveAndGetDispatch = async (current: any) => {
+      const resolved = await runResolvers(resolvers, current, ctx, status)
+
+      return Object.keys(resolved).reduce((res, key) => {
+        res[key] = getDispatch(current[key])
+
+        return res
+      }, {} as any)
+    }
+
+    const result = await (Array.isArray(data)
+      ? Promise.all(data.map(resolveAndGetDispatch))
+      : resolveAndGetDispatch(data))
+    const dispatch = isPaginated
+      ? {
+          ...context.result,
+          data: result
+        }
+      : result
+
+    context.dispatch = dispatch
+    Object.defineProperty(context.result, DISPATCH, {
+      value: dispatch,
+      enumerable: false,
+      configurable: false
+    })
+  }
+
+export const resolveAll = <H extends HookContext>(map: ResolveAllSettings<H>) => {
+  const middleware = []
+
+  middleware.push(resolveDispatch(map.dispatch))
+
+  if (map.result) {
+    middleware.push(resolveResult(map.result))
+  }
+
+  if (map.query) {
+    middleware.push(resolveQuery(map.query))
+  }
+
+  if (map.data) {
+    middleware.push(resolveData(map.data))
+  }
+
+  return compose(middleware)
+}

package/src/hooks/validate.ts

@@ -0,0 +1,44 @@
+import { HookContext, NextFunction } from '@feathersjs/feathers'
+import { BadRequest } from '../../../errors/lib'
+import { Schema } from '../schema'
+
+export const validateQuery =
+  <H extends HookContext>(schema: Schema<any>) =>
+  async (context: H, next?: NextFunction) => {
+    const data = context?.params?.query || {}
+
+    try {
+      const query = await schema.validate(data)
+
+      context.params = {
+        ...context.params,
+        query
+      }
+
+      if (typeof next === 'function') {
+        return next()
+      }
+    } catch (error: any) {
+      throw error.ajv ? new BadRequest(error.message, error.errors) : error
+    }
+  }
+
+export const validateData =
+  <H extends HookContext>(schema: Schema<any>) =>
+  async (context: H, next?: NextFunction) => {
+    const data = context.data
+
+    try {
+      if (Array.isArray(data)) {
+        context.data = await Promise.all(data.map((current) => schema.validate(current)))
+      } else {
+        context.data = await schema.validate(data)
+      }
+    } catch (error: any) {
+      throw error.ajv ? new BadRequest(error.message, error.errors) : error
+    }
+
+    if (typeof next === 'function') {
+      return next()
+    }
+  }

package/src/index.ts

@@ -1,14 +1,16 @@
-import { ResolverStatus  } from './resolver';
+import { ResolverStatus } from './resolver'
 
-export * from './schema';
-export * from './resolver';
-export * from './hooks';
-export * from './query';
+export * from './schema'
+export * from './resolver'
+export * from './hooks'
+export * from './query'
 
-export type Infer<S extends { _type: any }> = S['_type'];
+export type Infer<S extends { _type: any }> = S['_type']
+
+export type Combine<S extends { _type: any }, U> = Pick<Infer<S>, Exclude<keyof Infer<S>, keyof U>> & U
 
 declare module '@feathersjs/feathers/lib/declarations' {
   interface Params {
-    resolve?: ResolverStatus<any, HookContext>;
+    resolve?: ResolverStatus<any, HookContext>
   }
 }

package/src/query.ts

@@ -1,23 +1,24 @@
-import { JSONSchema } from 'json-schema-to-ts';
+import { _ } from '@feathersjs/commons'
+import { JSONSchema } from 'json-schema-to-ts'
 
 export type PropertyQuery<D extends JSONSchema> = {
   anyOf: [
     D,
     {
-      type: 'object',
-      additionalProperties: false,
+      type: 'object'
+      additionalProperties: false
       properties: {
-        $gt: D,
-        $gte: D,
-        $lt: D,
-        $lte: D,
-        $ne: D,
+        $gt: D
+        $gte: D
+        $lt: D
+        $lte: D
+        $ne: D
         $in: {
-          type: 'array',
+          type: 'array'
           items: D
-        },
+        }
         $nin: {
-          type: 'array',
+          type: 'array'
           items: D
         }
       }
@@ -25,64 +26,72 @@ export type PropertyQuery<D extends JSONSchema> = {
   ]
 }
 
-export const queryProperty = <T extends JSONSchema> (definition: T) => ({
-  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
+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);
+    ]
+  } as const
+}
 
-export const queryProperties = <T extends { [key: string]: JSONSchema }> (definition: T) =>
+export const queryProperties = <T extends { [key: string]: JSONSchema }>(definition: T) =>
   Object.keys(definition).reduce((res, key) => {
-    (res as any)[key] = queryProperty(definition[key])
+    const result = res as any
+
+    result[key] = queryProperty(definition[key])
 
-    return res
+    return result
   }, {} as { [K in keyof T]: PropertyQuery<T[K]> })
 
-export const querySyntax = <T extends { [key: string]: JSONSchema }> (definition: T) => ({
-  $limit: {
-    type: 'number',
-    minimum: 0
-  },
-  $skip: {
-    type: 'number',
-    minimum: 0
-  },
-  $sort: {
-    type: 'object',
-    properties: Object.keys(definition).reduce((res, key) => {
-      (res as any)[key] = {
-        type: 'number',
-        enum: [1, -1]
-      }
+export const querySyntax = <T extends { [key: string]: JSONSchema }>(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
 
-      return res
-    }, {} 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)
+        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

@@ -1,49 +1,55 @@
-import { BadRequest } from '@feathersjs/errors';
-import { Schema } from './schema';
+import { BadRequest } from '@feathersjs/errors'
+import { Schema } from './schema'
 
 export type PropertyResolver<T, V, C> = (
-  value: V|undefined,
+  value: V | undefined,
   obj: T,
   context: C,
   status: ResolverStatus<T, C>
-) => Promise<V|undefined>;
+) => Promise<V | undefined>
 
 export type PropertyResolverMap<T, C> = {
   [key in keyof T]?: PropertyResolver<T, T[key], C>
 }
 
+export type ResolverConverter<T, C> = (
+  obj: any,
+  context: C,
+  status: ResolverStatus<T, C>
+) => Promise<T | undefined>
+
 export interface ResolverConfig<T, C> {
-  schema?: Schema<T>,
-  validate?: 'before'|'after'|false,
+  schema?: Schema<T>
+  validate?: 'before' | 'after' | false
   properties: PropertyResolverMap<T, C>
+  converter?: ResolverConverter<T, C>
 }
 
 export interface ResolverStatus<T, C> {
-  path: string[];
-  originalContext?: C;
-  properties?: string[];
-  stack: PropertyResolver<T, any, C>[];
+  path: string[]
+  originalContext?: C
+  properties?: string[]
+  stack: PropertyResolver<T, any, C>[]
 }
 
 export class Resolver<T, C> {
-  readonly _type!: T;
+  readonly _type!: T
 
-  constructor (public options: ResolverConfig<T, C>) {
-  }
+  constructor(public options: ResolverConfig<T, C>) {}
 
-  async resolveProperty<D, K extends keyof T> (
+  async resolveProperty<D, K extends keyof T>(
     name: K,
     data: D,
     context: C,
     status: Partial<ResolverStatus<T, C>> = {}
   ): Promise<T[K]> {
-    const resolver = this.options.properties[name];
-    const value = (data as any)[name];
-    const { path = [], stack = [] } = status || {};
+    const resolver = this.options.properties[name]
+    const value = (data as any)[name]
+    const { path = [], stack = [] } = status || {}
 
     // This prevents circular dependencies
     if (stack.includes(resolver)) {
-      return undefined;
+      return undefined
     }
 
     const resolverStatus = {
@@ -52,59 +58,70 @@ export class Resolver<T, C> {
       stack: [...stack, resolver]
     }
 
-    return resolver(value, data as any, context, resolverStatus);
+    return resolver(value, data as any, context, resolverStatus)
   }
 
-  async resolve<D> (_data: D, context: C, status?: Partial<ResolverStatus<T, C>>): Promise<T> {
-    const { properties: resolvers, schema, validate } = this.options;
-    const data = schema && validate === 'before' ? await schema.validate(_data) : _data;
-    const propertyList = (Array.isArray(status?.properties)
-      ? status?.properties
-      // By default get all data and resolver keys but remove duplicates
-      : [...new Set(Object.keys(data).concat(Object.keys(resolvers)))]
-    ) as (keyof T)[];
+  async convert<D>(data: D, context: C, status?: Partial<ResolverStatus<T, C>>) {
+    if (this.options.converter) {
+      const { path = [], stack = [] } = status || {}
 
-    const result: any = {};
-    const errors: any = {};
-    let hasErrors = false;
+      return this.options.converter(data, context, { ...status, path, stack })
+    }
 
-    // Not the most elegant but better performance
-    await Promise.all(propertyList.map(async name => {
-      const value = (data as any)[name];
+    return data
+  }
 
-      if (resolvers[name]) {
-        try {
-          const resolved = await this.resolveProperty(name, data, context, status);
+  async resolve<D>(_data: D, context: C, status?: Partial<ResolverStatus<T, C>>): Promise<T> {
+    const { properties: resolvers, schema, validate } = this.options
+    const payload = await this.convert(_data, context, status)
+    const data = schema && validate === 'before' ? await schema.validate(payload) : payload
+    const propertyList = (
+      Array.isArray(status?.properties)
+        ? status?.properties
+        : // By default get all data and resolver keys but remove duplicates
+          [...new Set(Object.keys(data).concat(Object.keys(resolvers)))]
+    ) as (keyof T)[]
+
+    const result: any = {}
+    const errors: any = {}
+    let hasErrors = false
 
-          if (resolved !== undefined) {
-            result[name] = resolved;
+    // Not the most elegant but better performance
+    await Promise.all(
+      propertyList.map(async (name) => {
+        const value = (data as any)[name]
+
+        if (resolvers[name]) {
+          try {
+            const resolved = await this.resolveProperty(name, data, context, status)
+
+            if (resolved !== undefined) {
+              result[name] = resolved
+            }
+          } catch (error: any) {
+            // TODO add error stacks
+            const convertedError =
+              typeof error.toJSON === 'function' ? error.toJSON() : { message: error.message || error }
+
+            errors[name] = convertedError
+            hasErrors = true
           }
-        } catch (error: any) {
-          // TODO add error stacks
-          const convertedError = typeof error.toJSON === 'function'
-            ? error.toJSON()
-            : { message: error.message || error };
-
-          errors[name] = convertedError;
-          hasErrors = true;
+        } else if (value !== undefined) {
+          result[name] = value
         }
-      } else if (value !== undefined) {
-        result[name] = value;
-      }
-    }));
+      })
+    )
 
     if (hasErrors) {
-      const propertyName = status?.properties ? ` ${status.properties.join('.')}` : '';
+      const propertyName = status?.properties ? ` ${status.properties.join('.')}` : ''
 
-      throw new BadRequest('Error resolving data' + propertyName, errors);
+      throw new BadRequest('Error resolving data' + (propertyName ? ` ${propertyName}` : ''), errors)
     }
 
-    return schema && validate === 'after'
-      ? await schema.validate(result)
-      : result;
+    return schema && validate === 'after' ? await schema.validate(result) : result
   }
 }
 
-export function resolve <T, C> (options: ResolverConfig<T, C>) {
-  return new Resolver<T, C>(options);
+export function resolve<T, C>(options: ResolverConfig<T, C>) {
+  return new Resolver<T, C>(options)
 }