@conduit-client/generator-ts 3.16.0 → 3.17.1

package/dist/types/v1/files/file.d.ts

@@ -1,5 +1,6 @@
 import { type NamedService, type ServiceDescriptor } from '@conduit-client/utils';
 import { Code } from './code';
+import type { ImportableTypeReference, ImportableValueReference } from './code';
 /**
  * Service that builds TypeScript source files.
  */
@@ -66,6 +67,19 @@ export declare class File {
      * @returns this
      */
     pushTo(block: Symbol, ...chunks: any[]): this;
+    private reExports;
+    /** Registers a value re-export: `export { symbol [as alias] } from "…";` */
+    reExport(ref: ImportableValueReference & {
+        filename: string;
+        exportedSymbol: string;
+    }, alias?: string): void;
+    /** Registers a type re-export: `export type { symbol [as alias] } from "…";` */
+    reExportType(ref: ImportableTypeReference & {
+        filename: string;
+        exportedSymbol: string;
+    }, alias?: string): void;
+    /** Registers a wildcard type re-export: `export type * from "…";` */
+    reExportTypeAll(targetFilename: string): void;
     /**
      * Returns the code for this File, with ImportableReferences resolved.
      *

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

@@ -96,6 +96,11 @@ export declare abstract class CommandGenerator {
      * Override (e.g. GraphQL) when the constructor has a fixed param list with no rest.
      */
     protected getBuildCommandClassConstructorParams(): Code;
+    /**
+     * Additional generic type args for the Generated declare class that surface
+     * public constructor fields (config, typeRegistry, etc.) on InstanceType<>.
+     */
+    protected getBuildCommandClassConstructorFieldGenerics(): Code;
     protected buildCommandTypeGenerics(): Code;
     protected buildExtraServices(): Code | undefined;
     protected generateAfterRequestHooks(): Code;

package/dist/types/v1/generators/bindings-generator.d.ts

@@ -7,6 +7,7 @@ import { WireAdapterBindingGenerator } from './wire-binding-generator';
 import { GraphQLImperativeAdapterBindingGenerator } from './graphql-imperative-binding-generator';
 import { GraphQLWireAdapterBindingGenerator } from './graphql-wire-binding-generator';
 import { GraphQLMutationAdapterBindingGenerator } from './graphql-mutation-binding-generator';
+import type { File, ImportableValueReference } from '../files';
 import type { ICommandModel, ServiceDependency } from '../model/base-command-model';
 import type { NamedTypeRegistryGeneratorService, TypeRegistryGenerator } from '../normalization/type-registry-generator';
 import type { NamedGraphQLTypeRegistryGeneratorService } from '../normalization/graphql-type-registry-generator';
@@ -41,7 +42,10 @@ export declare class BindingsGenerator {
     protected typeInvalidationDefinitionSymbol: symbol;
     protected rootTypesInstantiationSymbol: symbol;
     protected exportsTypeMembersSymbol: symbol;
-    protected exportsAssignmentsSymbol: symbol;
+    protected initGeneratedBindingsExtraParamsSymbol: symbol;
+    protected returnStatementSymbol: symbol;
+    protected wrapperDeclarationsSymbol: symbol;
+    protected wrapperAssignmentsSymbol: symbol;
     /**
      * Template for generating the binding structure in the output file.
      * Includes placeholders for adapter declarations, service requirements, and adapter invocations.
@@ -55,13 +59,67 @@ export declare class BindingsGenerator {
      * @returns {Code[]} An array of code blocks forming the template for the binding output file.
      */
     get coreTemplate(): (symbol | Code)[];
-    get wrapperTemplate(): Code[];
+    get wrapperTemplate(): (symbol | Code)[];
     protected get serviceDependencies(): ServiceDependency[];
     /**
      * Builds the binding file, generating declarations, requirements, and invocations for each command model.
      * This method coordinates with individual binding generators to compile the necessary elements into a single file.
      */
     build(): void;
+    /**
+     * Emits re-export statements from bindings-core so that custom bindings modules
+     * can import generated internals from a single stable entry point.
+     */
+    protected buildReExports(coreFile: File, refs: {
+        typeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+        graphqlTypeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+    }): void;
+    /**
+     * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Capitalized>CommandClass`),
+     * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
+     * (aliased to `<Capitalized>Config`).
+     *
+     * The CONFIG_SCHEMA alias uses a simple uppercase of the commandName (e.g. `getItemsByIds`
+     * becomes `GETITEMSBYIDS_CONFIG_SCHEMA`) to avoid ambiguity from word-boundary heuristics.
+     */
+    protected buildCommandReExports(coreFile: File): void;
+    /**
+     * Re-exports the `TypeRegistry` (REST) and/or `GraphQLTypeRegistry` (GraphQL) classes
+     * so custom bindings can construct or extend them.
+     */
+    protected buildTypeRegistryReExports(coreFile: File, refs: {
+        typeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+        graphqlTypeRegistryRef?: ImportableValueReference & {
+            filename: string;
+            exportedSymbol: string;
+        };
+    }): void;
+    /**
+     * Re-exports individual generated type repository classes (e.g. `RecordRepresentationRepository`)
+     * so custom bindings can extend or reference them without importing from internal paths.
+     *
+     * If both REST and GraphQL registries produce a repository with the same exported symbol,
+     * the GraphQL version is aliased with a `GraphQL_` prefix to avoid collisions.
+     */
+    protected buildTypeRepositoryReExports(coreFile: File): void;
+    /**
+     * Re-exports all generated entity types so custom bindings can reference
+     * domain models (e.g. `api_Item`) without importing from internal paths.
+     *
+     * The barrel `types/index.ts` is built incrementally by TypeDefinitionService
+     * as types are generated; we just re-export it from bindings-core.
+     * GraphQL-only specs produce no REST types so the barrel is never created.
+     */
+    protected buildEntityTypeReExports(coreFile: File): void;
     buildTypeInvalidation(typesWithNormalization: TypeRegistryGenerator['invalidatableTypes']): {
         definitions: Code[];
         declarations: Code[];

package/dist/types/v1/normalization/graphql-type-registry-generator.d.ts

@@ -4,7 +4,7 @@ import type { NamedFileService, File, ImportableValueReference, ImportableRefere
 import type { NamedService } from '@conduit-client/utils';
 import type { GraphQLSchemaModel } from '../model/graphql-schema-model';
 import type { GraphQLObjectType } from './graphql-type-generator';
-type GraphQLTypeRepositoryReference = {
+export type GraphQLTypeRepositoryReference = {
     propertyName: string;
     typeClassRef: ImportableValueReference;
     typeName: string;
@@ -16,6 +16,7 @@ type Options = {
 export type IGraphQLTypeRegistryGeneratorService = {
     build(): ImportableValueReference;
     buildGraphQLType(options: Options): GraphQLTypeRepositoryReference;
+    readonly registeredTypes: ReadonlyMap<string, GraphQLTypeRepositoryReference>;
 };
 export type NamedGraphQLTypeRegistryGeneratorService<Name extends string = 'graphqlTypeRegistryGenerator'> = NamedService<Name, IGraphQLTypeRegistryGeneratorService>;
 export declare const NAMED_CACHE_CONTROLLER_SERVICE: ImportableReference;
@@ -35,6 +36,7 @@ export declare class GraphQLTypeRegistryGenerator implements IGraphQLTypeRegistr
     protected typeInstantiationsSymbol: symbol;
     protected typeGettersSymbol: symbol;
     cache: Map<string, GraphQLTypeRepositoryReference>;
+    get registeredTypes(): ReadonlyMap<string, GraphQLTypeRepositoryReference>;
     private get file();
     private buildFile;
     get template(): (symbol | import("..").Code)[];

package/dist/types/v1/normalization/type-registry-generator.d.ts

@@ -6,7 +6,7 @@ import type { INormalizedTypeGenerator } from './normalized-type-generator';
 import type { NamedService } from '@conduit-client/utils';
 import type { File, ImportableValueReference, NamedFileService } from '../files';
 import type { NamedNormalizeGeneratorService } from './normalize-code-gen/normalize-generator-service';
-type TypeRepositoryReference = {
+export type TypeRepositoryReference = {
     propertyName: string;
     typeClassRef: ImportableValueReference;
 };
@@ -20,6 +20,7 @@ export type ITypeRegistryGeneratorService = {
     build(): ImportableValueReference;
     buildType(type: Type, options: Options): TypeRepositoryReference;
     invalidatableTypes: TypeRepositoryReference[];
+    readonly registeredTypes: ReadonlyMap<string, TypeRepositoryReference>;
 };
 export type NamedTypeRegistryGeneratorService<Name extends string = 'typeRegistryGenerator'> = NamedService<Name, ITypeRegistryGeneratorService>;
 /**
@@ -40,6 +41,7 @@ export declare class TypeRegistryGenerator implements ITypeRegistryGeneratorServ
      * after all operations precessing is complete.
      */
     invalidatableTypes: TypeRepositoryReference[];
+    get registeredTypes(): ReadonlyMap<string, TypeRepositoryReference>;
     private get file();
     private buildFile;
     get template(): (symbol | Code)[];

package/dist/types/v1/types/type-definition.d.ts

@@ -9,6 +9,7 @@ export type TypeDefinitionForOptions = {
 };
 export type ITypeDefinitionService = {
     build(type: Type | undefined): Code;
+    readonly hasTypes: boolean;
 };
 export type NamedTypeDefinitionService = NamedService<'typeDefinition', ITypeDefinitionService>;
 export declare class TypeDefinitionService implements ITypeDefinitionService {
@@ -16,6 +17,7 @@ export declare class TypeDefinitionService implements ITypeDefinitionService {
     private fileFor;
     constructor(services: NamedAPIService & NamedFileService, fileFor?: (typename: string) => string);
     cache: Map<string, ImportableReference>;
+    get hasTypes(): boolean;
     build(type: Type | undefined, useReferences?: boolean): Code;
     buildTypeCode(t: Type, options: TypeDefinitionForOptions): Code;
     buildReferenceCode(refType: RefType, options: TypeDefinitionForOptions): Code;
@@ -32,4 +34,6 @@ export declare function typeDefinitions(services: NamedAPIService & NamedFileSer
     fileFor?: (typename: string) => string;
 }): TypeDefinitionService;
 export declare const FILE_PER_TYPE: (typename: string) => string;
+export declare const TYPES_SINGLE_FILE_PATH = "types/types.ts";
 export declare const SINGLE_FILE: (_: string) => string;
+export declare const TYPES_INDEX_PATH = "types/index.ts";