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

package/src/resolver.ts

@@ -1,23 +1,26 @@
-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 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>
 }
@@ -30,24 +33,23 @@ export interface ResolverStatus<T, 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 = {
@@ -56,10 +58,10 @@ 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 convert <D> (data: D, context: C, status?: Partial<ResolverStatus<T, C>>) {
+  async convert<D>(data: D, context: C, status?: Partial<ResolverStatus<T, C>>) {
     if (this.options.converter) {
       const { path = [], stack = [] } = status || {}
 
@@ -69,57 +71,57 @@ export class Resolver<T, C> {
     return data
   }
 
-  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;
+  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
 
     // 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;
+    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 ? ` ${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)
 }

package/src/schema.ts

@@ -1,60 +1,60 @@
-import Ajv, { AsyncValidateFunction, ValidateFunction } from 'ajv';
-import { FromSchema, JSONSchema } from 'json-schema-to-ts';
-import { BadRequest } from '@feathersjs/errors';
+import Ajv, { AsyncValidateFunction, ValidateFunction } from 'ajv'
+import { FromSchema, JSONSchema } from 'json-schema-to-ts'
+import { BadRequest } from '@feathersjs/errors'
 
 export const DEFAULT_AJV = new Ajv({
   coerceTypes: true
-});
+})
 
-export { Ajv };
+export { Ajv }
 
 export type JSONSchemaDefinition = JSONSchema & {
-  $id: string,
-  $async?: boolean,
+  $id: string
+  $async?: boolean
   properties?: { [key: string]: JSONSchema }
   required?: readonly string[]
-};
+}
 
 export interface Schema<T> {
-  validate <X = T> (...args: Parameters<ValidateFunction<X>>): Promise<X>;
+  validate<X = T>(...args: Parameters<ValidateFunction<X>>): Promise<X>
 }
 
 export class SchemaWrapper<S extends JSONSchemaDefinition> implements Schema<FromSchema<S>> {
-  ajv: Ajv;
-  validator: AsyncValidateFunction;
-  readonly _type!: FromSchema<S>;
+  ajv: Ajv
+  validator: AsyncValidateFunction
+  readonly _type!: FromSchema<S>
 
-  constructor (public definition: S, ajv: Ajv = DEFAULT_AJV) {
-    this.ajv = ajv;
+  constructor(public definition: S, ajv: Ajv = DEFAULT_AJV) {
+    this.ajv = ajv
     this.validator = this.ajv.compile({
       $async: true,
       ...(this.definition as any)
-    }) as AsyncValidateFunction;
+    }) as AsyncValidateFunction
   }
 
-  get properties () {
-    return this.definition.properties as S['properties'];
+  get properties() {
+    return this.definition.properties as S['properties']
   }
 
-  get required () {
-    return this.definition.required as S['required'];
+  get required() {
+    return this.definition.required as S['required']
   }
 
-  async validate <T = FromSchema<S>> (...args: Parameters<ValidateFunction<T>>) {
+  async validate<T = FromSchema<S>>(...args: Parameters<ValidateFunction<T>>) {
     try {
-      const validated = await this.validator(...args) as T;
+      const validated = (await this.validator(...args)) as T
 
-      return validated;
+      return validated
     } catch (error: any) {
-      throw new BadRequest(error.message, error.errors);
+      throw new BadRequest(error.message, error.errors)
     }
   }
 
-  toJSON () {
-    return this.definition;
+  toJSON() {
+    return this.definition
   }
 }
 
-export function schema <S extends JSONSchemaDefinition> (definition: S, ajv: Ajv = DEFAULT_AJV) {
-  return new SchemaWrapper(definition, ajv);
+export function schema<S extends JSONSchemaDefinition>(definition: S, ajv: Ajv = DEFAULT_AJV) {
+  return new SchemaWrapper(definition, ajv)
 }