@codexsploitx/schemaapi 1.0.0

package/src/adapters/remix.ts

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,104 @@
+// 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();
+          };
+        }
+      });
+    }
+  });
+}