@sdk-it/spec 0.17.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/loaders/load-spec.js';
+export * from './lib/operation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./lib/loaders/load-spec.js";
+export * from "./lib/operation.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export * from './lib/loaders/load-spec.js';\nexport * from './lib/operation.js';\n"],
+  "mappings": "AAAA,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/lib/loaders/load-spec.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+export declare function loadSpec(location: string): Promise<OpenAPIObject>;
+//# sourceMappingURL=load-spec.d.ts.map

package/dist/lib/loaders/load-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-spec.d.ts","sourceRoot":"","sources":["../../../src/lib/loaders/load-spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAKvD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAMjE"}

package/dist/lib/loaders/load-spec.js

@@ -0,0 +1,13 @@
+import { loadLocal } from "./local-loader.js";
+import { loadRemote } from "./remote-loader.js";
+function loadSpec(location) {
+  const [protocol] = location.split(":");
+  if (protocol === "http" || protocol === "https") {
+    return loadRemote(location);
+  }
+  return loadLocal(location);
+}
+export {
+  loadSpec
+};
+//# sourceMappingURL=load-spec.js.map

package/dist/lib/loaders/load-spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/loaders/load-spec.ts"],
+  "sourcesContent": ["import type { OpenAPIObject } from 'openapi3-ts/oas31';\n\nimport { loadLocal } from './local-loader.js';\nimport { loadRemote } from './remote-loader.js';\n\nexport function loadSpec(location: string): Promise<OpenAPIObject> {\n  const [protocol] = location.split(':');\n  if (protocol === 'http' || protocol === 'https') {\n    return loadRemote(location);\n  }\n  return loadLocal(location);\n}\n"],
+  "mappings": "AAEA,SAAS,iBAAiB;AAC1B,SAAS,kBAAkB;AAEpB,SAAS,SAAS,UAA0C;AACjE,QAAM,CAAC,QAAQ,IAAI,SAAS,MAAM,GAAG;AACrC,MAAI,aAAa,UAAU,aAAa,SAAS;AAC/C,WAAO,WAAW,QAAQ;AAAA,EAC5B;AACA,SAAO,UAAU,QAAQ;AAC3B;",
+  "names": []
+}

package/dist/lib/loaders/local-loader.d.ts

@@ -0,0 +1,2 @@
+export declare function loadLocal(location: string): Promise<any>;
+//# sourceMappingURL=local-loader.d.ts.map

package/dist/lib/loaders/local-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/loaders/local-loader.ts"],"names":[],"mappings":"AAIA,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,gBAY/C"}

package/dist/lib/loaders/local-loader.js

@@ -0,0 +1,20 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { parse } from "yaml";
+async function loadLocal(location) {
+  const extName = extname(location);
+  const text = await readFile(location, "utf-8");
+  switch (extName) {
+    case ".json":
+      return JSON.parse(text);
+    case ".yaml":
+    case ".yml":
+      return parse(text);
+    default:
+      throw new Error(`Unsupported file extension: ${extName}`);
+  }
+}
+export {
+  loadLocal
+};
+//# sourceMappingURL=local-loader.js.map

package/dist/lib/loaders/local-loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/loaders/local-loader.ts"],
+  "sourcesContent": ["import { readFile } from 'node:fs/promises';\nimport { extname } from 'node:path';\nimport { parse } from 'yaml';\n\nexport async function loadLocal(location: string) {\n  const extName = extname(location);\n  const text = await readFile(location, 'utf-8');\n  switch (extName) {\n    case '.json':\n      return JSON.parse(text);\n    case '.yaml':\n    case '.yml':\n      return parse(text);\n    default:\n      throw new Error(`Unsupported file extension: ${extName}`);\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,eAAe;AACxB,SAAS,aAAa;AAEtB,eAAsB,UAAU,UAAkB;AAChD,QAAM,UAAU,QAAQ,QAAQ;AAChC,QAAM,OAAO,MAAM,SAAS,UAAU,OAAO;AAC7C,UAAQ,SAAS;AAAA,IACf,KAAK;AACH,aAAO,KAAK,MAAM,IAAI;AAAA,IACxB,KAAK;AAAA,IACL,KAAK;AACH,aAAO,MAAM,IAAI;AAAA,IACnB;AACE,YAAM,IAAI,MAAM,+BAA+B,OAAO,EAAE;AAAA,EAC5D;AACF;",
+  "names": []
+}

package/dist/lib/loaders/remote-loader.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+export declare function loadRemote(location: string): Promise<OpenAPIObject>;
+//# sourceMappingURL=remote-loader.d.ts.map

package/dist/lib/loaders/remote-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/loaders/remote-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAqBzE"}

package/dist/lib/loaders/remote-loader.js

@@ -0,0 +1,26 @@
+import { extname } from "node:path";
+import { parse } from "yaml";
+async function loadRemote(location) {
+  const extName = extname(location);
+  const response = await fetch(location);
+  switch (extName) {
+    case ".json":
+      return response.json();
+    case ".yaml":
+    case ".yml": {
+      const text = await response.text();
+      return parse(text);
+    }
+    default:
+      try {
+        return response.json();
+      } catch {
+        const text = await response.text();
+        return parse(text);
+      }
+  }
+}
+export {
+  loadRemote
+};
+//# sourceMappingURL=remote-loader.js.map

package/dist/lib/loaders/remote-loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/loaders/remote-loader.ts"],
+  "sourcesContent": ["import { extname } from 'node:path';\nimport type { OpenAPIObject } from 'openapi3-ts/oas31';\nimport { parse } from 'yaml';\n\nexport async function loadRemote(location: string): Promise<OpenAPIObject> {\n  const extName = extname(location);\n  const response = await fetch(location);\n  switch (extName) {\n    case '.json':\n      return response.json() as Promise<OpenAPIObject>;\n    case '.yaml':\n    case '.yml': {\n      const text = await response.text();\n      return parse(text);\n    }\n    default:\n      try {\n        // try to parse it as json first\n        return response.json() as Promise<OpenAPIObject>;\n      } catch {\n        // parse as yaml\n        const text = await response.text();\n        return parse(text) as Promise<OpenAPIObject>;\n      }\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,eAAe;AAExB,SAAS,aAAa;AAEtB,eAAsB,WAAW,UAA0C;AACzE,QAAM,UAAU,QAAQ,QAAQ;AAChC,QAAM,WAAW,MAAM,MAAM,QAAQ;AACrC,UAAQ,SAAS;AAAA,IACf,KAAK;AACH,aAAO,SAAS,KAAK;AAAA,IACvB,KAAK;AAAA,IACL,KAAK,QAAQ;AACX,YAAM,OAAO,MAAM,SAAS,KAAK;AACjC,aAAO,MAAM,IAAI;AAAA,IACnB;AAAA,IACA;AACE,UAAI;AAEF,eAAO,SAAS,KAAK;AAAA,MACvB,QAAQ;AAEN,cAAM,OAAO,MAAM,SAAS,KAAK;AACjC,eAAO,MAAM,IAAI;AAAA,MACnB;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/lib/operation.d.ts

@@ -0,0 +1,43 @@
+import type { OpenAPIObject, OperationObject, ParameterObject, ReferenceObject } from 'openapi3-ts/oas31';
+export declare const defaults: Partial<GenerateSdkConfig> & Required<Pick<GenerateSdkConfig, 'operationId' | 'tag'>>;
+export type TunedOperationObject = OperationObject & {
+    operationId: string;
+    parameters: (ParameterObject | ReferenceObject)[];
+};
+export interface OperationEntry {
+    name?: string;
+    method: string;
+    path: string;
+    groupName: string;
+    tag: string;
+}
+export type Operation = {
+    entry: OperationEntry;
+    operation: TunedOperationObject;
+};
+export declare function forEachOperation<T>(config: GenerateSdkConfig, callback: (entry: OperationEntry, operation: TunedOperationObject) => T): T[];
+export interface GenerateSdkConfig {
+    spec: OpenAPIObject;
+    operationId?: (operation: OperationObject, path: string, method: string) => string;
+    tag?: (operation: OperationObject, path: string) => string;
+}
+/**
+ * Attempts to determine a generic tag for an OpenAPI operation based on path and operationId.
+ * Rules and fallbacks are documented within the code.
+ * @param pathString The path string.
+ * @param operation The OpenAPI Operation Object.
+ * @returns A sanitized, camelCased tag name string.
+ */
+export declare function determineGenericTag(pathString: string, operation: OperationObject): string;
+export declare function parseJsonContentType(contentType: string | null | undefined): string | null;
+/**
+ * Checks if a given content type string represents Server-Sent Events (SSE).
+ * Handles case-insensitivity, parameters (like charset), and leading/trailing whitespace.
+ *
+ * @param contentType The content type string to check (e.g., from a Content-Type header).
+ * @returns True if the content type is 'text/event-stream', false otherwise.
+ */
+export declare function isSseContentType(contentType: string | null | undefined): boolean;
+export declare function isStreamingContentType(contentType: string | null | undefined): boolean;
+export declare function isSuccessStatusCode(statusCode: number | string): boolean;
+//# sourceMappingURL=operation.d.ts.map

package/dist/lib/operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../src/lib/operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,eAAe,EACf,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAG3B,eAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAC/C,QAAQ,CAAC,IAAI,CAAC,iBAAiB,EAAE,aAAa,GAAG,KAAK,CAAC,CAmBxD,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,eAAe,GAAG,eAAe,CAAC,EAAE,CAAC;CACnD,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb;AACD,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,cAAc,CAAC;IACtB,SAAS,EAAE,oBAAoB,CAAC;CACjC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,oBAAoB,KAAK,CAAC,OAqCxE;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,CAAC,EAAE,CACZ,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,KACX,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,CAAC,SAAS,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5D;AAoHD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,eAAe,GACzB,MAAM,CAoLR;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,iBAuB1E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACrC,OAAO,CAoBT;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACrC,OAAO,CAET;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAGxE"}

package/dist/lib/operation.js

@@ -0,0 +1,306 @@
+import { camelcase } from "stringcase";
+const defaults = {
+  operationId: (operation, path, method) => {
+    if (operation.operationId) {
+      return camelcase(operation.operationId);
+    }
+    const metadata = operation["x-oaiMeta"];
+    if (metadata && metadata.name) {
+      return camelcase(metadata.name);
+    }
+    return camelcase(
+      [method, ...path.replace(/[\\/\\{\\}]/g, " ").split(" ")].filter(Boolean).join(" ").trim()
+    );
+  },
+  tag: (operation, path) => {
+    return operation.tags?.[0] || determineGenericTag(path, operation);
+  }
+};
+function forEachOperation(config, callback) {
+  const result = [];
+  for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
+    const { parameters = [], ...methods } = pathItem;
+    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
+    for (const [method, operation] of Object.entries(methods)) {
+      const formatOperationId = config.operationId ?? defaults.operationId;
+      const formatTag = config.tag ?? defaults.tag;
+      const operationName = formatOperationId(operation, fixedPath, method);
+      const operationTag = formatTag(operation, fixedPath);
+      const metadata = operation["x-oaiMeta"] ?? {};
+      result.push(
+        callback(
+          {
+            name: metadata.name,
+            method,
+            path: fixedPath,
+            groupName: operationTag,
+            tag: operationTag
+          },
+          {
+            ...operation,
+            parameters: [...parameters, ...operation.parameters ?? []],
+            operationId: operationName
+          }
+        )
+      );
+    }
+  }
+  return result;
+}
+const reservedKeywords = /* @__PURE__ */ new Set([
+  "abstract",
+  "arguments",
+  "await",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  // Potentially problematic identifiers / Common Verbs used as tags
+  "object",
+  "string",
+  "number",
+  "any",
+  "unknown",
+  "never",
+  "get",
+  "list",
+  "create",
+  "update",
+  "delete",
+  "post",
+  "put",
+  "patch",
+  "do",
+  "send",
+  "add",
+  "remove",
+  "set",
+  "find",
+  "search",
+  "check",
+  "make"
+  // Added make, check
+]);
+function sanitizeTag(camelCasedTag) {
+  if (/^\d/.test(camelCasedTag)) {
+    return `_${camelCasedTag}`;
+  }
+  return reservedKeywords.has(camelCasedTag) ? `${camelCasedTag}_` : camelCasedTag;
+}
+function determineGenericTag(pathString, operation) {
+  const operationId = operation.operationId || "";
+  const VERSION_REGEX = /^[vV]\d+$/;
+  const commonVerbs = /* @__PURE__ */ new Set([
+    // Verbs to potentially strip from operationId prefix
+    "get",
+    "list",
+    "create",
+    "update",
+    "delete",
+    "post",
+    "put",
+    "patch",
+    "do",
+    "send",
+    "add",
+    "remove",
+    "set",
+    "find",
+    "search",
+    "check",
+    "make"
+    // Added make
+  ]);
+  const segments = pathString.split("/").filter(Boolean);
+  const potentialCandidates = segments.filter(
+    (segment) => segment && !segment.startsWith("{") && !segment.endsWith("}") && !VERSION_REGEX.test(segment)
+  );
+  for (let i = potentialCandidates.length - 1; i >= 0; i--) {
+    const segment = potentialCandidates[i];
+    if (!segment.startsWith("@")) {
+      return sanitizeTag(camelcase(segment));
+    }
+  }
+  const canFallbackToPathSegment = potentialCandidates.length > 0;
+  if (operationId) {
+    const lowerOpId = operationId.toLowerCase();
+    const parts = operationId.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").replace(/([a-zA-Z])(\d)/g, "$1_$2").replace(/(\d)([a-zA-Z])/g, "$1_$2").toLowerCase().split(/[_-\s]+/);
+    const validParts = parts.filter(Boolean);
+    if (commonVerbs.has(lowerOpId) && validParts.length === 1 && canFallbackToPathSegment) {
+    } else if (validParts.length > 0) {
+      const firstPart = validParts[0];
+      const isFirstPartVerb = commonVerbs.has(firstPart);
+      if (isFirstPartVerb && validParts.length > 1) {
+        const verbPrefixLength = firstPart.length;
+        let nextPartStartIndex = -1;
+        if (operationId.length > verbPrefixLength) {
+          const charAfterPrefix = operationId[verbPrefixLength];
+          if (charAfterPrefix >= "A" && charAfterPrefix <= "Z") {
+            nextPartStartIndex = verbPrefixLength;
+          } else if (charAfterPrefix >= "0" && charAfterPrefix <= "9") {
+            nextPartStartIndex = verbPrefixLength;
+          } else if (["_", "-"].includes(charAfterPrefix)) {
+            nextPartStartIndex = verbPrefixLength + 1;
+          } else {
+            const match = operationId.substring(verbPrefixLength).match(/[A-Z0-9]/);
+            if (match && match.index !== void 0) {
+              nextPartStartIndex = verbPrefixLength + match.index;
+            }
+            if (nextPartStartIndex === -1 && operationId.length > verbPrefixLength) {
+              nextPartStartIndex = verbPrefixLength;
+            }
+          }
+        }
+        if (nextPartStartIndex !== -1 && nextPartStartIndex < operationId.length) {
+          const remainingOriginalSubstring = operationId.substring(nextPartStartIndex);
+          const potentialTag = camelcase(remainingOriginalSubstring);
+          if (potentialTag) {
+            return sanitizeTag(potentialTag);
+          }
+        }
+        const potentialTagJoined = camelcase(validParts.slice(1).join("_"));
+        if (potentialTagJoined) {
+          return sanitizeTag(potentialTagJoined);
+        }
+      }
+      const potentialTagFull = camelcase(operationId);
+      if (potentialTagFull) {
+        const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;
+        if (!(isResultSingleVerb && canFallbackToPathSegment)) {
+          if (potentialTagFull.length > 0) {
+            return sanitizeTag(potentialTagFull);
+          }
+        }
+      }
+      const firstPartCamel = camelcase(firstPart);
+      if (firstPartCamel) {
+        const isFirstPartCamelVerb = commonVerbs.has(firstPartCamel);
+        if (!isFirstPartCamelVerb || validParts.length === 1 || !canFallbackToPathSegment) {
+          return sanitizeTag(firstPartCamel);
+        }
+      }
+      if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
+        const secondPartCamel = camelcase(validParts[1]);
+        if (secondPartCamel) {
+          return sanitizeTag(secondPartCamel);
+        }
+      }
+    }
+  }
+  if (potentialCandidates.length > 0) {
+    let firstCandidate = potentialCandidates[0];
+    if (firstCandidate.startsWith("@")) {
+      firstCandidate = firstCandidate.substring(1);
+    }
+    if (firstCandidate) {
+      return sanitizeTag(camelcase(firstCandidate));
+    }
+  }
+  console.warn(
+    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
+  );
+  return "unknown";
+}
+function parseJsonContentType(contentType) {
+  if (!contentType) {
+    return null;
+  }
+  let mainType = contentType.trim();
+  const semicolonIndex = mainType.indexOf(";");
+  if (semicolonIndex !== -1) {
+    mainType = mainType.substring(0, semicolonIndex).trim();
+  }
+  mainType = mainType.toLowerCase();
+  if (mainType.endsWith("/json")) {
+    return mainType.split("/")[1];
+  } else if (mainType.endsWith("+json")) {
+    return mainType.split("+")[1];
+  }
+  return null;
+}
+function isSseContentType(contentType) {
+  if (!contentType) {
+    return false;
+  }
+  let mainType = contentType.trim();
+  const semicolonIndex = mainType.indexOf(";");
+  if (semicolonIndex !== -1) {
+    mainType = mainType.substring(0, semicolonIndex).trim();
+  }
+  mainType = mainType.toLowerCase();
+  return mainType === "text/event-stream";
+}
+function isStreamingContentType(contentType) {
+  return contentType === "application/octet-stream";
+}
+function isSuccessStatusCode(statusCode) {
+  statusCode = Number(statusCode);
+  return statusCode >= 200 && statusCode < 300;
+}
+export {
+  defaults,
+  determineGenericTag,
+  forEachOperation,
+  isSseContentType,
+  isStreamingContentType,
+  isSuccessStatusCode,
+  parseJsonContentType
+};
+//# sourceMappingURL=operation.js.map

package/dist/lib/operation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/operation.ts"],
+  "sourcesContent": ["import type {\n  OpenAPIObject,\n  OperationObject,\n  ParameterObject,\n  ReferenceObject,\n} from 'openapi3-ts/oas31';\nimport { camelcase } from 'stringcase';\n\nexport const defaults: Partial<GenerateSdkConfig> &\n  Required<Pick<GenerateSdkConfig, 'operationId' | 'tag'>> = {\n  operationId: (operation, path, method) => {\n    if (operation.operationId) {\n      return camelcase(operation.operationId);\n    }\n    const metadata = operation['x-oaiMeta'];\n    if (metadata && metadata.name) {\n      return camelcase(metadata.name);\n    }\n    return camelcase(\n      [method, ...path.replace(/[\\\\/\\\\{\\\\}]/g, ' ').split(' ')]\n        .filter(Boolean)\n        .join(' ')\n        .trim(),\n    );\n  },\n  tag: (operation, path) => {\n    return operation.tags?.[0] || determineGenericTag(path, operation);\n  },\n};\n\nexport type TunedOperationObject = OperationObject & {\n  operationId: string;\n  parameters: (ParameterObject | ReferenceObject)[];\n};\n\nexport interface OperationEntry {\n  name?: string;\n  method: string;\n  path: string;\n  groupName: string;\n  tag: string;\n}\nexport type Operation = {\n  entry: OperationEntry;\n  operation: TunedOperationObject;\n};\n\nexport function forEachOperation<T>(\n  config: GenerateSdkConfig,\n  callback: (entry: OperationEntry, operation: TunedOperationObject) => T,\n) {\n  const result: T[] = [];\n  for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {\n    const { parameters = [], ...methods } = pathItem;\n\n    // Convert Express-style routes (:param) to OpenAPI-style routes ({param})\n    const fixedPath = path.replace(/:([^/]+)/g, '{$1}');\n\n    for (const [method, operation] of Object.entries(methods) as [\n      string,\n      OperationObject,\n    ][]) {\n      const formatOperationId = config.operationId ?? defaults.operationId;\n      const formatTag = config.tag ?? defaults.tag;\n      const operationName = formatOperationId(operation, fixedPath, method);\n      const operationTag = formatTag(operation, fixedPath);\n      const metadata = operation['x-oaiMeta'] ?? {};\n      result.push(\n        callback(\n          {\n            name: metadata.name,\n            method,\n            path: fixedPath,\n            groupName: operationTag,\n            tag: operationTag,\n          },\n          {\n            ...operation,\n            parameters: [...parameters, ...(operation.parameters ?? [])],\n            operationId: operationName,\n          },\n        ),\n      );\n    }\n  }\n  return result;\n}\n\nexport interface GenerateSdkConfig {\n  spec: OpenAPIObject;\n  operationId?: (\n    operation: OperationObject,\n    path: string,\n    method: string,\n  ) => string;\n  tag?: (operation: OperationObject, path: string) => string;\n}\n\n// --- Function Definition (determineGenericTag, sanitizeTag, reservedKeywords, commonVerbs) ---\n/**\n * Set of reserved TypeScript keywords and common verbs potentially used as tags.\n */\nconst reservedKeywords = new Set([\n  'abstract',\n  'arguments',\n  'await',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  // Potentially problematic identifiers / Common Verbs used as tags\n  'object',\n  'string',\n  'number',\n  'any',\n  'unknown',\n  'never',\n  'get',\n  'list',\n  'create',\n  'update',\n  'delete',\n  'post',\n  'put',\n  'patch',\n  'do',\n  'send',\n  'add',\n  'remove',\n  'set',\n  'find',\n  'search',\n  'check',\n  'make', // Added make, check\n]);\n\n/**\n * Sanitizes a potential tag name (assumed to be already camelCased)\n * to avoid conflicts with reserved keywords or invalid starting characters (numbers).\n * Appends an underscore if the tag matches a reserved keyword.\n * Prepends an underscore if the tag starts with a number.\n * @param camelCasedTag The potential tag name, already camelCased.\n * @returns The sanitized tag name.\n */\nfunction sanitizeTag(camelCasedTag: string): string {\n  // Prepend underscore if starts with a number\n  if (/^\\d/.test(camelCasedTag)) {\n    return `_${camelCasedTag}`;\n  }\n  // Append underscore if it's a reserved keyword\n  return reservedKeywords.has(camelCasedTag)\n    ? `${camelCasedTag}_`\n    : camelCasedTag;\n}\n\n/**\n * Attempts to determine a generic tag for an OpenAPI operation based on path and operationId.\n * Rules and fallbacks are documented within the code.\n * @param pathString The path string.\n * @param operation The OpenAPI Operation Object.\n * @returns A sanitized, camelCased tag name string.\n */\nexport function determineGenericTag(\n  pathString: string,\n  operation: OperationObject,\n): string {\n  const operationId = operation.operationId || '';\n  const VERSION_REGEX = /^[vV]\\d+$/;\n  const commonVerbs = new Set([\n    // Verbs to potentially strip from operationId prefix\n    'get',\n    'list',\n    'create',\n    'update',\n    'delete',\n    'post',\n    'put',\n    'patch',\n    'do',\n    'send',\n    'add',\n    'remove',\n    'set',\n    'find',\n    'search',\n    'check',\n    'make', // Added make\n  ]);\n\n  const segments = pathString.split('/').filter(Boolean);\n\n  const potentialCandidates = segments.filter(\n    (segment) =>\n      segment &&\n      !segment.startsWith('{') &&\n      !segment.endsWith('}') &&\n      !VERSION_REGEX.test(segment),\n  );\n\n  // --- Heuristic 1: Last non-'@' path segment ---\n  for (let i = potentialCandidates.length - 1; i >= 0; i--) {\n    const segment = potentialCandidates[i];\n    if (!segment.startsWith('@')) {\n      // Sanitize just before returning\n      return sanitizeTag(camelcase(segment));\n    }\n  }\n\n  const canFallbackToPathSegment = potentialCandidates.length > 0;\n\n  // --- Heuristic 2: OperationId parsing ---\n  if (operationId) {\n    const lowerOpId = operationId.toLowerCase();\n    const parts = operationId\n      .replace(/([a-z])([A-Z])/g, '$1_$2')\n      .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')\n      .replace(/([a-zA-Z])(\\d)/g, '$1_$2')\n      .replace(/(\\d)([a-zA-Z])/g, '$1_$2')\n      .toLowerCase()\n      .split(/[_-\\s]+/);\n\n    const validParts = parts.filter(Boolean);\n\n    // Quick skip: If opId is just a verb and we can use Heuristic 3, prefer that.\n    if (\n      commonVerbs.has(lowerOpId) &&\n      validParts.length === 1 &&\n      canFallbackToPathSegment\n    ) {\n      // Proceed directly to Heuristic 3\n    }\n    // Only process if there are valid parts and the quick skip didn't happen\n    else if (validParts.length > 0) {\n      const firstPart = validParts[0];\n      const isFirstPartVerb = commonVerbs.has(firstPart);\n\n      // Case 2a: Starts with verb, has following parts\n      if (isFirstPartVerb && validParts.length > 1) {\n        const verbPrefixLength = firstPart.length;\n        let nextPartStartIndex = -1;\n        if (operationId.length > verbPrefixLength) {\n          // Simplified check for next part start\n          const charAfterPrefix = operationId[verbPrefixLength];\n          if (charAfterPrefix >= 'A' && charAfterPrefix <= 'Z') {\n            nextPartStartIndex = verbPrefixLength;\n          } else if (charAfterPrefix >= '0' && charAfterPrefix <= '9') {\n            nextPartStartIndex = verbPrefixLength;\n          } else if (['_', '-'].includes(charAfterPrefix)) {\n            nextPartStartIndex = verbPrefixLength + 1;\n          } else {\n            const match = operationId\n              .substring(verbPrefixLength)\n              .match(/[A-Z0-9]/);\n            if (match && match.index !== undefined) {\n              nextPartStartIndex = verbPrefixLength + match.index;\n            }\n            if (\n              nextPartStartIndex === -1 &&\n              operationId.length > verbPrefixLength\n            ) {\n              nextPartStartIndex = verbPrefixLength; // Default guess\n            }\n          }\n        }\n\n        if (\n          nextPartStartIndex !== -1 &&\n          nextPartStartIndex < operationId.length\n        ) {\n          const remainingOriginalSubstring =\n            operationId.substring(nextPartStartIndex);\n          const potentialTag = camelcase(remainingOriginalSubstring);\n          if (potentialTag) {\n            // Sanitize just before returning\n            return sanitizeTag(potentialTag);\n          }\n        }\n\n        // Fallback: join remaining lowercased parts\n        const potentialTagJoined = camelcase(validParts.slice(1).join('_'));\n        if (potentialTagJoined) {\n          // Sanitize just before returning\n          return sanitizeTag(potentialTagJoined);\n        }\n      }\n\n      // Case 2b: Doesn't start with verb, or only one part (might be verb)\n      const potentialTagFull = camelcase(operationId);\n      if (potentialTagFull) {\n        const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;\n\n        // Avoid returning only a verb if Heuristic 3 is possible\n        if (!(isResultSingleVerb && canFallbackToPathSegment)) {\n          if (potentialTagFull.length > 0) {\n            // Sanitize just before returning\n            return sanitizeTag(potentialTagFull);\n          }\n        }\n      }\n\n      // Case 2c: Further fallbacks within OpId if above failed/skipped\n      const firstPartCamel = camelcase(firstPart);\n      if (firstPartCamel) {\n        const isFirstPartCamelVerb = commonVerbs.has(firstPartCamel);\n        if (\n          !isFirstPartCamelVerb ||\n          validParts.length === 1 ||\n          !canFallbackToPathSegment\n        ) {\n          // Sanitize just before returning\n          return sanitizeTag(firstPartCamel);\n        }\n      }\n      if (\n        isFirstPartVerb &&\n        validParts.length > 1 &&\n        validParts[1] &&\n        canFallbackToPathSegment\n      ) {\n        const secondPartCamel = camelcase(validParts[1]);\n        if (secondPartCamel) {\n          // Sanitize just before returning\n          return sanitizeTag(secondPartCamel);\n        }\n      }\n    } // End if(validParts.length > 0) after quick skip check\n  } // End if(operationId)\n\n  // --- Heuristic 3: First path segment (stripping '@') ---\n  if (potentialCandidates.length > 0) {\n    let firstCandidate = potentialCandidates[0];\n    if (firstCandidate.startsWith('@')) {\n      firstCandidate = firstCandidate.substring(1);\n    }\n    if (firstCandidate) {\n      // Sanitize just before returning\n      return sanitizeTag(camelcase(firstCandidate));\n    }\n  }\n\n  // --- Heuristic 4: Default ---\n  console.warn(\n    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`,\n  );\n  return 'unknown'; // 'unknown' is safe\n}\n\nexport function parseJsonContentType(contentType: string | null | undefined) {\n  if (!contentType) {\n    return null;\n  }\n\n  // 1. Trim whitespace\n  let mainType = contentType.trim();\n\n  // 2. Remove parameters (anything after the first ';')\n  const semicolonIndex = mainType.indexOf(';');\n  if (semicolonIndex !== -1) {\n    mainType = mainType.substring(0, semicolonIndex).trim(); // Trim potential space before ';'\n  }\n\n  // 3. Convert to lowercase for case-insensitive comparison\n  mainType = mainType.toLowerCase();\n\n  if (mainType.endsWith('/json')) {\n    return mainType.split('/')[1];\n  } else if (mainType.endsWith('+json')) {\n    return mainType.split('+')[1];\n  }\n  return null;\n}\n\n/**\n * Checks if a given content type string represents Server-Sent Events (SSE).\n * Handles case-insensitivity, parameters (like charset), and leading/trailing whitespace.\n *\n * @param contentType The content type string to check (e.g., from a Content-Type header).\n * @returns True if the content type is 'text/event-stream', false otherwise.\n */\nexport function isSseContentType(\n  contentType: string | null | undefined,\n): boolean {\n  if (!contentType) {\n    return false; // Handle null, undefined, or empty string\n  }\n\n  // 1. Trim whitespace from the input string\n  let mainType = contentType.trim();\n\n  // 2. Find the position of the first semicolon (if any) to remove parameters\n  const semicolonIndex = mainType.indexOf(';');\n  if (semicolonIndex !== -1) {\n    // Extract the part before the semicolon and trim potential space\n    mainType = mainType.substring(0, semicolonIndex).trim();\n  }\n\n  // 3. Convert the main type part to lowercase for case-insensitive comparison\n  mainType = mainType.toLowerCase();\n\n  // 4. Compare against the standard SSE MIME type\n  return mainType === 'text/event-stream';\n}\n\nexport function isStreamingContentType(\n  contentType: string | null | undefined,\n): boolean {\n  return contentType === 'application/octet-stream';\n}\n\nexport function isSuccessStatusCode(statusCode: number | string): boolean {\n  statusCode = Number(statusCode);\n  return statusCode >= 200 && statusCode < 300;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test.d.ts.map

package/dist/lib/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/lib/test.ts"],"names":[],"mappings":""}

package/dist/lib/test.js

@@ -0,0 +1,261 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { determineGenericTag } from "./operation.ts";
+const mockOperation = (operationId = "") => ({ operationId });
+describe("determineGenericTag", () => {
+  describe("Heuristic 1: Path-Based Tag Determination", () => {
+    test("should use the last non-parameter, non-version, non-@ segment", () => {
+      assert.strictEqual(
+        determineGenericTag("/users", mockOperation()),
+        "users"
+      );
+      assert.strictEqual(
+        determineGenericTag("/users/{userId}/orders", mockOperation()),
+        "orders"
+      );
+      assert.strictEqual(
+        determineGenericTag("/admin/system/logs", mockOperation()),
+        "logs"
+      );
+    });
+    test("should ignore path parameters", () => {
+      assert.strictEqual(
+        determineGenericTag("/users/{userId}", mockOperation()),
+        "users"
+      );
+      assert.strictEqual(
+        determineGenericTag("/items/{itemId}", mockOperation()),
+        "items"
+      );
+    });
+    test("should ignore version segments", () => {
+      assert.strictEqual(
+        determineGenericTag("/v1/products", mockOperation()),
+        "products"
+      );
+      assert.strictEqual(
+        determineGenericTag("/api/V2/items/{itemId}/details", mockOperation()),
+        "details"
+      );
+      assert.strictEqual(
+        determineGenericTag("/api/resource/v2", mockOperation()),
+        "resource"
+      );
+    });
+    test("should ignore segments starting with @", () => {
+      assert.strictEqual(
+        determineGenericTag("/users/@me", mockOperation()),
+        "users"
+      );
+      assert.strictEqual(
+        determineGenericTag("/users/@me/guilds", mockOperation()),
+        "guilds"
+      );
+      assert.strictEqual(
+        determineGenericTag(
+          "/webhooks/{webhookId}/messages/@original",
+          mockOperation()
+        ),
+        "messages"
+      );
+      assert.strictEqual(
+        determineGenericTag("/@admin/users/{userId}", mockOperation()),
+        "users"
+      );
+      assert.strictEqual(
+        determineGenericTag(
+          "/guilds/{guild_id}/@audit-log/users/@me/settings",
+          mockOperation()
+        ),
+        "settings"
+      );
+      assert.strictEqual(
+        determineGenericTag("/system/tasks/@scheduled-jobs", mockOperation()),
+        "tasks"
+      );
+    });
+    test("should sanitize results matching reserved keywords", () => {
+      assert.strictEqual(
+        determineGenericTag("/api/v1/public", mockOperation()),
+        "public_"
+      );
+      assert.strictEqual(
+        determineGenericTag("/api/case/{id}", mockOperation()),
+        "case_"
+      );
+      assert.strictEqual(
+        determineGenericTag("/permissions/check", mockOperation()),
+        "check_"
+      );
+    });
+    test("should sanitize results starting with numbers", () => {
+      assert.strictEqual(
+        determineGenericTag("/api/2fa/enable", mockOperation()),
+        "enable"
+      );
+    });
+    test("should handle mixed separators via camelcase", () => {
+      assert.strictEqual(
+        determineGenericTag("/user-profiles/{id}", mockOperation()),
+        "userProfiles"
+      );
+    });
+  });
+  describe("Heuristic 2: OperationId Fallback", () => {
+    test("should be used when path has no valid segments (root)", () => {
+      assert.strictEqual(
+        determineGenericTag("/", mockOperation("getRootResource")),
+        "rootResource"
+      );
+      assert.strictEqual(
+        determineGenericTag("/", mockOperation("healthCheck")),
+        "healthCheck"
+      );
+    });
+    test("should be used when path has only params/version segments", () => {
+      assert.strictEqual(
+        determineGenericTag("/v3/{tenantId}/", mockOperation("getTenantRoot")),
+        "tenantRoot"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/{userId}/", mockOperation("listUserItems")),
+        "userItems"
+      );
+    });
+    test("should extract nouns after common verb prefixes", () => {
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("postUserPreferences")),
+        "userPreferences"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("doFoo")),
+        "foo"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("addUser")),
+        "user"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("makePublic")),
+        "public_"
+      );
+    });
+    test("should use the full operationId if no common verb prefix", () => {
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("metrics")),
+        "metrics"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("tenantAdminSettings")),
+        "tenantAdminSettings"
+      );
+    });
+    test("should handle numbers within the operationId correctly", () => {
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("getUser2FAStatus")),
+        "user2FAStatus"
+      );
+      assert.strictEqual(
+        determineGenericTag("/api/", mockOperation("get2FAStatus")),
+        "api"
+      );
+    });
+    test("should sanitize results matching reserved keywords", () => {
+      assert.strictEqual(
+        determineGenericTag("/v1/{id}", mockOperation("delete")),
+        "delete_"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/{id}", mockOperation("createCase")),
+        "case_"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/{id}", mockOperation("get")),
+        "get_"
+      );
+    });
+    test("should use verb if it is the only part and no path fallback", () => {
+      assert.strictEqual(
+        determineGenericTag("/v1/", mockOperation("get")),
+        "get_"
+      );
+      assert.strictEqual(
+        determineGenericTag("/v1/{id}", mockOperation("list")),
+        "list_"
+      );
+    });
+  });
+  describe("Heuristic 3: First Path Segment Fallback", () => {
+    test("should be used when path only has @ segments and no suitable opId", () => {
+      assert.strictEqual(
+        determineGenericTag("/@system/@status", mockOperation()),
+        "system"
+      );
+      assert.strictEqual(
+        determineGenericTag("/@audit-log/@entries", mockOperation()),
+        "auditLog"
+      );
+    });
+    test("should be used when opId fallback yields only a common verb", () => {
+      assert.strictEqual(
+        determineGenericTag("/@system/@status", mockOperation("get")),
+        "system"
+      );
+    });
+    test("should strip leading @ before using segment", () => {
+      assert.strictEqual(
+        determineGenericTag("/@system/@status", mockOperation()),
+        "system"
+      );
+    });
+    test("should sanitize results matching reserved keywords", () => {
+      assert.strictEqual(
+        determineGenericTag("/@public/@data", mockOperation()),
+        "public_"
+      );
+    });
+    test("should sanitize results starting with numbers", () => {
+      assert.strictEqual(
+        determineGenericTag("/@2fa/@status", mockOperation()),
+        "_2fa"
+      );
+    });
+  });
+  describe("Heuristic Priority", () => {
+    test("Path (Heuristic 1) should take priority over OperationId (Heuristic 2)", () => {
+      const tag = determineGenericTag(
+        "/users/{id}/permissions/check",
+        // Path -> 'check' -> sanitized 'check_'
+        mockOperation("verifyPermissions")
+        // opId -> 'permissions'
+      );
+      assert.strictEqual(tag, "check_");
+    });
+    test("OperationId (Heuristic 2) should take priority over First Path Segment (Heuristic 3)", () => {
+      const tag = determineGenericTag(
+        "/@system/@status",
+        mockOperation("getSystemStatus")
+      );
+      assert.strictEqual(tag, "systemStatus");
+    });
+    test("First Path Segment (Heuristic 3) is used if OperationId is skipped (verb-only)", () => {
+      const tag = determineGenericTag("/@system/@status", mockOperation("get"));
+      assert.strictEqual(tag, "system");
+    });
+  });
+  describe("Heuristic 4: Unknown Fallback", () => {
+    test('should return "unknown" when no path segments and no operationId', () => {
+      assert.strictEqual(determineGenericTag("/", mockOperation()), "unknown");
+    });
+    test('should return "unknown" when path has only params/version and no operationId', () => {
+      assert.strictEqual(
+        determineGenericTag("/v3/{tenantId}/", mockOperation()),
+        "unknown"
+      );
+    });
+    test('should return "unknown" for empty path string', () => {
+      assert.strictEqual(determineGenericTag("", mockOperation()), "unknown");
+    });
+  });
+});
+//# sourceMappingURL=test.js.map

package/dist/lib/test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/test.ts"],
+  "sourcesContent": ["import assert from 'node:assert/strict';\nimport { describe, test } from 'node:test';\nimport type { OperationObject } from 'openapi3-ts/oas31';\n\nimport { determineGenericTag } from './operation.ts';\n\nconst mockOperation = (operationId = ''): OperationObject => ({ operationId });\n\ndescribe('determineGenericTag', () => {\n  describe('Heuristic 1: Path-Based Tag Determination', () => {\n    test('should use the last non-parameter, non-version, non-@ segment', () => {\n      assert.strictEqual(\n        determineGenericTag('/users', mockOperation()),\n        'users',\n      );\n      assert.strictEqual(\n        determineGenericTag('/users/{userId}/orders', mockOperation()),\n        'orders',\n      );\n      assert.strictEqual(\n        determineGenericTag('/admin/system/logs', mockOperation()),\n        'logs',\n      );\n    });\n\n    test('should ignore path parameters', () => {\n      assert.strictEqual(\n        determineGenericTag('/users/{userId}', mockOperation()),\n        'users',\n      );\n      assert.strictEqual(\n        determineGenericTag('/items/{itemId}', mockOperation()),\n        'items',\n      );\n    });\n\n    test('should ignore version segments', () => {\n      assert.strictEqual(\n        determineGenericTag('/v1/products', mockOperation()),\n        'products',\n      );\n      assert.strictEqual(\n        determineGenericTag('/api/V2/items/{itemId}/details', mockOperation()),\n        'details',\n      );\n      assert.strictEqual(\n        determineGenericTag('/api/resource/v2', mockOperation()),\n        'resource',\n      );\n    });\n\n    test('should ignore segments starting with @', () => {\n      assert.strictEqual(\n        determineGenericTag('/users/@me', mockOperation()),\n        'users',\n      );\n      assert.strictEqual(\n        determineGenericTag('/users/@me/guilds', mockOperation()),\n        'guilds',\n      );\n      assert.strictEqual(\n        determineGenericTag(\n          '/webhooks/{webhookId}/messages/@original',\n          mockOperation(),\n        ),\n        'messages',\n      );\n      assert.strictEqual(\n        determineGenericTag('/@admin/users/{userId}', mockOperation()),\n        'users',\n      );\n      assert.strictEqual(\n        determineGenericTag(\n          '/guilds/{guild_id}/@audit-log/users/@me/settings',\n          mockOperation(),\n        ),\n        'settings',\n      );\n      assert.strictEqual(\n        determineGenericTag('/system/tasks/@scheduled-jobs', mockOperation()),\n        'tasks',\n      );\n    });\n\n    test('should sanitize results matching reserved keywords', () => {\n      assert.strictEqual(\n        determineGenericTag('/api/v1/public', mockOperation()),\n        'public_',\n      );\n      assert.strictEqual(\n        determineGenericTag('/api/case/{id}', mockOperation()),\n        'case_',\n      );\n      assert.strictEqual(\n        determineGenericTag('/permissions/check', mockOperation()),\n        'check_',\n      );\n    });\n\n    test('should sanitize results starting with numbers', () => {\n      // FIX: Expectation changed - last valid segment is 'enable'\n      assert.strictEqual(\n        determineGenericTag('/api/2fa/enable', mockOperation()),\n        'enable',\n      );\n    });\n\n    test('should handle mixed separators via camelcase', () => {\n      assert.strictEqual(\n        determineGenericTag('/user-profiles/{id}', mockOperation()),\n        'userProfiles',\n      );\n    });\n  });\n\n  describe('Heuristic 2: OperationId Fallback', () => {\n    test('should be used when path has no valid segments (root)', () => {\n      assert.strictEqual(\n        determineGenericTag('/', mockOperation('getRootResource')),\n        'rootResource',\n      );\n      // FIX: Expectation changed - 'healthCheck' is not reserved\n      assert.strictEqual(\n        determineGenericTag('/', mockOperation('healthCheck')),\n        'healthCheck',\n      );\n    });\n\n    test('should be used when path has only params/version segments', () => {\n      assert.strictEqual(\n        determineGenericTag('/v3/{tenantId}/', mockOperation('getTenantRoot')),\n        'tenantRoot',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/{userId}/', mockOperation('listUserItems')),\n        'userItems',\n      );\n    });\n\n    test('should extract nouns after common verb prefixes', () => {\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('postUserPreferences')),\n        'userPreferences',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('doFoo')),\n        'foo',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('addUser')),\n        'user',\n      );\n      // FIX: Added 'make' to commonVerbs\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('makePublic')),\n        'public_',\n      );\n    });\n\n    test('should use the full operationId if no common verb prefix', () => {\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('metrics')),\n        'metrics',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('tenantAdminSettings')),\n        'tenantAdminSettings',\n      );\n    });\n\n    test('should handle numbers within the operationId correctly', () => {\n      // FIX: Expectation aligned with stringcase behavior\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('getUser2FAStatus')),\n        'user2FAStatus',\n      );\n      assert.strictEqual(\n        determineGenericTag('/api/', mockOperation('get2FAStatus')),\n        'api',\n      ); // Sanitized (starts with number after verb removal)\n    });\n\n    test('should sanitize results matching reserved keywords', () => {\n      assert.strictEqual(\n        determineGenericTag('/v1/{id}', mockOperation('delete')),\n        'delete_',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/{id}', mockOperation('createCase')),\n        'case_',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/{id}', mockOperation('get')),\n        'get_',\n      );\n    });\n\n    test('should use verb if it is the only part and no path fallback', () => {\n      assert.strictEqual(\n        determineGenericTag('/v1/', mockOperation('get')),\n        'get_',\n      );\n      assert.strictEqual(\n        determineGenericTag('/v1/{id}', mockOperation('list')),\n        'list_',\n      );\n    });\n  });\n\n  describe('Heuristic 3: First Path Segment Fallback', () => {\n    test('should be used when path only has @ segments and no suitable opId', () => {\n      assert.strictEqual(\n        determineGenericTag('/@system/@status', mockOperation()),\n        'system',\n      );\n      assert.strictEqual(\n        determineGenericTag('/@audit-log/@entries', mockOperation()),\n        'auditLog',\n      );\n    });\n\n    test('should be used when opId fallback yields only a common verb', () => {\n      assert.strictEqual(\n        determineGenericTag('/@system/@status', mockOperation('get')),\n        'system',\n      );\n    });\n\n    test('should strip leading @ before using segment', () => {\n      assert.strictEqual(\n        determineGenericTag('/@system/@status', mockOperation()),\n        'system',\n      );\n    });\n\n    test('should sanitize results matching reserved keywords', () => {\n      assert.strictEqual(\n        determineGenericTag('/@public/@data', mockOperation()),\n        'public_',\n      );\n    });\n\n    test('should sanitize results starting with numbers', () => {\n      assert.strictEqual(\n        determineGenericTag('/@2fa/@status', mockOperation()),\n        '_2fa',\n      );\n    });\n  });\n\n  describe('Heuristic Priority', () => {\n    test('Path (Heuristic 1) should take priority over OperationId (Heuristic 2)', () => {\n      const tag = determineGenericTag(\n        '/users/{id}/permissions/check', // Path -> 'check' -> sanitized 'check_'\n        mockOperation('verifyPermissions'), // opId -> 'permissions'\n      );\n      assert.strictEqual(tag, 'check_');\n    });\n\n    test('OperationId (Heuristic 2) should take priority over First Path Segment (Heuristic 3)', () => {\n      const tag = determineGenericTag(\n        '/@system/@status',\n        mockOperation('getSystemStatus'),\n      );\n      assert.strictEqual(tag, 'systemStatus');\n    });\n\n    test('First Path Segment (Heuristic 3) is used if OperationId is skipped (verb-only)', () => {\n      const tag = determineGenericTag('/@system/@status', mockOperation('get'));\n      assert.strictEqual(tag, 'system');\n    });\n  });\n\n  describe('Heuristic 4: Unknown Fallback', () => {\n    test('should return \"unknown\" when no path segments and no operationId', () => {\n      assert.strictEqual(determineGenericTag('/', mockOperation()), 'unknown');\n    });\n\n    test('should return \"unknown\" when path has only params/version and no operationId', () => {\n      assert.strictEqual(\n        determineGenericTag('/v3/{tenantId}/', mockOperation()),\n        'unknown',\n      );\n    });\n\n    test('should return \"unknown\" for empty path string', () => {\n      assert.strictEqual(determineGenericTag('', mockOperation()), 'unknown');\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": []
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sdk-it/spec",
+  "version": "0.17.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/lib/*",
+      "import": "./dist/lib/*",
+      "default": "./dist/lib/*"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "openapi3-ts": "4.4.0",
+    "yaml": "^2.7.0",
+    "stringcase": "^4.3.1"
+  }
+}