@codexsploitx/schemaapi 1.0.0

package/src/adapters/fastify.ts

@@ -0,0 +1,133 @@
+import type { createContract } from "../core/contract";
+import { buildErrorPayload } from "../core/contract";
+
+type AnyContract = ReturnType<typeof createContract>;
+
+type MethodSchemaLike = {
+  media?: {
+    kind?: string;
+    contentTypes?: string[];
+    maxSize?: number;
+  };
+};
+
+type DownloadResult =
+  | {
+      data: unknown;
+      contentType?: string;
+      filename?: string;
+    }
+  | unknown;
+
+interface FastifyLikeRequest {
+  params: Record<string, string>;
+  query: Record<string, string>;
+  body: unknown;
+  headers: Record<string, string>;
+  user?: unknown;
+}
+
+interface FastifyLikeReply {
+  status: (code: number) => FastifyLikeReply;
+  send: (payload: unknown) => void;
+  header: (key: string, value: string) => FastifyLikeReply;
+}
+
+interface FastifyInstance {
+  route: (options: {
+    method: string | string[];
+    url: string;
+    handler: (
+      request: FastifyLikeRequest,
+      reply: FastifyLikeReply
+    ) => Promise<void> | void;
+  }) => void;
+}
+
+export function handleContract(
+  fastify: FastifyInstance,
+  contract: AnyContract,
+  handlers: Record<
+    string,
+    (ctx: Record<string, unknown>) => unknown | Promise<unknown>
+  >
+) {
+  const schema = contract.schema as Record<string, Record<string, unknown>>;
+
+  Object.keys(schema).forEach((route) => {
+    const methods = schema[route] as Record<string, unknown>;
+
+    Object.keys(methods).forEach((method) => {
+      const endpoint = `${method} ${route}`;
+      const implementation = handlers[endpoint];
+      const methodSchema = (methods as Record<string, unknown>)[
+        method
+      ] as MethodSchemaLike | undefined;
+
+      if (!implementation) {
+        return;
+      }
+
+      const wrapped = contract.handle(endpoint, implementation);
+
+      fastify.route({
+        method: method,
+        url: route, // Fastify soporta /:id sintaxis
+        handler: async (
+          request: FastifyLikeRequest,
+          reply: FastifyLikeReply
+        ) => {
+          try {
+            const context: Record<string, unknown> = {
+              params: request.params || {},
+              query: request.query || {},
+              body: request.body,
+              headers: request.headers || {},
+              user: request.user,
+            };
+
+            const result = await wrapped(context);
+            const media = methodSchema?.media;
+            if (media && media.kind === "download") {
+              const download = result as DownloadResult;
+              const data =
+                download &&
+                typeof download === "object" &&
+                "data" in download
+                  ? (download as { data: unknown }).data
+                  : download;
+              const contentType =
+                download &&
+                typeof download === "object" &&
+                "contentType" in download
+                  ? (download as { contentType: string }).contentType
+                  : "application/octet-stream";
+              const filename =
+                download &&
+                typeof download === "object" &&
+                "filename" in download
+                  ? (download as { filename: string }).filename
+                  : undefined;
+
+              if (typeof reply.header === "function") {
+                reply.header("Content-Type", contentType);
+                if (filename) {
+                  reply.header(
+                    "Content-Disposition",
+                    `attachment; filename="${filename}"`
+                  );
+                }
+              }
+              reply.send(data);
+              return;
+            }
+            reply.send(result);
+          } catch (error: unknown) {
+            const payload = buildErrorPayload(error);
+            reply.status(payload.status).send(payload);
+          }
+        },
+      });
+    });
+  });
+}

package/src/adapters/hapi.ts

@@ -0,0 +1,140 @@
+import type { createContract } from "../core/contract";
+import { buildErrorPayload } from "../core/contract";
+
+type AnyContract = ReturnType<typeof createContract>;
+
+type MethodSchemaLike = {
+  media?: {
+    kind?: string;
+    contentTypes?: string[];
+    maxSize?: number;
+  };
+};
+
+type DownloadResult =
+  | {
+      data: unknown;
+      contentType?: string;
+      filename?: string;
+    }
+  | unknown;
+
+interface HapiLikeRequest {
+  params: Record<string, string>;
+  query: Record<string, string>;
+  payload: unknown;
+  headers: Record<string, string>;
+  auth?: { credentials?: unknown };
+}
+
+interface HapiLikeResponseObject {
+  type: (contentType: string) => void;
+  header: (key: string, value: string) => void;
+  code: (statusCode: number) => void;
+}
+
+interface HapiLikeResponseToolkit {
+  response: (data: unknown) => HapiLikeResponseObject;
+}
+
+interface HapiServer {
+  route: (options: {
+    method: string;
+    path: string;
+    handler: (
+      request: HapiLikeRequest,
+      h: HapiLikeResponseToolkit
+    ) => Promise<unknown> | unknown;
+  }) => void;
+}
+
+export function handleContract(
+  server: HapiServer,
+  contract: AnyContract,
+  handlers: Record<
+    string,
+    (ctx: Record<string, unknown>) => unknown | Promise<unknown>
+  >
+) {
+  const schema = contract.schema as Record<string, Record<string, unknown>>;
+
+  Object.keys(schema).forEach((route) => {
+    const methods = schema[route] as Record<string, unknown>;
+
+    // Convertir ruta express-style :param a hapi-style {param}
+    const hapiRoute = route.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+
+    Object.keys(methods).forEach((method) => {
+      const endpoint = `${method} ${route}`;
+      const implementation = handlers[endpoint];
+      const methodSchema = (methods as Record<string, unknown>)[
+        method
+      ] as MethodSchemaLike | undefined;
+
+      if (!implementation) {
+        return;
+      }
+
+      const wrapped = contract.handle(endpoint, implementation);
+
+      server.route({
+        method: method,
+        path: hapiRoute,
+        handler: async (
+          request: HapiLikeRequest,
+          h: HapiLikeResponseToolkit
+        ) => {
+          try {
+            const context: Record<string, unknown> = {
+              params: request.params || {},
+              query: request.query || {},
+              body: request.payload,
+              headers: request.headers || {},
+              user: request.auth?.credentials, // Common Hapi auth pattern
+            };
+
+            const result = await wrapped(context);
+            const media = methodSchema?.media;
+            if (media && media.kind === "download") {
+              const download = result as DownloadResult;
+              const data =
+                download &&
+                typeof download === "object" &&
+                "data" in download
+                  ? (download as { data: unknown }).data
+                  : download;
+              const contentType =
+                download &&
+                typeof download === "object" &&
+                "contentType" in download
+                  ? (download as { contentType: string }).contentType
+                  : "application/octet-stream";
+              const filename =
+                download &&
+                typeof download === "object" &&
+                "filename" in download
+                  ? (download as { filename: string }).filename
+                  : undefined;
+
+              const response = h.response(data);
+              response.type(contentType);
+              if (filename) {
+                response.header(
+                  "Content-Disposition",
+                  `attachment; filename="${filename}"`
+                );
+              }
+              return response;
+            }
+            return result;
+          } catch (error: unknown) {
+            const payload = buildErrorPayload(error);
+            const response = h.response(payload);
+            response.code(payload.status);
+            return response;
+          }
+        },
+      });
+    });
+  });
+}

package/src/adapters/index.ts

@@ -0,0 +1,9 @@
+export * as express from "./express";
+export * as next from "./next";
+export * as fastify from "./fastify";
+export * as nest from "./nest";
+export * as koa from "./koa";
+export * as hapi from "./hapi";
+export * as remix from "./remix";
+export * as deno from "./deno";
+export * as ws from "./ws";

package/src/adapters/koa.ts

@@ -0,0 +1,128 @@
+import type { createContract } from "../core/contract";
+import { buildErrorPayload } from "../core/contract";
+
+type AnyContract = ReturnType<typeof createContract>;
+
+type MethodSchemaLike = {
+  media?: {
+    kind?: string;
+    contentTypes?: string[];
+    maxSize?: number;
+  };
+};
+
+type DownloadResult =
+  | {
+      data: unknown;
+      contentType?: string;
+      filename?: string;
+    }
+  | unknown;
+
+interface KoaLikeContext {
+  params: Record<string, string>;
+  query: Record<string, string>;
+  request: { body?: unknown };
+  headers: Record<string, string>;
+  state?: { user?: unknown };
+  body?: unknown;
+  type?: string;
+  set: (key: string, value: string) => void;
+  status?: number;
+}
+
+interface KoaRouter {
+  register: (
+    path: string,
+    methods: string[],
+    middleware: (
+      ctx: KoaLikeContext,
+      next: () => Promise<unknown>
+    ) => Promise<unknown>
+  ) => void;
+}
+
+export function handleContract(
+  router: KoaRouter,
+  contract: AnyContract,
+  handlers: Record<
+    string,
+    (ctx: Record<string, unknown>) => unknown | Promise<unknown>
+  >
+) {
+  const schema = contract.schema as Record<string, Record<string, unknown>>;
+
+  Object.keys(schema).forEach((route) => {
+    const methods = schema[route] as Record<string, unknown>;
+
+    Object.keys(methods).forEach((method) => {
+      const endpoint = `${method} ${route}`;
+      const implementation = handlers[endpoint];
+      const methodSchema = (methods as Record<string, unknown>)[
+        method
+      ] as MethodSchemaLike | undefined;
+
+      if (!implementation) {
+        return;
+      }
+
+      const wrapped = contract.handle(endpoint, implementation);
+
+      // Koa Router register
+      router.register(
+        route,
+        [method],
+        async (ctx: KoaLikeContext, _next: () => Promise<unknown>) => {
+          try {
+            const context: Record<string, unknown> = {
+              params: ctx.params || {},
+              query: ctx.query || {},
+              body: ctx.request.body, // requires koa-bodyparser or koa-body
+              headers: ctx.headers || {},
+              user: ctx.state?.user, // common pattern
+            };
+
+            const result = await wrapped(context);
+            const media = methodSchema?.media;
+            if (media && media.kind === "download") {
+              const download = result as DownloadResult;
+              const data =
+                download &&
+                typeof download === "object" &&
+                "data" in download
+                  ? (download as { data: unknown }).data
+                  : download;
+              const contentType =
+                download &&
+                typeof download === "object" &&
+                "contentType" in download
+                  ? (download as { contentType: string }).contentType
+                  : "application/octet-stream";
+              const filename =
+                download &&
+                typeof download === "object" &&
+                "filename" in download
+                  ? (download as { filename: string }).filename
+                  : undefined;
+
+              ctx.body = data;
+              ctx.type = contentType;
+              if (filename) {
+                ctx.set(
+                  "Content-Disposition",
+                  `attachment; filename="${filename}"`
+                );
+              }
+            } else {
+              ctx.body = result;
+            }
+          } catch (error: unknown) {
+            const payload = buildErrorPayload(error);
+            ctx.status = payload.status;
+            ctx.body = payload;
+          }
+        }
+      );
+    });
+  });
+}

package/src/adapters/nest.ts

@@ -0,0 +1,122 @@
+import type { createContract } from "../core/contract";
+
+type AnyContract = ReturnType<typeof createContract>;
+
+interface NestLikeRequest {
+  params: Record<string, string>;
+  query: Record<string, string>;
+  body: unknown;
+  headers: Record<string, string>;
+  user?: unknown;
+}
+
+interface NestLikeResponse {
+  send?: (payload: unknown) => void;
+  json?: (payload: unknown) => void;
+  end: (payload: string) => void;
+  status?: (code: number) => void;
+  code?: (code: number) => void;
+}
+
+type HttpMethodHandler = (
+  path: string,
+  handler: (
+    req: NestLikeRequest,
+    res: NestLikeResponse,
+    next: unknown
+  ) => Promise<void>
+) => void;
+
+interface NestApp {
+  getHttpAdapter: () => {
+    getInstance: () => unknown;
+    getRequestMethod: (request: unknown) => string;
+    getRequestUrl: (request: unknown) => string;
+    createMiddlewareFactory: (method: unknown) => unknown;
+    get: HttpMethodHandler;
+    post: HttpMethodHandler;
+    put: HttpMethodHandler;
+    delete: HttpMethodHandler;
+    patch: HttpMethodHandler;
+    [key: string]: unknown;
+  };
+}
+
+export const SchemaApiModule = {
+  register(
+    app: NestApp,
+    contract: AnyContract,
+    handlers: Record<
+      string,
+      (ctx: Record<string, unknown>) => unknown | Promise<unknown>
+    >
+  ) {
+    const adapter = app.getHttpAdapter();
+    const schema = contract.schema as Record<string, Record<string, unknown>>;
+
+    Object.keys(schema).forEach((route) => {
+      const methods = schema[route] as Record<string, unknown>;
+
+      Object.keys(methods).forEach((method) => {
+        const endpoint = `${method} ${route}`;
+        const implementation = handlers[endpoint];
+
+        if (!implementation) {
+          return;
+        }
+
+        const wrapped = contract.handle(endpoint, implementation);
+        const methodLower = method.toLowerCase() as
+          | "get"
+          | "post"
+          | "put"
+          | "delete"
+          | "patch";
+
+        if (
+          typeof adapter[methodLower] === "function"
+        ) {
+          (adapter[methodLower] as HttpMethodHandler)(
+            route,
+            async (req: NestLikeRequest, res: NestLikeResponse, _next: unknown) => {
+              try {
+                // Intentamos normalizar request/response independientemente del driver (Express/Fastify)
+                // Nota: Esto asume Express por defecto para req.params/query/body.
+                // En Fastify, req.params/query/body también existen en el objeto Request estándar de Fastify.
+
+                const context: Record<string, unknown> = {
+                  params: req.params || {},
+                  query: req.query || {},
+                  body: req.body,
+                  headers: req.headers || {},
+                  user: req.user,
+                };
+
+                const result = await wrapped(context);
+
+                // Responder
+                if (typeof res.send === "function") {
+                  // Express / Fastify
+                  res.send(result);
+                } else if (typeof res.json === "function") {
+                  // Express alternative
+                  res.json(result);
+                } else {
+                  // Fallback simple
+                  res.end(JSON.stringify(result));
+                }
+              } catch (error: unknown) {
+                const typedError = error as { message?: string; status?: number };
+                if (res.status) res.status(typedError.status || 500);
+                else if (res.code) res.code(typedError.status || 500); // Fastify
+
+                if (res.send) res.send({ error: typedError.message });
+                else res.end(JSON.stringify({ error: typedError.message }));
+              }
+            }
+          );
+        }
+      });
+    });
+  },
+};

package/src/adapters/next.ts

@@ -0,0 +1,175 @@
+import type { createContract } from "../core/contract";
+import { buildErrorPayload } from "../core/contract";
+
+type AnyContract = ReturnType<typeof createContract>;
+
+type MethodSchemaLike = {
+  media?: {
+    kind?: string;
+    contentTypes?: string[];
+    maxSize?: number;
+  };
+};
+
+type DownloadResult =
+  | {
+      data: unknown;
+      contentType?: string;
+      filename?: string;
+    }
+  | unknown;
+
+// Tipos mínimos compatibles con Next.js App Router
+interface NextRequest {
+  nextUrl: {
+    searchParams: URLSearchParams;
+    pathname: string;
+  };
+  json: () => Promise<unknown>;
+  headers: Headers;
+  method: string;
+  url: string;
+}
+
+interface NextResponse {
+  json: (body: unknown, init?: { status: number }) => unknown;
+}
+
+// Helper para obtener NextResponse (asumiendo que el usuario lo tiene disponible o lo importamos dinámicamente si fuera un paquete real)
+// Aquí simularemos una respuesta JSON estándar
+function jsonResponse(data: unknown, status: number = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+export function handleContract(
+  contract: AnyContract,
+  handlers: Record<
+    string,
+    (ctx: Record<string, unknown>) => unknown | Promise<unknown>
+  >
+) {
+  // Retorna un handler compatible con Route Handlers de Next.js (App Router)
+  // Uso: export const { GET, POST, PUT, DELETE } = adapters.next.handleContract(contract, handlers);
+  // en app/api/[...route]/route.ts
+
+  const dispatcher = async (
+    req: Request | NextRequest,
+    { params }: { params?: Record<string, string> }
+  ) => {
+    const url = new URL(req.url);
+    // En App Router [...route], params.route es un array. Pero aquí asumimos que el usuario mapea rutas específicas o catch-all.
+    // Si es catch-all, necesitamos reconstruir la ruta.
+    
+    // Simplificación: Iteramos sobre el contrato para encontrar la ruta que coincida.
+    // Esto es ineficiente O(N) por request, pero funciona para validación.
+    // Una implementación más robusta usaría un router interno.
+    
+    const method = req.method;
+    const path = url.pathname; // Ojo: esto incluye el prefijo /api si está ahí.
+
+    // Intentar hacer match con las rutas del contrato
+    const schema = contract.schema as Record<string, Record<string, unknown>>;
+    
+    for (const routePattern of Object.keys(schema)) {
+       // Convertir /users/:id a regex simple
+        const regexPattern = routePattern.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
+       const regex = new RegExp(`^.*${regexPattern}$`); // ^.* para permitir prefijos como /api
+       
+       const match = path.match(regex);
+       if (match) {
+         // Verificar método
+         const routeMethods = schema[routePattern] as Record<
+           string,
+           MethodSchemaLike
+         >;
+         if (routeMethods[method]) {
+            const endpoint = `${method} ${routePattern}`;
+            const implementation = handlers[endpoint];
+            const methodSchema = routeMethods[method];
+            
+            if (!implementation) return jsonResponse({ error: "Not Implemented" }, 501);
+
+            const contextParams = params || {};
+            
+            const wrapped = contract.handle(endpoint, implementation);
+            
+            try {
+               // Parse body safely
+               let body = undefined;
+               if (method !== 'GET' && method !== 'HEAD') {
+                  try {
+                    body = await req.json();
+                  } catch {}
+               }
+
+               const context = {
+                 params: contextParams,
+                 query: Object.fromEntries(url.searchParams.entries()),
+                 body,
+                 headers: Object.fromEntries(req.headers.entries()),
+               };
+
+               const result = await wrapped(context);
+               const media = methodSchema?.media;
+               if (media && media.kind === "download") {
+                 const download = result as DownloadResult;
+                 const hasData =
+                   download &&
+                   typeof download === "object" &&
+                   Object.prototype.hasOwnProperty.call(download, "data");
+                 const data = hasData
+                   ? (download as { data: unknown }).data
+                   : download;
+                 const contentType =
+                   download &&
+                   typeof download === "object" &&
+                   "contentType" in download &&
+                   typeof (download as { contentType?: unknown }).contentType ===
+                     "string"
+                     ? (download as { contentType?: string }).contentType
+                     : "application/octet-stream";
+                 const filename =
+                   download &&
+                   typeof download === "object" &&
+                   "filename" in download &&
+                   typeof (download as { filename?: unknown }).filename ===
+                     "string"
+                     ? (download as { filename?: string }).filename
+                     : undefined;
+
+                 const headers: Record<string, string> = {
+                   "Content-Type": String(contentType),
+                 };
+                 if (filename) {
+                   headers["Content-Disposition"] =
+                     `attachment; filename="${filename}"`;
+                 }
+
+                 return new Response(data as BodyInit, {
+                   status: 200,
+                   headers,
+                 });
+               }
+               return jsonResponse(result);
+            } catch (err) {
+               const payload = buildErrorPayload(err);
+               return jsonResponse(payload, payload.status);
+            }
+         }
+       }
+    }
+    
+    return jsonResponse({ error: "Not Found" }, 404);
+  };
+
+  return {
+    GET: dispatcher,
+    POST: dispatcher,
+    PUT: dispatcher,
+    DELETE: dispatcher,
+    PATCH: dispatcher,
+  };
+}