@ng-openapi/http-resource 0.1.3 → 0.2.1-pr-130-feat-npm-package-scaffold-0a3f1ed.0

package/index.cjs

@@ -36,7 +36,239 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/http-resource.generator.ts
-var import_ts_morph = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
+
+// ../../shared/src/errors.ts
+var NG_OPENAPI_ERROR_BRAND = "__ngOpenApiError";
+var ERROR_LINEAGE = /* @__PURE__ */ new WeakMap();
+var FALLBACK_LINEAGE = Object.freeze([
+  "NgOpenApiError"
+]);
+function registerError(cls, lineage) {
+  ERROR_LINEAGE.set(cls, Object.freeze([
+    ...lineage
+  ]));
+  return cls;
+}
+__name(registerError, "registerError");
+function inheritedLineage(cls) {
+  for (let current = cls; typeof current === "function"; current = Object.getPrototypeOf(current)) {
+    const lineage = ERROR_LINEAGE.get(current);
+    if (lineage) {
+      return lineage;
+    }
+  }
+  return FALLBACK_LINEAGE;
+}
+__name(inheritedLineage, "inheritedLineage");
+var NgOpenApiError = class extends Error {
+  static {
+    __name(this, "NgOpenApiError");
+  }
+  /** The underlying error that caused this one, when there is one. */
+  cause;
+  constructor(message, cause) {
+    super(message);
+    const lineage = inheritedLineage(new.target);
+    this.name = lineage[0];
+    this.cause = cause;
+    Object.defineProperty(this, NG_OPENAPI_ERROR_BRAND, {
+      value: lineage,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  /**
+   * `message` and `name` are non-enumerable on Error, so the default
+   * JSON.stringify dropped both — the least useful possible serialization for
+   * something that exists to be logged.
+   *
+   * The payload is spread rather than enumerated: `source`, `issues`,
+   * `operation`, `names` and `placeholders` are why these classes are typed
+   * in the first place, and listing fields by hand silently drops whichever
+   * ones a later subclass adds.
+   */
+  toJSON() {
+    const cause = this.cause instanceof Error ? this.cause.message : this.cause;
+    return {
+      name: this.name,
+      message: this.message,
+      ...cause === void 0 ? {} : {
+        cause
+      },
+      // Own enumerable properties: the brand is deliberately not one.
+      ...Object.fromEntries(Object.entries(this).filter(([key]) => key !== "cause"))
+    };
+  }
+  /**
+   * Recognizes branded errors from another bundled copy of this module, so
+   * `error instanceof SpecLoadError` works for a plugin-thrown error too.
+   * The prototype chain is checked first, so a caller's own subclass of these
+   * classes still matches even though it carries no lineage entry.
+   *
+   * Never throws and never runs foreign code: both reflective reads sit
+   * inside the try, because a Proxy traps `getPrototypeOf` just as readily as
+   * `getOwnPropertyDescriptor`.
+   */
+  static [Symbol.hasInstance](value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    try {
+      if (Object.prototype.isPrototypeOf.call(this.prototype, value)) {
+        return true;
+      }
+      const expected = ERROR_LINEAGE.get(this)?.[0];
+      if (expected === void 0) {
+        return false;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(value, NG_OPENAPI_ERROR_BRAND);
+      if (!descriptor || descriptor.enumerable || !("value" in descriptor)) {
+        return false;
+      }
+      return Array.isArray(descriptor.value) && descriptor.value.includes(expected);
+    } catch {
+      return false;
+    }
+  }
+};
+registerError(NgOpenApiError, [
+  "NgOpenApiError"
+]);
+var SpecLoadError = class extends NgOpenApiError {
+  static {
+    __name(this, "SpecLoadError");
+  }
+  /** The file path or URL that failed to load. */
+  source;
+  constructor(message, source, cause) {
+    super(message, cause);
+    this.source = source;
+  }
+};
+registerError(SpecLoadError, [
+  "SpecLoadError",
+  "NgOpenApiError"
+]);
+var SpecParseError = class extends NgOpenApiError {
+  static {
+    __name(this, "SpecParseError");
+  }
+  /** The file path or URL the content came from, when known. */
+  source;
+  constructor(message, source, cause) {
+    super(message, cause);
+    this.source = source;
+  }
+};
+registerError(SpecParseError, [
+  "SpecParseError",
+  "NgOpenApiError"
+]);
+function describeOperation(operation) {
+  const location = `(${operation.method}) ${operation.path}`;
+  return operation.operationId ? `${operation.operationId} (${location})` : location;
+}
+__name(describeOperation, "describeOperation");
+function captureOperation(operation) {
+  return Object.freeze({
+    operationId: operation.operationId,
+    method: operation.method,
+    path: operation.path
+  });
+}
+__name(captureOperation, "captureOperation");
+var InvalidIdentifierError = class extends NgOpenApiError {
+  static {
+    __name(this, "InvalidIdentifierError");
+  }
+  /** The rejected name, verbatim; absent when no name could be derived. */
+  identifier;
+  /** The operation whose name was being derived. */
+  operation;
+  constructor(message, operation, identifier) {
+    super(message);
+    this.operation = captureOperation(operation);
+    this.identifier = identifier;
+  }
+};
+registerError(InvalidIdentifierError, [
+  "InvalidIdentifierError",
+  "NgOpenApiError"
+]);
+var DuplicateGeneratedNameError = class extends NgOpenApiError {
+  static {
+    __name(this, "DuplicateGeneratedNameError");
+  }
+  /** The colliding generated names. */
+  names;
+  /** The operations that produced them, when known. */
+  operations;
+  constructor(message, names, operations = []) {
+    super(message);
+    this.names = Object.freeze([
+      ...names
+    ]);
+    this.operations = Object.freeze(operations.map(captureOperation));
+  }
+};
+registerError(DuplicateGeneratedNameError, [
+  "DuplicateGeneratedNameError",
+  "NgOpenApiError"
+]);
+var UnresolvedPathTemplateError = class extends NgOpenApiError {
+  static {
+    __name(this, "UnresolvedPathTemplateError");
+  }
+  /** The path as written in the spec. */
+  path;
+  /** Placeholder names with no declared parameter. */
+  placeholders;
+  constructor(message, path3, placeholders) {
+    super(message);
+    this.path = path3;
+    this.placeholders = Object.freeze([
+      ...placeholders
+    ]);
+  }
+};
+registerError(UnresolvedPathTemplateError, [
+  "UnresolvedPathTemplateError",
+  "NgOpenApiError"
+]);
+var ConfigValidationError = class extends NgOpenApiError {
+  static {
+    __name(this, "ConfigValidationError");
+  }
+  issues;
+  constructor(issues) {
+    super(`Invalid ng-openapi configuration:
+${issues.map((issue) => `  - ${issue}`).join("\n")}`);
+    this.issues = Object.freeze([
+      ...issues
+    ]);
+  }
+};
+registerError(ConfigValidationError, [
+  "ConfigValidationError",
+  "NgOpenApiError"
+]);
+var ConfigLoadError = class extends NgOpenApiError {
+  static {
+    __name(this, "ConfigLoadError");
+  }
+  /** Path of the config file that failed to load. */
+  source;
+  constructor(message, source, cause) {
+    super(message, cause);
+    this.source = source;
+  }
+};
+registerError(ConfigLoadError, [
+  "ConfigLoadError",
+  "NgOpenApiError"
+]);
 
 // ../../../node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -2741,19 +2973,75 @@ var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
 // ../../shared/src/utils/string.utils.ts
+var IDENTIFIER_SEPARATORS = /(?:_|[^\p{ID_Continue}$])+(.)?/gu;
+var INVALID_IDENTIFIER_START = /^[^\p{ID_Start}$_]/u;
+function toIdentifier(converted) {
+  if (converted === "") {
+    return "_";
+  }
+  return converted.replace(INVALID_IDENTIFIER_START, (char) => `_${char}`);
+}
+__name(toIdentifier, "toIdentifier");
+function isValidIdentifier(name) {
+  return /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(name);
+}
+__name(isValidIdentifier, "isValidIdentifier");
 function camelCase(str2) {
-  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toLowerCase());
+  const converted = str2.replace(IDENTIFIER_SEPARATORS, (_, char) => char ? char.toUpperCase() : "").replace(/^./u, (char) => char.toLowerCase());
+  return toIdentifier(converted);
 }
 __name(camelCase, "camelCase");
 function pascalCase(str2) {
-  return str2.replace(/[-_.\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toUpperCase());
+  const converted = str2.replace(IDENTIFIER_SEPARATORS, (_, char) => char ? char.toUpperCase() : "").replace(/^./u, (char) => char.toUpperCase());
+  return toIdentifier(converted);
 }
 __name(pascalCase, "pascalCase");
 function pascalCaseForEnums(str2) {
-  return str2.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
+  const converted = str2.replace(/[^a-zA-Z0-9]/g, "_").replace(/(?:^|_)([a-z])/g, (_, char) => char.toUpperCase()).replace(/^([0-9])/, "_$1");
+  return converted === "" ? "_" : converted;
 }
 __name(pascalCaseForEnums, "pascalCaseForEnums");
 
+// ../../shared/src/utils/content-types.constants.ts
+var CONTENT_TYPES = {
+  MULTIPART: "multipart/form-data",
+  FORM_URLENCODED: "application/x-www-form-urlencoded",
+  JSON: "application/json"
+};
+
+// ../../shared/src/emit/literal.emit.ts
+function quoteLiteral(value) {
+  return `'${escapeSingleQuoted(value)}'`;
+}
+__name(quoteLiteral, "quoteLiteral");
+function escapeSingleQuoted(value) {
+  return value.replace(/[\\']/g, (char) => `\\${char}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+__name(escapeSingleQuoted, "escapeSingleQuoted");
+function escapeTemplateLiteral(value) {
+  return value.replace(/[\\`]/g, (char) => `\\${char}`).replace(/\$\{/g, "\\${").replace(/\r/g, "\\r");
+}
+__name(escapeTemplateLiteral, "escapeTemplateLiteral");
+function emitObjectKey(name, quoteStyle = "double") {
+  const quoted = quoteStyle === "single" ? quoteLiteral(name) : `"${escapeDoubleQuoted(name)}"`;
+  return name === "__proto__" ? `[${quoted}]` : quoted;
+}
+__name(emitObjectKey, "emitObjectKey");
+function escapeDoubleQuoted(value) {
+  return value.replace(/[\\"]/g, (char) => `\\${char}`).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+__name(escapeDoubleQuoted, "escapeDoubleQuoted");
+function escapeJsDoc(text) {
+  return text.replace(/\*\//g, "*\\/");
+}
+__name(escapeJsDoc, "escapeJsDoc");
+function emitDocs(description) {
+  return typeof description === "string" && description ? [
+    escapeJsDoc(description)
+  ] : void 0;
+}
+__name(emitDocs, "emitDocs");
+
 // ../../shared/src/utils/functions/class-names.ts
 function decorate(base, defaultSuffix, naming) {
   return `${naming?.prefix ?? ""}${base}${naming?.suffix ?? defaultSuffix}`;
@@ -2796,7 +3084,7 @@ function getTypeScriptType(schemaOrType, config, formatOrNullable, isNullable, c
   switch (schema2.type) {
     case "string":
       if (schema2.enum) {
-        return schema2.enum.map((value) => typeof value === "string" ? `'${escapeString2(value)}'` : String(value)).join(" | ");
+        return schema2.enum.map((value) => typeof value === "string" ? `'${escapeSingleQuoted(value)}'` : String(value)).join(" | ");
       }
       if (schema2.format === "date" || schema2.format === "date-time") {
         const dateType = config.options.dateType === "Date" ? "Date" : "string";
@@ -2832,10 +3120,6 @@ function nullableType(type2, isNullable) {
   return type2 + (isNullable ? " | null" : "");
 }
 __name(nullableType, "nullableType");
-function escapeString2(str2) {
-  return str2.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-__name(escapeString2, "escapeString");
 
 // ../../shared/src/utils/functions/extract-swagger-response-type.ts
 function getResponseTypeFromResponse(response, responseTypeMapping) {
@@ -2984,7 +3268,7 @@ __name(getResponseType, "getResponseType");
 
 // ../../shared/src/emit/headers.emit.ts
 function emitDefaultHeadersMerge(optionsExpression, customHeaders) {
-  const defaultsLiteral = Object.entries(customHeaders).map(([key, value]) => `'${key}': '${value}'`).join(", ");
+  const defaultsLiteral = Object.entries(customHeaders).map(([key, value]) => `${emitObjectKey(key, "single")}: ${quoteLiteral(value)}`).join(", ");
   return `
 // Add default headers if not already present
 let headers = ${optionsExpression}?.headers;
@@ -2996,12 +3280,238 @@ ${emitDefaultHeaderGuards(customHeaders)}
 }
 __name(emitDefaultHeadersMerge, "emitDefaultHeadersMerge");
 function emitDefaultHeaderGuards(customHeaders) {
-  return Object.entries(customHeaders).map(([key, value]) => `if (!headers.has('${key}')) {
-  headers = headers.set('${key}', '${value}');
-}`).join("\n");
+  return Object.entries(customHeaders).map(([key, value]) => {
+    const name = quoteLiteral(key);
+    return `if (!headers.has(${name})) {
+  headers = headers.set(${name}, ${quoteLiteral(value)});
+}`;
+  }).join("\n");
 }
 __name(emitDefaultHeaderGuards, "emitDefaultHeaderGuards");
 
+// ../../shared/src/utils/functions/get-request-body-type.ts
+function getRequestBodyType(requestBody, config) {
+  const content = requestBody.content || {};
+  const jsonContent = content[CONTENT_TYPES.JSON];
+  if (jsonContent?.schema) {
+    return getTypeScriptType(jsonContent.schema, config, jsonContent.schema.nullable);
+  }
+  return "any";
+}
+__name(getRequestBodyType, "getRequestBodyType");
+
+// ../../shared/src/utils/functions/is-data-type-interface.ts
+function isDataTypeInterface(type2) {
+  const invalidTypes = [
+    "any",
+    "File",
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "unknown",
+    "[]",
+    "Array"
+  ];
+  return !invalidTypes.some((invalidType) => type2.includes(invalidType));
+}
+__name(isDataTypeInterface, "isDataTypeInterface");
+
+// ../../shared/src/utils/functions/argument-names.ts
+var RESERVED_WORDS = [
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+];
+var SERVICE_ARGUMENT_PROFILE = Object.freeze({
+  reserved: Object.freeze([
+    "observe",
+    "options",
+    "url",
+    "params",
+    "headers",
+    "formData",
+    "formBody"
+  ]),
+  bindsRequestBody: true
+});
+var RESOURCE_ARGUMENT_PROFILE = Object.freeze({
+  reserved: Object.freeze([
+    "resourceOptions",
+    "requestOptions",
+    "params",
+    "headers"
+  ]),
+  bindsRequestBody: false
+});
+var REQUEST_BODY_KEY = /* @__PURE__ */ Symbol("requestBody");
+function resolveArgumentNames(operation, config, profile) {
+  let byConfig = RESOLVED.get(operation);
+  if (!byConfig) {
+    byConfig = /* @__PURE__ */ new WeakMap();
+    RESOLVED.set(operation, byConfig);
+  }
+  let byProfile = byConfig.get(config);
+  if (!byProfile) {
+    byProfile = /* @__PURE__ */ new WeakMap();
+    byConfig.set(config, byProfile);
+  }
+  const cached = byProfile.get(profile);
+  if (cached) {
+    return cached;
+  }
+  const resolved = computeArgumentNames(operation, config, profile);
+  byProfile.set(profile, resolved);
+  return resolved;
+}
+__name(resolveArgumentNames, "resolveArgumentNames");
+var RESOLVED = /* @__PURE__ */ new WeakMap();
+function computeArgumentNames(operation, config, profile) {
+  const entries = [
+    ...operation.pathParams.map((param) => ({
+      key: param.name,
+      base: camelCase(param.name)
+    })),
+    ...operation.formDataFields.map((field) => ({
+      key: field,
+      base: camelCase(field)
+    })),
+    ...operation.urlEncodedFields.map((field) => ({
+      key: field,
+      base: camelCase(field)
+    }))
+  ];
+  const bodyBase = profile.bindsRequestBody ? jsonBodyIdentifier(operation, config) : void 0;
+  if (bodyBase !== void 0) {
+    entries.push({
+      key: REQUEST_BODY_KEY,
+      base: bodyBase
+    });
+  }
+  entries.push(...operation.queryParams.map((param) => ({
+    key: param.name,
+    base: camelCase(param.name)
+  })));
+  const identifiers = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set([
+    ...profile.reserved,
+    ...RESERVED_WORDS
+  ]);
+  const renamed2 = [];
+  const merged = /* @__PURE__ */ new Set();
+  for (const { key, base } of entries) {
+    if (identifiers.has(key)) {
+      if (typeof key === "string") {
+        merged.add(key);
+      }
+      continue;
+    }
+    let identifier = base;
+    let suffix = 2;
+    while (used.has(identifier)) {
+      identifier = `${base}${suffix}`;
+      suffix++;
+    }
+    if (identifier !== base) {
+      renamed2.push(Object.freeze({
+        source: typeof key === "string" ? key : base,
+        identifier
+      }));
+    }
+    used.add(identifier);
+    identifiers.set(key, identifier);
+  }
+  return {
+    // The fallback runs the *same* rules the resolver would have, rather
+    // than a bare camelCase: an unregistered wire name otherwise came back
+    // as `class` or `options`, names the resolver never assigns.
+    // Uniquified against everything already assigned, not just the reserved
+    // words: an unregistered wire name that camelCases onto an identifier
+    // this operation already bound would otherwise alias it — compiling
+    // fine and sending the wrong value. Only reachable for operations built
+    // outside the normalizer, but the resolver is public API.
+    of: /* @__PURE__ */ __name((wireName) => identifiers.get(wireName) ?? deriveLocalName(camelCase(wireName), [
+      ...used
+    ]), "of"),
+    body: identifiers.get(REQUEST_BODY_KEY),
+    all: Object.freeze([
+      ...identifiers.values()
+    ]),
+    renamed: Object.freeze(renamed2),
+    merged: Object.freeze([
+      ...merged
+    ])
+  };
+}
+__name(computeArgumentNames, "computeArgumentNames");
+function jsonBodyIdentifier(operation, config) {
+  if (!operation.requestBody || operation.isMultipart) {
+    return void 0;
+  }
+  if (!operation.requestBody.content?.[CONTENT_TYPES.JSON]) {
+    return void 0;
+  }
+  const bodyType = getRequestBodyType(operation.requestBody, config);
+  return isDataTypeInterface(bodyType) ? camelCase(bodyType) : "requestBody";
+}
+__name(jsonBodyIdentifier, "jsonBodyIdentifier");
+function deriveLocalName(base, taken) {
+  const used = new Set(taken);
+  let name = base;
+  let suffix = 2;
+  while (used.has(name)) {
+    name = `${base}${suffix}`;
+    suffix++;
+  }
+  return name;
+}
+__name(deriveLocalName, "deriveLocalName");
+
 // ../../shared/src/emit/url.emit.ts
 function plainParamValue(identifier) {
   return identifier;
@@ -3011,24 +3521,34 @@ function signalAwareParamValue(identifier) {
   return `typeof ${identifier} === 'function' ? ${identifier}() : ${identifier}`;
 }
 __name(signalAwareParamValue, "signalAwareParamValue");
-function emitUrlExpression(path3, pathParams, paramValue = plainParamValue) {
-  let urlExpression = `\`\${this.basePath}${path3}\``;
+function emitUrlExpression(path3, pathParams, argumentNames, paramValue = plainParamValue) {
+  const declared = new Set(pathParams.map((param) => param.name));
+  const unresolved = (path3.match(/{([^{}]*)}/g) ?? []).map((placeholder) => placeholder.slice(1, -1)).filter((name) => !declared.has(name));
+  if (unresolved.length > 0) {
+    throw new UnresolvedPathTemplateError(`Path "${path3}" declares no parameter for ${unresolved.map((name) => `{${name}}`).join(", ")}. Declare each placeholder as a path parameter, or remove it from the path.`, path3, unresolved);
+  }
+  let urlExpression = "`${this.basePath}" + escapeTemplateLiteral(path3) + "`";
   pathParams.forEach((param) => {
-    urlExpression = urlExpression.replace(`{${param.name}}`, `\${${paramValue(camelCase(param.name))}}`);
+    const replacement = "${" + paramValue(argumentNames.of(param.name)) + "}";
+    urlExpression = urlExpression.split(`{${escapeTemplateLiteral(param.name)}}`).join(replacement);
   });
   return urlExpression;
 }
 __name(emitUrlExpression, "emitUrlExpression");
 
 // ../../shared/src/emit/query-params.emit.ts
-function emitSignalAwareQueryParams(queryParams) {
+function emitSignalAwareQueryParams(queryParams, argumentNames) {
   if (queryParams.length === 0) {
     return "";
   }
-  const paramMappings = queryParams.map((param) => `const ${camelCase(param.name)}Value = ${signalAwareParamValue(camelCase(param.name))};
-                if (${camelCase(param.name)}Value != null) {
-                    params = HttpParamsBuilder.addToHttpParams(params, ${camelCase(param.name)}Value, '${param.name}');
-                }`).join("\n");
+  const paramMappings = queryParams.map((param) => {
+    const identifier = argumentNames.of(param.name);
+    const local = deriveLocalName(`${identifier}Value`, argumentNames.all);
+    return `const ${local} = ${signalAwareParamValue(identifier)};
+                if (${local} != null) {
+                    params = HttpParamsBuilder.addToHttpParams(params, ${local}, ${quoteLiteral(param.name)});
+                }`;
+  }).join("\n");
   return `
 let params = new HttpParams();
 ${paramMappings}`;
@@ -3064,7 +3584,11 @@ function joinRequestOptionEntries(entries) {
 }
 __name(joinRequestOptionEntries, "joinRequestOptionEntries");
 
+// ../../shared/src/emit/text-file.emit.ts
+var import_ts_morph = require("ts-morph");
+
 // ../../shared/src/utils/project.utils.ts
+var import_ts_morph2 = require("ts-morph");
 function listGeneratedFileNames(project, directoryPath, suffix) {
   const directory = project.getDirectory(directoryPath);
   if (!directory) {
@@ -3075,22 +3599,149 @@ function listGeneratedFileNames(project, directoryPath, suffix) {
 __name(listGeneratedFileNames, "listGeneratedFileNames");
 
 // ../../shared/src/utils/functions/token-names.ts
-function getClientContextTokenName(clientName = "default") {
-  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+function effectiveClientName(clientName) {
+  return clientName ? clientName : "default";
+}
+__name(effectiveClientName, "effectiveClientName");
+function tokenSuffix(clientName) {
+  return effectiveClientName(clientName).toUpperCase().replace(/[^A-Z0-9]/g, "_");
+}
+__name(tokenSuffix, "tokenSuffix");
+function getClientContextTokenName(clientName) {
+  const clientSuffix = tokenSuffix(clientName);
   return `CLIENT_CONTEXT_TOKEN_${clientSuffix}`;
 }
 __name(getClientContextTokenName, "getClientContextTokenName");
-function getBasePathTokenName(clientName = "default") {
-  const clientSuffix = clientName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+function getBasePathTokenName(clientName) {
+  const clientSuffix = tokenSuffix(clientName);
   return `BASE_PATH_${clientSuffix}`;
 }
 __name(getBasePathTokenName, "getBasePathTokenName");
 
-// ../../shared/src/utils/functions/duplicate-function-name.ts
-function hasDuplicateFunctionNames(arr) {
-  return new Set(arr.map((fn) => fn.getName())).size !== arr.length;
+// ../../shared/src/utils/functions/controller-groups.ts
+function groupOperationsByController(operations, onWarning) {
+  const groups = {};
+  const controllerByFold = /* @__PURE__ */ new Map();
+  const tagSpellings = /* @__PURE__ */ new Map();
+  const namelessTags = /* @__PURE__ */ new Set();
+  operations.forEach((operation) => {
+    const tag = operation.tags?.[0];
+    let rawName = "Default";
+    if (tag !== void 0) {
+      rawName = tag;
+    } else {
+      const pathParts = operation.path.split("/").filter((part) => part && !part.startsWith("{"));
+      if (pathParts.length > 1) {
+        rawName = pathParts[1];
+      }
+    }
+    const sanitized = pascalCase(rawName);
+    const isNameless = !/\p{L}/u.test(sanitized);
+    const candidate = isNameless ? "Default" : sanitized;
+    const fold = candidate.toLowerCase();
+    const controllerName = controllerByFold.get(fold) ?? candidate;
+    controllerByFold.set(fold, controllerName);
+    if (tag !== void 0 && isNameless) {
+      namelessTags.add(tag);
+    } else if (tag !== void 0) {
+      const spellings = tagSpellings.get(controllerName) ?? /* @__PURE__ */ new Set();
+      spellings.add(tag);
+      tagSpellings.set(controllerName, spellings);
+    }
+    if (!groups[controllerName]) {
+      groups[controllerName] = [];
+    }
+    groups[controllerName].push(operation);
+  });
+  for (const tag of namelessTags) {
+    onWarning?.(`Tag "${tag}" contains no characters usable in a name \u2014 its operations are generated into the "Default" controller. Rename the tag to give them a file of their own.`);
+  }
+  for (const [controllerName, spellings] of tagSpellings) {
+    if (spellings.size > 1) {
+      onWarning?.(`Tags ${[
+        ...spellings
+      ].map((name) => `"${name}"`).join(" and ")} all map to the controller "${controllerName}" \u2014 their operations are generated into one file. Rename one tag to keep them apart.`);
+    }
+  }
+  return groups;
 }
-__name(hasDuplicateFunctionNames, "hasDuplicateFunctionNames");
+__name(groupOperationsByController, "groupOperationsByController");
+
+// ../../shared/src/utils/functions/method-names.ts
+var RESERVED_MEMBER_NAMES = Object.freeze([
+  "constructor",
+  "httpClient",
+  "basePath",
+  "clientContextToken",
+  "createContextWithClientId"
+]);
+var RESERVED_MEMBER_SET = new Set(RESERVED_MEMBER_NAMES);
+function reservedMemberCollision(operation, config) {
+  if (config.options.customizeMethodName || !operation.operationId) {
+    return void 0;
+  }
+  const natural = camelCase(operation.operationId);
+  return RESERVED_MEMBER_SET.has(natural) ? {
+    from: natural,
+    to: `_${natural}`
+  } : void 0;
+}
+__name(reservedMemberCollision, "reservedMemberCollision");
+function getOperationMethodName(operation, config) {
+  const customize = config.options.customizeMethodName;
+  if (!customize) {
+    return defaultOperationMethodName(operation);
+  }
+  if (operation.operationId == null) {
+    throw new InvalidIdentifierError(`customizeMethodName needs an operationId, and ${describeOperation(operation)} has none. Add one to the spec, or drop customizeMethodName to use the derived name.`, operation);
+  }
+  const customName = customize(operation.operationId);
+  if (!isValidIdentifier(customName) || RESERVED_MEMBER_SET.has(customName)) {
+    throw new InvalidIdentifierError(`customizeMethodName returned "${customName}" for ${describeOperation(operation)}, which is not a usable TypeScript method name. Return an identifier \u2014 letters, digits, "_" and "$", not starting with a digit \u2014 and not one of ${RESERVED_MEMBER_NAMES.map((name) => `"${name}"`).join(", ")}.`, operation, customName);
+  }
+  return customName;
+}
+__name(getOperationMethodName, "getOperationMethodName");
+function defaultOperationMethodName(operation) {
+  if (operation.operationId) {
+    const name = camelCase(operation.operationId);
+    return RESERVED_MEMBER_SET.has(name) ? `_${name}` : name;
+  }
+  const method = pascalCase(operation.method.toLowerCase());
+  const pathParts = operation.path.split("/").filter((segment) => segment !== "").map((segment) => pascalCase(segment));
+  const resource = pathParts.join("") || "resource";
+  return `${camelCase(resource)}${method}`;
+}
+__name(defaultOperationMethodName, "defaultOperationMethodName");
+
+// ../../shared/src/utils/functions/distinct-member-names.ts
+function assertDistinctMemberNames(serviceClass, className, operations, methodNameOf) {
+  const methodNames = serviceClass.getMethods().map((method) => method.getName());
+  const propertyNames = new Set(serviceClass.getProperties().map((property) => property.getName()));
+  const duplicates = [
+    ...new Set(methodNames.filter((name, index) => methodNames.indexOf(name) !== index || propertyNames.has(name)))
+  ];
+  if (duplicates.length === 0) {
+    return;
+  }
+  const byName = new Map(duplicates.map((name) => [
+    name,
+    []
+  ]));
+  for (const operation of operations) {
+    byName.get(methodNameOf(operation))?.push(operation);
+  }
+  const detail = [
+    ...byName
+  ].map(([name, ops]) => {
+    const from = ops.map(describeOperation).join(" and ");
+    return propertyNames.has(name) ? `"${name}" from ${from} (a property of ${className})` : `"${name}" from ${from}`;
+  }).join("; ");
+  throw new DuplicateGeneratedNameError(`Operations map to the same member name in ${className}: ${detail}. Ensure each operationId maps to a unique name.`, duplicates, [
+    ...byName.values()
+  ].flat());
+}
+__name(assertDistinctMemberNames, "assertDistinctMemberNames");
 
 // ../../shared/src/config/constants.ts
 var disableLinting = `// @ts-nocheck
@@ -3143,6 +3794,14 @@ var HttpResourceMethodBodyGenerator = class {
   constructor(config) {
     this.config = config;
   }
+  /**
+   * The plugin reserves its own bindings (`resourceOptions`/`requestOptions`),
+   * not the core service's — resolving against the wrong set would let a
+   * `requestOptions` query parameter capture the plugin's own parameter.
+   */
+  argumentNames(operation) {
+    return resolveArgumentNames(operation, this.config, RESOURCE_ARGUMENT_PROFILE);
+  }
   generateMethodBody(operation) {
     const bodyParts = [
       this.generateDefaultHeaders(operation),
@@ -3174,7 +3833,7 @@ var HttpResourceMethodBodyGenerator = class {
   }
   generateRequestOptions(operation) {
     const entries = [];
-    const url = emitUrlExpression(operation.path, operation.pathParams, signalAwareParamValue);
+    const url = emitUrlExpression(operation.path, operation.pathParams, this.argumentNames(operation), signalAwareParamValue);
     entries.push(`url: ${url}`);
     entries.push(`method: "GET"`);
     entries.push("...requestOptions");
@@ -3192,7 +3851,7 @@ var HttpResourceMethodBodyGenerator = class {
   }
   generateHttpResource(operation) {
     const resourceOptions = this.generateRequestOptions(operation);
-    const queryParams = emitSignalAwareQueryParams(operation.queryParams);
+    const queryParams = emitSignalAwareQueryParams(operation.queryParams, this.argumentNames(operation));
     let httpResource = "httpResource";
     switch (operation.responseType) {
       case "blob":
@@ -3240,13 +3899,14 @@ var HttpResourceMethodParamsGenerator = class {
   }
   generateApiParameters(operation) {
     const params = [];
+    const argumentNames = resolveArgumentNames(operation, this.config, RESOURCE_ARGUMENT_PROFILE);
     operation.pathParams.forEach((param) => {
       const paramType = getTypeScriptType(param.schema || {
         ...param
       }, this.config);
       const signalParamType = param.required ? `Signal<${paramType}>` : `Signal<${paramType} | undefined>`;
       params.push({
-        name: camelCase(param.name),
+        name: argumentNames.of(param.name),
         type: `${signalParamType} | ${paramType}`,
         hasQuestionToken: !param.required
       });
@@ -3257,7 +3917,7 @@ var HttpResourceMethodParamsGenerator = class {
       }, this.config);
       const signalParamType = param.required ? `Signal<${paramType}>` : `Signal<${paramType} | undefined>`;
       params.push({
-        name: camelCase(param.name),
+        name: argumentNames.of(param.name),
         type: `${signalParamType} | ${paramType}`,
         hasQuestionToken: !param.required
       });
@@ -3328,31 +3988,11 @@ var HttpResourceMethodGenerator = class {
       returnType,
       statements: methodBody,
       overloads,
-      docs: operation.description ? [
-        operation.description
-      ] : void 0
+      docs: emitDocs(operation.description)
     });
   }
   generateMethodName(operation) {
-    if (this.config.options.customizeMethodName) {
-      if (operation.operationId == null) {
-        throw new Error(`Operation ID is required for method name customization of operation: (${operation.method}) ${operation.path}`);
-      }
-      return this.config.options.customizeMethodName(operation.operationId);
-    } else {
-      return this.defaultNameGenerator(operation);
-    }
-  }
-  defaultNameGenerator(operation) {
-    if (operation.operationId) {
-      return camelCase(operation.operationId);
-    }
-    const method = pascalCase(operation.method.toLowerCase());
-    const pathParts = operation.path.split("/").map((str2) => {
-      return pascalCase(pascalCase(str2).replace(/[^a-zA-Z0-9]/g, ""));
-    });
-    const resource = pathParts.join("") || "resource";
-    return `${camelCase(resource)}${method}`;
+    return getOperationMethodName(operation, this.config);
   }
   generateReturnType(operation) {
     const response = operation.responses?.["200"] || operation.responses?.["201"] || operation.responses?.["204"];
@@ -3427,7 +4067,6 @@ var HttpResourceIndexGenerator = class {
       });
     });
     sourceFile.formatText();
-    sourceFile.saveSync();
   }
 };
 
@@ -3457,32 +4096,15 @@ var HttpResourceGenerator = class {
       this.onWarning?.("No API paths found in the specification");
       return;
     }
-    const controllerGroups = this.groupPathsByController(paths);
-    await Promise.all(Object.entries(controllerGroups).map(([controllerName, operations]) => {
-      this.generateServiceFile(controllerName, operations, outputDir);
-    }));
+    const controllerGroups = groupOperationsByController(paths, this.onWarning);
+    await Promise.all(
+      // Must return the promise: without it Promise.all awaits [undefined],
+      // and a generateServiceFile rejection escapes as an unhandled
+      // rejection while generation reports success.
+      Object.entries(controllerGroups).map(([controllerName, operations]) => this.generateServiceFile(controllerName, operations, outputDir))
+    );
     this.indexGenerator.generateIndex(outputRoot);
   }
-  groupPathsByController(paths) {
-    const groups = {};
-    paths.forEach((path3) => {
-      let controllerName = "Default";
-      if (path3.tags && path3.tags.length > 0) {
-        controllerName = path3.tags[0];
-      } else {
-        const pathParts = path3.path.split("/").filter((p) => p && !p.startsWith("{"));
-        if (pathParts.length > 1) {
-          controllerName = pascalCase(pathParts[1]);
-        }
-      }
-      controllerName = pascalCase(controllerName);
-      if (!groups[controllerName]) {
-        groups[controllerName] = [];
-      }
-      groups[controllerName].push(path3);
-    });
-    return groups;
-  }
   async generateServiceFile(controllerName, operations, outputDir) {
     const fileName = `${camelCase(controllerName)}.resource.ts`;
     const filePath = path2.join(outputDir, fileName);
@@ -3492,7 +4114,6 @@ var HttpResourceGenerator = class {
     this.addServiceClass(sourceFile, controllerName, operations);
     sourceFile.fixMissingImports().formatText();
     sourceFile.insertText(0, HTTP_RESOURCE_GENERATOR_HEADER_COMMENT(getResourceClassName(controllerName, this.config.options.naming?.resources)));
-    sourceFile.saveSync();
   }
   addServiceClass(sourceFile, controllerName, operations) {
     const className = getResourceClassName(controllerName, this.config.options.naming?.resources);
@@ -3545,20 +4166,20 @@ var HttpResourceGenerator = class {
     serviceClass.addProperty({
       name: "basePath",
       type: "string",
-      scope: import_ts_morph.Scope.Private,
+      scope: import_ts_morph3.Scope.Private,
       isReadonly: true,
       initializer: `inject(${basePathTokenName})`
     });
     serviceClass.addProperty({
       name: "clientContextToken",
       type: "HttpContextToken<string>",
-      scope: import_ts_morph.Scope.Private,
+      scope: import_ts_morph3.Scope.Private,
       isReadonly: true,
       initializer: clientContextTokenName
     });
     serviceClass.addMethod({
       name: "createContextWithClientId",
-      scope: import_ts_morph.Scope.Private,
+      scope: import_ts_morph3.Scope.Private,
       parameters: [
         {
           name: "existingContext",
@@ -3568,14 +4189,23 @@ var HttpResourceGenerator = class {
       ],
       returnType: "HttpContext",
       statements: `const context = existingContext || new HttpContext();
-return context.set(this.clientContextToken, '${this.config.clientName || "default"}');`
+return context.set(this.clientContextToken, ${quoteLiteral(effectiveClientName(this.config.clientName))});`
     });
     operations.forEach((operation) => {
+      const { renamed: renamed2, merged } = resolveArgumentNames(operation, this.config, RESOURCE_ARGUMENT_PROFILE);
+      for (const { source, identifier } of renamed2) {
+        this.onWarning?.(`Parameter "${source}" of ${describeOperation(operation)} is exposed as "${identifier}" \u2014 its natural name is already taken by another parameter or by the resource method itself.`);
+      }
+      for (const wireName of merged) {
+        this.onWarning?.(`Parameter "${wireName}" of ${describeOperation(operation)} is declared in more than one location; they collapse into one argument, so the first declaration's type wins and the same value is sent for both.`);
+      }
+      const collision = reservedMemberCollision(operation, this.config);
+      if (collision) {
+        this.onWarning?.(`Operation ${describeOperation(operation)} would be named "${collision.from}", which the generated class already binds \u2014 it is emitted as "${collision.to}". Rename the operationId to choose the name.`);
+      }
       this.methodGenerator.addResourceMethod(serviceClass, operation);
     });
-    if (hasDuplicateFunctionNames(serviceClass.getMethods())) {
-      throw new Error(`Duplicate method names found in service class ${className}. Please ensure unique method names for each operation.`);
-    }
+    assertDistinctMemberNames(serviceClass, className, operations, (op) => this.methodGenerator.generateMethodName(op));
   }
 };
 // Annotate the CommonJS export names for ESM import in node: