stitchkit 0.0.1 → 0.2.0

package/dist/index-kckky6zw.js

@@ -0,0 +1,96 @@
+// src/contract/define.ts
+var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT"];
+function defineContract(meta, endpoints) {
+  const toolTransports = new Map;
+  for (const [key, ep] of Object.entries(endpoints)) {
+    if (ep.desc.trim() === "") {
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" has an empty desc`);
+    }
+    if (!("toolName" in ep) || !ep.toolName)
+      continue;
+    const transports = new Set(ep.expose ? ep.expose.filter((t) => t !== "HTTP") : ["MCP", "AGENT"]);
+    if (transports.size === 0) {
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" sets toolName "${ep.toolName}" but is not exposed on any tool transport (MCP / AGENT)`);
+    }
+    const existing = toolTransports.get(ep.toolName);
+    if (existing) {
+      for (const t of transports) {
+        if (existing.transports.has(t)) {
+          throw new Error(`Contract "${meta.prefix}": duplicate toolName "${ep.toolName}" on transport "${t}" (endpoints: "${existing.key}" and "${key}")`);
+        }
+        existing.transports.add(t);
+      }
+    } else {
+      toolTransports.set(ep.toolName, { key, transports });
+    }
+  }
+  return { meta, endpoints };
+}
+// src/contract/errors.ts
+class AppError extends Error {
+  code;
+  status;
+  details;
+  hint;
+  constructor(code, message, status = 500, details, hint) {
+    super(message ?? code);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.hint = hint;
+    this.name = "AppError";
+  }
+  static is(err) {
+    return err instanceof AppError;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.details && { details: this.details },
+        ...this.hint && { hint: this.hint }
+      }
+    };
+  }
+}
+function notFound(message = "Not found") {
+  throw new AppError("NOT_FOUND", message, 404);
+}
+function badRequest(message, details) {
+  throw new AppError("BAD_REQUEST", message, 400, details);
+}
+function unauthorized(message = "Unauthorized") {
+  throw new AppError("UNAUTHORIZED", message, 401);
+}
+function forbidden(message = "Forbidden") {
+  throw new AppError("FORBIDDEN", message, 403);
+}
+function conflict(message = "Conflict", details) {
+  throw new AppError("CONFLICT", message, 409, details);
+}
+function rateLimited(message = "Too many requests") {
+  throw new AppError("RATE_LIMITED", message, 429);
+}
+var ERROR_STATUS = {
+  NOT_FOUND: 404,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  CONFLICT: 409,
+  RATE_LIMITED: 429,
+  VALIDATION_ERROR: 400,
+  INTERNAL_SERVER_ERROR: 500
+};
+function appError(code, message, details) {
+  throw new AppError(code, message, ERROR_STATUS[code] ?? 500, details);
+}
+// src/contract/pagination.ts
+import { z } from "zod";
+function paginatedSchema(itemSchema) {
+  return z.object({
+    items: z.array(itemSchema),
+    nextCursor: z.string().nullable()
+  });
+}
+export { ALL_TRANSPORTS, defineContract, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, appError, paginatedSchema };

package/dist/index-ke4mx4ea.js

@@ -0,0 +1,38 @@
+// src/server/request.ts
+function generateTraceId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+function resolveTraceId(req) {
+  const header = req.headers.get("x-request-id") ?? req.headers.get("x-trace-id");
+  const trimmed = header?.trim();
+  if (trimmed && trimmed.length <= 128 && /^[\w.-]+$/.test(trimmed)) {
+    return trimmed;
+  }
+  return generateTraceId();
+}
+function extractIp(req) {
+  const forwarded = req.headers.get("x-forwarded-for");
+  if (forwarded)
+    return (forwarded.split(",")[0] ?? "").trim().replace("::ffff:", "");
+  const realIp = req.headers.get("x-real-ip");
+  if (realIp)
+    return realIp.trim().replace("::ffff:", "");
+  return "";
+}
+function getClientInfo(req) {
+  return {
+    ipAddress: extractIp(req) || undefined,
+    userAgent: req.headers.get("user-agent") ?? undefined
+  };
+}
+function parseQueryParams(url) {
+  const query = {};
+  for (const key of new Set(url.searchParams.keys())) {
+    const values = url.searchParams.getAll(key);
+    const [first] = values;
+    query[key] = values.length === 1 && first !== undefined ? first : values;
+  }
+  return query;
+}
+
+export { generateTraceId, resolveTraceId, extractIp, getClientInfo, parseQueryParams };

package/dist/index-n7bmdwmz.js

@@ -0,0 +1,68 @@
+// src/server/stream.ts
+function streamSSE(generator) {
+  const encoder = new TextEncoder;
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const chunk of generator) {
+          const data = JSON.stringify(chunk);
+          controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+        }
+        controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+        controller.close();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: msg })}
+
+`));
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function* parseSSE(response, options) {
+  const reader = response.body?.getReader();
+  if (!reader)
+    return;
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const rawLine of lines) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (!line.startsWith("data: "))
+          continue;
+        const data = line.slice(6);
+        if (data === "[DONE]")
+          return;
+        try {
+          yield JSON.parse(data);
+        } catch (err) {
+          options?.onParseError?.(data, err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export { streamSSE, parseSSE };