@conduit-client/generator-ts 3.15.1 → 3.16.0-dev1

package/dist/types/v1/generators/__tests__/built-test-model.d.ts

@@ -1,5 +1,5 @@
-import { Type } from '@conduit-client/model/v1';
-import { ICommandModel } from '../../model/base-command-model';
+import type { Type } from '@conduit-client/model/v1';
+import type { ICommandModel } from '../../model/base-command-model';
 export declare function buildAuraCommandModel(filePath: string, configType: Type, responseType: Type): ICommandModel;
 export declare function buildAuraResourceCacheCommandModel(filePath: string, configType: Type, responseType: Type): ICommandModel;
 export declare function buildAuraNormalizedCacheCommandModel(filePath: string, configType: Type, responseType: Type): ICommandModel;

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

@@ -42,6 +42,8 @@ export declare class BindingsGenerator {
     protected rootTypesInstantiationSymbol: symbol;
     protected exportsTypeMembersSymbol: symbol;
     protected exportsAssignmentsSymbol: symbol;
+    protected initGeneratedBindingsExtraParamsSymbol: symbol;
+    protected reExportsSymbol: symbol;
     /**
      * Template for generating the binding structure in the output file.
      * Includes placeholders for adapter declarations, service requirements, and adapter invocations.
@@ -62,6 +64,58 @@ export declare class BindingsGenerator {
      * This method coordinates with individual binding generators to compile the necessary elements into a single file.
      */
     build(): void;
+    /**
+     * Computes a relative import specifier from the bindings-core file to the
+     * given generated file path (e.g. `commands/getTestCommand.ts` -> `../commands/getTestCommand`).
+     */
+    protected relativeImportPath(coreFilename: string, targetFilePath: string): string;
+    /**
+     * 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: {
+        filename: string;
+        pushTo: (...args: any[]) => any;
+    }): void;
+    /**
+     * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Pascal>CommandClass`),
+     * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
+     * (aliased to `<Pascal>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: {
+        filename: string;
+        pushTo: (...args: any[]) => any;
+    }): void;
+    /**
+     * Re-exports the `TypeRegistry` (REST) and/or `GraphQLTypeRegistry` (GraphQL) classes
+     * so custom bindings can construct or extend them.
+     */
+    protected buildTypeRegistryReExports(coreFile: {
+        filename: string;
+        pushTo: (...args: any[]) => any;
+    }): 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: {
+        filename: string;
+        pushTo: (...args: any[]) => any;
+    }): void;
+    /**
+     * Re-exports all generated entity types so custom bindings can reference
+     * domain models (e.g. `api_Item`) without importing from internal paths.
+     */
+    protected buildEntityTypeReExports(coreFile: {
+        filename: string;
+        pushTo: (...args: any[]) => any;
+    }): 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/normalize-code-gen/__tests__/utils.d.ts

@@ -1,5 +1,6 @@
-import { BaseTypeRegistry, Type } from '@conduit-client/model/v1';
+import { BaseTypeRegistry } from '@conduit-client/model/v1';
 import { NormalizeGeneratorService } from '../../normalize-code-gen/normalize-generator-service';
+import type { Type } from '@conduit-client/model/v1';
 export declare const baseOptions: {
     namespace: string;
     typeRegistryRef: 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/v1/index.js

@@ -6,7 +6,7 @@
 import * as path from "path";
 import { resolve } from "path";
 import * as prettier from "prettier";
-import { toTypeScriptSafeIdentifier, JSONStringify, ok, err, stringIsVersion, stableJSONStringify } from "@conduit-client/utils";
+import { toTypeScriptSafeIdentifier, JSONStringify, ok, err, toPascalCase, stringIsVersion, stableJSONStringify } from "@conduit-client/utils";
 import * as fs from "fs";
 import { readFileSync } from "fs";
 import { isAnyType, isRefType, isAllOfType, isOneOfType, isNotType, isObjectType as isObjectType$2, isDiscriminatedObjectType, isArrayType, isScalar, isEnumType as isEnumType$1, isNilType, isCanonicalStringType, isCanonicalNumberType, isBooleanType, typesEqual, isIdentifiableType as isIdentifiableType$1, canonicalizeType } from "@conduit-client/model/v1";
@@ -1453,6 +1453,9 @@ class TypeRegistryGenerator {
     this.cache = /* @__PURE__ */ new Map();
     this.invalidatableTypes = [];
   }
+  get registeredTypes() {
+    return this.cache;
+  }
   get file() {
     return this.buildFile();
   }
@@ -2048,6 +2051,9 @@ class GraphQLTypeRegistryGenerator {
   setGraphQLTypeGenerator(generator) {
     this.graphqlTypeGenerator = generator;
   }
+  get registeredTypes() {
+    return this.cache;
+  }
   get file() {
     if (this._file) {
       return this._file;
@@ -3530,6 +3536,10 @@ class BindingsGenerator {
     this.rootTypesInstantiationSymbol = Symbol.for("rootTypesInstantiation");
     this.exportsTypeMembersSymbol = Symbol.for("exportsTypeMembers");
     this.exportsAssignmentsSymbol = Symbol.for("exportsAssignments");
+    this.initGeneratedBindingsExtraParamsSymbol = Symbol.for(
+      "initGeneratedBindingsExtraParams"
+    );
+    this.reExportsSymbol = Symbol.for("reExports");
   }
   /**
    * Template for generating the binding structure in the output file.
@@ -3555,13 +3565,16 @@ class BindingsGenerator {
       code`export const serviceRequirements=`,
       this.serviceRequirementsSymbol,
       code` as const;`,
-      code`export function initGeneratedBindings(services: ${REQUESTED_SERVICES_TYPE}<typeof serviceRequirements>, exports: BindingsExports) {`,
+      code`export function initGeneratedBindings<S extends ${REQUESTED_SERVICES_TYPE}<typeof serviceRequirements>>(services: S, exports: BindingsExports`,
+      this.initGeneratedBindingsExtraParamsSymbol,
+      code`) {`,
       this.typeRegistryInstantiationSymbol,
       this.rootTypesInstantiationSymbol,
       this.typeInvalidationDefinitionSymbol,
       this.adapterInvocationSymbol,
       this.exportsAssignmentsSymbol,
-      code`}`
+      code`}`,
+      this.reExportsSymbol
     ];
   }
   get wrapperTemplate() {
@@ -3705,9 +3718,14 @@ class BindingsGenerator {
     wrapperFile.template = this.wrapperTemplate;
     if (this.hasRESTNormalization) {
       const { typeRegistryGenerator } = this.services;
+      const typeRegistryRef = typeRegistryGenerator.build();
+      coreFile.pushTo(
+        this.initGeneratedBindingsExtraParamsSymbol,
+        code`, typeRegistry?: ${typeRegistryRef}`
+      );
       coreFile.pushTo(
         this.typeRegistryInstantiationSymbol,
-        code`const typeRegistry = new ${typeRegistryGenerator.build()}(services);`
+        code`typeRegistry ??= new ${typeRegistryRef}(services);`
       );
       const { declarations, definitions } = this.buildTypeInvalidation(
         typeRegistryGenerator.invalidatableTypes
@@ -3717,7 +3735,11 @@ class BindingsGenerator {
     }
     if (this.hasGraphQL) {
       const { graphqlTypeRegistryGenerator } = this.services;
-      const graphqlTypeRegistry = graphqlTypeRegistryGenerator.build();
+      const graphqlTypeRegistryRef = graphqlTypeRegistryGenerator.build();
+      coreFile.pushTo(
+        this.initGeneratedBindingsExtraParamsSymbol,
+        code`, graphqlTypeRegistry?: ${graphqlTypeRegistryRef}`
+      );
       const firstGraphQLCommand = this.commandModels.find(
         (model) => model.operationType === "graphql"
       );
@@ -3737,7 +3759,7 @@ class BindingsGenerator {
       }) : void 0;
       coreFile.pushTo(
         this.rootTypesInstantiationSymbol,
-        code`const graphqlTypeRegistry = new ${graphqlTypeRegistry}(services);
+        code`graphqlTypeRegistry ??= new ${graphqlTypeRegistryRef}(services);
                 const ${QUERY_TYPE_VARIABLE_NAME} = graphqlTypeRegistry.${queryType.propertyName};`
       );
       if (mutationType) {
@@ -3801,6 +3823,116 @@ class BindingsGenerator {
         "\n"
       )
     );
+    this.buildReExports(coreFile);
+  }
+  /**
+   * Computes a relative import specifier from the bindings-core file to the
+   * given generated file path (e.g. `commands/getTestCommand.ts` -> `../commands/getTestCommand`).
+   */
+  relativeImportPath(coreFilename, targetFilePath) {
+    const rel = path.relative(path.dirname(coreFilename), targetFilePath).replace(/\.ts$/, "");
+    return rel.startsWith(".") ? rel : "./" + rel;
+  }
+  /**
+   * Emits re-export statements from bindings-core so that custom bindings modules
+   * can import generated internals from a single stable entry point.
+   */
+  buildReExports(coreFile) {
+    this.buildCommandReExports(coreFile);
+    this.buildTypeRegistryReExports(coreFile);
+    this.buildTypeRepositoryReExports(coreFile);
+    this.buildEntityTypeReExports(coreFile);
+  }
+  /**
+   * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Pascal>CommandClass`),
+   * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
+   * (aliased to `<Pascal>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.
+   */
+  buildCommandReExports(coreFile) {
+    for (const model of this.commandModels) {
+      const pascal = toPascalCase(model.commandName);
+      const upper = model.commandName.toUpperCase();
+      const relPath = this.relativeImportPath(coreFile.filename, model.filePath);
+      coreFile.pushTo(
+        this.reExportsSymbol,
+        code`export { buildCommandClass as build${pascal}CommandClass, CONFIG_SCHEMA as ${upper}_CONFIG_SCHEMA } from "${relPath}";`,
+        code`export type { Config as ${pascal}Config } from "${relPath}";`
+      );
+    }
+  }
+  /**
+   * Re-exports the `TypeRegistry` (REST) and/or `GraphQLTypeRegistry` (GraphQL) classes
+   * so custom bindings can construct or extend them.
+   */
+  buildTypeRegistryReExports(coreFile) {
+    if (this.hasRESTNormalization) {
+      const relPath = this.relativeImportPath(
+        coreFile.filename,
+        "normalization/type-registry.ts"
+      );
+      coreFile.pushTo(this.reExportsSymbol, code`export { TypeRegistry } from "${relPath}";`);
+    }
+    if (this.hasGraphQL) {
+      const relPath = this.relativeImportPath(
+        coreFile.filename,
+        "normalization/graphql-type-registry.ts"
+      );
+      coreFile.pushTo(
+        this.reExportsSymbol,
+        code`export { GraphQLTypeRegistry } from "${relPath}";`
+      );
+    }
+  }
+  /**
+   * 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.
+   */
+  buildTypeRepositoryReExports(coreFile) {
+    const restRepos = this.hasRESTNormalization ? [...this.services.typeRegistryGenerator.registeredTypes.values()] : [];
+    const graphqlRepos = this.hasGraphQL ? [...this.services.graphqlTypeRegistryGenerator.registeredTypes.values()] : [];
+    const restNames = new Set(restRepos.map((r) => r.typeClassRef.exportedSymbol));
+    const graphqlNames = new Set(graphqlRepos.map((r) => r.typeClassRef.exportedSymbol));
+    const conflicts = new Set([...restNames].filter((n) => graphqlNames.has(n)));
+    for (const { typeClassRef } of restRepos) {
+      if (!("filename" in typeClassRef)) continue;
+      const relPath = this.relativeImportPath(coreFile.filename, typeClassRef.filename);
+      coreFile.pushTo(
+        this.reExportsSymbol,
+        code`export { ${typeClassRef.exportedSymbol} } from "${relPath}";`
+      );
+    }
+    for (const { typeClassRef } of graphqlRepos) {
+      if (!("filename" in typeClassRef)) continue;
+      const relPath = this.relativeImportPath(coreFile.filename, typeClassRef.filename);
+      const symbol = typeClassRef.exportedSymbol;
+      if (conflicts.has(symbol)) {
+        coreFile.pushTo(
+          this.reExportsSymbol,
+          code`export { ${symbol} as GraphQL_${symbol} } from "${relPath}";`
+        );
+      } else {
+        coreFile.pushTo(
+          this.reExportsSymbol,
+          code`export { ${symbol} } from "${relPath}";`
+        );
+      }
+    }
+  }
+  /**
+   * Re-exports all generated entity types so custom bindings can reference
+   * domain models (e.g. `api_Item`) without importing from internal paths.
+   */
+  buildEntityTypeReExports(coreFile) {
+    if (this.hasRESTNormalization) {
+      const relPath = this.relativeImportPath(coreFile.filename, "types/types.ts");
+      coreFile.pushTo(this.reExportsSymbol, code`export type * from "${relPath}";`);
+    }
   }
   buildTypeInvalidation(typesWithNormalization) {
     return typesWithNormalization.reduce(