every-plugin 0.1.0 → 0.1.2

package/dist/runtime/streaming.js

@@ -1,59 +0,0 @@
-import { Duration, Effect, Option, Stream } from "effect";
-const extractDelayFromState = (state) => {
-    return state?.nextPollMs ? Duration.millis(state.nextPollMs) : null;
-};
-/**
- * Create a stream from a source plugin
- * Note: Validation is handled at the runtime level before this function is called
- */
-export const createSourceStream = (initializedPlugin, executePlugin, input, options = {}, isStreamable) => {
-    // For non-streamable procedures, execute once and return items
-    if (!isStreamable) {
-        return Stream.fromEffect(executePlugin(initializedPlugin, input).pipe(Effect.map((result) => {
-            const resultObj = result;
-            const items = Array.isArray(resultObj.items)
-                ? resultObj.items
-                : resultObj.item
-                    ? [resultObj.item]
-                    : [];
-            return items;
-        }))).pipe(Stream.flatMap(items => Stream.fromIterable(items)));
-    }
-    const initialState = input.state;
-    const stream = Stream.unfoldEffect({ state: initialState, invocations: 0 }, ({ state: currentState, invocations }) => Effect.gen(function* () {
-        console.log(`[STREAM] Invocation ${invocations}:`);
-        console.log(`[STREAM] - Current state:`, JSON.stringify(currentState, null, 2));
-        console.log(`[STREAM] - Input:`, JSON.stringify(input, null, 2));
-        // Check invocation limit if specified
-        if (options.maxInvocations && invocations >= options.maxInvocations) {
-            console.log(`[STREAM] - Stopping: maxInvocations (${options.maxInvocations}) reached`);
-            return Option.none();
-        }
-        // Extract timing from plugin state (nextPollMs)
-        const nextDelay = extractDelayFromState(currentState) || Duration.minutes(1); // 1min default
-        yield* Effect.sleep(nextDelay);
-        // Execute plugin
-        const pluginInput = { ...input, state: currentState };
-        console.log(`[STREAM] - Plugin input:`, JSON.stringify(pluginInput, null, 2));
-        const result = yield* executePlugin(initializedPlugin, pluginInput);
-        const resultObj = result;
-        const items = Array.isArray(resultObj.items)
-            ? resultObj.items
-            : [];
-        const nextState = resultObj.nextState;
-        console.log(`[STREAM] - Plugin output:`, JSON.stringify(resultObj, null, 2));
-        console.log(`[STREAM] - Items count: ${items.length}`);
-        console.log(`[STREAM] - Next state:`, JSON.stringify(nextState, null, 2));
-        // Check stop conditions ONLY
-        if (options.stopWhenEmpty && items.length === 0) {
-            console.log(`[STREAM] - Stopping: stopWhenEmpty=true and items.length=0`);
-            return Option.none();
-        }
-        console.log(`[STREAM] - Continuing to next iteration`);
-        return Option.some([items, { state: nextState, invocations: invocations + 1 }]);
-    })).pipe(
-    // Flatten items from each iteration
-    Stream.flatMap(items => Stream.fromIterable(items)));
-    // Apply maxItems limit if specified
-    return options.maxItems ? stream.pipe(Stream.take(options.maxItems)) : stream;
-};

package/dist/runtime/streaming.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=streaming.test.d.ts.map

package/dist/runtime/streaming.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"streaming.test.d.ts","sourceRoot":"","sources":["../../src/runtime/streaming.test.ts"],"names":[],"mappings":""}

package/dist/runtime/streaming.test.js

@@ -1,271 +0,0 @@
-import { Effect, Stream } from "effect";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createPluginRuntime, PluginRuntime } from "./index";
-// Test registry with our example source plugin
-const TEST_REGISTRY = {
-    "test-source-plugin": {
-        remoteUrl: "http://localhost:3001/remoteEntry.js",
-        type: "source",
-        version: "0.0.1",
-        description: "Example source plugin for streaming tests",
-    },
-    "test-plugin": {
-        remoteUrl: "http://localhost:3000/remoteEntry.js",
-        type: "transformer",
-        version: "0.0.1",
-        description: "Local template plugin for testing",
-    },
-};
-const TEST_CONFIG = {
-    variables: {
-        baseUrl: "http://localhost:1337",
-        timeout: 5000,
-    },
-    secrets: {
-        apiKey: "test-api-key-value",
-    },
-};
-// Contract-based input for search procedure
-const TEST_SEARCH_INPUT = {
-    procedure: "search",
-    input: {
-        query: "test query",
-        limit: 10,
-    },
-    state: null,
-};
-// Contract-based input for getById procedure
-const TEST_GETBYID_INPUT = {
-    procedure: "getById",
-    input: {
-        id: "test-id-123",
-    },
-    state: null,
-};
-// Contract-based input for getBulk procedure
-const TEST_GETBULK_INPUT = {
-    procedure: "getBulk",
-    input: {
-        ids: ["id1", "id2", "id3"],
-    },
-    state: null,
-};
-const SECRETS_CONFIG = {
-    API_KEY: "test-api-key-value",
-};
-describe("Plugin Streaming", () => {
-    let runtime;
-    beforeEach(() => {
-        runtime = createPluginRuntime({
-            registry: TEST_REGISTRY,
-            secrets: SECRETS_CONFIG,
-        });
-    });
-    afterEach(async () => {
-        if (runtime) {
-            await runtime.dispose();
-        }
-    });
-    it("should respect maxItems limit", async () => {
-        const result = await runtime.runPromise(Effect.gen(function* () {
-            const pluginRuntime = yield* PluginRuntime;
-            // Start from Phase 3 state that immediately produces items
-            const inputWithProductiveState = {
-                ...TEST_SEARCH_INPUT,
-                state: { phase: "historical", status: "processing", nextPollMs: 10 }
-            };
-            const stream = yield* pluginRuntime.streamPlugin("test-source-plugin", TEST_CONFIG, inputWithProductiveState, {
-                maxItems: 3, // Strict limit
-                maxInvocations: 3
-            });
-            const items = yield* stream.pipe(Stream.runCollect);
-            return Array.from(items);
-        }));
-        expect(result.length).toBeLessThanOrEqual(3);
-        expect(result.length).toBeGreaterThan(0);
-    }, 4000);
-    it("should validate invalid state and fail with proper error", async () => {
-        const result = await runtime.runPromise(Effect.gen(function* () {
-            const pluginRuntime = yield* PluginRuntime;
-            // Use invalid state that doesn't match plugin's stateSchema
-            const inputWithInvalidState = {
-                ...TEST_SEARCH_INPUT,
-                state: {
-                    pageNumber: 10, // Invalid - plugin expects { phase, status?, jobId?, lastId?, nextPollMs? }
-                    invalidField: "should not be here",
-                },
-            };
-            // The error should occur when creating the stream, not when running it
-            return yield* pluginRuntime.streamPlugin("test-source-plugin", TEST_CONFIG, inputWithInvalidState, {
-                stopWhenEmpty: true,
-            }).pipe(Effect.flatMap(() => 
-            // If we get here, validation didn't work
-            Effect.succeed("validation-should-have-failed")), Effect.catchTag("PluginRuntimeError", (error) => {
-                // Should catch state validation error
-                expect(error.operation).toBe("validate-state");
-                expect(error.retryable).toBe(false);
-                expect(error.pluginId).toBe("test-source-plugin");
-                expect(error.cause).toBeDefined();
-                console.debug("Caught expected state validation error:", {
-                    operation: error.operation,
-                    pluginId: error.pluginId,
-                    retryable: error.retryable,
-                    cause: error.cause?.message,
-                });
-                return Effect.succeed("state-validation-error-handled");
-            }), Effect.catchAll((unexpectedError) => {
-                console.error("Unexpected error type:", unexpectedError);
-                expect.fail(`Expected PluginRuntimeError but got: ${unexpectedError._tag || typeof unexpectedError}`);
-                return Effect.succeed("should-not-reach-here");
-            }));
-        }));
-        expect(result).toBe("state-validation-error-handled");
-    }, 4000);
-    it("should handle stopWhenEmpty option", async () => {
-        const result = await runtime.runPromise(Effect.gen(function* () {
-            const pluginRuntime = yield* PluginRuntime;
-            // Use the deterministic "empty" phase that always returns 0 items
-            const inputWithEmptyState = {
-                ...TEST_SEARCH_INPUT,
-                state: {
-                    phase: "empty",
-                    nextPollMs: 10,
-                },
-            };
-            const stream = yield* pluginRuntime.streamPlugin("test-source-plugin", TEST_CONFIG, inputWithEmptyState, {
-                stopWhenEmpty: true,
-                maxInvocations: 3, // Allow a few iterations to verify it stops
-            });
-            const items = yield* stream.pipe(Stream.runCollect);
-            return Array.from(items);
-        }));
-        // Should stop immediately when no items are returned from empty phase
-        expect(Array.isArray(result)).toBe(true);
-        expect(result.length).toBe(0); // Empty phase always returns 0 items
-    }, 4000);
-    it("should validate plugin type", async () => {
-        const result = await runtime.runPromise(Effect.gen(function* () {
-            const pluginRuntime = yield* PluginRuntime;
-            return yield* pluginRuntime.streamPlugin("test-plugin", TEST_CONFIG, TEST_SEARCH_INPUT).pipe(Effect.catchTag("PluginRuntimeError", (error) => {
-                expect(error.operation).toBe("stream-plugin-validate");
-                expect(error.cause?.message).toContain("not a source plugin");
-                return Effect.succeed("validation-error-handled");
-            }));
-        }));
-        expect(result).toBe("validation-error-handled");
-    });
-    it("should handle workflow phases correctly", async () => {
-        const pluginRuntime = await runtime.runPromise(PluginRuntime);
-        const plugin = await runtime.runPromise(pluginRuntime.usePlugin("test-source-plugin", TEST_CONFIG));
-        // Phase 1: null state -> historical job (empty items)
-        const phase1 = await runtime.runPromise(pluginRuntime.executePlugin(plugin, TEST_SEARCH_INPUT));
-        const phase1Result = phase1;
-        expect(phase1Result.items).toHaveLength(0);
-        expect(phase1Result.nextState.phase).toBe("historical");
-        expect(phase1Result.nextState.jobId).toMatch(/^hist_\d+$/);
-        expect(phase1Result.nextState.nextPollMs).toBe(10);
-        // Phase 2: historical job -> processing (empty items)
-        const phase2Input = { ...TEST_SEARCH_INPUT, state: phase1Result.nextState };
-        const phase2 = await runtime.runPromise(pluginRuntime.executePlugin(plugin, phase2Input));
-        const phase2Result = phase2;
-        expect(phase2Result.items).toHaveLength(0);
-        expect(phase2Result.nextState.phase).toBe("historical");
-        expect(phase2Result.nextState.status).toBe("processing");
-        expect(phase2Result.nextState.nextPollMs).toBe(10);
-        // Phase 3: processing -> historical items + realtime transition
-        const phase3Input = { ...TEST_SEARCH_INPUT, state: phase2Result.nextState };
-        const phase3 = await runtime.runPromise(pluginRuntime.executePlugin(plugin, phase3Input));
-        const phase3Result = phase3;
-        expect(phase3Result.items.length).toBeGreaterThan(0);
-        expect(phase3Result.items[0]?.content).toContain("Historical");
-        expect(phase3Result.nextState.phase).toBe("realtime");
-        expect(phase3Result.nextState.lastId).toMatch(/^hist_end_\d+$/);
-        expect(phase3Result.nextState.nextPollMs).toBe(10);
-        // Phase 4: realtime polling (may have items)
-        const phase4Input = { ...TEST_SEARCH_INPUT, state: phase3Result.nextState };
-        const phase4 = await runtime.runPromise(pluginRuntime.executePlugin(plugin, phase4Input));
-        const phase4Result = phase4;
-        expect(phase4Result.nextState.phase).toBe("realtime");
-        // Items may be empty or contain real-time items (random)
-        if (phase4Result.items.length > 0) {
-            expect(phase4Result.items[0]?.content).toContain("Real-time");
-        }
-    }, 4000);
-    describe("Contract-based Procedures", () => {
-        it("should execute getById procedure", async () => {
-            const result = await runtime.runPromise(Effect.gen(function* () {
-                const pluginRuntime = yield* PluginRuntime;
-                const plugin = yield* pluginRuntime.usePlugin("test-source-plugin", TEST_CONFIG);
-                const output = yield* pluginRuntime.executePlugin(plugin, TEST_GETBYID_INPUT);
-                return output;
-            }));
-            expect(result).toBeDefined();
-            const typedResult = result;
-            expect(typedResult.item).toBeDefined();
-            expect(typedResult.item.externalId).toBe("test-id-123");
-            expect(typedResult.item.content).toContain("Content for item test-id-123");
-        });
-        it("should execute getBulk procedure", async () => {
-            const result = await runtime.runPromise(Effect.gen(function* () {
-                const pluginRuntime = yield* PluginRuntime;
-                const plugin = yield* pluginRuntime.usePlugin("test-source-plugin", TEST_CONFIG);
-                const output = yield* pluginRuntime.executePlugin(plugin, TEST_GETBULK_INPUT);
-                return output;
-            }));
-            expect(result).toBeDefined();
-            const typedResult = result;
-            expect(typedResult.items).toBeDefined();
-            expect(Array.isArray(typedResult.items)).toBe(true);
-            expect(typedResult.items.length).toBe(3);
-            expect(typedResult.items[0].externalId).toBe("id1");
-            expect(typedResult.items[1].externalId).toBe("id2");
-            expect(typedResult.items[2].externalId).toBe("id3");
-        });
-        it("should execute search procedure", async () => {
-            const result = await runtime.runPromise(Effect.gen(function* () {
-                const pluginRuntime = yield* PluginRuntime;
-                const plugin = yield* pluginRuntime.usePlugin("test-source-plugin", TEST_CONFIG);
-                // Use Phase 3 state to get historical items
-                const searchInputWithState = {
-                    ...TEST_SEARCH_INPUT,
-                    state: { phase: "historical", status: "processing" }
-                };
-                const output = yield* pluginRuntime.executePlugin(plugin, searchInputWithState);
-                return output;
-            }));
-            expect(result).toBeDefined();
-            const typedResult = result;
-            expect(typedResult.items).toBeDefined();
-            expect(Array.isArray(typedResult.items)).toBe(true);
-            expect(typedResult.items.length).toBeGreaterThan(0);
-            expect(typedResult.items[0].content).toContain("test query");
-            expect(typedResult.nextState).toBeDefined();
-        });
-        it("should stream getById procedure (single item)", async () => {
-            const result = await runtime.runPromise(Effect.gen(function* () {
-                const pluginRuntime = yield* PluginRuntime;
-                const stream = yield* pluginRuntime.streamPlugin("test-source-plugin", TEST_CONFIG, TEST_GETBYID_INPUT, {
-                    maxItems: 5, // Safety limit
-                });
-                const items = yield* stream.pipe(Stream.runCollect);
-                return Array.from(items);
-            }));
-            expect(result).toBeDefined();
-            expect(result.length).toBe(1);
-            expect(result[0].externalId).toBe("test-id-123");
-        });
-        it("should stream getBulk procedure", async () => {
-            const result = await runtime.runPromise(Effect.gen(function* () {
-                const pluginRuntime = yield* PluginRuntime;
-                const stream = yield* pluginRuntime.streamPlugin("test-source-plugin", TEST_CONFIG, TEST_GETBULK_INPUT, {
-                    maxItems: 5, // Safety limit
-                });
-                const items = yield* stream.pipe(Stream.runCollect);
-                return Array.from(items);
-            }));
-            expect(result).toBeDefined();
-            expect(result.length).toBe(3);
-            expect(result.map(item => item.externalId)).toEqual(["id1", "id2", "id3"]);
-        });
-    });
-});

package/dist/source.d.ts

@@ -1,70 +0,0 @@
-import type { Effect } from "effect";
-import { z } from "zod";
-import type { ConfigurationError, PluginExecutionError } from "./errors";
-import type { PluginLoggerTag } from "./plugin";
-/**
- * Source-specific schema creators for contract-based plugins
- */
-export declare function createSourceInputSchema<
-	TContract,
-	TStateSchema extends z.ZodTypeAny,
->(
-	contract: TContract,
-	stateSchema: TStateSchema,
-): z.ZodDiscriminatedUnion<
-	[z.ZodObject<any, z.core.$strip>, ...z.ZodObject<any, z.core.$strip>[]],
-	"procedure"
->;
-/**
- * Contract-based output schema creator that infers from oRPC contract
- */
-export declare function createSourceOutputSchema<
-	TContract,
-	TStateSchema extends z.ZodTypeAny,
->(
-	contract: TContract,
-	stateSchema: TStateSchema,
-): z.ZodUnion<
-	[
-		z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>,
-		...z.ZodType<
-			unknown,
-			unknown,
-			z.core.$ZodTypeInternals<unknown, unknown>
-		>[],
-	]
->;
-/**
- * Contract-first source plugin interface following the Plugin pattern
- */
-export interface SourcePlugin<
-	TContract = Record<string, any>,
-	TConfigSchema extends z.ZodTypeAny = z.ZodTypeAny,
-	TStateSchema extends z.ZodTypeAny = z.ZodTypeAny,
-> {
-	readonly id: string;
-	readonly type: "source";
-	readonly contract: TContract;
-	readonly configSchema: TConfigSchema;
-	readonly stateSchema: TStateSchema;
-	readonly inputSchema: ReturnType<
-		typeof createSourceInputSchema<TContract, TStateSchema>
-	>;
-	readonly outputSchema: ReturnType<
-		typeof createSourceOutputSchema<TContract, TStateSchema>
-	>;
-	initialize(
-		config?: z.infer<TConfigSchema>,
-	): Effect.Effect<void, ConfigurationError, PluginLoggerTag>;
-	execute(
-		input: z.infer<this["inputSchema"]>,
-	): Effect.Effect<
-		z.infer<this["outputSchema"]>,
-		PluginExecutionError,
-		PluginLoggerTag
-	>;
-	shutdown(): Effect.Effect<void, never, PluginLoggerTag>;
-	createRouter(): any;
-	isStreamable(procedureName: string): boolean;
-}
-//# sourceMappingURL=source.d.ts.map

package/dist/source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;GAEG;AACH,wBAAgB,uBAAuB,CACtC,SAAS,EACT,YAAY,SAAS,CAAC,CAAC,UAAU,EAEjC,QAAQ,EAAE,SAAS,EACnB,WAAW,EAAE,YAAY,iHAwBzB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACvC,SAAS,EACT,YAAY,SAAS,CAAC,CAAC,UAAU,EAEjC,QAAQ,EAAE,SAAS,EACnB,WAAW,EAAE,YAAY,uKAWzB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAC5B,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,aAAa,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,EACjD,YAAY,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU;IAEhD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IAC1F,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;IAE5F,UAAU,CACT,MAAM,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,GAC7B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,eAAe,CAAC,CAAC;IAE5D,OAAO,CACN,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,GACjC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,oBAAoB,EAAE,eAAe,CAAC,CAAC;IAEvF,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;IAExD,YAAY,IAAI,GAAG,CAAC;IAEpB,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7C"}

package/dist/source.js

@@ -1,37 +0,0 @@
-import { z } from "zod";
-/**
- * Source-specific schema creators for contract-based plugins
- */
-export function createSourceInputSchema(contract, stateSchema) {
-	const contractEntries = Object.entries(contract);
-	const procedureSchemas = contractEntries.map(
-		([procedureName, procedureSpec]) => {
-			// Extract input and output schemas from oRPC contract procedure
-			const inputSchema = procedureSpec["~orpc"]?.inputSchema || z.object({});
-			const outputSchema = procedureSpec["~orpc"]?.outputSchema || z.object({});
-			// Check if this procedure is streamable (has nextState in output)
-			const isStreamable = outputSchema._def?.shape?.nextState !== undefined;
-			const baseSchema = z.object({
-				procedure: z.literal(procedureName),
-				input: inputSchema,
-			});
-			// Only add state field for streamable procedures
-			return isStreamable
-				? baseSchema.extend({ state: stateSchema })
-				: baseSchema;
-		},
-	);
-	return z.discriminatedUnion("procedure", procedureSchemas);
-}
-/**
- * Contract-based output schema creator that infers from oRPC contract
- */
-export function createSourceOutputSchema(contract, stateSchema) {
-	const contractEntries = Object.entries(contract);
-	const procedureOutputSchemas = contractEntries.map(([_, procedureSpec]) => {
-		// Extract output schema from oRPC contract procedure
-		return procedureSpec["~orpc"]?.outputSchema || z.object({});
-	});
-	// Return union of all procedure output schemas
-	return z.union(procedureOutputSchemas);
-}