@superblocksteam/sdk-api 2.0.103 → 2.0.104-next.0

package/src/api/streaming.test.ts

@@ -1,433 +0,0 @@
-/**
- * Tests for streaming API definition.
- */
-
-import { describe, it, expect, vi } from "vitest";
-import { z } from "zod";
-
-import { postgres, anthropic } from "../integrations/declarations.js";
-import type { ApiContext } from "../types.js";
-import { api, __setEntryPoint } from "./definition.js";
-import { streamingApi, isStreamingApi } from "./streaming.js";
-
-describe("streamingApi()", () => {
-  describe("basic creation", () => {
-    it("creates a streaming API with input and chunk schemas", () => {
-      const inputSchema = z.object({ prompt: z.string() });
-      const chunkSchema = z.object({ text: z.string() });
-
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: inputSchema,
-        chunk: chunkSchema,
-        async *run() {
-          yield { text: "Hello" };
-          yield { text: " World" };
-        },
-      });
-
-      expect(streamingApiDef.inputSchema).toBe(inputSchema);
-      expect(streamingApiDef.chunkSchema).toBe(chunkSchema);
-      expect(streamingApiDef.isStreaming).toBe(true);
-      expect(typeof streamingApiDef.run).toBe("function");
-    });
-
-    it("creates a streaming API with integrations", () => {
-      const inputSchema = z.object({ prompt: z.string() });
-      const chunkSchema = z.object({ text: z.string() });
-
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        integrations: {
-          ai: anthropic("Production Anthropic"),
-        },
-        input: inputSchema,
-        chunk: chunkSchema,
-        async *run() {
-          yield { text: "test" };
-        },
-      });
-
-      expect(streamingApiDef.integrations).toHaveLength(1);
-      expect(streamingApiDef.integrations[0]).toMatchObject({
-        key: "ai",
-        pluginId: "anthropic",
-        id: "Production Anthropic",
-      });
-    });
-
-    it("has empty integrations array when none declared", () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run() {
-          yield { text: "test" };
-        },
-      });
-
-      expect(streamingApiDef.integrations).toEqual([]);
-    });
-  });
-
-  describe("async generator execution", () => {
-    it("run function returns an async iterable", async () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run() {
-          yield { text: "Hello" };
-          yield { text: " World" };
-        },
-      });
-
-      const mockContext = {
-        integrations: {} as Record<string, unknown>,
-        log: {
-          info: vi.fn(),
-          warn: vi.fn(),
-          error: vi.fn(),
-          debug: vi.fn(),
-        },
-        env: {},
-      };
-
-      const iterator = streamingApiDef.run(
-        mockContext as unknown as ApiContext<Record<string, never>>,
-        { prompt: "test" },
-      );
-
-      expect(Symbol.asyncIterator in iterator).toBe(true);
-
-      const chunks: { text: string }[] = [];
-      for await (const chunk of iterator) {
-        chunks.push(chunk);
-      }
-
-      expect(chunks).toEqual([{ text: "Hello" }, { text: " World" }]);
-    });
-
-    it("can access input in the run function", async () => {
-      const inputCapture: string[] = [];
-
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run(ctx, { prompt }) {
-          inputCapture.push(prompt);
-          yield { text: prompt };
-        },
-      });
-
-      const mockContext = {
-        integrations: {} as Record<string, unknown>,
-        log: {
-          info: vi.fn(),
-          warn: vi.fn(),
-          error: vi.fn(),
-          debug: vi.fn(),
-        },
-        env: {},
-      };
-
-      const iterator = streamingApiDef.run(
-        mockContext as unknown as ApiContext<Record<string, never>>,
-        { prompt: "Hello, AI!" },
-      );
-      const chunks: { text: string }[] = [];
-      for await (const chunk of iterator) {
-        chunks.push(chunk);
-      }
-
-      expect(inputCapture).toEqual(["Hello, AI!"]);
-      expect(chunks).toEqual([{ text: "Hello, AI!" }]);
-    });
-
-    it("yields multiple chunks over time", async () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ count: z.number() }),
-        chunk: z.object({ index: z.number(), text: z.string() }),
-        async *run(ctx, { count }) {
-          for (let i = 0; i < count; i++) {
-            yield { index: i, text: `Chunk ${i}` };
-          }
-        },
-      });
-
-      const mockContext = {
-        integrations: {} as Record<string, unknown>,
-        log: {
-          info: vi.fn(),
-          warn: vi.fn(),
-          error: vi.fn(),
-          debug: vi.fn(),
-        },
-        env: {},
-      };
-
-      const iterator = streamingApiDef.run(
-        mockContext as unknown as ApiContext<Record<string, never>>,
-        { count: 5 },
-      );
-      const chunks: { index: number; text: string }[] = [];
-      for await (const chunk of iterator) {
-        chunks.push(chunk);
-      }
-
-      expect(chunks).toHaveLength(5);
-      expect(chunks[0]).toEqual({ index: 0, text: "Chunk 0" });
-      expect(chunks[4]).toEqual({ index: 4, text: "Chunk 4" });
-    });
-  });
-
-  describe("readonly properties", () => {
-    it("inputSchema is readonly", () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run() {
-          yield { text: "test" };
-        },
-      });
-
-      expect(streamingApiDef.inputSchema).toBeDefined();
-    });
-
-    it("chunkSchema is readonly", () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run() {
-          yield { text: "test" };
-        },
-      });
-
-      expect(streamingApiDef.chunkSchema).toBeDefined();
-    });
-
-    it("isStreaming is always true", () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run() {
-          yield { text: "test" };
-        },
-      });
-
-      expect(streamingApiDef.isStreaming).toBe(true);
-    });
-  });
-});
-
-describe("isStreamingApi()", () => {
-  describe("with streaming APIs", () => {
-    it("returns true for streaming API", () => {
-      const streamingApiDef = streamingApi({
-        name: "TestStreamingApi",
-        input: z.object({ prompt: z.string() }),
-        chunk: z.object({ text: z.string() }),
-        async *run() {
-          yield { text: "test" };
-        },
-      });
-
-      expect(isStreamingApi(streamingApiDef)).toBe(true);
-    });
-  });
-
-  describe("with regular APIs", () => {
-    it("returns false for regular API", () => {
-      const regularApi = api({
-        name: "RegularApi",
-        input: z.object({ userId: z.string() }),
-        output: z.object({ name: z.string() }),
-        async run() {
-          return { name: "Test" };
-        },
-      });
-
-      expect(isStreamingApi(regularApi)).toBe(false);
-    });
-  });
-
-  describe("with non-API values", () => {
-    it("returns false for null", () => {
-      expect(isStreamingApi(null)).toBe(false);
-    });
-
-    it("returns false for undefined", () => {
-      expect(isStreamingApi(undefined)).toBe(false);
-    });
-
-    it("returns false for plain object", () => {
-      expect(isStreamingApi({ isStreaming: false })).toBe(false);
-    });
-
-    it("returns false for number", () => {
-      expect(isStreamingApi(42)).toBe(false);
-    });
-
-    it("returns false for string", () => {
-      expect(isStreamingApi("streaming")).toBe(false);
-    });
-
-    it("returns false for object without isStreaming property", () => {
-      expect(isStreamingApi({ inputSchema: z.string() })).toBe(false);
-    });
-
-    it("returns false for object with only isStreaming true but missing required fields", () => {
-      expect(isStreamingApi({ isStreaming: true })).toBe(false);
-    });
-
-    it("returns true for object with isStreaming true and all required fields", () => {
-      expect(
-        isStreamingApi({
-          isStreaming: true,
-          inputSchema: z.string(),
-          chunkSchema: z.string(),
-          run: () => {},
-        }),
-      ).toBe(true);
-    });
-  });
-});
-
-describe("type inference", () => {
-  it("infers input type from schema", () => {
-    const streamingApiDef = streamingApi({
-      name: "TestStreamingApi",
-      input: z.object({
-        prompt: z.string(),
-        maxTokens: z.number().optional(),
-      }),
-      chunk: z.object({ text: z.string() }),
-      async *run(ctx, { prompt, maxTokens }) {
-        const p: string = prompt;
-        const m: number | undefined = maxTokens;
-        yield { text: `${p} ${m ?? 100}` };
-      },
-    });
-
-    expect(streamingApiDef).toBeDefined();
-  });
-
-  it("infers chunk type from schema", () => {
-    const streamingApiDef = streamingApi({
-      name: "TestStreamingApi",
-      input: z.object({ prompt: z.string() }),
-      chunk: z.object({
-        type: z.literal("text-delta"),
-        text: z.string(),
-        index: z.number(),
-      }),
-      async *run() {
-        yield {
-          type: "text-delta" as const,
-          text: "Hello",
-          index: 0,
-        };
-      },
-    });
-
-    expect(streamingApiDef.chunkSchema).toBeDefined();
-  });
-
-  it("infers integration types", () => {
-    const streamingApiDef = streamingApi({
-      name: "TestStreamingApi",
-      integrations: {
-        ai: anthropic("AI Service"),
-        db: postgres("Database"),
-      },
-      input: z.object({ prompt: z.string() }),
-      chunk: z.object({ text: z.string() }),
-      async *run() {
-        yield { text: "test" };
-      },
-    });
-
-    expect(streamingApiDef.integrations).toHaveLength(2);
-  });
-});
-
-describe("entryPoint mechanism", () => {
-  it("streamingApi() has no entryPoint when __setEntryPoint was not called", () => {
-    const compiled = streamingApi({
-      name: "NoEntryPoint",
-      input: z.object({}),
-      chunk: z.object({ text: z.string() }),
-      async *run() {
-        yield { text: "hello" };
-      },
-    });
-
-    expect(compiled.entryPoint).toBeUndefined();
-  });
-
-  it("streamingApi() picks up entryPoint set via __setEntryPoint", () => {
-    __setEntryPoint("server/apis/Chat/api.ts");
-    const compiled = streamingApi({
-      name: "Chat",
-      input: z.object({ prompt: z.string() }),
-      chunk: z.object({ text: z.string() }),
-      async *run() {
-        yield { text: "hello" };
-      },
-    });
-
-    expect(compiled.entryPoint).toBe("server/apis/Chat/api.ts");
-  });
-
-  it("entryPoint is consumed once — second streamingApi() call gets undefined", () => {
-    __setEntryPoint("server/apis/Stream/api.ts");
-    const first = streamingApi({
-      name: "Stream",
-      input: z.object({}),
-      chunk: z.object({ text: z.string() }),
-      async *run() {
-        yield { text: "a" };
-      },
-    });
-    const second = streamingApi({
-      name: "Stream2",
-      input: z.object({}),
-      chunk: z.object({ text: z.string() }),
-      async *run() {
-        yield { text: "b" };
-      },
-    });
-
-    expect(first.entryPoint).toBe("server/apis/Stream/api.ts");
-    expect(second.entryPoint).toBeUndefined();
-  });
-
-  it("__setEntryPoint works across api() and streamingApi()", () => {
-    __setEntryPoint("server/apis/Mixed/api.ts");
-    const compiled = streamingApi({
-      name: "Mixed",
-      input: z.object({}),
-      chunk: z.object({ text: z.string() }),
-      async *run() {
-        yield { text: "mixed" };
-      },
-    });
-
-    expect(compiled.entryPoint).toBe("server/apis/Mixed/api.ts");
-
-    const afterConsume = api({
-      name: "After",
-      input: z.object({}),
-      output: z.object({}),
-      async run() {
-        return {};
-      },
-    });
-    expect(afterConsume.entryPoint).toBeUndefined();
-  });
-});