@feathersjs/schema 0.0.1-alpha.4 → 5.0.0-pre.15

package/src/core.ts

@@ -1,133 +0,0 @@
-import Joi from '@hapi/joi';
-
-export const Type = Joi;
-
-export const typeMap = new WeakMap<any, any>();
-export const nameMap: { [key: string]: Schema } = {};
-
-export let id = 0;
-
-typeMap.set(String, Joi.string());
-typeMap.set(Number, Joi.number());
-typeMap.set(Boolean, Joi.boolean());
-
-export type SchemaTypes = Schema|string|Joi.AnySchema|typeof String|typeof Number|typeof Boolean;
-// tslint:disable-next-line:ban-types
-export type SchemaPropertyType = SchemaTypes|SchemaTypes[]|Function;
-
-export interface SchemaPropertyDefinition {
-  type: SchemaPropertyType;
-  [key: string]: any;
-}
-
-export interface SchemaMeta {
-  name: string;
-  [key: string]: any;
-}
-
-export interface SchemaProperties {
-  [key: string]: SchemaPropertyDefinition;
-}
-
-export const validatorFromType = (type: Schema|SchemaPropertyType|(() => Joi.AnySchema)): Joi.AnySchema => {
-  const value = typeMap.get(type) || type;
-
-  if (Array.isArray(value) && value.length === 1) {
-    const [ arrayValue ] = value;
-
-    return Joi.array().items(validatorFromType(arrayValue));
-  }
-
-  const valueSchema = value instanceof Schema ? value : getSchema(value);
-
-  if (valueSchema !== null) {
-    return valueSchema.validator;
-  }
-
-  return value;
-};
-
-export function getValidator (properties: SchemaProperties) {
-  const validators: Joi.SchemaMap = Object.keys(properties).reduce((current, key) => {
-    const { type } = properties[key];
-
-    return {
-      ...current,
-      [key]: validatorFromType(type)
-    };
-  }, {});
-
-  return Joi.object(validators);
-}
-
-export class Schema {
-  meta: SchemaMeta;
-  properties: SchemaProperties;
-  validator: Joi.ObjectSchema;
-
-  constructor (schemaMeta: Partial<SchemaMeta>, schemaProperties: SchemaProperties) {
-    this.properties = {};
-    this.meta = {
-      name: `schema-${++id}`
-    };
-
-    this.addMetadata(schemaMeta);
-    this.addProperties(schemaProperties);
-  }
-
-  async validate (value: any, options?: Joi.AsyncValidationOptions) {
-    return this.validator.validateAsync(value, options);
-  }
-
-  addProperties (schemaProperties: SchemaProperties) {
-    this.properties = Object.assign(this.properties, schemaProperties);
-    this.validator = getValidator(this.properties);
-
-    return this;
-  }
-
-  addMetadata (schemaMeta: Partial<SchemaMeta>) {
-    const oldName = this.meta.name;
-
-    this.meta = Object.assign(this.meta, schemaMeta);
-
-    delete nameMap[oldName];
-    nameMap[this.meta.name] = this;
-
-    return this;
-  }
-}
-
-export function setSchema (schema: Schema, target: any) {
-  typeMap.set(target !== null ? target : schema, schema);
-
-  return schema;
-}
-
-export function getSchema (target: any): Schema|null {
-  if (target instanceof Schema) {
-    return target;
-  }
-
-  if (typeof target === 'string') {
-    return nameMap[target] || null;
-  }
-
-  if (!target) {
-    return null;
-  }
-
-  let p = target;
-
-  do {
-    const schema = typeMap.get(p);
-
-    if (schema !== undefined) {
-      return schema;
-    }
-
-    p = p.prototype;
-  } while (!!p);
-
-  return null;
-}

package/src/decorator.ts

@@ -1,40 +0,0 @@
-import 'reflect-metadata';
-import Joi, { AnySchema } from '@hapi/joi';
-import { getSchema, schema, SchemaPropertyDefinition, validatorFromType } from './index';
-import { SchemaMeta } from './core';
-
-export type TypeInitializer<T> = (type: T) => T;
-
-export function propertyDecorator<T extends AnySchema = Joi.AnySchema> (
-  definition: Partial<SchemaPropertyDefinition>|TypeInitializer<T> = {},
-  propDef: Partial<SchemaPropertyDefinition> = {}
-) {
-  return (target: any, propertyName: string) => {
-    const type = Reflect.getMetadata('design:type', target, propertyName);
-    const targetSchema = getSchema(target) || schema(target, {}, {});
-
-    if (typeof definition === 'function') {
-      targetSchema.addProperties({
-        [propertyName]: {
-          type: definition(validatorFromType(type) as T),
-          ...propDef
-        }
-      });
-    } else {
-      targetSchema.addProperties({
-        [propertyName]: {
-          type,
-          ...definition
-        }
-      });
-    }
-  };
-}
-
-export function schemaDecorator (definition: Partial<SchemaMeta>) {
-  return (target: any) => {
-    const targetSchema = getSchema(target) || schema(target, {}, {});
-
-    targetSchema.addMetadata(definition);
-  };
-}

package/src/resolve.ts

@@ -1,33 +0,0 @@
-import { getSchema } from './core';
-
-export async function resolve<T = any> (source: T, schemaTarget: any, context: any, path: any[] = []): Promise<T|T[]> {
-  if (Array.isArray(source)) {
-    return Promise.all(source.map((current: any) => resolve(current, schemaTarget, context, path)));
-  }
-
-  const isArray = Array.isArray(schemaTarget);
-  const schema = getSchema(isArray ? schemaTarget[0] : schemaTarget);
-  const { properties } = schema;
-  const resolveKeys = Object.keys(properties).filter(key =>
-    typeof properties[key].resolve === 'function' && !path.includes(properties[key])
-  );
-
-  if (resolveKeys.length) {
-    const entities: any[] = await Promise.all(resolveKeys.map(async key => {
-      const property = properties[key];
-      const { resolve: resolver, type } = property;
-      const entity = await resolver(source, context);
-
-      return resolve(entity, type, context, path.concat(property));
-    }));
-
-    return resolveKeys.reduce((result, key, index) => {
-      return {
-        ...result,
-        [key]: entities[index]
-      };
-    }, source);
-  }
-
-  return source;
-}