stitchkit 0.45.0 → 0.47.0

package/dist/{index-r6czv7yt.js → index-45dz4m51.js}

@@ -1,6 +1,6 @@
 import {
   mapObjectTypeBoundary
-} from "./index-s4qsmgwe.js";
+} from "./index-tss6bk5c.js";
 
 // src/contract/define.ts
 import { z } from "zod";
@@ -47,6 +47,11 @@ function parseTrailingWildcard(path) {
   return wildcard;
 }
 
+// src/internal/safe-json.ts
+function isUnsafeKey(key) {
+  return key === "__proto__";
+}
+
 // src/contract/define.ts
 var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
 function defineContract(meta, endpoints) {
@@ -68,6 +73,8 @@ function defineContract(meta, endpoints) {
     if (ep.maxJsonBodyBytes !== undefined && (!Number.isSafeInteger(ep.maxJsonBodyBytes) || ep.maxJsonBodyBytes <= 0)) {
       throw new Error(`Contract "${meta.prefix}": endpoint "${key}" maxJsonBodyBytes must be a positive safe integer, received ${ep.maxJsonBodyBytes}`);
     }
+    if (ep.multipart)
+      assertMultipartEndpoint(meta.prefix, key, ep);
     if (ep.rawResponse)
       assertRawEndpoint(meta.prefix, key, ep);
     if (ep.method === "HEAD")
@@ -96,6 +103,45 @@ function defineContract(meta, endpoints) {
   }
   return { meta, endpoints };
 }
+function assertPositiveLimit(where, name, value) {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+    throw new Error(`${where} ${name} must be a positive safe integer, received ${value}`);
+  }
+}
+function assertMultipartEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": multipart endpoint "${key}"`;
+  if (ep.method !== "POST" && ep.method !== "PUT" && ep.method !== "PATCH") {
+    throw new Error(`${where} must use POST, PUT or PATCH`);
+  }
+  const multipart = ep.multipart;
+  if (!multipart || typeof multipart !== "object") {
+    throw new Error(`${where} must declare a multipart descriptor`);
+  }
+  assertPositiveLimit(where, "maxRequestBytes", multipart.maxRequestBytes);
+  assertPositiveLimit(where, "maxFieldBytes", multipart.maxFieldBytes);
+  const entries = Object.entries(multipart.files);
+  if (entries.length === 0)
+    throw new Error(`${where} must declare at least one file field`);
+  for (const [field, policy] of entries) {
+    if (!field || isUnsafeKey(field))
+      throw new Error(`${where} has an invalid file field name`);
+    assertPositiveLimit(`${where} field "${field}"`, "maxBytes", policy.maxBytes);
+    assertPositiveLimit(`${where} field "${field}"`, "maxFiles", policy.maxFiles);
+    if (policy.multiple !== true && policy.maxFiles !== undefined) {
+      throw new Error(`${where} field "${field}" may set maxFiles only with multiple: true`);
+    }
+    if (policy.contentTypes) {
+      if (policy.contentTypes.length === 0) {
+        throw new Error(`${where} field "${field}" contentTypes cannot be empty`);
+      }
+      for (const contentType of policy.contentTypes) {
+        if (!/^[a-z0-9!#$&^_.+-]+\/(?:[a-z0-9!#$&^_.+-]+|\*)$/i.test(contentType)) {
+          throw new Error(`${where} field "${field}" has invalid content type policy "${contentType}"`);
+        }
+      }
+    }
+  }
+}
 function assertRawEndpoint(prefix, key, ep) {
   const where = `Contract "${prefix}": raw endpoint "${key}"`;
   if (ep.output)
@@ -228,10 +274,11 @@ var STITCH_ERROR_STATUS = {
   CONFLICT: 409,
   RATE_LIMITED: 429,
   VALIDATION_ERROR: 400,
+  REALTIME_CONTRACT_VIOLATION: 500,
   INTERNAL_SERVER_ERROR: 500
 };
 function isStitchErrorCode(code) {
-  return code in STITCH_ERROR_STATUS;
+  return Object.hasOwn(STITCH_ERROR_STATUS, code);
 }
 function appError(code, message, details) {
   throw new AppError(code, message, isStitchErrorCode(code) ? STITCH_ERROR_STATUS[code] : 500, details);
@@ -342,4 +389,4 @@ function decodeCursor(cursor, schema) {
     return null;
   }
 }
-export { parseTrailingWildcard, ALL_TRANSPORTS, defineContract, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor };
+export { parseTrailingWildcard, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, ALL_TRANSPORTS, defineContract, defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor };

package/dist/index-8ekq6res.js

@@ -0,0 +1,181 @@
+import {
+  isRecord,
+  isUnsafeKey
+} from "./index-ee621cmy.js";
+
+// src/observability/sanitize.ts
+var SENSITIVE_WORDS = new Set([
+  "password",
+  "passwords",
+  "passwd",
+  "pwd",
+  "secret",
+  "secrets",
+  "token",
+  "tokens",
+  "apikey",
+  "auth",
+  "authorization",
+  "bearer",
+  "cookie",
+  "cookies",
+  "credential",
+  "credentials"
+]);
+var SENSITIVE_WORD_PAIRS = new Set([
+  "apikey",
+  "privatekey",
+  "initdata",
+  "sessionid",
+  "sessionkey"
+]);
+var SENSITIVE_EXACT = new Set(["session"]);
+function splitKeyWords(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 0);
+}
+function isSensitiveKeyDefault(key) {
+  const words = splitKeyWords(key);
+  if (words.length === 1 && SENSITIVE_EXACT.has(words[0] ?? ""))
+    return true;
+  for (let index = 0;index < words.length; index += 1) {
+    const word = words[index] ?? "";
+    if (SENSITIVE_WORDS.has(word))
+      return true;
+    const next = words[index + 1];
+    if (next !== undefined && SENSITIVE_WORD_PAIRS.has(word + next))
+      return true;
+  }
+  return false;
+}
+var DEFAULT_MAX_BYTES = 16000;
+var DEFAULT_MAX_DEPTH = 20;
+var MASK = "[redacted]";
+function redact(value, options = {}) {
+  const custom = options.sensitiveKeys;
+  const isSensitive = custom === undefined ? isSensitiveKeyDefault : (key) => {
+    custom.lastIndex = 0;
+    return custom.test(key);
+  };
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const ancestors = new Set;
+  const walk = (input, depth) => {
+    if (depth > maxDepth)
+      return "[max depth]";
+    if (input === null || input === undefined)
+      return null;
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+      return input;
+    }
+    if (input instanceof Uint8Array || input instanceof ArrayBuffer) {
+      return { _type: "binary", size: input.byteLength };
+    }
+    if (input instanceof Blob) {
+      return { _type: "blob", size: input.size, mime: input.type };
+    }
+    if (typeof FormData !== "undefined" && input instanceof FormData) {
+      return { _type: "formdata", keys: [...input.keys()] };
+    }
+    if (input instanceof Map) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const result = [...input.entries()].map(([key, value2]) => [
+        walk(key, depth + 1),
+        walk(value2, depth + 1)
+      ]);
+      ancestors.delete(input);
+      return { _type: "map", entries: result };
+    }
+    if (input instanceof Set) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const values = [...input].map((item) => walk(item, depth + 1));
+      ancestors.delete(input);
+      return { _type: "set", values };
+    }
+    if (input instanceof Error) {
+      return {
+        _type: "error",
+        name: input.name,
+        message: input.message,
+        ...input.stack !== undefined && { stack: input.stack }
+      };
+    }
+    if (Array.isArray(input)) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const result = input.map((item) => walk(item, depth + 1));
+      ancestors.delete(input);
+      return result;
+    }
+    if (isRecord(input)) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const out = {};
+      for (const key of Object.keys(input)) {
+        if (isUnsafeKey(key))
+          continue;
+        if (isSensitive(key)) {
+          out[key] = MASK;
+          continue;
+        }
+        try {
+          out[key] = walk(Reflect.get(input, key), depth + 1);
+        } catch {
+          out[key] = "[unreadable]";
+        }
+      }
+      ancestors.delete(input);
+      return out;
+    }
+    return String(input);
+  };
+  return walk(value, 0);
+}
+function truncatePreview(value, maxBytes = DEFAULT_MAX_BYTES) {
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.byteLength <= maxBytes)
+    return value;
+  let end = Math.max(0, maxBytes);
+  while (end > 0 && ((bytes[end] ?? 0) & 192) === 128)
+    end -= 1;
+  const preview = new TextDecoder().decode(bytes.subarray(0, end));
+  return {
+    _truncated: true,
+    _originalBytes: bytes.byteLength,
+    preview: `${preview}…`
+  };
+}
+function sanitizePayload(value, options = {}) {
+  if (value === undefined || value === null)
+    return null;
+  try {
+    return truncatePreview(redact(value, options), options.maxBytes ?? DEFAULT_MAX_BYTES);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function measureSize(value) {
+  if (value === undefined || value === null) {
+    return { resultSize: null, responseBytes: 0 };
+  }
+  let responseBytes = 0;
+  try {
+    responseBytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  } catch {
+    return { resultSize: null, responseBytes: 0, unserializable: true };
+  }
+  if (Array.isArray(value)) {
+    return { resultSize: value.length, responseBytes };
+  }
+  if (isRecord(value) && Array.isArray(value.items) && "nextCursor" in value) {
+    return { resultSize: value.items.length, responseBytes };
+  }
+  return { resultSize: null, responseBytes };
+}
+
+export { redact, truncatePreview, sanitizePayload, measureSize };

package/dist/{index-yh0p5ddn.js → index-ee621cmy.js}

@@ -59,10 +59,11 @@ var STITCH_ERROR_STATUS = {
   CONFLICT: 409,
   RATE_LIMITED: 429,
   VALIDATION_ERROR: 400,
+  REALTIME_CONTRACT_VIOLATION: 500,
   INTERNAL_SERVER_ERROR: 500
 };
 function isStitchErrorCode(code) {
-  return code in STITCH_ERROR_STATUS;
+  return Object.hasOwn(STITCH_ERROR_STATUS, code);
 }
 function appError(code, message, details) {
   throw new AppError(code, message, isStitchErrorCode(code) ? STITCH_ERROR_STATUS[code] : 500, details);
@@ -113,6 +114,14 @@ function parseTrailingWildcard(path) {
   return wildcard;
 }
 
+// src/internal/safe-json.ts
+function isUnsafeKey(key) {
+  return key === "__proto__";
+}
+function safeJsonParse(text) {
+  return JSON.parse(text, (key, value) => isUnsafeKey(key) ? undefined : value);
+}
+
 // src/contract/define.ts
 function mergeMeta(contractMeta, endpointMeta) {
   if (!contractMeta)
@@ -131,6 +140,12 @@ function typedEntries(value) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function callRuntimeHandler(handler, context) {
+  if (typeof handler !== "function") {
+    throw new TypeError("Runtime handler must be a function");
+  }
+  return Reflect.apply(handler, undefined, [context]);
+}
 // src/contract/pagination.ts
 import { z as z3 } from "zod";
 
@@ -178,7 +193,7 @@ function errorCode(err) {
   return;
 }
 function recordedErrorMessage(code, envelopeMessage, thrown) {
-  if (code === "INTERNAL_SERVER_ERROR" && thrown !== undefined) {
+  if ((code === "INTERNAL_SERVER_ERROR" || code === "REALTIME_CONTRACT_VIOLATION") && thrown !== undefined) {
     if (thrown instanceof Error)
       return thrown.message;
     if (typeof thrown === "string")
@@ -187,8 +202,12 @@ function recordedErrorMessage(code, envelopeMessage, thrown) {
   return envelopeMessage;
 }
 function normalizeError(err) {
-  if (AppError.is(err))
+  if (AppError.is(err)) {
+    if (err.code === "REALTIME_CONTRACT_VIOLATION") {
+      return new AppError("REALTIME_CONTRACT_VIOLATION", "Realtime contract violation", 500);
+    }
     return err;
+  }
   if (err instanceof z4.ZodError) {
     return new AppError("VALIDATION_ERROR", formatZodError(err), 400, {
       issues: zodIssues(err).slice(0, MAX_DETAIL_ISSUES)
@@ -249,14 +268,6 @@ function validateDeclaredOutput(schema, data, onStripped) {
   return validateHandlerOutput(schema, data, onStripped);
 }
 
-// src/internal/safe-json.ts
-function isUnsafeKey(key) {
-  return key === "__proto__";
-}
-function safeJsonParse(text) {
-  return JSON.parse(text, (key, value) => isUnsafeKey(key) ? undefined : value);
-}
-
 // src/server/request.ts
 function generateTraceId() {
   return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
@@ -310,7 +321,7 @@ function parseQueryParams(url) {
 }
 
 // src/observability/trace.ts
-var TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
 function randomHex(bytes) {
   const arr = new Uint8Array(bytes);
   crypto.getRandomValues(arr);
@@ -326,16 +337,24 @@ function parseTraceparent(header) {
   if (!header)
     return null;
   const match = TRACEPARENT_RE.exec(header.trim());
-  if (!match?.[1] || !match[2])
+  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
     return null;
-  const traceId = match[1].toLowerCase();
-  const parentSpanId = match[2].toLowerCase();
+  const version = match[1].toLowerCase();
+  if (version === "ff")
+    return null;
+  const suffix = match[5];
+  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
+    return null;
+  }
+  const traceId = match[2].toLowerCase();
+  const parentSpanId = match[3].toLowerCase();
+  const traceFlags = match[4].toLowerCase();
   if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
     return null;
-  return { traceId, spanId: randomHex(8), parentSpanId };
+  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
 }
 function formatTraceparent(ctx) {
-  return `00-${ctx.traceId}-${ctx.spanId}-01`;
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
 }
 function resolveTraceContext(req) {
   return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
@@ -346,7 +365,8 @@ function childSpan(parent) {
     spanId: randomHex(8),
     parentSpanId: parent.spanId,
     ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
-    ...parent.baggage !== undefined && { baggage: parent.baggage }
+    ...parent.baggage !== undefined && { baggage: parent.baggage },
+    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
   };
 }
 var encoder = new TextEncoder;
@@ -434,4 +454,4 @@ function wrapInRequestContext(handler, options = {}) {
   };
 }
 
-export { __require, parseTrailingWildcard, mergeMeta, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, typedEntries, isRecord, bytesToBase64Url, base64UrlToBytes, formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput, isUnsafeKey, safeJsonParse, generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };
+export { __require, parseTrailingWildcard, isUnsafeKey, safeJsonParse, mergeMeta, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, typedEntries, isRecord, callRuntimeHandler, bytesToBase64Url, base64UrlToBytes, formatZodError, zodIssues, errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput, generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext, runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };