ts-procedures 5.10.0 → 5.10.2

package/build/src/index.test.js

@@ -0,0 +1,890 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { describe, expect, test } from 'vitest';
+import { Procedures } from './index.js';
+import { v } from 'suretype';
+import { Type } from 'typebox';
+import { ProcedureError, ProcedureValidationError } from './errors.js';
+describe('Procedures', () => {
+    test('Procedures', () => {
+        const result = Procedures({
+            onCreate: () => {
+                return undefined;
+            },
+        });
+        expect(result).toHaveProperty('Create');
+    });
+    test('Procedures generic context & extended config', () => {
+        const { Create } = Procedures();
+        const { info } = Create('TestProcedure', {
+            // should not throw type errors
+            customProp: 'customProp',
+        }, async (ctx) => {
+            // should not throw type errors
+            return ctx.authToken;
+        });
+        expect(info.customProp).toEqual('customProp');
+        expect(info.optionalProp).toEqual(undefined);
+    });
+    test('Create Single Procedures', () => {
+        const { procedure: procedure1, info: info1 } = Procedures().Create('test1', {}, async () => {
+            return '1';
+        });
+        const { procedure: procedure2, info: info2 } = Procedures().Create('test2', {}, async () => {
+            return '2';
+        });
+        expect(procedure1).toBeDefined();
+        expect(info1).toBeDefined();
+        expect(procedure2).toBeDefined();
+        expect(info2).toBeDefined();
+    });
+    test('Procedures - Create call', () => new Promise((done) => {
+        let mockHttpCall;
+        const { Create } = Procedures({
+            onCreate: ({ handler }) => {
+                mockHttpCall = handler;
+            },
+        });
+        Create('Handler', {
+            schema: {
+                params: v.object({ name: v.string() }),
+                returnType: v.string(),
+            },
+        }, async (ctx, params) => {
+            expect(params).toEqual({ name: 'name' });
+            done();
+            return 'name';
+        });
+        mockHttpCall({}, { name: 'name' });
+    }));
+    test('Procedures - Create call w/ Typebox', () => new Promise((done) => {
+        let mockHttpCall;
+        const { Create } = Procedures({
+            onCreate: ({ handler, config, name }) => {
+                mockHttpCall = handler;
+            },
+        });
+        Create('Handler', {
+            schema: {
+                params: Type.Object({ name: Type.Optional(Type.String()) }),
+                returnType: Type.String(),
+            },
+        }, async (ctx, params) => {
+            expect(params).toEqual({ name: 'name' });
+            done();
+            return 'name';
+        });
+        mockHttpCall({}, { name: 'name' });
+    }));
+    test('Procedures - Create returns a handler to call/test the Procedure registration', async () => {
+        let ProcedureRegisteredCbHandler;
+        const { Create } = Procedures({
+            onCreate: (Procedure) => {
+                ProcedureRegisteredCbHandler = Procedure.handler;
+            },
+        });
+        const { NamedExportHandler, procedure, info } = Create('NamedExportHandler', {
+            description: 'Handler description',
+            schema: {
+                params: v.object({ number: v.number() }),
+            },
+        }, async (ctx, params) => {
+            return params.number;
+        });
+        expect(NamedExportHandler).toBeDefined();
+        expect(procedure).toBeDefined();
+        expect(ProcedureRegisteredCbHandler).toEqual(NamedExportHandler);
+        expect(ProcedureRegisteredCbHandler).toEqual(procedure);
+        const result = NamedExportHandler({}, { number: 1 });
+        expect(result).toBeDefined();
+        expect(result).toBeInstanceOf(Promise);
+        await expect(result).resolves.toEqual(1);
+        expect(info).toBeDefined();
+        expect(info).toBeInstanceOf(Object);
+        expect(info.schema).toHaveProperty('params');
+        expect(info.schema.params).toEqual({
+            type: 'object',
+            properties: { number: { type: 'number' } },
+        });
+        expect(info).toHaveProperty('description');
+        expect(info.description).toEqual('Handler description');
+    });
+    test('Procedures - Create params validation w/ no params provided', () => new Promise((done) => {
+        let mockHttpCall;
+        const { Create } = Procedures({
+            onCreate: ({ handler, config, name }) => {
+                mockHttpCall = (callParams) => {
+                    if (config.validation?.params) {
+                        const { errors } = config.validation.params(callParams);
+                        if (errors && 'message' in errors[0]) {
+                            expect(errors[0].message).toEqual('must be object');
+                            done();
+                            return;
+                        }
+                    }
+                    handler(callParams, {});
+                };
+            },
+        });
+        Create('test', {
+            schema: {
+                params: v.object({}),
+            },
+        }, async () => {
+            done();
+        });
+        mockHttpCall();
+    }));
+    test('Procedures - Create params validation w/ missing params', async () => new Promise((done) => {
+        let mockHttpCall;
+        const { Create } = Procedures({
+            onCreate: async ({ handler, config, name }) => {
+                mockHttpCall = async (callParams) => {
+                    if (config.validation?.params) {
+                        const { errors } = config.validation.params(callParams);
+                        expect(errors).toBeDefined();
+                        expect(errors?.length).toEqual(2);
+                    }
+                    try {
+                        await handler(callParams, {});
+                    }
+                    catch (e) {
+                        expect(e).instanceof(ProcedureValidationError);
+                        expect(e.errors.length).toEqual(2);
+                        done();
+                    }
+                };
+            },
+        });
+        Create('test', {
+            schema: {
+                params: v.object({
+                    name: v.string().required(),
+                    id: v.number().required(),
+                    email: v.string(),
+                }),
+            },
+        }, async () => {
+            return;
+        });
+        mockHttpCall({});
+    }));
+    test('Procedures - Create call provides ctx to handler', () => new Promise((done) => {
+        let mockHttpCall;
+        const { Create } = Procedures({
+            onCreate: ({ handler }) => {
+                mockHttpCall = () => handler({ testCtx: 'testCtx' });
+            },
+        });
+        Create('test', {}, async (ctx, params) => {
+            expect(ctx.testCtx).toEqual('testCtx');
+            done();
+        });
+        mockHttpCall();
+    }));
+    test('Procedure handler can throw local ctx error and is caught', async () => {
+        const { Create } = Procedures();
+        const { TestProcedureHandlerError } = Create('TestProcedureHandlerError', {}, async (ctx) => {
+            throw ctx.error('Local context error');
+        });
+        try {
+            await TestProcedureHandlerError({}, {});
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.message).toEqual('Local context error');
+            expect(e.procedureName).toEqual('TestProcedureHandlerError');
+        }
+    });
+    test('Procedures - getRegisteredProcedures', () => {
+        const { Create, getProcedures } = Procedures({
+            onCreate: () => {
+                return undefined;
+            },
+        });
+        Create('test-docs', {
+            schema: {
+                params: v.object({ name: v.string().required() }),
+                returnType: v.string(),
+            },
+        }, async () => {
+            return 'test-docs';
+        });
+        const procedures = getProcedures();
+        const testDocsProcedure = procedures.find((p) => p.name === 'test-docs');
+        expect(testDocsProcedure).toBeDefined();
+        expect(testDocsProcedure?.config?.schema).toEqual({
+            params: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                    },
+                },
+                required: ['name'],
+            },
+            returnType: {
+                type: 'string',
+            },
+        });
+    });
+    test('Procedures - context() throws', async () => {
+        const { Create } = Procedures();
+        function validateAuthToken(token) {
+            return token === 'valid-token';
+        }
+        const { CheckIsAuthenticated } = Create('CheckIsAuthenticated', {
+            schema: {
+                returnType: v.string(),
+            },
+        }, async (ctx) => {
+            if (!validateAuthToken(ctx.authToken)) {
+                throw ctx.error('Invalid auth token');
+            }
+            return 'User authentication is valid';
+        });
+        await expect(CheckIsAuthenticated({ authToken: 'valid-token' }, {})).resolves.toEqual('User authentication is valid');
+        await expect(CheckIsAuthenticated({ authToken: 'not-valid-token' }, {})).rejects.toThrowError(ProcedureError);
+    });
+    test('Procedures - duplicate registration throws before schema computation', () => {
+        const { Create } = Procedures();
+        Create('DuplicateTest', {}, async () => 'first');
+        expect(() => {
+            Create('DuplicateTest', {}, async () => 'second');
+        }).toThrow('Procedure with name DuplicateTest is already registered');
+    });
+    test('Procedures - wrapped errors preserve cause', async () => {
+        const { Create } = Procedures();
+        const originalError = new Error('Database connection failed');
+        originalError.code = 'ECONNREFUSED';
+        const { TestCause } = Create('TestCause', {}, async () => {
+            throw originalError;
+        });
+        try {
+            await TestCause({}, {});
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.cause).toBe(originalError);
+            expect(e.cause.code).toBe('ECONNREFUSED');
+        }
+    });
+    test('Procedures - getProcedure returns specific procedure', () => {
+        const { Create, getProcedure } = Procedures();
+        Create('FindMe', {}, async () => 'found');
+        const proc = getProcedure('FindMe');
+        expect(proc).toBeDefined();
+        expect(proc?.name).toBe('FindMe');
+        expect(getProcedure('NotFound')).toBeUndefined();
+    });
+    test('Procedures - removeProcedure allows re-registration', () => {
+        const { Create, removeProcedure, getProcedure } = Procedures();
+        Create('Removable', {}, async () => 'v1');
+        expect(getProcedure('Removable')).toBeDefined();
+        const removed = removeProcedure('Removable');
+        expect(removed).toBe(true);
+        expect(getProcedure('Removable')).toBeUndefined();
+        // Can now re-register
+        Create('Removable', {}, async () => 'v2');
+        expect(getProcedure('Removable')).toBeDefined();
+    });
+    test('Procedures - clear removes all procedures', () => {
+        const { Create, getProcedures, clear } = Procedures();
+        Create('One', {}, async () => '1');
+        Create('Two', {}, async () => '2');
+        expect(getProcedures().length).toBe(2);
+        clear();
+        expect(getProcedures().length).toBe(0);
+    });
+    test('Procedures - ctx.error still works after optimization', async () => {
+        const { Create } = Procedures();
+        const { ErrorTest } = Create('ErrorTest', {}, async (ctx) => {
+            throw ctx.error('Custom error message', { code: 'ERR_001' });
+        });
+        try {
+            await ErrorTest({}, {});
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.message).toBe('Custom error message');
+            expect(e.procedureName).toBe('ErrorTest');
+            expect(e.meta).toEqual({ code: 'ERR_001' });
+        }
+    });
+    test('Create passes through external signal from context', async () => {
+        const { Create } = Procedures();
+        const externalAc = new AbortController();
+        let capturedSignal = null;
+        const { WithSignal } = Create('WithSignal', {}, async (ctx) => {
+            capturedSignal = ctx.signal;
+            return 'done';
+        });
+        await WithSignal({ signal: externalAc.signal }, {});
+        expect(capturedSignal).toBe(externalAc.signal);
+        expect(capturedSignal.aborted).toBe(false);
+    });
+    test('Create external signal reflects abort from caller', async () => {
+        const { Create } = Procedures();
+        const externalAc = new AbortController();
+        let capturedSignal = null;
+        const { AbortedSignal } = Create('AbortedSignal', {}, async (ctx) => {
+            capturedSignal = ctx.signal;
+            expect(ctx.signal.aborted).toBe(true);
+            return 'done';
+        });
+        externalAc.abort();
+        await AbortedSignal({ signal: externalAc.signal }, {});
+        expect(capturedSignal.aborted).toBe(true);
+    });
+    test('Create external signal cancels in-flight async work', async () => {
+        const { Create } = Procedures();
+        const externalAc = new AbortController();
+        let wasAbortedDuringWork = false;
+        const ready = Promise.withResolvers();
+        const { LongWork } = Create('LongWork', {}, async (ctx) => {
+            ready.resolve();
+            await new Promise((resolve) => {
+                ctx.signal.addEventListener('abort', () => {
+                    wasAbortedDuringWork = true;
+                    resolve();
+                });
+            });
+            return 'done';
+        });
+        const p = LongWork({ signal: externalAc.signal }, {});
+        await ready.promise;
+        externalAc.abort();
+        await p;
+        expect(wasAbortedDuringWork).toBe(true);
+    });
+});
+describe('Procedures - Definition Location in Errors', () => {
+    test('ProcedureValidationError includes definition location', async () => {
+        const { Create } = Procedures();
+        const { TestValidation } = Create('TestValidation', {
+            schema: {
+                params: v.object({ name: v.string().required() }),
+            },
+        }, async (ctx, params) => {
+            return params.name;
+        });
+        try {
+            // @ts-expect-error - intentionally passing invalid params
+            await TestValidation({}, {}); // Missing required 'name' param
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+            expect(e.definedAt).toBeDefined();
+            expect(e.definedAt.file).toContain('index.test.ts');
+            expect(e.definedAt.line).toBeGreaterThan(0);
+            expect(e.definedAt.column).toBeGreaterThan(0);
+            expect(e.stack).toContain('--- Procedure "TestValidation" defined at ---');
+        }
+    });
+    test('ctx.error() includes definition location', async () => {
+        const { Create } = Procedures();
+        const { TestCtxError } = Create('TestCtxError', {}, async (ctx) => {
+            throw ctx.error('Custom error');
+        });
+        try {
+            await TestCtxError({}, {});
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.definedAt).toBeDefined();
+            expect(e.definedAt.file).toContain('index.test.ts');
+            expect(e.getDefinitionLocation()).toBeDefined();
+            expect(e.stack).toContain('--- Procedure "TestCtxError" defined at ---');
+        }
+    });
+    test('wrapped errors include definition location', async () => {
+        const { Create } = Procedures();
+        const { TestWrappedError } = Create('TestWrappedError', {}, async () => {
+            throw new Error('Original error');
+        });
+        try {
+            await TestWrappedError({}, {});
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.definedAt).toBeDefined();
+            expect(e.definedAt.file).toContain('index.test.ts');
+            expect(e.message).toContain('Error in handler for TestWrappedError');
+            expect(e.cause).toBeInstanceOf(Error);
+            expect(e.cause.message).toBe('Original error');
+        }
+    });
+    test('getDefinitionLocation returns formatted string', async () => {
+        const { Create } = Procedures();
+        const { TestGetLocation } = Create('TestGetLocation', {
+            schema: {
+                params: v.object({ id: v.number().required() }),
+            },
+        }, async (ctx, params) => {
+            return params.id;
+        });
+        try {
+            // @ts-expect-error - intentionally passing invalid params
+            await TestGetLocation({}, {}); // Missing required 'id' param
+        }
+        catch (e) {
+            const location = e.getDefinitionLocation();
+            expect(location).toBeDefined();
+            expect(location).toMatch(/index\.test\.ts:\d+:\d+/);
+        }
+    });
+    test('error stack shows procedure definition location at the end', async () => {
+        const { Create } = Procedures();
+        const { TestStackFormat } = Create('TestStackFormat', {
+            schema: {
+                params: v.object({ value: v.string().required() }),
+            },
+        }, async (ctx, params) => {
+            return params.value;
+        });
+        try {
+            // @ts-expect-error - intentionally passing invalid params
+            await TestStackFormat({}, {});
+        }
+        catch (e) {
+            // Verify it's a validation error
+            expect(e.name).toBe('ProcedureValidationError');
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+            // Stack should contain the error message and definition location
+            expect(e.stack).toContain('Validation error for TestStackFormat');
+            expect(e.stack).toContain('--- Procedure "TestStackFormat" defined at ---');
+            // The definition section should be at the end of the stack
+            const stackLines = e.stack.split('\n');
+            const definitionIndex = stackLines.findIndex((line) => line.includes('--- Procedure "TestStackFormat" defined at ---'));
+            expect(definitionIndex).toBeGreaterThan(0);
+        }
+    });
+});
+describe('Streaming Procedures - CreateStream', () => {
+    test('CreateStream creates a streaming procedure', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamTest, procedure, info } = CreateStream('StreamTest', {
+            description: 'Test streaming procedure',
+            schema: {
+                params: v.object({ count: v.number().required() }),
+                yieldType: v.object({ value: v.number().required() }),
+            },
+        }, async function* (ctx, params) {
+            for (let i = 0; i < params.count; i++) {
+                yield { value: i };
+            }
+        });
+        expect(StreamTest).toBeDefined();
+        expect(procedure).toBeDefined();
+        expect(info.isStream).toBe(true);
+        expect(info.name).toBe('StreamTest');
+        expect(info.description).toBe('Test streaming procedure');
+        expect(info.schema.params).toEqual({
+            type: 'object',
+            properties: { count: { type: 'number' } },
+            required: ['count'],
+        });
+        expect(info.schema.yieldType).toEqual({
+            type: 'object',
+            properties: { value: { type: 'number' } },
+            required: ['value'],
+        });
+        // Collect yielded values
+        const values = [];
+        for await (const val of StreamTest({}, { count: 3 })) {
+            values.push(val);
+        }
+        expect(values).toEqual([{ value: 0 }, { value: 1 }, { value: 2 }]);
+    });
+    test('CreateStream validates params', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamWithParams } = CreateStream('StreamWithParams', {
+            schema: {
+                params: v.object({ name: v.string().required() }),
+                yieldType: v.string(),
+            },
+        }, async function* (ctx, params) {
+            yield params.name;
+        });
+        // Missing required param should throw ProcedureValidationError
+        try {
+            // @ts-expect-error - intentionally passing invalid params
+            for await (const _val of StreamWithParams({}, {})) {
+                // Should not reach here
+            }
+            expect.fail('Should have thrown');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+            expect(e.message).toContain('Validation error for StreamWithParams');
+        }
+    });
+    test('CreateStream with validateYields validates each yielded value', async () => {
+        const { CreateStream } = Procedures();
+        const { ProcedureYieldValidationError } = await import('./errors.js');
+        const { StreamValidateYields } = CreateStream('StreamValidateYields', {
+            schema: {
+                yieldType: v.object({ id: v.number().required() }),
+            },
+            validateYields: true,
+        }, async function* () {
+            yield { id: 1 }; // Valid
+            yield { id: 'not-a-number' }; // Invalid - should throw
+        });
+        const values = [];
+        try {
+            for await (const val of StreamValidateYields({}, {})) {
+                values.push(val);
+            }
+            expect.fail('Should have thrown on invalid yield');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureYieldValidationError);
+            expect(e.message).toContain('Yield validation error for StreamValidateYields');
+            expect(values).toEqual([{ id: 1 }]); // First value was valid
+        }
+    });
+    test('CreateStream without validateYields does not validate yields', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamNoValidate } = CreateStream('StreamNoValidate', {
+            schema: {
+                yieldType: v.object({ id: v.number().required() }),
+            },
+            // validateYields defaults to false
+        }, async function* () {
+            yield { id: 1 };
+            yield { id: 'not-a-number' }; // Invalid but won't throw
+        });
+        const values = [];
+        for await (const val of StreamNoValidate({}, {})) {
+            values.push(val);
+        }
+        expect(values).toEqual([{ id: 1 }, { id: 'not-a-number' }]);
+    });
+    test('CreateStream ctx.error throws ProcedureError', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamError } = CreateStream('StreamError', {}, async function* (ctx) {
+            yield 'first';
+            throw ctx.error('Custom stream error', { code: 'STREAM_ERR' });
+        });
+        const values = [];
+        try {
+            for await (const val of StreamError({}, {})) {
+                values.push(val);
+            }
+            expect.fail('Should have thrown');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.message).toBe('Custom stream error');
+            expect(e.procedureName).toBe('StreamError');
+            expect(e.meta).toEqual({ code: 'STREAM_ERR' });
+            expect(values).toEqual(['first']);
+        }
+    });
+    test('CreateStream provides ctx.signal for abort handling', async () => {
+        const { CreateStream } = Procedures();
+        let signalReceived = false;
+        const { StreamWithSignal } = CreateStream('StreamWithSignal', {}, async function* (ctx) {
+            expect(ctx.signal).toBeDefined();
+            expect(ctx.signal).toBeInstanceOf(AbortSignal);
+            signalReceived = true;
+            yield 'value';
+        });
+        for await (const _val of StreamWithSignal({}, {})) {
+            // consume
+        }
+        expect(signalReceived).toBe(true);
+    });
+    test('CreateStream appears in getProcedures with isStream flag', () => {
+        const { Create, CreateStream, getProcedures } = Procedures();
+        Create('RegularProc', {}, async () => 'regular');
+        CreateStream('StreamProc', {}, async function* () {
+            yield 'stream';
+        });
+        const procs = getProcedures();
+        expect(procs.length).toBe(2);
+        const regular = procs.find((p) => p.name === 'RegularProc');
+        const stream = procs.find((p) => p.name === 'StreamProc');
+        expect(regular?.isStream).toBeUndefined();
+        expect(stream?.isStream).toBe(true);
+    });
+    test('CreateStream onCreate callback receives isStream flag', () => new Promise((done) => {
+        let receivedProc;
+        const { CreateStream } = Procedures({
+            onCreate: (proc) => {
+                receivedProc = proc;
+            },
+        });
+        CreateStream('OnCreateStream', {}, async function* () {
+            yield 'test';
+        });
+        expect(receivedProc).toBeDefined();
+        expect(receivedProc.isStream).toBe(true);
+        expect(receivedProc.name).toBe('OnCreateStream');
+        done();
+    }));
+    test('CreateStream duplicate registration throws', () => {
+        const { CreateStream } = Procedures();
+        CreateStream('DuplicateStream', {}, async function* () {
+            yield 'first';
+        });
+        expect(() => {
+            CreateStream('DuplicateStream', {}, async function* () {
+                yield 'second';
+            });
+        }).toThrow('Procedure with name DuplicateStream is already registered');
+    });
+    test('CreateStream error includes definition location', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamErrorLocation } = CreateStream('StreamErrorLocation', {
+            schema: {
+                params: v.object({ id: v.number().required() }),
+            },
+        }, async function* () {
+            yield 'test';
+        });
+        try {
+            // @ts-expect-error - intentionally passing invalid params
+            for await (const _val of StreamErrorLocation({}, {})) {
+                // consume
+            }
+            expect.fail('Should have thrown');
+        }
+        catch (e) {
+            expect(e.definedAt).toBeDefined();
+            expect(e.definedAt.file).toContain('index.test.ts');
+            expect(e.stack).toContain('--- Procedure "StreamErrorLocation" defined at ---');
+        }
+    });
+    test('CreateStream with Typebox schema', async () => {
+        const { CreateStream } = Procedures();
+        const { TypeboxStream } = CreateStream('TypeboxStream', {
+            schema: {
+                params: Type.Object({ limit: Type.Number() }),
+                yieldType: Type.Object({ data: Type.String() }),
+            },
+        }, async function* (ctx, params) {
+            for (let i = 0; i < params.limit; i++) {
+                yield { data: `item-${i}` };
+            }
+        });
+        const values = [];
+        for await (const val of TypeboxStream({}, { limit: 2 })) {
+            values.push(val);
+        }
+        expect(values).toEqual([{ data: 'item-0' }, { data: 'item-1' }]);
+    });
+    test('CreateStream with context type', async () => {
+        const { CreateStream } = Procedures();
+        const { ContextStream } = CreateStream('ContextStream', {}, async function* (ctx) {
+            // ctx should have both userId and error
+            expect(ctx.userId).toBe('user-123');
+            expect(ctx.error).toBeDefined();
+            expect(ctx.signal).toBeDefined();
+            yield ctx.userId;
+        });
+        const values = [];
+        for await (const val of ContextStream({ userId: 'user-123' }, {})) {
+            values.push(val);
+        }
+        expect(values).toEqual(['user-123']);
+    });
+    test('CreateStream wrapped errors preserve cause', async () => {
+        const { CreateStream } = Procedures();
+        const originalError = new Error('Stream underlying error');
+        originalError.code = 'STREAM_FAIL';
+        const { StreamCause } = CreateStream('StreamCause', {}, 
+        // eslint-disable-next-line require-yield
+        async function* () {
+            throw originalError;
+        });
+        try {
+            for await (const _val of StreamCause({}, {})) {
+                // consume
+            }
+            expect.fail('Should have thrown');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureError);
+            expect(e.cause).toBe(originalError);
+            expect(e.cause.code).toBe('STREAM_FAIL');
+        }
+    });
+    test('CreateStream with extended config', () => {
+        const { CreateStream } = Procedures();
+        const { info } = CreateStream('ExtendedStream', {
+            scope: 'api',
+            version: 1,
+            description: 'Extended config stream',
+        }, async function* () {
+            yield 'data';
+        });
+        expect(info.scope).toBe('api');
+        expect(info.version).toBe(1);
+        expect(info.description).toBe('Extended config stream');
+        expect(info.isStream).toBe(true);
+    });
+    test('CreateStream signal.aborted becomes true after generator completes', async () => {
+        const { CreateStream } = Procedures();
+        let capturedSignal = null;
+        const { AbortStream } = CreateStream('AbortStream', {}, async function* (ctx) {
+            capturedSignal = ctx.signal;
+            yield 'value';
+        });
+        // Consume the generator
+        for await (const _val of AbortStream({}, {})) {
+            // consume
+        }
+        // After generator completes, signal should be aborted
+        expect(capturedSignal).not.toBeNull();
+        expect(capturedSignal.aborted).toBe(true);
+    });
+    test('CreateStream signal.reason is stream-completed after normal completion', async () => {
+        const { CreateStream } = Procedures();
+        let capturedSignal = null;
+        const { ReasonStream } = CreateStream('ReasonStream', {}, async function* (ctx) {
+            capturedSignal = ctx.signal;
+            yield 'value';
+        });
+        for await (const _val of ReasonStream({}, {})) {
+            // consume
+        }
+        expect(capturedSignal.reason).toBe('stream-completed');
+    });
+    test('CreateStream combines external signal with internal signal', async () => {
+        const { CreateStream } = Procedures();
+        const externalAc = new AbortController();
+        let capturedSignal = null;
+        const { CombinedStream } = CreateStream('CombinedStream', {}, async function* (ctx) {
+            capturedSignal = ctx.signal;
+            // Combined signal is a new object, not the raw external signal
+            expect(ctx.signal).not.toBe(externalAc.signal);
+            yield 'value';
+        });
+        // Abort external before consuming — combined signal should reflect it
+        externalAc.abort('client-disconnected');
+        for await (const _val of CombinedStream({ signal: externalAc.signal }, {})) {
+            // consume
+        }
+        expect(capturedSignal.aborted).toBe(true);
+        // Reason comes from external abort, not internal 'stream-completed'
+        expect(capturedSignal.reason).toBe('client-disconnected');
+    });
+});
+describe('isPrevalidated context property', () => {
+    test('Create skips validation when ctx.isPrevalidated is true', async () => {
+        const { Create } = Procedures();
+        const { SkipValidation } = Create('SkipValidation', {
+            schema: {
+                params: v.object({ name: v.string().required() }),
+            },
+        }, async (ctx, params) => {
+            return params;
+        });
+        // Without isPrevalidated, missing required param would throw
+        // With isPrevalidated: true, validation is skipped
+        const result = await SkipValidation({ isPrevalidated: true }, {});
+        expect(result).toEqual({});
+    });
+    test('Create validates when ctx.isPrevalidated is false', async () => {
+        const { Create } = Procedures();
+        const { ValidateParams } = Create('ValidateParams', {
+            schema: {
+                params: v.object({ name: v.string().required() }),
+            },
+        }, async (ctx, params) => {
+            return params;
+        });
+        // With isPrevalidated: false, validation should still run
+        try {
+            await ValidateParams({ isPrevalidated: false }, {});
+            expect.fail('Should have thrown validation error');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+        }
+    });
+    test('Create validates when ctx.isPrevalidated is undefined', async () => {
+        const { Create } = Procedures();
+        const { ValidateUndefined } = Create('ValidateUndefined', {
+            schema: {
+                params: v.object({ id: v.number().required() }),
+            },
+        }, async (ctx, params) => {
+            return params;
+        });
+        // Without isPrevalidated property, validation should run
+        try {
+            await ValidateUndefined({}, {});
+            expect.fail('Should have thrown validation error');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+        }
+    });
+    test('CreateStream skips validation when ctx.isPrevalidated is true', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamSkipValidation } = CreateStream('StreamSkipValidation', {
+            schema: {
+                params: v.object({ count: v.number().required() }),
+            },
+        }, async function* (ctx, params) {
+            yield { received: params };
+        });
+        // With isPrevalidated: true, validation is skipped even with invalid params
+        const values = [];
+        for await (const val of StreamSkipValidation({ isPrevalidated: true }, {})) {
+            values.push(val);
+        }
+        expect(values).toEqual([{ received: {} }]);
+    });
+    test('CreateStream validates when ctx.isPrevalidated is false', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamValidate } = CreateStream('StreamValidate', {
+            schema: {
+                params: v.object({ count: v.number().required() }),
+            },
+        }, async function* (ctx, params) {
+            yield { received: params };
+        });
+        // With isPrevalidated: false, validation should run
+        try {
+            for await (const _val of StreamValidate({ isPrevalidated: false }, {})) {
+                // consume
+            }
+            expect.fail('Should have thrown validation error');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+        }
+    });
+    test('CreateStream validates when ctx.isPrevalidated is undefined', async () => {
+        const { CreateStream } = Procedures();
+        const { StreamValidateUndefined } = CreateStream('StreamValidateUndefined', {
+            schema: {
+                params: v.object({ value: v.string().required() }),
+            },
+        }, async function* (ctx, params) {
+            yield params;
+        });
+        // Without isPrevalidated property, validation should run
+        try {
+            for await (const _val of StreamValidateUndefined({}, {})) {
+                // consume
+            }
+            expect.fail('Should have thrown validation error');
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ProcedureValidationError);
+        }
+    });
+    test('isPrevalidated is not exposed in handler context type', async () => {
+        const { Create } = Procedures();
+        Create('CheckCtxType', {}, async (ctx) => {
+            // @ts-expect-error - isPrevalidated should not be on handler context type
+            void ctx.isPrevalidated;
+            return 'done';
+        });
+    });
+});
+//# sourceMappingURL=index.test.js.map