@logbrew/sdk 0.1.37 → 0.1.38

package/log-context.cjs

@@ -1,95 +1,115 @@
-const ZERO_TRACE_ID = "00000000000000000000000000000000";
-const ZERO_SPAN_ID = "0000000000000000";
+const { SdkError } = require("./sdk-error.cjs");
+const { ZERO_SPAN_ID, ZERO_TRACE_ID, isRecord } = require("./validation.cjs");
 
-function buildLogContextHelpers({ SdkError }) {
-  function compactMetadata(metadata) {
-    if (metadata === undefined) {
-      return {};
-    }
-    if (!metadata || Array.isArray(metadata) || typeof metadata !== "object") {
-      throw new SdkError("validation_error", "metadata must be an object");
-    }
-    const safeMetadata = {};
-    for (const [key, value] of Object.entries(metadata)) {
-      if (isMetadataValue(value)) {
-        safeMetadata[key] = value;
-      }
-    }
-    return safeMetadata;
-  }
+/**
+ * @import { LogCorrelationTraceContext, Metadata, MetadataValue } from "./index.cjs"
+ */
 
-  function traceFromProvider(provider, onError) {
-    if (!provider) {
-      return undefined;
-    }
-    try {
-      return provider();
-    } catch (error) {
-      onError(error);
-      return undefined;
-    }
-  }
-
-  return {
-    compactMetadata,
-    isMetadataValue,
-    normalizeLogTraceContext,
-    traceFromProvider,
-    traceMetadataFromLogContext
-  };
-}
+const TRACE_ID_PATTERN = /^[0-9a-fA-F]{32}$/u;
+const SPAN_ID_PATTERN = /^[0-9a-fA-F]{16}$/u;
 
+/**
+ * @param {unknown} value
+ * @returns {value is MetadataValue}
+ */
 function isMetadataValue(value) {
   return (
     value === null
     || typeof value === "string"
-    || typeof value === "number" && Number.isFinite(value)
+    || (typeof value === "number" && Number.isFinite(value))
     || typeof value === "boolean"
   );
 }
 
-function traceMetadataFromLogContext(trace) {
-  const normalized = normalizeLogTraceContext(trace);
-  if (!normalized) {
+/**
+ * @param {unknown} metadata
+ * @returns {Metadata}
+ */
+function compactMetadata(metadata) {
+  if (metadata === undefined) {
     return {};
   }
-  return {
-    traceId: normalized.traceId,
-    spanId: normalized.spanId,
-    ...(normalized.parentSpanId !== undefined ? { parentSpanId: normalized.parentSpanId } : {}),
-    ...(normalized.sampled !== undefined ? { sampled: normalized.sampled } : {})
-  };
+  if (!isRecord(metadata)) {
+    throw new SdkError("validation_error", "metadata must be an object");
+  }
+  /** @type {Metadata} */
+  const safeMetadata = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (isMetadataValue(value)) {
+      safeMetadata[key] = value;
+    }
+  }
+  return safeMetadata;
 }
 
+/**
+ * @template Trace
+ * @param {(() => Trace) | null | undefined} provider
+ * @param {(error: unknown) => void} onError
+ * @returns {Trace | undefined}
+ */
+function traceFromProvider(provider, onError) {
+  if (!provider) {
+    return undefined;
+  }
+  try {
+    return provider();
+  } catch (error) {
+    onError(error);
+    return undefined;
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @param {Readonly<RegExp>} pattern
+ * @param {string} zeroValue
+ * @returns {string | undefined}
+ */
+function normalizeHexId(value, pattern, zeroValue) {
+  if (typeof value !== "string" || !pattern.test(value) || value.toLowerCase() === zeroValue) {
+    return undefined;
+  }
+  return value.toLowerCase();
+}
+
+/**
+ * @param {unknown} trace
+ * @returns {LogCorrelationTraceContext | undefined}
+ */
 function normalizeLogTraceContext(trace) {
-  if (!trace || Array.isArray(trace) || typeof trace !== "object") {
+  if (!isRecord(trace)) {
     return undefined;
   }
-  const traceId = normalizeHexId(trace.traceId, 32, ZERO_TRACE_ID);
-  const spanId = normalizeHexId(trace.spanId, 16, ZERO_SPAN_ID);
-  if (!traceId || !spanId) {
+  const traceId = normalizeHexId(trace["traceId"], TRACE_ID_PATTERN, ZERO_TRACE_ID);
+  const spanId = normalizeHexId(trace["spanId"], SPAN_ID_PATTERN, ZERO_SPAN_ID);
+  if (traceId === undefined || spanId === undefined) {
     return undefined;
   }
-  const parentSpanId = normalizeHexId(trace.parentSpanId, 16, ZERO_SPAN_ID);
+  const parentSpanId = normalizeHexId(trace["parentSpanId"], SPAN_ID_PATTERN, ZERO_SPAN_ID);
+  const { sampled } = trace;
   return {
     traceId,
+
     spanId,
-    ...(parentSpanId !== undefined ? { parentSpanId } : {}),
-    ...(typeof trace.sampled === "boolean" ? { sampled: trace.sampled } : {})
+    ...(parentSpanId === undefined ? {} : { parentSpanId }),
+    ...(typeof sampled === "boolean" ? { sampled } : {})
   };
 }
 
-function normalizeHexId(value, length, zeroValue) {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const pattern = length === 32
-    ? /^[0-9a-fA-F]{32}$/u
-    : /^[0-9a-fA-F]{16}$/u;
-  if (!pattern.test(value) || value.toLowerCase() === zeroValue) {
-    return undefined;
-  }
-  return value.toLowerCase();
+/**
+ * @param {unknown} trace
+ * @returns {Metadata}
+ */
+function traceMetadataFromLogContext(trace) {
+  const normalized = normalizeLogTraceContext(trace);
+  return normalized === undefined ? {} : { ...normalized };
 }
 
-module.exports = { buildLogContextHelpers };
+module.exports = {
+  compactMetadata,
+  isMetadataValue,
+  normalizeLogTraceContext,
+  traceFromProvider,
+  traceMetadataFromLogContext
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/sdk",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "Public LogBrew JavaScript SDK for building, validating, and flushing event batches.",
   "type": "module",
   "main": "./index.cjs",
@@ -48,15 +48,24 @@
     "index.js",
     "index.d.ts",
     "index.d.cts",
+    "issue-breadcrumbs.cjs",
     "issue-diagnostics.cjs",
+    "issue-evidence.cjs",
+    "issue-exception.cjs",
     "issue-stack.cjs",
+    "issue-stack-frames.cjs",
+    "issue-stack-text.cjs",
+    "issue-text.cjs",
     "log-context.cjs",
     "opentelemetry.cjs",
     "react-native.js",
     "react-native.d.ts",
+    "sdk-error.cjs",
     "support-ticket.cjs",
     "telemetry-context.cjs",
     "trace-context.cjs",
+    "transport-error.cjs",
+    "validation.cjs",
     "winston.cjs",
     "release-artifacts-common.js",
     "release-artifacts-build.cjs",

package/sdk-error.cjs

@@ -0,0 +1,36 @@
+const MIN_RETRY_AFTER_MS = 0;
+
+/**
+ * @param {unknown} value
+ * @returns {number | undefined}
+ */
+function retryAfterMsOrUndefined(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= MIN_RETRY_AFTER_MS ? value : undefined;
+}
+
+class SdkError extends Error {
+  /**
+   * @param {string} code
+   * @param {string} message
+   * @param {Readonly<{ retryAfterMs?: unknown, retryable?: unknown }> | null} [details]
+   */
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "SdkError";
+    this.code = code;
+    const retryAfterMs = retryAfterMsOrUndefined(details?.retryAfterMs);
+    if (retryAfterMs !== undefined) {
+      /** @type {number | undefined} */
+      this.retryAfterMs = retryAfterMs;
+    }
+    if (details?.retryable === true) {
+      /** @type {boolean | undefined} */
+      this.retryable = true;
+    }
+  }
+}
+
+module.exports = { SdkError, retryAfterMsOrUndefined };

package/support-ticket.cjs

@@ -1,4 +1,18 @@
+const { SdkError } = require("./sdk-error.cjs");
+const { isRecord, requireAllowedValue, requireNonEmpty, requireTraceId } = require("./validation.cjs");
+
+/**
+ * @import { SupportTicketCategory, SupportTicketDraft, SupportTicketSource } from "./index.cjs"
+ * @typedef {string | number | boolean | null | undefined | SanitizedDiagnosticsValue[] | SanitizedDiagnostics} SanitizedDiagnosticsValue
+ * @typedef {{ [key: string]: SanitizedDiagnosticsValue }} SanitizedDiagnostics
+ * @typedef {Omit<SupportTicketDraft, "diagnostics"> & { diagnostics?: SanitizedDiagnostics }} SanitizedSupportTicketDraft
+ * @typedef {Omit<SanitizedSupportTicketDraft, "category" | "description" | "source" | "title">} SupportTicketContext
+ * @typedef {(child: unknown, childKey: string) => SanitizedDiagnosticsValue} SanitizeChild
+ */
+
+/** @type {ReadonlySet<SupportTicketSource>} */
 const SUPPORT_TICKET_SOURCES = new Set(["cli", "sdk", "website", "docs", "mobile"]);
+/** @type {ReadonlySet<SupportTicketCategory>} */
 const SUPPORT_TICKET_CATEGORIES = new Set([
   "sdk_install_failure",
   "ingest_failure",
@@ -11,165 +25,261 @@ const SUPPORT_TICKET_CATEGORIES = new Set([
   "billing_question",
   "other"
 ]);
+const SENSITIVE_KEY_PARTS = [
+  "apikey",
+  "auth",
+  "authorization",
+  "authtoken",
+  "bearer",
+  "clientsecret",
+  "connectionstring",
+  "cookie",
+  "credential",
+  "dsn",
+  "email",
+  "password",
+  "passwd",
+  "privatekey",
+  "refreshtoken",
+  "secret",
+  "session",
+  "setcookie",
+  "token"
+];
 const SUPPORT_DIAGNOSTICS_MAX_DEPTH = 5;
 const SUPPORT_DIAGNOSTICS_MAX_ARRAY_LENGTH = 20;
 const SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH = 500;
+const ROOT_DEPTH = 0;
+const DEPTH_STEP = 1;
+const TEXT_START = 0;
+const KEY_SEPARATOR_PATTERN = /[^a-z0-9]/giu;
+const SENSITIVE_ASSIGNMENT_PATTERN = /(?:authorization|api[_-]?key|token|secret|password|passwd|cookie)\s*[:=]/iu;
+const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/iu;
+const LOGBREW_KEY_PATTERN = /\blbw_(?:ingest|client|api)_[A-Za-z0-9._-]+/iu;
+const VENDOR_KEY_PATTERN = /\b(?:github_pat|ghp|gho|npm|pypi|sk_live|sk_test|xox[baprs]|AKIA)[A-Za-z0-9._-]+/u;
+const LOCAL_PATH_PATTERN = /^(?:\/Users\/|\/home\/|\/var\/folders\/|[A-Za-z]:\\)/u;
+const QUERY_OR_FRAGMENT_PATTERN = /[?#]/u;
 
-function buildCreateSupportTicketDraft({ SdkError, requireAllowedValue, requireNonEmpty, requireTraceId }) {
-  return function createSupportTicketDraft(input) {
-    if (!input || Array.isArray(input) || typeof input !== "object") {
-      throw new SdkError("validation_error", "support ticket draft input must be an object");
-    }
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isSensitiveSupportKey(key) {
+  if (key === "") {
+    return false;
+  }
+  const normalized = key.replaceAll(KEY_SEPARATOR_PATTERN, "").toLowerCase();
+  return SENSITIVE_KEY_PARTS.some((needle) => normalized.includes(needle));
+}
 
-    requireAllowedValue("support ticket source", input.source, SUPPORT_TICKET_SOURCES);
-    requireAllowedValue("support ticket category", input.category, SUPPORT_TICKET_CATEGORIES);
-    const draft = {
-      source: input.source,
-      category: input.category,
-      title: requiredSupportString(requireNonEmpty, "support ticket title", input.title),
-      description: requiredSupportString(requireNonEmpty, "support ticket description", input.description)
-    };
-
-    addOptionalSupportString(draft, "project_id", "support ticket projectId", input.projectId, requireNonEmpty);
-    addOptionalSupportString(draft, "environment", "support ticket environment", input.environment, requireNonEmpty);
-    addOptionalSupportString(draft, "runtime", "support ticket runtime", input.runtime, requireNonEmpty);
-    addOptionalSupportString(draft, "framework", "support ticket framework", input.framework, requireNonEmpty);
-    addOptionalSupportString(draft, "sdk_package", "support ticket sdkPackage", input.sdkPackage, requireNonEmpty);
-    addOptionalSupportString(draft, "sdk_version", "support ticket sdkVersion", input.sdkVersion, requireNonEmpty);
-    addOptionalSupportString(draft, "release", "support ticket release", input.release, requireNonEmpty);
-    if (input.traceId !== undefined) {
-      requireTraceId(input.traceId);
-      draft.trace_id = input.traceId.toLowerCase();
-    }
-    addOptionalSupportString(draft, "event_id", "support ticket eventId", input.eventId, requireNonEmpty);
-    if (input.diagnostics !== undefined) {
-      draft.diagnostics = sanitizeSupportDiagnostics(input.diagnostics, SdkError);
-    }
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isSensitiveSupportString(value) {
+  return SENSITIVE_ASSIGNMENT_PATTERN.test(value)
+    || BEARER_PATTERN.test(value)
+    || LOGBREW_KEY_PATTERN.test(value)
+    || VENDOR_KEY_PATTERN.test(value);
+}
 
-    return draft;
-  };
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function redactUrl(value) {
+  try {
+    const url = new URL(value);
+    return `[redacted-url]${url.pathname || "/"}`;
+  } catch {
+    const [beforeQuery = value] = value.split(QUERY_OR_FRAGMENT_PATTERN);
+    return beforeQuery;
+  }
 }
 
-function requiredSupportString(requireNonEmpty, label, value) {
-  requireNonEmpty(label, value);
-  return value.trim();
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function sanitizeSupportDiagnosticString(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return "";
+  }
+  if (isSensitiveSupportString(trimmed)) {
+    return "[redacted]";
+  }
+  const urlRedacted = redactUrl(LOCAL_PATH_PATTERN.test(trimmed) ? "[redacted-path]" : trimmed);
+  return urlRedacted.length > SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH
+    ? `${urlRedacted.slice(TEXT_START, SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH)}...`
+    : urlRedacted;
+}
+
+/**
+ * @param {Readonly<Error>} error
+ * @returns {SanitizedDiagnostics}
+ */
+function errorDiagnostics(error) {
+  return { name: error.name || "Error" };
 }
 
-function addOptionalSupportString(target, key, label, value, requireNonEmpty) {
-  if (value === undefined) {
-    return;
+/**
+ * @param {unknown} value
+ * @returns {SanitizedDiagnosticsValue}
+ */
+function sanitizeSupportDiagnosticScalar(value) {
+  if (value === null || (typeof value === "number" && Number.isFinite(value)) || typeof value === "boolean") {
+    return value;
   }
-  target[key] = requiredSupportString(requireNonEmpty, label, value);
+  return typeof value === "string" ? sanitizeSupportDiagnosticString(value) : undefined;
 }
 
-function sanitizeSupportDiagnostics(diagnostics, SdkError) {
-  if (!diagnostics || Array.isArray(diagnostics) || typeof diagnostics !== "object") {
-    throw new SdkError("validation_error", "support ticket diagnostics must be an object");
+/**
+ * @param {readonly unknown[]} value
+ * @param {SanitizeChild} sanitizeChild
+ * @returns {SanitizedDiagnosticsValue[]}
+ */
+function sanitizeSupportDiagnosticList(value, sanitizeChild) {
+  return value.slice(TEXT_START, SUPPORT_DIAGNOSTICS_MAX_ARRAY_LENGTH).map((item) => sanitizeChild(item, ""));
+}
+
+/**
+ * @param {Readonly<Record<string, unknown>>} value
+ * @param {SanitizeChild} sanitizeChild
+ * @returns {SanitizedDiagnostics}
+ */
+function sanitizeSupportDiagnosticRecord(value, sanitizeChild) {
+  /** @type {SanitizedDiagnostics} */
+  const safe = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    const sanitized = sanitizeChild(childValue, childKey);
+    if (sanitized !== undefined) {
+      safe[childKey] = sanitized;
+    }
   }
-  return sanitizeSupportDiagnosticValue(diagnostics, 0, "");
+  return safe;
 }
 
+/**
+ * @param {unknown} value
+ * @param {number} depth
+ * @param {string} key
+ * @returns {SanitizedDiagnosticsValue}
+ */
 function sanitizeSupportDiagnosticValue(value, depth, key) {
   if (isSensitiveSupportKey(key)) {
     return "[redacted]";
   }
   if (value instanceof Error) {
-    return { name: value.name || "Error" };
+    return errorDiagnostics(value);
   }
-  if (value === null || typeof value === "number" && Number.isFinite(value) || typeof value === "boolean") {
-    return value;
+  if (!Array.isArray(value) && !isRecord(value)) {
+    return sanitizeSupportDiagnosticScalar(value);
   }
-  if (typeof value === "string") {
-    return sanitizeSupportDiagnosticString(value);
+  if (depth >= SUPPORT_DIAGNOSTICS_MAX_DEPTH) {
+    return "[max-depth]";
   }
-  if (Array.isArray(value)) {
-    if (depth >= SUPPORT_DIAGNOSTICS_MAX_DEPTH) {
-      return "[max-depth]";
-    }
-    return value
-      .slice(0, SUPPORT_DIAGNOSTICS_MAX_ARRAY_LENGTH)
-      .map((item) => sanitizeSupportDiagnosticValue(item, depth + 1, ""));
+  const childDepth = depth + DEPTH_STEP;
+  return isRecord(value)
+    ? sanitizeSupportDiagnosticRecord(value, (child, childKey) => sanitizeSupportDiagnosticValue(child, childDepth, childKey))
+    : sanitizeSupportDiagnosticList(value, (child, childKey) => sanitizeSupportDiagnosticValue(child, childDepth, childKey));
+}
+
+/**
+ * @param {unknown} diagnostics
+ * @returns {{ diagnostics?: SanitizedDiagnostics }}
+ */
+function optionalDiagnostics(diagnostics) {
+  if (diagnostics === undefined) {
+    return {};
   }
-  if (value && typeof value === "object") {
-    if (depth >= SUPPORT_DIAGNOSTICS_MAX_DEPTH) {
-      return "[max-depth]";
-    }
-    const safe = {};
-    for (const [childKey, childValue] of Object.entries(value)) {
-      const sanitized = sanitizeSupportDiagnosticValue(childValue, depth + 1, childKey);
-      if (sanitized !== undefined) {
-        safe[childKey] = sanitized;
-      }
-    }
-    return safe;
+  if (!isRecord(diagnostics)) {
+    throw new SdkError("validation_error", "support ticket diagnostics must be an object");
+  }
+  if (diagnostics instanceof Error) {
+    return { diagnostics: errorDiagnostics(diagnostics) };
   }
-  return undefined;
+  return {
+    diagnostics: sanitizeSupportDiagnosticRecord(
+      diagnostics,
+      (child, childKey) => sanitizeSupportDiagnosticValue(child, ROOT_DEPTH + DEPTH_STEP, childKey)
+    )
+  };
 }
 
-function isSensitiveSupportKey(key) {
-  if (typeof key !== "string" || key === "") {
-    return false;
-  }
-  const normalized = key.replace(/[^a-z0-9]/giu, "").toLowerCase();
-  return [
-    "apikey",
-    "auth",
-    "authorization",
-    "authtoken",
-    "bearer",
-    "clientsecret",
-    "connectionstring",
-    "cookie",
-    "credential",
-    "dsn",
-    "email",
-    "password",
-    "passwd",
-    "privatekey",
-    "refreshtoken",
-    "secret",
-    "session",
-    "setcookie",
-    "token"
-  ].some((needle) => normalized.includes(needle));
+/**
+ * @param {string} label
+ * @param {unknown} value
+ * @returns {string}
+ */
+function requiredSupportString(label, value) {
+  return requireNonEmpty(label, value).trim();
 }
 
-function sanitizeSupportDiagnosticString(value) {
-  const trimmed = value.trim();
-  if (trimmed === "") {
-    return "";
+/**
+ * @template {string} Key
+ * @param {Key} key
+ * @param {string} label
+ * @param {unknown} value
+ * @returns {{ [Field in Key]?: string }}
+ */
+function optionalSupportString(key, label, value) {
+  /** @type {{ [Field in Key]?: string }} */
+  const field = {};
+  if (value !== undefined) {
+    field[key] = requiredSupportString(label, value);
   }
-  if (isSensitiveSupportString(trimmed)) {
-    return "[redacted]";
-  }
-  const pathRedacted = redactLocalPath(trimmed);
-  const urlRedacted = redactUrl(pathRedacted);
-  return urlRedacted.length > SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH
-    ? `${urlRedacted.slice(0, SUPPORT_DIAGNOSTICS_MAX_STRING_LENGTH)}...`
-    : urlRedacted;
+  return field;
 }
 
-function isSensitiveSupportString(value) {
-  return /(?:authorization|api[_-]?key|token|secret|password|passwd|cookie)\s*[:=]/iu.test(value)
-    || /\bBearer\s+[A-Za-z0-9._~+/-]+=*/iu.test(value)
-    || /\blbw_(?:ingest|client|api)_[A-Za-z0-9._-]+/iu.test(value)
-    || /\b(?:github_pat|ghp|gho|npm|pypi|sk_live|sk_test|xox[baprs]|AKIA)[A-Za-z0-9._-]+/u.test(value);
+/**
+ * @param {unknown} traceId
+ * @returns {{ trace_id?: string }}
+ */
+function optionalTraceId(traceId) {
+  return traceId === undefined ? {} : { trace_id: requireTraceId(traceId).toLowerCase() };
 }
 
-function redactLocalPath(value) {
-  if (/^(?:\/Users\/|\/home\/|\/var\/folders\/|[A-Za-z]:\\)/u.test(value)) {
-    return "[redacted-path]";
-  }
-  return value;
+/**
+ * @param {Readonly<Record<string, unknown>>} input
+ * @returns {SupportTicketContext}
+ */
+function supportTicketContext(input) {
+  return {
+    ...optionalSupportString("project_id", "support ticket projectId", input["projectId"]),
+    ...optionalSupportString("environment", "support ticket environment", input["environment"]),
+    ...optionalSupportString("runtime", "support ticket runtime", input["runtime"]),
+    ...optionalSupportString("framework", "support ticket framework", input["framework"]),
+    ...optionalSupportString("sdk_package", "support ticket sdkPackage", input["sdkPackage"]),
+    ...optionalSupportString("sdk_version", "support ticket sdkVersion", input["sdkVersion"]),
+    ...optionalSupportString("release", "support ticket release", input["release"]),
+    ...optionalTraceId(input["traceId"]),
+    ...optionalSupportString("event_id", "support ticket eventId", input["eventId"]),
+    ...optionalDiagnostics(input["diagnostics"])
+  };
 }
 
-function redactUrl(value) {
-  try {
-    const url = new URL(value);
-    return `[redacted-url]${url.pathname || "/"}`;
-  } catch {
-    return value.split(/[?#]/u)[0];
+/**
+ * @param {unknown} input
+ * @returns {SanitizedSupportTicketDraft}
+ */
+function createSupportTicketDraft(input) {
+  if (!isRecord(input)) {
+    throw new SdkError("validation_error", "support ticket draft input must be an object");
   }
+  const source = requireAllowedValue("support ticket source", input["source"], SUPPORT_TICKET_SOURCES);
+  const category = requireAllowedValue("support ticket category", input["category"], SUPPORT_TICKET_CATEGORIES);
+  const title = requiredSupportString("support ticket title", input["title"]);
+  const description = requiredSupportString("support ticket description", input["description"]);
+  return {
+    source,
+
+    category,
+    title,
+
+    description,
+    ...supportTicketContext(input)
+  };
 }
 
-module.exports = { buildCreateSupportTicketDraft };
+module.exports = { createSupportTicketDraft };