@conduit-client/generator-ts 3.5.0 → 3.6.2

package/dist/types/v1/generators/http-command-generator.d.ts

@@ -1,7 +1,6 @@
 import { Code } from '../files';
 import { CommandGenerator } from './base-command-generator';
 import type { ImportableTypeReference } from '../files';
-import { type Type } from '@conduit-client/model/v1';
 export declare const MEDIATYPE_APP_JSON = "application/json";
 /**
  * Extends CommandGenerator to provide functionality for generating command files specifically designed for HTTP operations.
@@ -51,17 +50,5 @@ export declare class HttpCommandGenerator extends CommandGenerator {
      * @returns {Code | undefined} A code snippet for the input payload parameter, if applicable.
      */
     generateInputPayloadParameter(): Code | undefined;
-    /**
-     * Encodes a parameter based on its type.
-     * @param {string} name The name of the parameter to encode.
-     * @param {Type} type The type descriptor of the parameter.
-     * @returns {string | undefined} The encoded parameter value as a string, or undefined if the type is unsupported.
-     */
-    encodeParam(name: string, type: Type, required: boolean): string | undefined;
-    /**
-     * Processes the URL with replacements for URI parameters based on their values specified in the command model.
-     * @returns {string} The fully constructed URL with all necessary URI parameter substitutions.
-     */
-    processUrl(): string;
     generateCoerceError(): Code;
 }

package/dist/types/v1/generators/utils.d.ts

@@ -1,5 +1,6 @@
 import { type Code } from '../files';
 import { ICommandModel } from '../model/base-command-model';
+import { type Type } from '@conduit-client/model/v1';
 /**
  * Generates a destructuring assignment code block for a given property name, ensuring that the variable names are valid TypeScript identifiers.
  * This function is particularly useful when dealing with property names that may not directly translate into valid TypeScript variable names,
@@ -15,3 +16,27 @@ export declare function buildPropertyDestructureDeclaration(propertyName: string
     variableName: string;
 };
 export declare function buildServiceProjection(model: ICommandModel): string[];
+/**
+ * Encodes a parameter based on its type for use in URL template strings.
+ * @param name The name of the parameter variable to encode.
+ * @param type The type descriptor of the parameter.
+ * @param required Whether the parameter is required.
+ * @returns The encoded parameter value as a string expression, or undefined if the type is unsupported.
+ */
+export declare function encodeParam(name: string, type: Type, required: boolean): string | undefined;
+/**
+ * Processes the URL with replacements for URI parameters based on their values specified in the command model.
+ * Combines serverUrlPath and endpointUrlPath, then replaces URI parameter placeholders (e.g., {id}) with
+ * template string expressions that encode the parameter values.
+ * @param commandModel The command model containing URL paths and URI parameters.
+ * @returns The fully constructed URL template string with all necessary URI parameter substitutions.
+ */
+export declare function processUrl(commandModel: ICommandModel): string;
+/**
+ * Generates code for a URL getter method with URI parameter destructuring.
+ * Always destructures URI parameters from this.config to ensure consistency.
+ *
+ * @param commandModel The command model containing URL paths and URI parameters
+ * @returns Code block containing a getter method that returns the processed URL
+ */
+export declare function generateUrlGetter(commandModel: ICommandModel): Code;

package/dist/v1/index.js

@@ -2346,6 +2346,66 @@ function buildServiceProjection(model) {
   }
   return [name, overrides];
 }
+function encodeParam(name, type, required) {
+  const isScalarArrayType = (t) => {
+    const canonicalizedType = canonicalizeType(t);
+    if (canonicalizedType.type !== "array") {
+      return false;
+    }
+    const canonicalizedItems = canonicalizeType(canonicalizedType.items);
+    return isCanonicalStringType(canonicalizedItems) || isCanonicalNumberType(canonicalizedItems);
+  };
+  const canonicalType = canonicalizeType(type);
+  return isCanonicalNumberType(canonicalType) ? `${name}` : isCanonicalStringType(canonicalType) ? required ? `encodeURIComponent(${name})` : `encodeURIComponent(${name} ? ${name} : '')` : isScalarArrayType(canonicalType) ? isCanonicalStringType(canonicalType.items) ? `${name}.map(item=>encodeURIComponent(item)).join(',')` : `${name}.join(',')` : void 0;
+}
+function processUrl(commandModel) {
+  const uriParams = commandModel.uriParameters.reduce(
+    (result, param) => {
+      result[param.name] = param;
+      return result;
+    },
+    {}
+  );
+  let url = [
+    commandModel.serverUrlPath.replace(/\/$/, ""),
+    commandModel.endpointUrlPath.replace(/^\//, "")
+  ].join("/");
+  url = url.replace(/\{(.+?)\}/g, (_, uriParameter) => {
+    const uriParam = uriParams[uriParameter];
+    if (!uriParam) {
+      throw new Error(
+        `unknown uri parameter ${uriParameter} in ${url} for ${commandModel.method} ${commandModel.endpointUrlPath} operation`
+      );
+    }
+    const paramName = buildPropertyDestructureDeclaration(uriParameter).variableName;
+    const value = encodeParam(paramName, uriParam.type, uriParam.required);
+    return `\${${value}}`;
+  });
+  return url;
+}
+function generateUrlGetter(commandModel) {
+  const processedUrl = processUrl(commandModel);
+  const uriParams = commandModel.uriParameters;
+  const hasUriParams = uriParams.length > 0;
+  if (hasUriParams) {
+    const paramDestructuring = uriParams.map((param) => {
+      return buildPropertyDestructureDeclaration(param.name).code;
+    });
+    return code`
+            get url() {
+                const {
+                    ${paramDestructuring.join(",")}
+                } = this.config;
+                return \`${processedUrl}\`;
+            }
+        `;
+  }
+  return code`
+        get url() { 
+            return \`${processedUrl}\`; 
+        }
+    `;
+}
 const HEADER_CONTENT_TYPE = "Content-Type";
 const FETCH_SERVICE = {
   module: "@conduit-client/service-fetch-network/v1",
@@ -2420,7 +2480,8 @@ class HttpCommandGenerator extends CommandGenerator {
    * @returns {Code} A code snippet that defines the URL to be used in fetch operations.
    */
   generateUrl() {
-    return code`let url:Parameters<${FETCH_SERVICE}>[0]=\`${this.processUrl()}\`;`;
+    const processedUrl = processUrl(this.commandModel);
+    return code`let url:Parameters<${FETCH_SERVICE}>[0]=\`${processedUrl}\`;`;
   }
   /**
    * Generates headers necessary for the HTTP fetch based on the command model's requirements.
@@ -2514,57 +2575,6 @@ class HttpCommandGenerator extends CommandGenerator {
       }
     }
   }
-  /**
-   * Encodes a parameter based on its type.
-   * @param {string} name The name of the parameter to encode.
-   * @param {Type} type The type descriptor of the parameter.
-   * @returns {string | undefined} The encoded parameter value as a string, or undefined if the type is unsupported.
-   */
-  encodeParam(name, type, required) {
-    const isScalarArrayType = (t) => {
-      const canonicalizedType = canonicalizeType(t);
-      if (canonicalizedType.type !== "array") {
-        return false;
-      }
-      const canonicalizedItems = canonicalizeType(canonicalizedType.items);
-      return isCanonicalStringType(canonicalizedItems) || isCanonicalNumberType(canonicalizedItems);
-    };
-    const canonicalType = canonicalizeType(type);
-    return isCanonicalNumberType(canonicalType) ? `${name}` : isCanonicalStringType(canonicalType) ? required ? `encodeURIComponent(${name})` : `encodeURIComponent(${name} ? ${name} : '')` : isScalarArrayType(canonicalType) ? isCanonicalStringType(canonicalType.items) ? `${name}.map(item=>encodeURIComponent(item)).join(',')` : `${name}.join(',')` : void 0;
-  }
-  /**
-   * Processes the URL with replacements for URI parameters based on their values specified in the command model.
-   * @returns {string} The fully constructed URL with all necessary URI parameter substitutions.
-   */
-  processUrl() {
-    const uriParams = this.commandModel.uriParameters.reduce(
-      (result, param) => {
-        result[param.name] = param;
-        return result;
-      },
-      {}
-    );
-    let url = [
-      this.commandModel.serverUrlPath.replace(/\/$/, ""),
-      this.commandModel.endpointUrlPath.replace(/^\//, "")
-    ].join("/");
-    url = url.replace(/\{(.+?)\}/g, (_, uriParameter) => {
-      const uriParam = uriParams[uriParameter];
-      if (!uriParam) {
-        throw new Error(
-          `unknown uri parameter ${uriParameter} in ${url} for ${this.commandModel.method} ${this.commandModel.endpointUrlPath} operation`
-        );
-      }
-      const paramName = buildPropertyDestructureDeclaration(uriParameter).variableName;
-      const value = this.encodeParam(
-        paramName,
-        uriParam.type,
-        uriParam.required
-      );
-      return `\${${value}}`;
-    });
-    return url;
-  }
   generateCoerceError() {
     if (this.commandModel.errorStrategy.type === "fetchResponse") {
       return code`async coerceError(errorResponse: Response):Promise<${FETCH_RESPONSE$1}<unknown>>{
@@ -4112,14 +4122,10 @@ function GraphQLNormalizedCacheControlGeneratorMixin(Base, commandBaseClass) {
     }
     /**
      * Generate the URL getter for the GraphQL endpoint
+     * Uses the same URL processing logic as HTTP commands to handle server URL, endpoint path, and URI parameters
      */
     generateUrl() {
-      const path2 = this.commandModel.endpointUrlPath;
-      return code`
-                get url() { 
-                    return '${path2}'; 
-                }
-            `;
+      return generateUrlGetter(this.commandModel);
     }
     /**
      * Generate the endpoint property for GraphQL commands