WIP: Implement schema validation in Collector

lib/collector.js

@@ -7,15 +7,17 @@ class Collector {
   count = 0;
   exact = true;
   timeout = 0;
+  schema = null;
   #fulfill = null;
   #reject = null;
   #timer = null;
   #cause = null;
 
-  constructor(keys, { exact = true, timeout = 0 } = {}) {
+  constructor(keys, { exact = true, timeout = 0, schema = null } = {}) {
     this.keys = keys;
     if (exact === false) this.exact = false;
     if (typeof timeout === 'number') this.#timeout(timeout);
+    if (schema) this.schema = schema;
   }
 
   #timeout(msec) {
@@ -29,6 +31,12 @@ class Collector {
     this.#timer = setTimeout(handler, msec);
   }
 
+  #validate(data) {
+    if (!this.schema) return { valid: true, errors: [] };
+
+    return this.schema.check(data);
+  }
+
   set(key, value) {
     if (this.done) return;
     const has = this.data[key] !== undefined;
@@ -40,6 +48,12 @@ class Collector {
     if (!has && expected) this.count++;
     this.data[key] = value;
     if (this.count === this.keys.length) {
+      const { valid, errors } = this.#validate(this.data);
+      if (!valid) {
+        const problems = errors.join('; ');
+        this.fail(new Error(`Invalid keys type: ${problems}`));
+        return;
+      }
       this.done = true;
       this.#timeout(0);
       if (this.#fulfill) this.#fulfill(this.data);

metautil.d.ts

@@ -1,5 +1,6 @@
 import { IncomingMessage } from 'node:http';
 import { ScryptOptions, X509Certificate } from 'node:crypto';
+import { Schema } from 'metaschema';
 
 type Strings = Array<string>;
 type Dictionary = Record<string, unknown>;
@@ -235,6 +236,7 @@ export function sizeToBytes(size: string): number;
 export interface CollectorOptions {
   exact?: boolean;
   timeout?: number;
+  schema?: Schema;
 }
 
 type AsyncFunction = (...args: Array<unknown>) => Promise<unknown>;
@@ -245,6 +247,7 @@ export class Collector {
   keys: Array<string>;
   count: number;
   exact: boolean;
+  schema: Schema | null;
   timeout: number;
   constructor(keys: Array<string>, options?: CollectorOptions);
   set(key: string, value: unknown): void;

package.json

@@ -48,6 +48,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-prettier": "^5.0.0",
+    "metaschema": "^2.1.5",
     "metatests": "^0.8.2",
     "prettier": "^3.1.1",
     "typescript": "^5.3.3"

test/collector.js

@@ -2,6 +2,7 @@
 
 const { collect } = require('..');
 const metatests = require('metatests');
+const { Schema } = require('metaschema');
 
 metatests.test('Collector: keys', async (test) => {
   const expectedResult = { key1: 1, key2: 2 };
@@ -209,3 +210,105 @@ metatests.test('Collector: error in then chain', (test) => {
     },
   );
 });
+
+metatests.test('Collector: collect with schema validation', async (test) => {
+  const schema = Schema.from({
+    firstname: 'string',
+    lastname: 'string',
+  });
+  const ac1 = collect(['firstname', 'lastname'], { schema });
+
+  ac1.set('firstname', undefined);
+  ac1.set('lastname', 1);
+
+  const expectedResult1 = new Error(
+    'Invalid keys type: Field "firstname" not of expected type: string; Field "lastname" not of expected type: string',
+  );
+
+  try {
+    await ac1;
+  } catch (error) {
+    test.strictSame(error.message, expectedResult1.message);
+  }
+
+  const ac2 = collect(['firstname', 'lastname'], {
+    schema,
+    exact: false,
+  });
+
+  ac2.set('fullName', 'Michael Jordan');
+  ac2.set('firstname', 'Michael');
+  ac2.set('lastname', 'Jordan');
+
+  const expectedResult2 = new Error(
+    'Invalid keys type: Field "fullName" is not expected',
+  );
+  try {
+    await ac2;
+  } catch (error) {
+    test.strictSame(error.message, expectedResult2.message);
+  }
+
+  test.end();
+});
+
+metatests.test(
+  'Collector: compose collect with schema validation',
+  async (test) => {
+    const schema = Schema.from({
+      id: 'number',
+      profile: {
+        firstname: 'string',
+        lastname: 'string',
+        fullName: { type: 'string', required: false },
+        age: 'number',
+      },
+    });
+
+    const ac1 = collect(['id', 'profile'], { schema });
+    const profile1 = collect(['firstname', 'lastname', 'fullName', 'age']);
+
+    ac1.collect({ profile: profile1 });
+    ac1.set('id', 1);
+    profile1.set('firstname', 'Michael');
+    profile1.set('lastname', 'Jordan');
+    profile1.set('fullName', undefined);
+    profile1.set('age', 60);
+
+    const expectedResult1 = {
+      id: 1,
+      profile: {
+        firstname: 'Michael',
+        lastname: 'Jordan',
+        fullName: undefined,
+        age: 60,
+      },
+    };
+
+    const result1 = await ac1;
+
+    test.strictSame(result1, expectedResult1);
+
+    const ac2 = collect(['id', 'profile'], { schema });
+    const profile2 = collect(['firstname', 'lastname', 'fullName', 'age']);
+
+    ac2.collect({ profile: profile2 });
+    ac2.set('id', 'string');
+    profile2.set('firstname', undefined);
+    profile2.set('lastname', 'Jordan');
+    profile2.set('fullName', undefined);
+    profile2.set('age', 'string');
+
+    const expectedResult2 = new Error(
+      'Invalid keys type: Field "id" not of expected type: number; Field "profile.firstname" not of expected type: string; Field "profile.age" not of expected type: number',
+    );
+
+    try {
+      await ac2;
+    } catch (error) {
+      test.strictSame(error.message, expectedResult2.message);
+    }
+
+    test.end();
+  },
+);