@conduit-client/generator-ts 3.10.0 → 3.12.0

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

@@ -11,6 +11,7 @@ import { HttpCommandGenerator } from './http-command-generator';
  */
 export declare class AuraCommandGenerator extends HttpCommandGenerator {
     commandBaseClass: ImportableTypeReference;
+    get commandGeneratedClass(): ImportableTypeReference;
     /**
      * Constructs and returns an array of code blocks that form the body of the Aura-specific command class.
      * @returns {Code[]} An array of code snippets that define the command class body, tailored for Aura components.

package/dist/types/v1/generators/aura-resource-cache-control-command-generator.d.ts

@@ -1,5 +1,5 @@
 import { AuraCommandGenerator } from './aura-command-generator';
-import type { Code } from '../files';
+import type { Code, ImportableTypeReference } from '../files';
 /**
  * Extends AuraCommandGenerator to add cache control strategies specific to resource caching in Aura components.
  *
@@ -14,6 +14,7 @@ export declare class AuraResourceCacheControlCommandGenerator extends AuraComman
         readonly exportedSymbol: "AuraResourceCacheControlCommand";
         readonly isType: true;
     };
+    get commandGeneratedClass(): ImportableTypeReference;
     /**
      * Generates a method to build cache control metadata based on the response type and cache strategy defined in the command model.
      * Throws an error if the cache strategy is set to 'none'.

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

@@ -43,7 +43,14 @@ export declare abstract class CommandGenerator {
     protected commandConfigTypeSymbol: symbol;
     protected commandClassBodySymbol: symbol;
     protected commandOptionsTypeSymbol: symbol;
+    protected commandBuildCommandClassReturnTypeSymbol: symbol;
+    protected commandBuildCommandClassReturnAssertionSymbol: symbol;
     abstract get commandBaseClass(): ImportableTypeReference;
+    /**
+     * When set, the generated buildCommandClass is strongly typed to return this declare class type
+     * (e.g. GeneratedFetchNetworkCommand) and the return statement uses a type assertion.
+     */
+    get commandGeneratedClass(): ImportableTypeReference | undefined;
     get classBody(): Code[];
     get commandTypeConstructorArgs(): Code;
     get commandConstructorArgs(): Code;
@@ -77,6 +84,18 @@ export declare abstract class CommandGenerator {
     protected buildCommandConfigType(): Code;
     protected buildCommandConfigSchema(): Code;
     protected buildCommandOptionsType(): Code;
+    /**
+     * Type arguments for the Generated class in the buildCommandClass return type.
+     * Default: same as buildCommandTypeGenerics(). Override (e.g. normalized cache control)
+     * to pass a full generic tuple so execute() and bindings are correctly typed.
+     */
+    protected getBuildCommandClassReturnTypeGenerics(): Code;
+    /**
+     * Constructor parameter list for the buildCommandClass return type signature.
+     * Default: commandTypeConstructorArgs + ...args: CommandConstructorParams.
+     * Override (e.g. GraphQL) when the constructor has a fixed param list with no rest.
+     */
+    protected getBuildCommandClassConstructorParams(): Code;
     protected buildCommandTypeGenerics(): Code;
     protected buildExtraServices(): Code | undefined;
     protected generateAfterRequestHooks(): Code;

package/dist/types/v1/generators/graphql-normalized-cache-control-generator-mixin.d.ts

@@ -9,5 +9,5 @@ type Constructor = new (...args: any[]) => CommandGenerator & NormalizedCacheCon
  * 2. Adding documentRootType parameter to constructor
  * 3. Generating GraphQL-specific methods like buildRequestQuery
  */
-export declare function GraphQLNormalizedCacheControlGeneratorMixin(Base: Constructor, commandBaseClass: ImportableTypeReference): Constructor;
+export declare function GraphQLNormalizedCacheControlGeneratorMixin(Base: Constructor, commandBaseClass: ImportableTypeReference, commandGeneratedClass?: ImportableTypeReference): Constructor;
 export {};

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

@@ -12,6 +12,7 @@ export declare const MEDIATYPE_APP_JSON = "application/json";
  */
 export declare class HttpCommandGenerator extends CommandGenerator {
     commandBaseClass: ImportableTypeReference;
+    get commandGeneratedClass(): ImportableTypeReference;
     /**
      * Constructs and returns an array of code blocks that form the body of the HTTP command class.
      * Includes methods for generating fetch parameters and error coercion logic.

package/dist/types/v1/generators/normalized-cache-control-generator-mixin.d.ts

@@ -9,7 +9,8 @@ type NormalizedCacheControlConstructor = new (...args: any[]) => CommandGenerato
  *
  * @param Base The base class to mix in the normalized code generation logic to
  * @param commandBaseClass An importable refernce to the command base class to use in the generated code
+ * @param commandGeneratedClass Optional importable reference to the declare-block type for strong typing (e.g. GeneratedHttpNormalizedCacheControlCommand)
  * @returns A new class with the normalized generation behavior mixed in
  */
-export declare function NormalizedCacheControlGeneratorMixin(Base: Constructor, commandBaseClass: ImportableTypeReference): NormalizedCacheControlConstructor;
+export declare function NormalizedCacheControlGeneratorMixin(Base: Constructor, commandBaseClass: ImportableTypeReference, commandGeneratedClass?: ImportableTypeReference): NormalizedCacheControlConstructor;
 export {};

package/dist/v1/index.js

@@ -962,6 +962,11 @@ const BUILD_READ_WRITE_RESULT = {
   exportedSymbol: "buildReadWriteResult",
   isType: false
 };
+const READ_RESULT = {
+  module: "@conduit-client/type-normalization/v1",
+  exportedSymbol: "ReadResult",
+  isType: true
+};
 const DEEP_EQUALS = {
   module: "@conduit-client/utils",
   exportedSymbol: "deepEquals",
@@ -1121,7 +1126,7 @@ function generateUnidentifiableType(services, type, options) {
             return ${BUILD_READ_WRITE_RESULT}<NormalizedReference, ${WRITE_ERRORS}>(normalized, errors)
         }
 
-        read(cache: ${READONLY_CACHE}, input: ${readInput}){
+        read(cache: ${READONLY_CACHE}, input: ${readInput}): ${READ_RESULT}<Data>{
             const errors: ${READ_ERRORS} = []
             const denormalized = ${normalizationCode.denormalize}
             return ${BUILD_READ_WRITE_RESULT}<Data, ${READ_ERRORS}>(denormalized, errors)
@@ -2146,6 +2151,19 @@ class CommandGenerator {
     this.commandConfigTypeSymbol = Symbol.for("commandConfigType");
     this.commandClassBodySymbol = Symbol.for("commandClassBody");
     this.commandOptionsTypeSymbol = Symbol.for("commandOptionsType");
+    this.commandBuildCommandClassReturnTypeSymbol = Symbol.for(
+      "commandBuildCommandClassReturnType"
+    );
+    this.commandBuildCommandClassReturnAssertionSymbol = Symbol.for(
+      "commandBuildCommandClassReturnAssertion"
+    );
+  }
+  /**
+   * When set, the generated buildCommandClass is strongly typed to return this declare class type
+   * (e.g. GeneratedFetchNetworkCommand) and the return statement uses a type assertion.
+   */
+  get commandGeneratedClass() {
+    return void 0;
   }
   get classBody() {
     return [];
@@ -2213,14 +2231,18 @@ class CommandGenerator {
       code`>;`,
       code`export type CommandConstructorParams=ConstructorParameters<CommandConstructorType>;`,
       this.generateCommandType(),
-      code`export function buildCommandClass(baseClass: CommandConstructorType): Command{`,
+      code`export function buildCommandClass(baseClass: CommandConstructorType): `,
+      this.commandBuildCommandClassReturnTypeSymbol,
+      code`{`,
       code`return class extends baseClass{`,
       this.generateConstructor(),
       ...this.classBody,
       this.exposeSubscribeAndRefresh,
       this.generateOperationType(),
       this.generateAfterRequestHooks(),
-      code`}};`
+      code`}`,
+      this.commandBuildCommandClassReturnAssertionSymbol,
+      code`};`
     ];
   }
   /**
@@ -2235,6 +2257,18 @@ class CommandGenerator {
     file.pushTo(this.commandOptionsTypeSymbol, this.buildCommandOptionsType());
     file.pushTo(this.commandTypeGenericsSymbol, this.buildCommandTypeGenerics());
     file.pushTo(this.commandClassBodySymbol, ...this.classBody);
+    const generatedClass = this.commandGeneratedClass;
+    if (generatedClass) {
+      const constructorSignature = code`new (${this.getBuildCommandClassConstructorParams()}) => ${generatedClass}<${this.getBuildCommandClassReturnTypeGenerics()}>`;
+      file.pushTo(this.commandBuildCommandClassReturnTypeSymbol, constructorSignature);
+      file.pushTo(
+        this.commandBuildCommandClassReturnAssertionSymbol,
+        code` as unknown as ${constructorSignature}`
+      );
+    } else {
+      file.pushTo(this.commandBuildCommandClassReturnTypeSymbol, code`Command`);
+      file.pushTo(this.commandBuildCommandClassReturnAssertionSymbol, code``);
+    }
   }
   buildCommandConfigType() {
     return this.services.typeDefinition.build(this.commandModel.configType);
@@ -2246,6 +2280,22 @@ class CommandGenerator {
     const commandName = this.commandModel.className;
     return code`export type ${commandName}Options = ${ABORTABLE_COMMAND_OPTIONS};`;
   }
+  /**
+   * Type arguments for the Generated class in the buildCommandClass return type.
+   * Default: same as buildCommandTypeGenerics(). Override (e.g. normalized cache control)
+   * to pass a full generic tuple so execute() and bindings are correctly typed.
+   */
+  getBuildCommandClassReturnTypeGenerics() {
+    return this.buildCommandTypeGenerics();
+  }
+  /**
+   * Constructor parameter list for the buildCommandClass return type signature.
+   * Default: commandTypeConstructorArgs + ...args: CommandConstructorParams.
+   * Override (e.g. GraphQL) when the constructor has a fixed param list with no rest.
+   */
+  getBuildCommandClassConstructorParams() {
+    return code`${this.commandTypeConstructorArgs}, ...args: CommandConstructorParams`;
+  }
   buildCommandTypeGenerics() {
     var _a;
     const extraServicesCode = this.buildExtraServices();
@@ -2417,6 +2467,11 @@ const FETCH_COMMAND_BASE_CLASS = {
   exportedSymbol: "FetchNetworkCommand",
   isType: true
 };
+const GENERATED_FETCH_NETWORK_COMMAND = {
+  module: "@conduit-client/command-fetch-network/v1",
+  exportedSymbol: "GeneratedFetchNetworkCommand",
+  isType: true
+};
 const FETCH_RESPONSE$1 = {
   module: "@conduit-client/utils",
   exportedSymbol: "FetchResponse",
@@ -2438,6 +2493,9 @@ class HttpCommandGenerator extends CommandGenerator {
     super(...arguments);
     this.commandBaseClass = FETCH_COMMAND_BASE_CLASS;
   }
+  get commandGeneratedClass() {
+    return GENERATED_FETCH_NETWORK_COMMAND;
+  }
   /**
    * Constructs and returns an array of code blocks that form the body of the HTTP command class.
    * Includes methods for generating fetch parameters and error coercion logic.
@@ -2604,11 +2662,19 @@ const AURA_COMMAND_BASE_CLASS = {
   exportedSymbol: "AuraNetworkCommand",
   isType: true
 };
+const GENERATED_AURA_NETWORK_COMMAND = {
+  module: "@conduit-client/command-aura-network/v1",
+  exportedSymbol: "GeneratedAuraNetworkCommand",
+  isType: true
+};
 class AuraCommandGenerator extends HttpCommandGenerator {
   constructor() {
     super(...arguments);
     this.commandBaseClass = AURA_COMMAND_BASE_CLASS;
   }
+  get commandGeneratedClass() {
+    return GENERATED_AURA_NETWORK_COMMAND;
+  }
   /**
    * Constructs and returns an array of code blocks that form the body of the Aura-specific command class.
    * @returns {Code[]} An array of code snippets that define the command class body, tailored for Aura components.
@@ -2709,11 +2775,19 @@ const AURA_CACHE_CONTROL_COMMAND_BASE_CLASS = {
   exportedSymbol: "AuraResourceCacheControlCommand",
   isType: true
 };
+const GENERATED_AURA_RESOURCE_CACHE_CONTROL_COMMAND = {
+  module: "@conduit-client/command-aura-resource-cache-control/v1",
+  exportedSymbol: "GeneratedAuraResourceCacheControlCommand",
+  isType: true
+};
 class AuraResourceCacheControlCommandGenerator extends AuraCommandGenerator {
   constructor() {
     super(...arguments);
     this.commandBaseClass = AURA_CACHE_CONTROL_COMMAND_BASE_CLASS;
   }
+  get commandGeneratedClass() {
+    return GENERATED_AURA_RESOURCE_CACHE_CONTROL_COMMAND;
+  }
   /**
    * Generates a method to build cache control metadata based on the response type and cache strategy defined in the command model.
    * Throws an error if the cache strategy is set to 'none'.
@@ -4008,12 +4082,30 @@ const DATA_OF = {
   exportedSymbol: "DataOf",
   isType: true
 };
-function NormalizedCacheControlGeneratorMixin(Base, commandBaseClass) {
+const READ_INPUT_OF = {
+  module: "@conduit-client/type-normalization/v1",
+  exportedSymbol: "ReadInputOf",
+  isType: true
+};
+const WRITE_RESPONSE_OF = {
+  module: "@conduit-client/type-normalization/v1",
+  exportedSymbol: "WriteResponseOf",
+  isType: true
+};
+const WRITE_INPUT_OF = {
+  module: "@conduit-client/type-normalization/v1",
+  exportedSymbol: "WriteInputOf",
+  isType: true
+};
+function NormalizedCacheControlGeneratorMixin(Base, commandBaseClass, commandGeneratedClass) {
   return class NormalizedCacheControl extends Base {
     constructor() {
       super(...arguments);
       this.commandBaseClass = commandBaseClass;
     }
+    get commandGeneratedClass() {
+      return commandGeneratedClass;
+    }
     get commandTypeConstructorArgs() {
       return code`config: Config, typeRegistry: ${this.services.typeRegistryGenerator.build()}`;
     }
@@ -4025,6 +4117,22 @@ function NormalizedCacheControlGeneratorMixin(Base, commandBaseClass) {
       const builtType = this.buildResponseType();
       return code`${builtType.typeClassRef}${extraServicesCode ? code`, ${extraServicesCode}` : ""}`;
     }
+    /**
+     * Pass all 7 type args to the Generated declare class so Data, ReadInput, etc. are
+     * inferred and execute() / bindings match (e.g. GetCommand<Pet[], Config>).
+     * Only override when commandGeneratedClass is set (HTTP/Aura normalized); when this
+     * mixin is used without it (e.g. as base for GraphQL), we do not add the 7-tuple so
+     * the GraphQL mixin's single-type override is used.
+     */
+    getBuildCommandClassReturnTypeGenerics() {
+      if (!commandGeneratedClass) {
+        return super.getBuildCommandClassReturnTypeGenerics();
+      }
+      const builtType = this.buildResponseType();
+      const extraServicesCode = this.buildExtraServices();
+      const resultType = builtType.typeClassRef;
+      return code`${resultType}, ${DATA_OF}<${resultType}>, ${DATA_OF}<${resultType}>, ${READ_INPUT_OF}<${resultType}>, ${WRITE_RESPONSE_OF}<${resultType}>, ${WRITE_INPUT_OF}<${resultType}>${extraServicesCode ? code`, ${extraServicesCode}` : code`, object`}`;
+    }
     get classBody() {
       return [
         ...super.classBody,
@@ -4155,13 +4263,16 @@ const NAMED_FETCH_SERVICE$2 = {
   exportedSymbol: "NamedFetchService",
   isType: true
 };
-function GraphQLNormalizedCacheControlGeneratorMixin(Base, commandBaseClass) {
+function GraphQLNormalizedCacheControlGeneratorMixin(Base, commandBaseClass, commandGeneratedClass) {
   return class GraphQLNormalizedCacheControl extends Base {
     constructor() {
       super(...arguments);
       this.commandBaseClass = commandBaseClass;
       this.documentRootTypeSymbol = Symbol.for("documentRootType");
     }
+    get commandGeneratedClass() {
+      return commandGeneratedClass;
+    }
     get template() {
       return [
         code`export type DocumentRootType = ${GRAPHQL_DOCUMENT_ROOT_TYPE_REPOSITORY}<${GRAPHQL_DATA$1}, ${GRAPHQL_DATA$1}>;`,
@@ -4177,6 +4288,18 @@ function GraphQLNormalizedCacheControlGeneratorMixin(Base, commandBaseClass) {
     get commandTypeConstructorArgs() {
       return code`config: Config, documentRootType: DocumentRootType, services: ${NAMED_CACHE_CONTROLLER_SERVICE} & ${NAMED_PUBSUB_SERVICE$3} & ${this.buildNetworkServicesCode()} & object`;
     }
+    /**
+     * GraphQL command constructor has exactly 3 params; no rest. Avoids "Expected 6 arguments, but got 3".
+     */
+    getBuildCommandClassConstructorParams() {
+      return this.commandTypeConstructorArgs;
+    }
+    /**
+     * GraphQL Generated class has only ExtraServices; use buildCommandTypeGenerics() (do not use 7-tuple from mixin).
+     */
+    getBuildCommandClassReturnTypeGenerics() {
+      return this.buildCommandTypeGenerics();
+    }
     get commandConstructorArgs() {
       return code`protected config: Config, protected documentRootType: DocumentRootType, protected services: ${NAMED_CACHE_CONTROLLER_SERVICE} & ${NAMED_PUBSUB_SERVICE$3} & ${this.buildNetworkServicesCode()} & object`;
     }
@@ -4240,9 +4363,12 @@ function GraphQLNormalizedCacheControlGeneratorMixin(Base, commandBaseClass) {
     generateConstructor() {
       return code`constructor(${this.commandConstructorArgs}){${this.commandConstructorBody}}`;
     }
+    /**
+     * GraphQL command has a single type param (ExtraServices). Return one type, no leading comma.
+     */
     buildCommandTypeGenerics() {
       const extraServicesCode = this.buildExtraServices();
-      return code`${extraServicesCode ? code`, ${extraServicesCode}` : "object"}`;
+      return extraServicesCode ? extraServicesCode : code`object`;
     }
   };
 }
@@ -4251,13 +4377,19 @@ const HTTP_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS = {
   exportedSymbol: "HttpGraphQLNormalizedCacheControlCommand",
   isType: true
 };
+const GENERATED_HTTP_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND = {
+  module: "@conduit-client/command-http-graphql-normalized-cache-control/v1",
+  exportedSymbol: "GeneratedHttpGraphQLNormalizedCacheControlCommand",
+  isType: true
+};
 const HttpNormalizedCacheControlCommandGenerator$1 = NormalizedCacheControlGeneratorMixin(
   HttpCommandGenerator,
   HTTP_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS
 );
 const HttpGraphQLNormalizedCacheControlCommandGenerator = GraphQLNormalizedCacheControlGeneratorMixin(
   HttpNormalizedCacheControlCommandGenerator$1,
-  HTTP_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS
+  HTTP_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS,
+  GENERATED_HTTP_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND
 );
 class BaseCommandModel {
   constructor(operation) {
@@ -4668,18 +4800,30 @@ const AURA_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS = {
   exportedSymbol: "AuraNormalizedCacheControlCommand",
   isType: true
 };
+const GENERATED_AURA_NORMALIZED_CACHE_CONTROL_COMMAND = {
+  module: "@conduit-client/command-aura-normalized-cache-control/v1",
+  exportedSymbol: "GeneratedAuraNormalizedCacheControlCommand",
+  isType: true
+};
 const AuraNormalizedCacheControlCommandGenerator$1 = NormalizedCacheControlGeneratorMixin(
   AuraCommandGenerator,
-  AURA_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS
+  AURA_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS,
+  GENERATED_AURA_NORMALIZED_CACHE_CONTROL_COMMAND
 );
 const HTTP_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS = {
   module: "@conduit-client/command-http-normalized-cache-control/v1",
   exportedSymbol: "HttpNormalizedCacheControlCommand",
   isType: true
 };
+const GENERATED_HTTP_NORMALIZED_CACHE_CONTROL_COMMAND = {
+  module: "@conduit-client/command-http-normalized-cache-control/v1",
+  exportedSymbol: "GeneratedHttpNormalizedCacheControlCommand",
+  isType: true
+};
 const HttpNormalizedCacheControlCommandGenerator = NormalizedCacheControlGeneratorMixin(
   HttpCommandGenerator,
-  HTTP_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS
+  HTTP_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS,
+  GENERATED_HTTP_NORMALIZED_CACHE_CONTROL_COMMAND
 );
 const HTTP_CACHE_CONTROL_COMMAND_BASE_CLASS_DESCRIPTOR = {
   module: "@conduit-client/command-http-normalized-cache-control/v1",
@@ -11199,13 +11343,19 @@ const AURA_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS = {
   exportedSymbol: "AuraGraphQLNormalizedCacheControlCommand",
   isType: true
 };
+const GENERATED_AURA_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND = {
+  module: "@conduit-client/command-aura-graphql-normalized-cache-control/v1",
+  exportedSymbol: "GeneratedAuraGraphQLNormalizedCacheControlCommand",
+  isType: true
+};
 const AuraNormalizedCacheControlCommandGenerator = NormalizedCacheControlGeneratorMixin(
   AuraCommandGenerator,
   AURA_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS
 );
 const AuraGraphQLNormalizedCacheControlCommandGenerator = GraphQLNormalizedCacheControlGeneratorMixin(
   AuraNormalizedCacheControlCommandGenerator,
-  AURA_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS
+  AURA_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND_BASE_CLASS,
+  GENERATED_AURA_GRAPHQL_NORMALIZED_CACHE_CONTROL_COMMAND
 );
 function defaultCommandModelFactory(operation) {
   let commandModel;