@codexsploitx/schemaapi 1.0.0 → 1.0.1

package/tests/adapters.deno.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { handleContract } from "../src/adapters/deno";
-
-describe("adapters.deno.handleContract", () => {
-  it("maneja una petición GET devolviendo JSON según el contrato", async () => {
-    const contract = createContract({
-      "/api/data/:id": {
-        GET: {
-          params: z.object({ id: z.string() }),
-          response: z.object({ id: z.string(), ok: z.boolean() }),
-        },
-      },
-    });
-
-    const handlers = {
-      "GET /api/data/:id": async (ctx: any) => ({
-        id: ctx.params.id as string,
-        ok: true,
-      }),
-    };
-
-    const handler = handleContract(contract, handlers);
-
-    const req = new Request("http://localhost/api/data/123", {
-      method: "GET",
-    });
-
-    const res = await handler(req);
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json).toEqual({ id: "123", ok: true });
-  });
-
-  it("maneja una ruta de download devolviendo binario y headers correctos", async () => {
-    const contract = createContract({
-      "/file": {
-        GET: {
-          media: {
-            kind: "download",
-          },
-        },
-      },
-    });
-
-    const handlers = {
-      "GET /file": async () => ({
-        data: new TextEncoder().encode("hello"),
-        contentType: "text/plain",
-        filename: "hello.txt",
-      }),
-    };
-
-    const handler = handleContract(contract, handlers);
-
-    const req = new Request("http://localhost/file", {
-      method: "GET",
-    });
-
-    const res = await handler(req);
-    expect(res.status).toBe(200);
-    expect(res.headers.get("Content-Type")).toBe("text/plain");
-    expect(res.headers.get("Content-Disposition")).toBe(
-      'attachment; filename="hello.txt"'
-    );
-    const text = await res.text();
-    expect(text).toBe("hello");
-  });
-});

package/tests/adapters.express.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { handleContract, ExpressLikeHandler, ExpressLikeRequest } from "../src/adapters/express";
-
-type StoredRoute = {
-  method: string;
-  path: string;
-  handler: ExpressLikeHandler;
-};
-
-describe("adapters.express.handleContract", () => {
-  it("registra rutas y ejecuta handlers usando createContract", async () => {
-    const routes: StoredRoute[] = [];
-
-    const app = {
-      get(path: string, handler: StoredRoute["handler"]) {
-        routes.push({ method: "get", path, handler });
-      },
-    };
-
-    const contract = createContract({
-      "/users/:id": {
-        GET: {
-          params: z.object({ id: z.string() }),
-          response: z.object({ id: z.string() }),
-        },
-      },
-    });
-
-    handleContract(app, contract, {
-      "GET /users/:id": async (ctx) => ({
-        id: (ctx.params as { id: string }).id,
-      }),
-    });
-
-    expect(routes).toHaveLength(1);
-    const route = routes[0];
-    expect(route.method).toBe("get");
-    expect(route.path).toBe("/users/:id");
-
-    let jsonResult: unknown;
-    const req = {
-      params: { id: "123" },
-      query: {},
-      body: undefined,
-      headers: {},
-      user: undefined,
-    } as unknown as ExpressLikeRequest;
-    const res = {
-      json(body: unknown) {
-        jsonResult = body;
-      },
-    };
-
-    const next = (err?: unknown) => {
-      if (err) {
-        throw err;
-      }
-    };
-
-    await route.handler(req, res, next);
-
-    expect(jsonResult).toEqual({ id: "123" });
-  });
-});
-

package/tests/adapters.fastify.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { handleContract } from "../src/adapters/fastify";
-
-type StoredRoute = {
-  method: string | string[];
-  url: string;
-  handler: (request: any, reply: any) => void | Promise<void>;
-};
-
-describe("adapters.fastify.handleContract", () => {
-  it("registra una ruta y ejecuta el handler con contexto", async () => {
-    const routes: StoredRoute[] = [];
-
-    const fastify = {
-      route(options: StoredRoute) {
-        routes.push(options);
-      },
-    };
-
-    const contract = createContract({
-      "/ping": {
-        GET: {
-          response: z.object({ pong: z.boolean() }),
-        },
-      },
-    });
-
-    handleContract(fastify, contract, {
-      "GET /ping": async () => ({ pong: true }),
-    });
-
-    expect(routes).toHaveLength(1);
-    const route = routes[0];
-    expect(route.method).toBe("GET");
-    expect(route.url).toBe("/ping");
-
-    let sent: unknown;
-    const request = {
-      params: {},
-      query: {},
-      body: undefined,
-      headers: {},
-      user: undefined,
-    };
-    const reply = {
-      statusCode: 200,
-      status(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-      send(body: unknown) {
-        sent = body;
-      },
-    };
-
-    await route.handler(request, reply);
-    expect(reply.statusCode).toBe(200);
-    expect(sent).toEqual({ pong: true });
-  });
-});
-

package/tests/adapters.hapi.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { handleContract } from "../src/adapters/hapi";
-
-type StoredRoute = {
-  method: string;
-  path: string;
-  handler: (request: any, h: any) => Promise<any> | any;
-};
-
-describe("adapters.hapi.handleContract", () => {
-  it("registra una ruta y devuelve la respuesta correcta", async () => {
-    const routes: StoredRoute[] = [];
-
-    const server = {
-      route(options: StoredRoute) {
-        routes.push(options);
-      },
-    };
-
-    const contract = createContract({
-      "/hello/:name": {
-        GET: {
-          params: z.object({ name: z.string() }),
-          response: z.object({ message: z.string() }),
-        },
-      },
-    });
-
-    handleContract(server, contract, {
-      "GET /hello/:name": async (ctx: any) => ({
-        message: `Hello ${ctx.params.name as string}`,
-      }),
-    });
-
-    expect(routes).toHaveLength(1);
-    const route = routes[0];
-    expect(route.method).toBe("GET");
-    expect(route.path).toBe("/hello/{name}");
-
-    const request = {
-      params: { name: "Ada" },
-      query: {},
-      payload: undefined,
-      headers: {},
-      auth: { credentials: undefined },
-    };
-
-    const h = {
-      response(body: unknown) {
-        return {
-          body,
-          statusCode: 200,
-          code(code: number) {
-            this.statusCode = code;
-          },
-        };
-      },
-    };
-
-    const result = await route.handler(request, h);
-    expect(result).toEqual({ message: "Hello Ada" });
-  });
-});
-

package/tests/adapters.koa.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { handleContract } from "../src/adapters/koa";
-
-type StoredRoute = {
-  path: string;
-  methods: string[];
-  middleware: (ctx: any, next: () => Promise<void>) => Promise<void>;
-};
-
-describe("adapters.koa.handleContract", () => {
-  it("registra una ruta y fija ctx.body con el resultado", async () => {
-    const routes: StoredRoute[] = [];
-
-    const router = {
-      register(path: string, methods: string[], middleware: StoredRoute["middleware"]) {
-        routes.push({ path, methods, middleware });
-      },
-    };
-
-    const contract = createContract({
-      "/users/:id": {
-        GET: {
-          params: z.object({ id: z.string() }),
-          response: z.object({ id: z.string() }),
-        },
-      },
-    });
-
-    handleContract(router, contract, {
-      "GET /users/:id": async (ctx: any) => ({
-        id: ctx.params.id as string,
-      }),
-    });
-
-    expect(routes).toHaveLength(1);
-    const route = routes[0];
-    expect(route.path).toBe("/users/:id");
-    expect(route.methods).toEqual(["GET"]);
-
-    const ctx: any = {
-      params: { id: "7" },
-      query: {},
-      request: { body: undefined },
-      headers: {},
-      state: {},
-      body: undefined,
-      status: 200,
-    };
-
-    await route.middleware(ctx, async () => {});
-
-    expect(ctx.status).toBe(200);
-    expect(ctx.body).toEqual({ id: "7" });
-  });
-});
-

package/tests/adapters.nest.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { SchemaApiModule } from "../src/adapters/nest";
-
-type StoredRoute = {
-  method: string;
-  path: string;
-  handler: (req: any, res: any, next: () => void) => void | Promise<void>;
-};
-
-describe("adapters.nest.SchemaApiModule.register", () => {
-  it("registra rutas en el adaptador HTTP y ejecuta el handler", async () => {
-    const routes: StoredRoute[] = [];
-
-    const httpAdapter = {
-      get(path: string, handler: StoredRoute["handler"]) {
-        routes.push({ method: "get", path, handler });
-      },
-    };
-
-    const app = {
-      getHttpAdapter() {
-        return httpAdapter;
-      },
-    };
-
-    const contract = createContract({
-      "/items/:id": {
-        GET: {
-          params: z.object({ id: z.string() }),
-          response: z.object({ id: z.string() }),
-        },
-      },
-    });
-
-    SchemaApiModule.register(app as any, contract, {
-      "GET /items/:id": async (ctx: any) => ({
-        id: ctx.params.id as string,
-      }),
-    });
-
-    expect(routes).toHaveLength(1);
-    const route = routes[0];
-    expect(route.method).toBe("get");
-    expect(route.path).toBe("/items/:id");
-
-    let sent: unknown;
-    const req = {
-      params: { id: "10" },
-      query: {},
-      body: undefined,
-      headers: {},
-      user: undefined,
-    };
-    const res = {
-      value: undefined as unknown,
-      statusCode: 200,
-      send(body: unknown) {
-        this.value = body;
-      },
-      json(body: unknown) {
-        this.value = body;
-      },
-      end(body: string) {
-        this.value = JSON.parse(body);
-      },
-      status(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-      code(code: number) {
-        this.statusCode = code;
-        return this;
-      },
-    };
-
-    await route.handler(req, res, () => {});
-    sent = res.value;
-
-    expect(res.statusCode).toBe(200);
-    expect(sent).toEqual({ id: "10" });
-  });
-});
-

package/tests/adapters.next.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { handleContract } from "../src/adapters/next";
-
-describe("adapters.next.handleContract", () => {
-  it("resuelve una ruta GET usando contrato y params", async () => {
-    const contract = createContract({
-      "/users/:id": {
-        GET: {
-          params: z.object({ id: z.string() }),
-          response: z.object({
-            id: z.string(),
-            search: z.string().optional(),
-          }),
-        },
-      },
-    });
-
-    const handlers = {
-      "GET /users/:id": async (ctx: any) => ({
-        id: ctx.params.id as string,
-        search: (ctx.query as { search?: string }).search,
-      }),
-    };
-
-    const routes = handleContract(contract, handlers);
-
-    const req = new Request("http://localhost/api/users/42?search=test", {
-      method: "GET",
-    });
-
-    const res = await routes.GET(req, { params: { id: "42" } });
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json).toEqual({ id: "42", search: "test" });
-  });
-});
-

package/tests/adapters.remix.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createContract } from "../src/core/contract";
-import { createRouteHandlers } from "../src/adapters/remix";
-
-describe("adapters.remix.createRouteHandlers", () => {
-  it("usa loader para GET y action para POST basados en contrato", async () => {
-    const contract = createContract({
-      "/users/:id": {
-        GET: {
-          params: z.object({ id: z.string() }),
-          response: z.object({ id: z.string(), source: z.literal("loader") }),
-        },
-        POST: {
-          params: z.object({ id: z.string() }),
-          body: z.object({ name: z.string() }),
-          response: z.object({ id: z.string(), name: z.string(), source: z.literal("action") }),
-        },
-      },
-    });
-
-    const handlers = {
-      "GET /users/:id": async (ctx: any) => ({
-        id: ctx.params.id as string,
-        source: "loader",
-      }),
-      "POST /users/:id": async (ctx: any) => ({
-        id: ctx.params.id as string,
-        name: (ctx.body as { name: string }).name,
-        source: "action",
-      }),
-    };
-
-    const { loader, action } = createRouteHandlers(contract, handlers, "/users/:id");
-
-    const getRequest = new Request("http://localhost/users/5", { method: "GET" });
-    const getResponse = await loader({ request: getRequest, params: { id: "5" } });
-    expect(getResponse.status).toBe(200);
-    const getJson = await getResponse.json();
-    expect(getJson).toEqual({ id: "5", source: "loader" });
-
-    const postRequest = new Request("http://localhost/users/9", {
-      method: "POST",
-      body: JSON.stringify({ name: "John" }),
-      headers: { "Content-Type": "application/json" },
-    });
-    const postResponse = await action({ request: postRequest, params: { id: "9" } });
-    expect(postResponse.status).toBe(200);
-    const postJson = await postResponse.json();
-    expect(postJson).toEqual({ id: "9", name: "John", source: "action" });
-  });
-});

package/tests/adapters.ws.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { WebSocketServer, WebSocket } from "ws";
-import { createContract } from "../src/core/contract";
-import { z } from "zod";
-import * as adapters from "../src/adapters";
-import { createServer } from "http";
-import type { AddressInfo } from "net";
-
-describe("Adapter: WS", () => {
-  it("maneja conexiones websocket correctamente", async () => {
-    // 1. Definir contrato
-    const contract = createContract({
-      "/chat": {
-        WS: {
-          clientMessages: z.object({ text: z.string() }),
-          serverMessages: z.object({ text: z.string() }),
-        },
-      },
-    });
-
-    // 2. Setup Server
-    const server = createServer();
-    const wss = new WebSocketServer({ server });
-
-    // 3. Implementar Handler
-    const handlers = {
-      "WS /chat": (ctx: any) => {
-        // Usamos ctx.onMessage helper que ya parsea y valida
-        ctx.onMessage((msg: any) => {
-          // Usamos ctx.send helper
-          ctx.send({ text: `echo: ${msg.text}` });
-        });
-      },
-    };
-
-    adapters.ws.handleContract(wss, contract, handlers);
-
-    await new Promise<void>((resolve) => server.listen(0, resolve));
-    const port = (server.address() as AddressInfo).port;
-
-    // 4. Test Client
-    const ws = new WebSocket(`ws://localhost:${port}/chat`);
-
-    const messages: any[] = [];
-    ws.on("message", (data) => {
-      messages.push(JSON.parse(data.toString()));
-    });
-
-    await new Promise((resolve) => ws.on("open", resolve));
-    ws.send(JSON.stringify({ text: "hello" }));
-
-    // Esperar respuesta
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(messages).toHaveLength(1);
-    expect(messages[0]).toEqual({ text: "echo: hello" });
-
-    ws.close();
-    wss.close(); // Important to close wss
-    server.close();
-  });
-
-  it("rechaza rutas no definidas", async () => {
-      const contract = createContract({});
-      const server = createServer();
-      const wss = new WebSocketServer({ server });
-      adapters.ws.handleContract(wss, contract, {});
-      
-      await new Promise<void>((resolve) => server.listen(0, resolve));
-      const port = (server.address() as AddressInfo).port;
-
-      const ws = new WebSocket(`ws://localhost:${port}/unknown`);
-      
-      const closePromise = new Promise<number>((resolve) => {
-          ws.on('close', (code) => resolve(code));
-      });
-      
-      // Wait for close
-      const code = await closePromise;
-      // 404 is technically an HTTP code, but WS handshake failure usually results in connection drop or close.
-      // In my implementation: ws.close(404, "Not Found") -> 404 is not a valid WS close code (must be 1000-4999).
-      // Ah, I used 404 in implementation. That might throw or be invalid.
-      // Standard custom close codes are 4000-4999.
-      // Or 1002 (Protocol Error).
-      
-      // Let's check implementation again.
-      
-      wss.close();
-      server.close();
-  });
-});