@travetto/schema 3.1.0-rc.0 → 3.1.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/schema",
-  "version": "3.1.0-rc.0",
+  "version": "3.1.0-rc.1",
   "description": "Data type registry for runtime validation, reflection and binding.",
   "keywords": [
     "schema",

package/src/decorator/common.ts

@@ -16,9 +16,10 @@ export function Describe(config: Partial<DescribableConfig>) {
   return (target: Class | ClassInstance, property?: string, descOrIdx?: PropertyDescriptor | number): void => {
     if (isClassInstance(target, property)) {
       if (descOrIdx !== undefined && typeof descOrIdx === 'number') {
-        property = `${property}.${descOrIdx}`;
+        SchemaRegistry.registerPendingParamFacet(target.constructor, property!, descOrIdx, config);
+      } else {
+        SchemaRegistry.registerPendingFieldFacet(target.constructor, property!, config);
       }
-      SchemaRegistry.registerPendingFieldFacet(target.constructor, property!, config);
     } else {
       SchemaRegistry.register(target, config);
     }

package/src/service/registry.ts

@@ -28,7 +28,6 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
   #subTypes = new Map<Class, Map<string, Class>>();
   #typeKeys = new Map<Class, string>();
   #pendingViews = new Map<Class, Map<string, ViewFieldsConfig<unknown>>>();
-  #methodSchemas = new Map<Class, Map<string, FieldConfig[]>>();
 
   constructor() {
     super(RootRegistry);
@@ -191,6 +190,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       validators: [],
       subType: false,
       metadata: {},
+      methods: {},
       views: {
         [AllViewⲐ]: {
           schema: {},
@@ -225,22 +225,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param method
    */
   getMethodSchema<T>(cls: Class<T>, method: string): FieldConfig[] {
-    if (!this.#methodSchemas.has(cls)) {
-      this.#methodSchemas.set(cls, new Map());
-    }
-    const cache = this.#methodSchemas.get(cls)!;
-    if (!cache.has(method) && this.has(cls)) {
-      const { fields, schema } = this.getViewSchema(cls);
-      const out = [];
-      for (const el of fields) {
-        if (el.startsWith(`${method}.`) && schema[el].forMethod) {
-          out.push(schema[el]);
-        }
-      }
-      out.sort((a, b) => a.index! - b.index!);
-      cache.set(method, out);
-    }
-    return cache.get(method)! ?? [];
+    return (this.get(cls)?.methods?.[method] ?? []).filter(x => !!x).sort((a, b) => a.index! - b.index!);
   }
 
   /**
@@ -265,9 +250,18 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param idx The param index
    * @param config The config to register
    */
-  registerPendingParamFacet(target: Class, prop: string, idx: number, config: Partial<FieldConfig>): Class {
-    config.index = idx;
-    return this.registerPendingFieldFacet(target, `${prop}.${idx}`, config);
+  registerPendingParamFacet(target: Class, method: string, idx: number, config: Partial<FieldConfig>): Class {
+    const methods = this.getOrCreatePending(target)!.methods!;
+    const params = (methods[method] ??= []);
+    params[idx] = {
+      // @ts-expect-error
+      name: `${method}.${idx}`,
+      ...params[idx] ?? {},
+      owner: target,
+      index: idx,
+      ...config,
+    };
+    return target;
   }
 
   /**
@@ -300,10 +294,11 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
    * @param conf Extra config
    */
   registerPendingParamConfig(target: Class, method: string, idx: number, type: ClassList, conf?: Partial<FieldConfig>): Class {
-    conf ??= {};
-    conf.index = idx;
-    conf.forMethod = true;
-    return this.registerPendingFieldConfig(target, `${method}.${idx}`, type, conf);
+    return this.registerPendingParamFacet(target, method, idx, {
+      ...conf,
+      array: Array.isArray(type),
+      type: Array.isArray(type) ? type[0] : type,
+    });
   }
 
   /**
@@ -335,6 +330,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       schema: { ...dest.views[AllViewⲐ].schema, ...src.views?.[AllViewⲐ].schema },
       fields: [...dest.views[AllViewⲐ].fields, ...src.views?.[AllViewⲐ].fields ?? []]
     };
+    dest.methods = { ...src.methods ?? {}, ...dest.methods ?? {} };
     dest.metadata = { ...src.metadata ?? {}, ...dest.metadata ?? {} };
     dest.subType = src.subType || dest.subType;
     dest.title = src.title || dest.title;
@@ -411,7 +407,6 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       // Recompute subtypes
       this.#subTypes.clear();
       this.#typeKeys.delete(cls);
-      this.#methodSchemas.delete(cls);
       this.#accessorDescriptors.delete(cls);
 
       // Recompute subtype mappings

package/src/service/types.ts

@@ -71,6 +71,10 @@ export interface ClassConfig extends DescribableConfig {
    * Metadata that is related to the schema structure
    */
   metadata?: Record<symbol, unknown>;
+  /**
+   * Method parameter configs
+   */
+  methods: Record<string, FieldConfig[]>;
 }
 
 /**
@@ -160,10 +164,6 @@ export interface FieldConfig extends DescribableConfig {
    * Is this field a getter or setter
    */
   accessor?: string;
-  /**
-   * Is the field for a method
-   */
-  forMethod?: boolean;
 }
 
 export type ViewFieldsConfig<T> = { with: Extract<(keyof T), string>[] } | { without: Extract<(keyof T), string>[] };

package/src/validate/validator.ts

@@ -40,7 +40,7 @@ export class SchemaValidator {
 
     const fields = TypedObject.keys<SchemaConfig>(schema);
     for (const field of fields) {
-      if (schema[field].access !== 'readonly' && !schema[field].forMethod) { // Do not validate readonly fields
+      if (schema[field].access !== 'readonly') { // Do not validate readonly fields
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         errors = errors.concat(this.#validateFieldSchema(schema[field], o[field as keyof T], relative));
       }
@@ -107,20 +107,24 @@ export class SchemaValidator {
   static #validateRange(field: FieldConfig, key: 'min' | 'max', value: string | number | Date): boolean {
 
     const f = field[key]!;
-    if (typeof f.n === 'number') {
+    const fn = f.n;
+    if (typeof fn === 'number') {
       if (typeof value === 'string') {
         value = parseInt(value, 10);
       }
       if (field.type === Date) {
         value = new Date(value);
       }
-      if (key === 'min' && value < f.n || key === 'max' && value > f.n) {
+      const valN = typeof value === 'number' ? value : value.getTime();
+      if (key === 'min' && valN < fn || key === 'max' && valN > fn) {
         return true;
       }
     } else {
-      const date = f.n.getTime();
+      const date = fn.getTime();
       if (typeof value === 'string') {
         value = Date.parse(value);
+      } else if (value instanceof Date) {
+        value = value.getTime();
       }
       if (key === 'min' && value < date || key === 'max' && value > date) {
         return true;