@feathersjs/schema 5.0.0-pre.21 → 5.0.0-pre.24

package/src/hooks/resolve.ts

@@ -1,8 +1,8 @@
-import { HookContext, NextFunction } from '@feathersjs/feathers';
-import { compose } from '@feathersjs/hooks';
-import { Resolver, ResolverStatus } from '../resolver';
+import { HookContext, NextFunction } from '@feathersjs/feathers'
+import { compose } from '@feathersjs/hooks'
+import { Resolver, ResolverStatus } from '../resolver'
 
-const getContext = <H extends HookContext> (context: H) => {
+const getContext = <H extends HookContext>(context: H) => {
   return {
     ...context,
     params: {
@@ -12,35 +12,56 @@ const getContext = <H extends HookContext> (context: H) => {
   }
 }
 
-const getData = <H extends HookContext> (context: H) => {
-  const isPaginated = context.method === 'find' && context.result.data;
-  const data = isPaginated ? context.result.data : context.result;
+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 };
+  return { isPaginated, data }
 }
 
-const runResolvers = async <T, H extends HookContext> (
+const runResolvers = async <T, H extends HookContext>(
   resolvers: Resolver<T, H>[],
   data: any,
   ctx: H,
   status?: Partial<ResolverStatus<T, H>>
 ) => {
-  let current: any = data;
+  let current: any = data
 
   for (const resolver of resolvers) {
-    current = await resolver.resolve(current, ctx, status);
+    if (resolver && typeof resolver.resolve === 'function') {
+      current = await resolver.resolve(current, ctx, status)
+    }
   }
 
-  return current as T;
+  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 DISPATCH = Symbol('@feathersjs/schema/dispatch')
 
-export const resolveQuery = <T, H extends HookContext> (...resolvers: Resolver<T, H>[]) =>
+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);
+    const ctx = getContext(context)
+    const data = context?.params?.query || {}
+    const query = await runResolvers(resolvers, data, ctx)
 
     context.params = {
       ...context.params,
@@ -48,43 +69,44 @@ export const resolveQuery = <T, H extends HookContext> (...resolvers: Resolver<T
     }
 
     if (typeof next === 'function') {
-      return next();
+      return next()
     }
-  };
+  }
 
-export const resolveData = <T, H extends HookContext> (...resolvers: Resolver<T, H>[]) =>
+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 ctx = getContext(context);
-      const data = context.data;
+      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)
-        ));
+        context.data = await Promise.all(data.map((current) => runResolvers(resolvers, current, ctx, status)))
       } else {
-        context.data = await runResolvers(resolvers, data, ctx, status);
+        context.data = await runResolvers(resolvers, data, ctx, status)
       }
     }
 
     if (typeof next === 'function') {
-      return next();
+      return next()
     }
-  };
+  }
 
-export const resolveResult = <T, H extends HookContext> (...resolvers: Resolver<T, H>[]) =>
+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: properties, ...query } = context.params?.query || {}
       const resolve = {
         originalContext: context,
         ...context.params.resolve,
         properties
-      };
+      }
 
       context.params = {
         ...context.params,
@@ -92,79 +114,78 @@ export const resolveResult = <T, H extends HookContext> (...resolvers: Resolver<
         query
       }
 
-      await next();
+      await next()
     }
 
-    const ctx = getContext(context);
-    const status = context.params.resolve;
-    const { isPaginated, data } = getData(context);
+    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);
+    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;
+      context.result.data = result
     } else {
-      context.result = result;
+      context.result = result
     }
-  };
+  }
 
-export const resolveDispatch = <T, H extends HookContext> (...resolvers: Resolver<T, H>[]) =>
+export const resolveDispatch =
+  <T, H extends HookContext>(...resolvers: Resolver<T, H>[]) =>
   async (context: H, next?: NextFunction) => {
     if (typeof next === 'function') {
-      await next();
+      await next()
     }
 
-    const ctx = getContext(context);
-    const status = context.params.resolve;
-    const { isPaginated, data } = getData(context);
-    const resolveDispatch = async (current: any) => {
-      const resolved = await runResolvers(resolvers, current, ctx, status)
+    const ctx = getContext(context)
+    const status = context.params.resolve
+    const { isPaginated, data } = getData(context)
+    const resolveAndGetDispatch = async (current: any) => {
+      const resolved: any = await runResolvers(resolvers, current, ctx, status)
 
       return Object.keys(resolved).reduce((res, key) => {
-        const value = current[key];
-        const hasDispatch = typeof value === 'object' && value !== null && value[DISPATCH] !== undefined;
-
-        res[key] = hasDispatch ? value[DISPATCH] : value;
+        res[key] = getDispatch(resolved[key])
 
         return res
       }, {} as any)
     }
 
-    const result = await (Array.isArray(data) ? Promise.all(data.map(resolveDispatch)) : resolveDispatch(data));
-    const dispatch = isPaginated ? {
-      ...context.result,
-      data: result
-    } : result;
-
-    context.dispatch = dispatch;
+    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 type ResolveAllSettings<H extends HookContext> = {
-  data?: Resolver<any, H>|Resolver<any, H>[]
-  query?: Resolver<any, H>|Resolver<any, H>[]
-  result?: Resolver<any, H>|Resolver<any, H>[]
-  dispatch?: Resolver<any, H>|Resolver<any, H>[]
-}
+export const resolveAll = <H extends HookContext>(map: ResolveAllSettings<H>) => {
+  const middleware = []
 
-const getResolvers = <H extends HookContext> (
-  map: ResolveAllSettings<H>,
-  name: keyof ResolveAllSettings<H>
-) => {
-  const value = map[name];
+  middleware.push(resolveDispatch(map.dispatch))
 
-  return Array.isArray(value) ? value : (value !== undefined ? [ value ] : []);
-}
+  if (map.result) {
+    middleware.push(resolveResult(map.result))
+  }
+
+  if (map.query) {
+    middleware.push(resolveQuery(map.query))
+  }
 
-export const resolveAll = <H extends HookContext> (map: ResolveAllSettings<H>) => compose([
-  resolveDispatch(...getResolvers(map, 'dispatch')),
-  resolveResult(...getResolvers(map, 'result')),
-  resolveQuery(...getResolvers(map, 'query')),
-  resolveData(...getResolvers(map, 'data'))
-])
+  if (map.data) {
+    middleware.push(resolveData(map.data))
+  }
+
+  return compose(middleware)
+}

package/src/hooks/validate.ts

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

package/src/index.ts

@@ -1,16 +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;
+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]: 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
 
-      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)