@apicircle/shared 1.0.0

package/dist/index.js

@@ -0,0 +1,487 @@
+// src/ids.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/validators.ts
+var OK = { ok: true };
+var fail = (reason) => ({ ok: false, reason });
+function validateUrl(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return fail("URL is required.");
+  if (/^\s*\{\{\s*[^{}]+\s*\}\}/.test(trimmed)) return OK;
+  const probe = trimmed.replace(/\{\{[^{}]+\}\}/g, "placeholder");
+  try {
+    const u = new URL(probe);
+    if (!/^https?:|^file:$/i.test(u.protocol)) {
+      return fail(`Unsupported scheme "${u.protocol}". Use http(s):// or file://.`);
+    }
+    if (u.protocol !== "file:" && !u.host) return fail("URL is missing a host.");
+    return OK;
+  } catch {
+    return fail("Not a valid URL. Expected http(s)://host/path.");
+  }
+}
+var AWS_DIRECTIONS = /* @__PURE__ */ new Set([
+  "east",
+  "west",
+  "north",
+  "south",
+  "central",
+  "northeast",
+  "northwest",
+  "southeast",
+  "southwest"
+]);
+function validateAwsRegion(value) {
+  const v = value.trim().toLowerCase();
+  if (!v) return fail("Region is required (e.g. us-east-1).");
+  const m = /^([a-z]{2,3})-(?:([a-z]+)-)?([a-z]+)-(\d+)$/.exec(v);
+  if (!m) return fail('Region must look like "us-east-1" or "us-gov-west-1".');
+  const direction = m[3];
+  if (!AWS_DIRECTIONS.has(direction)) {
+    return fail(`Unknown direction "${direction}". Expected east/west/north/south/central/etc.`);
+  }
+  return OK;
+}
+function validateMockPath(value) {
+  const v = value.trim();
+  if (!v) return fail("Path is required.");
+  if (!v.startsWith("/")) return fail('Path must start with "/".');
+  if (/\s/.test(v)) return fail("Path must not contain whitespace.");
+  if (v.includes("?")) return fail("Path must not include a query string.");
+  if (v.includes("#")) return fail("Path must not include a fragment.");
+  return OK;
+}
+function validateEnvVarName(value) {
+  const v = value.trim();
+  if (!v) return fail("Variable name is required.");
+  if (/[\s{}]/.test(v)) return fail("Variable name cannot contain spaces or braces.");
+  if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(v)) {
+    return fail("Use letters, digits, underscores, hyphens. Must start with a letter or _.");
+  }
+  return OK;
+}
+function validatePlanName(value) {
+  const v = value.trim();
+  if (!v) return fail("Plan name is required.");
+  if (v.length > 80) return fail("Plan name must be 80 characters or fewer.");
+  return OK;
+}
+function validatePRTitle(value) {
+  const v = value.trim();
+  if (!v) return fail("Title is required.");
+  if (v.length > 256) return fail("Title must be 256 characters or fewer.");
+  return OK;
+}
+function validateJsonString(value, opts = {}) {
+  const v = value.trim();
+  if (!v) {
+    if (opts.allowEmpty) return OK;
+    return fail("JSON cannot be empty.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(v);
+  } catch (e) {
+    return fail(`Invalid JSON: ${e instanceof Error ? e.message : "parse failed"}.`);
+  }
+  const allow = opts.allowRoots ?? "any";
+  if (allow === "object" && (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))) {
+    return fail("JSON root must be an object.");
+  }
+  if (allow === "array" && !Array.isArray(parsed)) {
+    return fail("JSON root must be an array.");
+  }
+  return OK;
+}
+var HEADER_TOKEN_RE = /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/;
+function validateHttpHeaderName(value) {
+  const v = value.trim();
+  if (!v) return fail("Header name is required.");
+  if (!HEADER_TOKEN_RE.test(v)) {
+    return fail("Header name must be a valid HTTP token (letters, digits, and -_.!#$%&'*+^`|~).");
+  }
+  return OK;
+}
+function validateRegex(value, flags) {
+  if (value === "") return fail("Regex cannot be empty.");
+  try {
+    new RegExp(value, flags);
+    return OK;
+  } catch (e) {
+    return fail(`Invalid regex: ${e instanceof Error ? e.message : "parse failed"}.`);
+  }
+}
+var JSON_PATH_RE = /^\$(\.\.?[A-Za-z_$][\w$]*|\[(?:\*|\d+|'[^']*')\])*$/;
+function validateJsonPath(value) {
+  const v = value.trim();
+  if (!v) return fail("JSONPath cannot be empty.");
+  if (!v.startsWith("$")) return fail('JSONPath must start with "$".');
+  if (!JSON_PATH_RE.test(v)) {
+    return fail("JSONPath syntax looks malformed \u2014 expected $.foo.bar or $.items[0].name.");
+  }
+  return OK;
+}
+function validatePositiveDuration(value) {
+  const n = typeof value === "string" ? Number(value) : value;
+  if (!Number.isFinite(n)) return fail("Duration must be a number.");
+  if (n < 0) return fail("Duration cannot be negative.");
+  if (!Number.isInteger(n)) return fail("Duration must be a whole number.");
+  return OK;
+}
+function safeExternalHref(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+  return parsed.toString();
+}
+
+// src/format.ts
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return "\u2014";
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unitIdx = 0;
+  while (value >= 1024 && unitIdx < units.length - 1) {
+    value /= 1024;
+    unitIdx++;
+  }
+  return `${value.toFixed(value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[unitIdx]}`;
+}
+function utf8ByteLength(s) {
+  if (typeof TextEncoder === "undefined") return s.length;
+  return new TextEncoder().encode(s).length;
+}
+
+// src/envPriority.ts
+function envPriorityKey(ref) {
+  if (ref.kind === "local") return `local:${ref.name}`;
+  return `linked:${ref.linkedWorkspaceId}:${ref.envName}`;
+}
+function parseEnvPriorityKey(key) {
+  if (key.startsWith("local:")) {
+    return { kind: "local", name: key.slice("local:".length) };
+  }
+  if (key.startsWith("linked:")) {
+    const rest = key.slice("linked:".length);
+    const colonIdx = rest.indexOf(":");
+    if (colonIdx === -1) return null;
+    return {
+      kind: "linked",
+      linkedWorkspaceId: rest.slice(0, colonIdx),
+      envName: rest.slice(colonIdx + 1)
+    };
+  }
+  return null;
+}
+function envPriorityRefEqual(a, b) {
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "local") return b.kind === "local" && a.name === b.name;
+  return b.kind === "linked" && a.linkedWorkspaceId === b.linkedWorkspaceId && a.envName === b.envName;
+}
+function envPriorityDisplayName(ref) {
+  return ref.kind === "local" ? ref.name : ref.envName;
+}
+
+// src/types.ts
+var DEFAULT_WORKSPACE_NAME = "My Workspace";
+var RUN_BODY_PREVIEW_LIMIT = 64 * 1024;
+var FONT_SIZE_PERCENT_MIN = 80;
+var FONT_SIZE_PERCENT_MAX = 150;
+var FONT_SIZE_PERCENT_STEP = 10;
+var FONT_SIZE_PERCENT_DEFAULT = 100;
+
+// src/authDefaults.ts
+var oauth2TokenDefaults = {
+  accessToken: "",
+  tokenType: "Bearer",
+  refreshToken: "",
+  expiresAt: null,
+  obtainedScope: ""
+};
+var FACTORIES = {
+  none: () => ({ type: "none" }),
+  inherit: () => ({ type: "inherit" }),
+  bearer: () => ({ type: "bearer", token: "" }),
+  basic: () => ({ type: "basic", username: "", password: "" }),
+  "api-key": () => ({ type: "api-key", key: "", value: "", addTo: "header" }),
+  "custom-header": () => ({ type: "custom-header", key: "", value: "" }),
+  "oauth2-client-credentials": () => ({
+    type: "oauth2-client-credentials",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    scope: "",
+    clientAuthMethod: "header",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-auth-code": () => ({
+    type: "oauth2-auth-code",
+    authUrl: "",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    redirectUri: "",
+    scope: "",
+    state: "",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-pkce": () => ({
+    type: "oauth2-pkce",
+    authUrl: "",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    redirectUri: "",
+    scope: "",
+    state: "",
+    codeVerifier: "",
+    codeChallengeMethod: "S256",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-password": () => ({
+    type: "oauth2-password",
+    tokenUrl: "",
+    clientId: "",
+    clientSecret: "",
+    username: "",
+    password: "",
+    scope: "",
+    ...oauth2TokenDefaults
+  }),
+  "oauth2-implicit": () => ({
+    type: "oauth2-implicit",
+    authUrl: "",
+    clientId: "",
+    redirectUri: "",
+    scope: "",
+    accessToken: "",
+    tokenType: "Bearer",
+    expiresAt: null,
+    obtainedScope: ""
+  }),
+  "oauth2-device": () => ({
+    type: "oauth2-device",
+    deviceAuthUrl: "",
+    tokenUrl: "",
+    clientId: "",
+    scope: "",
+    deviceCode: "",
+    userCode: "",
+    verificationUri: "",
+    ...oauth2TokenDefaults
+  }),
+  "aws-sigv4": () => ({
+    type: "aws-sigv4",
+    accessKeyId: "",
+    secretAccessKey: "",
+    sessionToken: "",
+    region: "us-east-1",
+    service: "",
+    addTo: "header"
+  }),
+  digest: () => ({ type: "digest", username: "", password: "" }),
+  ntlm: () => ({
+    type: "ntlm",
+    username: "",
+    password: "",
+    domain: "",
+    workstation: ""
+  }),
+  hawk: () => ({
+    type: "hawk",
+    hawkId: "",
+    hawkKey: "",
+    algorithm: "sha256",
+    ext: ""
+  }),
+  "jwt-bearer": () => ({
+    type: "jwt-bearer",
+    algorithm: "HS256",
+    secretOrKey: "",
+    payload: '{\n  "sub": "user-id",\n  "iat": 1700000000\n}',
+    jwtHeaders: '{\n  "typ": "JWT"\n}',
+    token: ""
+  })
+};
+function defaultAuthFor(type) {
+  return FACTORIES[type]();
+}
+function normalizeAuth(input) {
+  if (input && typeof input === "object" && "type" in input && typeof input.type === "string" && input.type in FACTORIES) {
+    return input;
+  }
+  return { type: "none" };
+}
+var REQUEST_AUTH_TYPES = Object.keys(
+  FACTORIES
+);
+
+// src/mcp.ts
+var MCP_TOOL_NAMES = [
+  "import.curl",
+  "import.openapi",
+  "import.postman",
+  "import.insomnia",
+  "import.har",
+  "generate.code",
+  "workspace.read",
+  "workspace.write",
+  "request.create",
+  "request.read",
+  "request.update",
+  "request.delete",
+  "folder.create",
+  "folder.read",
+  "folder.update",
+  "folder.delete",
+  "environment.create",
+  "environment.read",
+  "environment.update",
+  "environment.delete",
+  "environment.set_active",
+  "environment.set_priority",
+  "environment.export",
+  "environment.import",
+  "plan.create",
+  "plan.run",
+  "plan.read",
+  "plan.update",
+  "plan.delete",
+  "plan.add_step",
+  "plan.remove_step",
+  "plan.reorder_steps",
+  "plan.set_variables",
+  "assertion.create",
+  "assertion.read",
+  "assertion.update",
+  "assertion.delete",
+  "history.list_runs",
+  "history.get_run",
+  "history.delete_run",
+  "history.purge_by_age",
+  "codebase.extract_collection",
+  "prompt.create_environment",
+  "prompt.create_assertion",
+  "prompt.create_plan",
+  "prompt.create_request",
+  "prompt.update_request",
+  "prompt.create_folder_tree",
+  "prompt.add_plan_steps",
+  "prompt.set_plan_variables",
+  "prompt.create_mock_server",
+  "prompt.add_mock_endpoint",
+  "prompt.set_endpoint_validation_rules",
+  "prompt.set_endpoint_response_rules",
+  "prompt.set_endpoint_multipliers",
+  "mock.create_from_openapi",
+  "mock.create_from_postman",
+  "mock.create_from_insomnia",
+  "mock.create_manual",
+  "mock.list",
+  "mock.list_endpoints",
+  "mock.start",
+  "mock.stop",
+  "mock.delete",
+  "mock.add_endpoint",
+  "mock.update_endpoint",
+  "mock.delete_endpoint",
+  "mock.set_validation_rules",
+  "mock.set_response_rules",
+  "mock.set_multipliers",
+  "mock.import_postman_mock_collection"
+];
+
+// src/mock.ts
+var NO_BODY_STATUSES = /* @__PURE__ */ new Set([100, 101, 102, 103, 204, 205, 304]);
+function getAllowedMockResponseBodyTypes(status) {
+  if (NO_BODY_STATUSES.has(status)) return ["none"];
+  if (status === 200) {
+    return ["none", "json", "text", "xml", "urlencoded", "form-data", "binary"];
+  }
+  return ["none", "json", "text", "xml", "urlencoded", "form-data"];
+}
+function coerceMockResponseBodyTypeForStatus(currentBodyType, status) {
+  const allowed = getAllowedMockResponseBodyTypes(status);
+  if (allowed.includes(currentBodyType)) return null;
+  if (allowed.includes("json")) return "json";
+  return "none";
+}
+function makeDefaultMockResponseBody(type) {
+  switch (type) {
+    case "none":
+      return { type: "none", content: "" };
+    case "form-data":
+      return { type: "form-data", content: "", formRows: [] };
+    case "binary":
+      return { type: "binary", content: "" };
+    default:
+      return { type, content: "" };
+  }
+}
+function makeDefaultMockResponse() {
+  return {
+    status: 200,
+    headers: [{ key: "Content-Type", value: "application/json", enabled: true }],
+    body: { type: "json", content: '{\n  "ok": true\n}' }
+  };
+}
+function makeDefaultRequestSchema() {
+  return { pathParams: [], queryParams: [], headers: [], cookies: [] };
+}
+export {
+  DEFAULT_WORKSPACE_NAME,
+  FONT_SIZE_PERCENT_DEFAULT,
+  FONT_SIZE_PERCENT_MAX,
+  FONT_SIZE_PERCENT_MIN,
+  FONT_SIZE_PERCENT_STEP,
+  MCP_TOOL_NAMES,
+  REQUEST_AUTH_TYPES,
+  RUN_BODY_PREVIEW_LIMIT,
+  coerceMockResponseBodyTypeForStatus,
+  defaultAuthFor,
+  envPriorityDisplayName,
+  envPriorityKey,
+  envPriorityRefEqual,
+  formatBytes,
+  generateId,
+  getAllowedMockResponseBodyTypes,
+  makeDefaultMockResponse,
+  makeDefaultMockResponseBody,
+  makeDefaultRequestSchema,
+  normalizeAuth,
+  parseEnvPriorityKey,
+  safeExternalHref,
+  utf8ByteLength,
+  validateAwsRegion,
+  validateEnvVarName,
+  validateHttpHeaderName,
+  validateJsonPath,
+  validateJsonString,
+  validateMockPath,
+  validatePRTitle,
+  validatePlanName,
+  validatePositiveDuration,
+  validateRegex,
+  validateUrl
+};
+//# sourceMappingURL=index.js.map