@codexsploitx/schemaapi 1.0.0 → 1.0.1

package/src/adapters/next.ts

@@ -1,175 +0,0 @@
-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,
-  };
-}

package/src/adapters/remix.ts

@@ -1,145 +0,0 @@
-import type { createContract } from "../core/contract";
-import { buildErrorPayload } from "../core/contract";
-
-type AnyContract = ReturnType<typeof createContract>;
-
-type RemixParams = Record<string, string | undefined>;
-
-type MethodSchemaLike = {
-  media?: {
-    kind?: string;
-    contentTypes?: string[];
-    maxSize?: number;
-  };
-};
-
-type DownloadResult =
-  | {
-      data: unknown;
-      contentType?: string;
-      filename?: string;
-    }
-  | unknown;
-
-export function createRouteHandlers(
-  contract: AnyContract,
-  handlers: Record<
-    string,
-    (ctx: Record<string, unknown>) => unknown | Promise<unknown>
-  >,
-  routePattern: string
-) {
-  const schema = contract.schema as Record<string, Record<string, unknown>>;
-  const methods = schema[routePattern] as
-    | Record<string, MethodSchemaLike>
-    | undefined;
-
-  if (!methods) {
-    const notFound = () => {
-      throw new Response("Not Found in Contract", { status: 404 });
-    };
-    return { loader: notFound, action: notFound };
-  }
-
-  const handleRequest = async (request: Request, params: RemixParams) => {
-    const method = request.method;
-    const endpoint = `${method} ${routePattern}`;
-    const implementation = handlers[endpoint];
-    const methodSchema = methods && methods[method];
-
-    if (!implementation) {
-      throw new Response("Method Not Implemented", { status: 501 });
-    }
-
-    const wrapped = contract.handle(endpoint, implementation);
-
-    try {
-      let body = undefined;
-      // Parse body only for non-GET/HEAD methods
-      if (method !== "GET" && method !== "HEAD") {
-        try {
-          body = await request.json();
-        } catch {
-          // Si falla json, tal vez es FormData? Remix usa mucho FormData.
-          // Por simplicidad, aquí asumimos JSON como el estándar de SchemaApi.
-          // Si se requiere FormData, se debería procesar antes o aquí.
-        }
-      }
-
-      const url = new URL(request.url);
-      const context: Record<string, unknown> = {
-        params: params || {},
-        query: Object.fromEntries(url.searchParams.entries()),
-        body,
-        headers: Object.fromEntries(request.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, {
-          headers,
-        });
-      }
-
-      return new Response(JSON.stringify(result), {
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (err) {
-      const payload = buildErrorPayload(err);
-      return new Response(JSON.stringify(payload), {
-        status: payload.status,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-  };
-
-  const loader = async (args: { request: Request; params: RemixParams }) => {
-    if (methods["GET"]) {
-      return handleRequest(args.request, args.params);
-    }
-    // Si no hay GET definido pero se llama al loader
-    throw new Response("Method Not Allowed", { status: 405 });
-  };
-
-  const action = async (args: { request: Request; params: RemixParams }) => {
-    const method = args.request.method;
-    if (methods[method]) {
-      return handleRequest(args.request, args.params);
-    }
-    throw new Response("Method Not Allowed", { status: 405 });
-  };
-
-  return { loader, action };
-}

package/src/adapters/ws.ts

@@ -1,132 +0,0 @@
-import { WebSocketServer, WebSocket } from "ws";
-import type { IncomingMessage } from "http";
-import type { createContract } from "../core/contract";
-
-type AnyContract = ReturnType<typeof createContract>;
-
-type WsSchemaDefinition = {
-  params?: unknown;
-  query?: unknown;
-  serverMessages?: {
-    parse: (value: unknown) => unknown;
-  };
-  clientMessages?: {
-    parse: (value: unknown) => unknown;
-  };
-};
-
-type WsHandlerContext = {
-  params: Record<string, string>;
-  query: Record<string, string>;
-  headers: IncomingMessage["headers"];
-  ws: WebSocket;
-  send: (data: unknown) => void;
-  onMessage: (cb: (data: unknown) => void) => void;
-};
-
-export function handleContract(
-  wss: WebSocketServer,
-  contract: AnyContract,
-  handlers: Record<string, (ctx: WsHandlerContext) => void | Promise<void>>
-) {
-  const schema = contract.schema as Record<string, Record<string, unknown>>;
-
-  wss.on("connection", async (ws: WebSocket, req: IncomingMessage) => {
-    const url = req.url ? new URL(req.url, "http://localhost") : null;
-    if (!url) {
-      ws.close(1002, "Invalid URL");
-      return;
-    }
-
-    const path = url.pathname;
-    let matched = false;
-
-    for (const routePattern of Object.keys(schema)) {
-      const methods = schema[routePattern] as Record<string, unknown>;
-      const wsDef = methods["WS"] as WsSchemaDefinition | undefined;
-      if (!wsDef) continue;
-
-      // Match path
-      const regexPattern = routePattern.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
-      const regex = new RegExp(`^${regexPattern}$`);
-      const match = path.match(regex);
-
-      if (match) {
-        matched = true;
-        const implementation = handlers[`WS ${routePattern}`];
-        if (!implementation) {
-          ws.close(1011, "Handler not found");
-          return;
-        }
-
-        // Extract params
-        const paramNames = (routePattern.match(/:[a-zA-Z0-9_]+/g) || []).map(
-          (p) => p.substring(1)
-        );
-        const params: Record<string, string> = {};
-        paramNames.forEach((name, index) => {
-          params[name] = match[index + 1];
-        });
-
-        const query = Object.fromEntries(url.searchParams.entries());
-
-        const context: WsHandlerContext = {
-          params,
-          query,
-          headers: req.headers,
-          ws,
-          send: (data: unknown) => {
-            if (wsDef.serverMessages) {
-              try {
-                wsDef.serverMessages.parse(data);
-              } catch (e) {
-                console.error("Server message validation failed", e);
-              }
-            }
-            ws.send(JSON.stringify(data));
-          },
-          onMessage: (cb: (data: unknown) => void) => {
-            ws.on("message", (raw) => {
-              try {
-                const json = JSON.parse(raw.toString());
-                if (wsDef.clientMessages) {
-                  try {
-                    const parsed = wsDef.clientMessages.parse(json);
-                    cb(parsed);
-                  } catch (e) {
-                    console.error("Client message validation failed", e);
-                    ws.send(
-                      JSON.stringify({
-                        error: "Invalid Message Schema",
-                        details: e,
-                      })
-                    );
-                  }
-                } else {
-                  cb(json);
-                }
-              } catch (e) {
-                console.error("Invalid JSON", e);
-              }
-            });
-          },
-        };
-
-        try {
-          await implementation(context);
-        } catch (e) {
-          console.error("Error in WS handler", e);
-          ws.close(1011, "Internal Error");
-        }
-
-        break; 
-      }
-    }
-
-    if (!matched) {
-      ws.close(4404, "Not Found");
-    }
-  });
-
-  return wss;
-}

package/src/core/client.ts

@@ -1,104 +0,0 @@
-// Definimos tipos básicos para simular la estructura del cliente
-// En una implementación real, estos tipos se inferirían recursivamente del esquema T
-
-type WebSocketLike = {
-  close: (code?: number, reason?: string) => void;
-};
-
-type WebSocketConstructor = new (url: string) => WebSocketLike;
-
-type ClientConfig = {
-  baseUrl: string;
-  fetch?: typeof fetch;
-  WebSocket?: WebSocketConstructor;
-};
-
-export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-
-export type ExtractSchema<TContract> = TContract;
-
-export type InferResponse<TContract, Endpoint extends string> = unknown;
-
-type RequestParams = {
-  id?: string;
-  body?: unknown;
-  headers?: Record<string, string>;
-  [key: string]: unknown;
-};
-
-export function createClient<T>(contract: { schema: T }, config: ClientConfig) {
-  const { baseUrl, fetch: customFetch } = config;
-  const fetchFn = customFetch || globalThis.fetch;
-
-  return new Proxy({} as Record<string, unknown>, {
-    get(_target, resource: string) {
-      return new Proxy({} as Record<string, unknown>, {
-        get(_target, operation: string) {
-          // operation podría ser 'get', 'post', 'put', 'delete', 'ws', etc.
-          // resource sería 'users', 'posts', etc.
-          
-          return async (params: RequestParams = {}) => {
-            const method = operation.toUpperCase();
-            let path = `/${resource}`;
-            
-            // Si hay params.id, asumimos que va en la URL
-            if (params.id) {
-               path += `/${params.id}`;
-            }
-
-            // Manejo de WebSocket
-            if (method === "WS") {
-                const wsUrlStr = baseUrl.replace(/^http/, "ws");
-                const url = new URL(`${wsUrlStr}${path}`);
-
-                // Agregar query params
-                Object.keys(params).forEach(key => {
-                   if (key !== 'id' && key !== 'headers' && key !== 'body') {
-                       url.searchParams.append(key, String(params[key]));
-                   }
-                });
-
-                type GlobalWithWebSocket = typeof globalThis & {
-                  WebSocket?: WebSocketConstructor;
-                };
-                const globalWithWebSocket = globalThis as GlobalWithWebSocket;
-                const WebSocketCtor =
-                  config.WebSocket || globalWithWebSocket.WebSocket;
-                if (!WebSocketCtor) {
-                    throw new Error("WebSocket implementation not found. Please provide it in config.");
-                }
-
-                return new WebSocketCtor(url.toString());
-            }
-
-            const url = new URL(`${baseUrl}${path}`);
-
-            // Agregar query params si existen (excluyendo id y body)
-            Object.keys(params).forEach(key => {
-               if (key !== 'id' && key !== 'body' && key !== 'headers') {
-                   url.searchParams.append(key, String(params[key]));
-               }
-            });
-
-            const headers = {
-                "Content-Type": "application/json",
-                ...(params.headers || {})
-            };
-
-            const response = await fetchFn(url.toString(), {
-              method,
-              headers,
-              body: params.body ? JSON.stringify(params.body) : undefined,
-            });
-
-            if (!response.ok) {
-              throw new Error(`Request failed: ${response.status} ${response.statusText}`);
-            }
-
-            return response.json();
-          };
-        }
-      });
-    }
-  });
-}