Refactor Validator from interface to plain function type

Change Validator<T> from an object with a .parse() method to a plain
function type (value: unknown) => T. This removes the bias toward Zod's
API convention and lets any validation library plug in directly without
an adapter object.

- src/models/composable.ts: Validator is now a type alias for a function
- src/system/platform.ts: call inputSchema()/outputSchema() directly
- src/system/function-registry.ts: duck-type check is now typeof === 'function'
- tests/po.test.ts: test validators rewritten as arrow functions

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ernestojballon

dist/models/composable.d.ts

@@ -1,16 +1,20 @@
 import { EventEnvelope } from "./event-envelope.js";
 /**
- * Minimal library-agnostic validator protocol.
+ * Library-agnostic validator — a plain function that receives an unknown value,
+ * throws on invalid input, and returns the parsed/coerced result.
  *
- * Any object exposing a `parse(value) => T` method that throws on invalid input
- * satisfies this interface. Zod schemas satisfy it natively. TypeBox users can
- * wrap a schema with a small adapter:
+ * Any validation library can be plugged in directly:
  *
- *     const v: Validator<T> = { parse: (x) => { if (!Check(schema, x)) throw new Error(...); return x as T; } };
+ *     // Zod
+ *     inputSchema = (v: unknown) => MyZodSchema.parse(v);
+ *
+ *     // TypeBox + Ajv
+ *     inputSchema = (v: unknown) => { if (!ajv.validate(schema, v)) throw new Error(ajv.errorsText()); return v as T; };
+ *
+ *     // Hand-rolled
+ *     inputSchema = (v: unknown) => { if (typeof v !== 'string') throw new Error('expected string'); return v; };
  */
-export interface Validator<T = unknown> {
-    parse(value: unknown): T;
-}
+export type Validator<T = unknown> = (value: unknown) => T;
 /**
  * Type helper: extract the parsed type of a Validator (akin to z.infer).
  */

dist/models/composable.js.map

@@ -4,17 +4,21 @@ import { Logger } from "../util/logger.js";
 const log = Logger.getInstance();
 
 /**
- * Minimal library-agnostic validator protocol.
+ * Library-agnostic validator — a plain function that receives an unknown value,
+ * throws on invalid input, and returns the parsed/coerced result.
  *
- * Any object exposing a `parse(value) => T` method that throws on invalid input
- * satisfies this interface. Zod schemas satisfy it natively. TypeBox users can
- * wrap a schema with a small adapter:
+ * Any validation library can be plugged in directly:
  *
- *     const v: Validator<T> = { parse: (x) => { if (!Check(schema, x)) throw new Error(...); return x as T; } };
+ *     // Zod
+ *     inputSchema = (v: unknown) => MyZodSchema.parse(v);
+ *
+ *     // TypeBox + Ajv
+ *     inputSchema = (v: unknown) => { if (!ajv.validate(schema, v)) throw new Error(ajv.errorsText()); return v as T; };
+ *
+ *     // Hand-rolled
+ *     inputSchema = (v: unknown) => { if (typeof v !== 'string') throw new Error('expected string'); return v; };
  */
-export interface Validator<T = unknown> {
-    parse(value: unknown): T;
-}
+export type Validator<T = unknown> = (value: unknown) => T;
 
 /**
  * Type helper: extract the parsed type of a Validator (akin to z.infer).

dist/system/function-registry.js

@@ -145,12 +145,12 @@ class SimpleRegistry {
                 'instances': instances, 'private': isPrivate, 'interceptor': interceptor
             };
             // Capture optional input/output schemas from the Composable instance.
-            // Duck-typed: anything exposing a .parse(value) function qualifies.
+            // Validators are plain functions: (value: unknown) => T
             const anyThat = that as Record<string, unknown>;
-            if (anyThat['inputSchema'] && typeof (anyThat['inputSchema'] as {parse?: unknown}).parse === 'function') {
+            if (typeof anyThat['inputSchema'] === 'function') {
                 meta['inputSchema'] = anyThat['inputSchema'];
             }
-            if (anyThat['outputSchema'] && typeof (anyThat['outputSchema'] as {parse?: unknown}).parse === 'function') {
+            if (typeof anyThat['outputSchema'] === 'function') {
                 meta['outputSchema'] = anyThat['outputSchema'];
             }
             this.metadata.set(route, meta);

dist/system/function-registry.js.map

@@ -353,7 +353,7 @@ class ServiceManager {
                 // Input schema validation (strict: AppException 400 on failure)
                 if (this.inputSchema) {
                     try {
-                        const parsed = this.inputSchema.parse(evt.getBody());
+                        const parsed = this.inputSchema(evt.getBody());
                         evt.setBody(parsed as string | number | object | boolean | Buffer | Uint8Array);
                     } catch (err) {
                         const msg = err instanceof Error ? err.message : String(err);
@@ -372,10 +372,10 @@ class ServiceManager {
                         if (this.outputSchema && !this.interceptor) {
                             try {
                                 if (v instanceof EventEnvelope) {
-                                    const parsed = this.outputSchema.parse(v.getBody());
+                                    const parsed = this.outputSchema(v.getBody());
                                     v.setBody(parsed as string | number | object | boolean | Buffer | Uint8Array);
                                 } else {
-                                    v = this.outputSchema.parse(v);
+                                    v = this.outputSchema(v);
                                 }
                             } catch (err) {
                                 const msg = err instanceof Error ? err.message : String(err);

dist/system/platform.js

@@ -108,32 +108,28 @@ class DemoHealth implements Composable {
 }
 
 // Minimal hand-rolled validators (avoids adding zod as a test dependency).
-// Any object with a .parse(value) that throws on invalid input satisfies Validator.
+// Validators are plain functions: (value: unknown) => T, throwing on invalid input.
 interface SchemaInput { id: string; amount: number; }
 interface SchemaOutput { ok: boolean; doubled: number; }
 
-const schemaInputValidator: Validator<SchemaInput> = {
-  parse(value: unknown): SchemaInput {
-    if (!value || typeof value !== 'object') {
-      throw new Error('expected object');
-    }
-    const v = value as Record<string, unknown>;
-    if (typeof v.id !== 'string') throw new Error('id must be string');
-    if (typeof v.amount !== 'number') throw new Error('amount must be number');
-    return { id: v.id, amount: v.amount };
+const schemaInputValidator: Validator<SchemaInput> = (value: unknown): SchemaInput => {
+  if (!value || typeof value !== 'object') {
+    throw new Error('expected object');
   }
+  const v = value as Record<string, unknown>;
+  if (typeof v.id !== 'string') throw new Error('id must be string');
+  if (typeof v.amount !== 'number') throw new Error('amount must be number');
+  return { id: v.id, amount: v.amount };
 };
 
-const schemaOutputValidator: Validator<SchemaOutput> = {
-  parse(value: unknown): SchemaOutput {
-    if (!value || typeof value !== 'object') {
-      throw new Error('expected object');
-    }
-    const v = value as Record<string, unknown>;
-    if (typeof v.ok !== 'boolean') throw new Error('ok must be boolean');
-    if (typeof v.doubled !== 'number') throw new Error('doubled must be number');
-    return { ok: v.ok, doubled: v.doubled };
+const schemaOutputValidator: Validator<SchemaOutput> = (value: unknown): SchemaOutput => {
+  if (!value || typeof value !== 'object') {
+    throw new Error('expected object');
   }
+  const v = value as Record<string, unknown>;
+  if (typeof v.ok !== 'boolean') throw new Error('ok must be boolean');
+  if (typeof v.doubled !== 'number') throw new Error('doubled must be number');
+  return { ok: v.ok, doubled: v.doubled };
 };
 
 class SchemaValidatedService implements Composable {