@bluelibs/runner 3.3.2 → 3.4.1

package/src/__tests__/typesafety.test.ts

@@ -6,15 +6,12 @@ import {
   defineOverride,
   defineTag,
 } from "../define";
+import { IMeta } from "../defs";
 import {
-  IEventDefinition,
-  IMiddlewareDefinition,
-  IResource,
-  IResourceWithConfig,
-  ITaskDefinition,
-  RegisterableItems,
-} from "../defs";
-import { createTestResource } from "..";
+  EnsureResponseSatisfiesContracts,
+  HasContracts,
+} from "../defs.returnTag";
+import { createTestResource, run } from "..";
 
 // This is skipped because we mostly check typesafety.
 describe.skip("typesafety", () => {
@@ -244,7 +241,7 @@ describe.skip("typesafety", () => {
     const harness = createTestResource(app);
 
     // Types: input must match, override deps must match, output is awaited number
-    const { value: t } = await (await import("../run")).run(harness);
+    const { value: t } = await run(harness);
     const r1: number | undefined = await t.runTask(add, { x: 1 });
     // @ts-expect-error wrong input type
     await t.runTask(add, { z: 1 });
@@ -313,8 +310,114 @@ describe.skip("typesafety", () => {
           tag3,
         ],
       },
+      run: async (input) => {
+        return input;
+      },
     });
 
     expect(true).toBe(true);
   });
+
+  it("should enforce contracts on tasks", async () => {
+    interface IUser {
+      name: string;
+    }
+
+    interface IOther {
+      age: number;
+    }
+
+    const tag = defineTag<{ value: number }, IUser>({ id: "tag" });
+    const tag2 = defineTag<void, IOther>({ id: "tag2" });
+
+    const meta = {
+      tags: [tag.with({ value: 123 }), tag2, "string"],
+    } satisfies IMeta;
+
+    const response = {
+      age: 123,
+      name: "123", // intentional
+    };
+    type TEST = HasContracts<typeof meta>;
+    type TEST2 = EnsureResponseSatisfiesContracts<typeof meta, typeof response>;
+
+    const task = defineTask({
+      id: "task",
+      meta,
+      run: async (input: { name: string }) => {
+        return {
+          age: 123,
+          name: "123",
+        };
+      },
+    });
+    const task2 = defineTask({
+      id: "task",
+      meta,
+      // @ts-expect-error
+      run: async (input: { name: string }) => {
+        return {
+          age: "123",
+        };
+      },
+    });
+
+    const task3 = defineTask({
+      id: "task",
+      meta,
+      // @ts-expect-error
+      run: async (input: { name: string }) => {
+        return {};
+      },
+    });
+  });
+
+  it("should enforce contracts on resources", async () => {
+    interface IUser {
+      name: string;
+    }
+
+    interface IOther {
+      age: number;
+    }
+
+    const tag = defineTag<{ value: number }, IUser>({ id: "tag" });
+    const tag2 = defineTag<void, IOther>({ id: "tag2" });
+
+    const meta = {
+      tags: [tag.with({ value: 123 }), tag2, "string"],
+    } satisfies IMeta;
+
+    const resourceOk = defineResource({
+      id: "resource.ok",
+      meta,
+      init: async () => {
+        return {
+          age: 123,
+          name: "123",
+        };
+      },
+    });
+
+    const resourceBad1 = defineResource({
+      id: "resource.bad1",
+      meta,
+      // @ts-expect-error
+      init: async () => {
+        return {
+          age: "123",
+          name: "123",
+        };
+      },
+    });
+
+    const resourceBad2 = defineResource({
+      id: "resource.bad2",
+      meta,
+      // @ts-expect-error
+      init: async () => {
+        return {};
+      },
+    });
+  });
 });

package/src/__tests__/validation-edge-cases.test.ts

@@ -0,0 +1,111 @@
+import { defineTask, defineResource, defineEvent, defineMiddleware } from "../define";
+import { run } from "../run";
+import { ValidationError } from "../errors";
+import { IValidationSchema } from "../defs";
+
+// Mock validation schema similar to the existing pattern
+class MockValidationSchema<T> implements IValidationSchema<T> {
+  constructor(
+    private validator: (input: unknown) => T,
+  ) {}
+
+  parse(input: unknown): T {
+    return this.validator(input);
+  }
+}
+
+describe("Validation Edge Cases", () => {
+  it("should handle non-Error thrown from task input validation", async () => {
+    const taskSchema = new MockValidationSchema<string>((input: unknown) => {
+      // Throw a non-Error object to trigger the instanceof Error === false branch
+      throw "Non-error string thrown";
+    });
+
+    const task = defineTask({
+      id: "task.nonErrorValidation",
+      inputSchema: taskSchema,
+      run: async (input: string) => "success",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+      dependencies: { task },
+      init: async (_, { task }) => {
+        await task("invalid");
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(ValidationError);
+    await expect(run(app)).rejects.toThrow("Task input validation failed for task.nonErrorValidation: Non-error string thrown");
+  });
+
+  it("should handle non-Error thrown from resource config validation", async () => {
+    const configSchema = new MockValidationSchema<any>((input: unknown) => {
+      throw "Resource config error string";
+    });
+
+    const resource = defineResource({
+      id: "resource.nonErrorValidation",
+      configSchema: configSchema,
+      init: async (config: any) => "success",
+    });
+
+    expect(() => {
+      resource.with({ invalid: "config" } as any);
+    }).toThrow(ValidationError);
+    expect(() => {
+      resource.with({ invalid: "config" } as any);
+    }).toThrow("Resource config validation failed for resource.nonErrorValidation: Resource config error string");
+  });
+
+  it("should handle non-Error thrown from middleware config validation", async () => {
+    const configSchema = new MockValidationSchema<any>((input: unknown) => {
+      throw "Middleware config error string";
+    });
+
+    const middleware = defineMiddleware({
+      id: "middleware.nonErrorValidation",
+      configSchema: configSchema,
+      run: async ({ next }) => next(),
+    });
+
+    expect(() => {
+      middleware.with({ invalid: "config" } as any);
+    }).toThrow(ValidationError);
+    expect(() => {
+      middleware.with({ invalid: "config" } as any);
+    }).toThrow("Middleware config validation failed for middleware.nonErrorValidation: Middleware config error string");
+  });
+
+  it("should handle non-Error thrown from event payload validation", async () => {
+    const payloadSchema = new MockValidationSchema<any>((input: unknown) => {
+      throw "Event payload error string";
+    });
+
+    const event = defineEvent({
+      id: "event.nonErrorValidation",
+      payloadSchema: payloadSchema,
+    });
+
+    const listenerTask = defineTask({
+      id: "task.listener",
+      on: event,
+      run: async (event) => {
+        // This won't be called because validation will fail
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [event, listenerTask],
+      dependencies: { event },
+      init: async (_, { event }) => {
+        await event({ invalid: "payload" });
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(ValidationError);
+    await expect(run(app)).rejects.toThrow("Event payload validation failed for event.nonErrorValidation: Event payload error string");
+  });
+});

package/src/__tests__/validation-interface.test.ts

@@ -0,0 +1,428 @@
+import { defineTask, defineResource, defineEvent, defineMiddleware } from "../define";
+import { run } from "../run";
+import { IValidationSchema } from "../defs";
+
+// Simple mock validation schemas for testing the interface
+class MockValidationSchema<T> implements IValidationSchema<T> {
+  constructor(
+    private validator: (input: unknown) => T,
+    private errorMessage?: string
+  ) {}
+
+  parse(input: unknown): T {
+    try {
+      return this.validator(input);
+    } catch (error) {
+      throw new Error(this.errorMessage || "Validation failed");
+    }
+  }
+}
+
+// Helper functions to create mock schemas similar to Zod
+const mockSchema = {
+  object: <T extends Record<string, any>>(shape: Record<keyof T, string>): IValidationSchema<T> => {
+    return new MockValidationSchema((input: unknown) => {
+      if (typeof input !== "object" || input === null) {
+        throw new Error("Expected object");
+      }
+      const obj = input as any;
+      for (const [key, expectedType] of Object.entries(shape)) {
+        if (expectedType === "string" && typeof obj[key] !== "string") {
+          throw new Error(`${key} must be string`);
+        }
+        if (expectedType === "number" && typeof obj[key] !== "number") {
+          throw new Error(`${key} must be number`);
+        }
+        if (expectedType === "boolean" && typeof obj[key] !== "boolean") {
+          throw new Error(`${key} must be boolean`);
+        }
+      }
+      return obj as T;
+    });
+  },
+  
+  string: (): IValidationSchema<string> => {
+    return new MockValidationSchema((input: unknown) => {
+      if (typeof input !== "string") {
+        throw new Error("Expected string");
+      }
+      return input;
+    });
+  },
+  
+  number: (): IValidationSchema<number> => {
+    return new MockValidationSchema((input: unknown) => {
+      if (typeof input !== "number") {
+        throw new Error("Expected number");
+      }
+      return input;
+    });
+  },
+  
+  boolean: (): IValidationSchema<boolean> => {
+    return new MockValidationSchema((input: unknown) => {
+      if (typeof input !== "boolean") {
+        throw new Error("Expected boolean");
+      }
+      return input;
+    });
+  },
+
+  transform: <T, U>(schema: IValidationSchema<T>, transformer: (value: T) => U): IValidationSchema<U> => {
+    return new MockValidationSchema((input: unknown) => {
+      const validated = schema.parse(input);
+      return transformer(validated);
+    });
+  },
+
+  withDefaults: <T>(defaultValue: T): IValidationSchema<T> => {
+    return new MockValidationSchema((input: unknown) => {
+      return input === undefined ? defaultValue : (input as T);
+    });
+  },
+};
+
+describe("Generic Validation Interface", () => {
+  describe("Task Input Validation", () => {
+    it("should validate task input successfully with valid data", async () => {
+      const userSchema = mockSchema.object<{
+        name: string;
+        age: number;
+      }>({
+        name: "string",
+        age: "number",
+      });
+
+      const createUserTask = defineTask({
+        id: "task.createUser",
+        inputSchema: userSchema,
+        run: async (input) => {
+          return `Created user ${(input as any).name}`;
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [createUserTask],
+        dependencies: { createUserTask },
+        init: async (_, { createUserTask }) => {
+          const result = await createUserTask({
+            name: "John Doe",
+            age: 30,
+          });
+          expect(result).toBe("Created user John Doe");
+          return result;
+        },
+      });
+
+      await run(app);
+    });
+
+    it("should throw validation error for invalid task input", async () => {
+      const userSchema = new MockValidationSchema((input: unknown) => {
+        if (typeof input !== "object" || input === null) {
+          throw new Error("Expected object");
+        }
+        const obj = input as any;
+        if (typeof obj.name !== "string") {
+          throw new Error("name must be string");
+        }
+        if (typeof obj.age !== "number" || obj.age < 0) {
+          throw new Error("age must be positive number");
+        }
+        return obj;
+      });
+
+      const createUserTask = defineTask({
+        id: "task.createUser.invalid",
+        inputSchema: userSchema,
+        run: async (input) => {
+          return `Created user ${(input as any).name}`;
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [createUserTask],
+        dependencies: { createUserTask },
+        init: async (_, { createUserTask }) => {
+          await createUserTask({
+            name: "John Doe",
+            age: -5, // Invalid: negative age
+          });
+        },
+      });
+
+      await expect(run(app)).rejects.toThrow(/Task input validation failed/);
+    });
+
+    it("should transform input data when schema supports it", async () => {
+      const stringToNumberSchema = mockSchema.transform(
+        mockSchema.string(),
+        (val: string) => parseInt(val, 10)
+      );
+
+      const mathTask = defineTask({
+        id: "task.math",
+        inputSchema: stringToNumberSchema,
+        run: async (input: number) => {
+          expect(typeof input).toBe("number");
+          return input * 2;
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [mathTask],
+        dependencies: { mathTask },
+        init: async (_, { mathTask }) => {
+          const result = await (mathTask as any)("42"); // String input should be transformed to number
+          expect(result).toBe(84);
+          return result;
+        },
+      });
+
+      await run(app);
+    });
+  });
+
+  describe("Resource Config Validation", () => {
+    it("should validate resource config when .with() is called (fail fast)", async () => {
+      const configSchema = new MockValidationSchema((input: unknown) => {
+        if (typeof input !== "object" || input === null) {
+          throw new Error("Expected object");
+        }
+        const obj = input as any;
+        if (typeof obj.host !== "string") {
+          throw new Error("host must be string");
+        }
+        if (typeof obj.port !== "number" || obj.port < 1 || obj.port > 65535) {
+          throw new Error("port must be number between 1-65535");
+        }
+        return obj;
+      });
+
+      const databaseResource = defineResource({
+        id: "resource.database",
+        configSchema: configSchema,
+        init: async (config) => {
+          return {
+            connect: () => `Connected to ${(config as any).host}:${(config as any).port}`,
+          };
+        },
+      });
+
+      // This should throw immediately when .with() is called, not during init
+      expect(() => {
+        databaseResource.with({
+          host: "localhost",
+          port: 99999, // Invalid: port too high
+        });
+      }).toThrow(/Resource config validation failed/);
+    });
+
+    it("should work with valid resource config", async () => {
+      const configSchema = mockSchema.object<{
+        host: string;
+        port: number;
+      }>({
+        host: "string",
+        port: "number",
+      });
+
+      const databaseResource = defineResource({
+        id: "resource.database.valid",
+        configSchema: configSchema,
+        init: async (config) => {
+          return {
+            connect: () => `Connected to ${(config as any).host}:${(config as any).port}`,
+          };
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [
+          databaseResource.with({
+            host: "localhost",
+            port: 5432,
+          }),
+        ],
+        dependencies: { database: databaseResource },
+        init: async (_, { database }) => {
+          const result = database.connect();
+          expect(result).toBe("Connected to localhost:5432");
+          return result;
+        },
+      });
+
+      await run(app);
+    });
+  });
+
+  describe("Event Payload Validation", () => {
+    it("should validate event payload when emitted", async () => {
+      const payloadSchema = new MockValidationSchema((input: unknown) => {
+        if (typeof input !== "object" || input === null) {
+          throw new Error("Expected object");
+        }
+        const obj = input as any;
+        if (typeof obj.message !== "string") {
+          throw new Error("message must be string");
+        }
+        return obj;
+      });
+
+      const testEvent = defineEvent({
+        id: "event.test",
+        payloadSchema: payloadSchema,
+      });
+
+      let receivedMessage = "";
+      const listenerTask = defineTask({
+        id: "task.listener",
+        on: testEvent,
+        run: async (event) => {
+          receivedMessage = (event.data as any).message;
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testEvent, listenerTask],
+        dependencies: { testEvent },
+        init: async (_, { testEvent }) => {
+          // This should work with valid payload
+          await testEvent({ message: "Hello World" });
+          expect(receivedMessage).toBe("Hello World");
+
+          // This should throw with invalid payload
+          await expect(testEvent({ invalidField: 123 } as any)).rejects.toThrow(/Event payload validation failed/);
+        },
+      });
+
+      await run(app);
+    });
+  });
+
+  describe("Middleware Config Validation", () => {
+    it("should validate middleware config when .with() is called (fail fast)", async () => {
+      const configSchema = new MockValidationSchema((input: unknown) => {
+        if (typeof input !== "object" || input === null) {
+          throw new Error("Expected object");
+        }
+        const obj = input as any;
+        if (typeof obj.timeout !== "number" || obj.timeout <= 0) {
+          throw new Error("timeout must be positive number");
+        }
+        return obj;
+      });
+
+      const timingMiddleware = defineMiddleware({
+        id: "middleware.timing",
+        configSchema: configSchema,
+        run: async ({ next }, _, config) => {
+          return next();
+        },
+      });
+
+      // This should throw immediately when .with() is called
+      expect(() => {
+        timingMiddleware.with({
+          timeout: -5, // Invalid: negative timeout
+        });
+      }).toThrow(/Middleware config validation failed/);
+    });
+
+    it("should work with valid middleware config", async () => {
+      const configSchema = mockSchema.object<{
+        timeout: number;
+      }>({
+        timeout: "number",
+      });
+
+      const timingMiddleware = defineMiddleware({
+        id: "middleware.timing.valid",
+        configSchema: configSchema,
+        run: async ({ next }, _, config) => {
+          const start = Date.now();
+          const result = await next();
+          const duration = Date.now() - start;
+          expect(typeof (config as any).timeout).toBe("number");
+          return result;
+        },
+      });
+
+      const testTask = defineTask({
+        id: "task.test",
+        middleware: [timingMiddleware.with({ timeout: 5000 })],
+        run: async () => {
+          return "success";
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [timingMiddleware, testTask],
+        dependencies: { testTask },
+        init: async (_, { testTask }) => {
+          const result = await testTask();
+          expect(result).toBe("success");
+          return result;
+        },
+      });
+
+      await run(app);
+    });
+  });
+
+  describe("No Validation (Backward Compatibility)", () => {
+    it("should work without any validation schemas", async () => {
+      const task = defineTask({
+        id: "task.noValidation",
+        run: async (input: any) => {
+          return `Received: ${JSON.stringify(input)}`;
+        },
+      });
+
+      const resource = defineResource({
+        id: "resource.noValidation",
+        init: async (config: any) => {
+          return { config };
+        },
+      });
+
+      const event = defineEvent<any>({
+        id: "event.noValidation",
+      });
+
+      const middleware = defineMiddleware({
+        id: "middleware.noValidation",
+        run: async ({ next }) => next(),
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [
+          task,
+          resource.with({ anything: "goes" }),
+          event,
+          middleware,
+        ],
+        dependencies: { task, resource, event },
+        init: async (_, { task, resource, event }) => {
+          const taskResult = await task({ any: "data" });
+          expect(taskResult).toBe('Received: {"any":"data"}');
+          
+          expect(resource.config.anything).toBe("goes");
+          
+          await event({ any: "payload" }); // Should work without validation
+          
+          return "success";
+        },
+      });
+
+      await run(app);
+    });
+  });
+});