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

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/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';
@@ -43,7 +44,6 @@ export declare class BindingsGenerator {
     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.
@@ -64,38 +64,42 @@ 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;
+    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<Pascal>CommandClass`),
+     * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Capitalized>CommandClass`),
      * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
-     * (aliased to `<Pascal>Config`).
+     * (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: {
-        filename: string;
-        pushTo: (...args: any[]) => any;
-    }): void;
+    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: {
-        filename: string;
-        pushTo: (...args: any[]) => any;
+    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`)
@@ -104,18 +108,16 @@ export declare class BindingsGenerator {
      * 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;
+    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: {
-        filename: string;
-        pushTo: (...args: any[]) => any;
-    }): void;
+    protected buildEntityTypeReExports(coreFile: File): void;
     buildTypeInvalidation(typesWithNormalization: TypeRegistryGenerator['invalidatableTypes']): {
         definitions: Code[];
         declarations: 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";

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, toPascalCase, stringIsVersion, stableJSONStringify } from "@conduit-client/utils";
+import { toTypeScriptSafeIdentifier, JSONStringify, ok, err, capitalizeFirst, 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";
@@ -116,6 +116,10 @@ class Files {
 function fileService() {
   return new Files();
 }
+function resolveRelativeImportPath(fromFile, toFile) {
+  const rel = path.relative(path.dirname(fromFile), toFile).replace(/\.(js|ts)$/, "");
+  return rel.startsWith(".") ? rel : "./" + rel;
+}
 class Imports {
   /**
    * Constructor
@@ -156,10 +160,7 @@ class Imports {
     }
     let from;
     if ("filename" in ref) {
-      from = path.relative(path.dirname(this.filename), ref.filename).replace(/\.(js|ts)$/, "");
-      if (!from.startsWith(".")) {
-        from = "./" + from;
-      }
+      from = resolveRelativeImportPath(this.filename, ref.filename);
     } else {
       from = ref.module;
     }
@@ -224,11 +225,59 @@ class Imports {
     ].join("");
   }
 }
+class ReExports {
+  constructor(filename) {
+    this.filename = filename;
+    this.entries = {};
+    this.typeAllPaths = /* @__PURE__ */ new Set();
+  }
+  resolveFrom(targetFilename) {
+    return resolveRelativeImportPath(this.filename, targetFilename);
+  }
+  /**
+   * Registers a value or type re-export: `export { symbol [as alias] } from "…";`
+   * @param targetFilename the filename of the target file to re-export
+   * @param exportedSymbol the symbol to export
+   * @param alias an optional alias for the symbol
+   * @param isType true if the re-export is for a type; false if it is for a value
+   */
+  add(targetFilename, exportedSymbol, alias, isType2) {
+    const from = this.resolveFrom(targetFilename);
+    if (!this.entries[from]) {
+      this.entries[from] = [];
+    }
+    this.entries[from].push({ exportedSymbol, alias, isType: isType2 });
+  }
+  /**
+   * Registers a wildcard type re-export: `export type * from "…";`
+   * @param targetFilename the filename of the target file to re-export
+   */
+  addTypeAll(targetFilename) {
+    this.typeAllPaths.add(this.resolveFrom(targetFilename));
+  }
+  toString() {
+    const statements = [];
+    for (const from of Object.keys(this.entries)) {
+      const entries = this.entries[from];
+      for (const isType2 of [false, true]) {
+        const clauses = entries.filter((e) => e.isType === isType2).map((e) => e.alias ? `${e.exportedSymbol} as ${e.alias}` : e.exportedSymbol).join(",");
+        if (clauses) {
+          statements.push(`export ${isType2 ? "type " : ""}{${clauses}} from '${from}';`);
+        }
+      }
+    }
+    for (const from of this.typeAllPaths) {
+      statements.push(`export type * from '${from}';`);
+    }
+    return statements.length > 0 ? statements.join("") : "";
+  }
+}
 const _File = class _File {
   constructor(filename) {
     this.filename = filename;
     this.blocks = /* @__PURE__ */ new Map();
     this.template = [_File.DEFAULT_BLOCK];
+    this.reExports = new ReExports(this.filename);
   }
   /**
    * Appends new chunks of code to the default code block. Chunks are handled
@@ -256,6 +305,18 @@ const _File = class _File {
     code2.push(...chunks);
     return this;
   }
+  /** Registers a value re-export: `export { symbol [as alias] } from "…";` */
+  reExport(ref, alias) {
+    this.reExports.add(ref.filename, ref.exportedSymbol, alias, false);
+  }
+  /** Registers a type re-export: `export type { symbol [as alias] } from "…";` */
+  reExportType(ref, alias) {
+    this.reExports.add(ref.filename, ref.exportedSymbol, alias, true);
+  }
+  /** Registers a wildcard type re-export: `export type * from "…";` */
+  reExportTypeAll(targetFilename) {
+    this.reExports.addTypeAll(targetFilename);
+  }
   /**
    * Returns the code for this File, with ImportableReferences resolved.
    *
@@ -272,7 +333,7 @@ const _File = class _File {
     const executableCode = finalCode.toString({
       importStringifier: (ir) => imports.localSymbolFor(ir)
     });
-    const code2 = imports.toString() + executableCode;
+    const code2 = imports.toString() + executableCode + this.reExports.toString();
     if (options.prettified) {
       try {
         return prettier.format(code2, { parser: "typescript" });
@@ -395,6 +456,9 @@ class TypeDefinitionService {
     this.fileFor = fileFor;
     this.cache = /* @__PURE__ */ new Map();
   }
+  get hasTypes() {
+    return this.cache.size > 0;
+  }
   build(type, useReferences = true) {
     return type ? this.buildTypeCode(type, {
       referenceFor: (t) => {
@@ -581,6 +645,7 @@ class TypeDefinitionService {
     this.cache.set(typename, result);
     const declaration = code`export type ${exportedSymbol}=${this.build(type, false)};`;
     this.services.file.build(filename).push(declaration);
+    this.services.file.build(TYPES_INDEX_PATH).reExportTypeAll(filename);
     return result;
   }
 }
@@ -588,7 +653,9 @@ function typeDefinitions(services, options = {}) {
   return new TypeDefinitionService(services, options.fileFor || SINGLE_FILE);
 }
 const FILE_PER_TYPE = (typename) => `types/${typename}.ts`;
-const SINGLE_FILE = (_) => "types/types.ts";
+const TYPES_SINGLE_FILE_PATH = "types/types.ts";
+const SINGLE_FILE = (_) => TYPES_SINGLE_FILE_PATH;
+const TYPES_INDEX_PATH = "types/index.ts";
 const SCHEMA_FILE_PATH = "json-schema/index.ts";
 const COMBINED_SCHEMA = {
   filename: SCHEMA_FILE_PATH,
@@ -3539,7 +3606,6 @@ class BindingsGenerator {
     this.initGeneratedBindingsExtraParamsSymbol = Symbol.for(
       "initGeneratedBindingsExtraParams"
     );
-    this.reExportsSymbol = Symbol.for("reExports");
   }
   /**
    * Template for generating the binding structure in the output file.
@@ -3573,8 +3639,7 @@ class BindingsGenerator {
       this.typeInvalidationDefinitionSymbol,
       this.adapterInvocationSymbol,
       this.exportsAssignmentsSymbol,
-      code`}`,
-      this.reExportsSymbol
+      code`}`
     ];
   }
   get wrapperTemplate() {
@@ -3716,9 +3781,11 @@ class BindingsGenerator {
     const wrapperFilename = "artifacts/bindings.ts";
     const wrapperFile = this.services.file.build(wrapperFilename);
     wrapperFile.template = this.wrapperTemplate;
+    let typeRegistryRef;
+    let graphqlTypeRegistryRef;
     if (this.hasRESTNormalization) {
       const { typeRegistryGenerator } = this.services;
-      const typeRegistryRef = typeRegistryGenerator.build();
+      typeRegistryRef = typeRegistryGenerator.build();
       coreFile.pushTo(
         this.initGeneratedBindingsExtraParamsSymbol,
         code`, typeRegistry?: ${typeRegistryRef}`
@@ -3735,7 +3802,7 @@ class BindingsGenerator {
     }
     if (this.hasGraphQL) {
       const { graphqlTypeRegistryGenerator } = this.services;
-      const graphqlTypeRegistryRef = graphqlTypeRegistryGenerator.build();
+      graphqlTypeRegistryRef = graphqlTypeRegistryGenerator.build();
       coreFile.pushTo(
         this.initGeneratedBindingsExtraParamsSymbol,
         code`, graphqlTypeRegistry?: ${graphqlTypeRegistryRef}`
@@ -3823,67 +3890,60 @@ 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;
+    this.buildReExports(coreFile, { typeRegistryRef, graphqlTypeRegistryRef });
   }
   /**
    * Emits re-export statements from bindings-core so that custom bindings modules
    * can import generated internals from a single stable entry point.
    */
-  buildReExports(coreFile) {
+  buildReExports(coreFile, refs) {
     this.buildCommandReExports(coreFile);
-    this.buildTypeRegistryReExports(coreFile);
+    this.buildTypeRegistryReExports(coreFile, refs);
     this.buildTypeRepositoryReExports(coreFile);
     this.buildEntityTypeReExports(coreFile);
   }
   /**
-   * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Pascal>CommandClass`),
+   * Re-exports per-command symbols: `buildCommandClass` (aliased to `build<Capitalized>CommandClass`),
    * `CONFIG_SCHEMA` (aliased to `<UPPER>_CONFIG_SCHEMA`), and the `Config` type
-   * (aliased to `<Pascal>Config`).
+   * (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.
    */
   buildCommandReExports(coreFile) {
     for (const model of this.commandModels) {
-      const pascal = toPascalCase(model.commandName);
+      const capitalized = capitalizeFirst(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}";`
-      );
+      const buildRef = {
+        filename: model.filePath,
+        exportedSymbol: "buildCommandClass",
+        isType: false
+      };
+      const schemaRef = {
+        filename: model.filePath,
+        exportedSymbol: "CONFIG_SCHEMA",
+        isType: false
+      };
+      const configRef = {
+        filename: model.filePath,
+        exportedSymbol: "Config",
+        isType: true
+      };
+      coreFile.reExport(buildRef, `build${capitalized}CommandClass`);
+      coreFile.reExport(schemaRef, `${upper}_CONFIG_SCHEMA`);
+      coreFile.reExportType(configRef, `${capitalized}Config`);
     }
   }
   /**
    * 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}";`);
+  buildTypeRegistryReExports(coreFile, refs) {
+    if (refs.typeRegistryRef) {
+      coreFile.reExport(refs.typeRegistryRef);
     }
-    if (this.hasGraphQL) {
-      const relPath = this.relativeImportPath(
-        coreFile.filename,
-        "normalization/graphql-type-registry.ts"
-      );
-      coreFile.pushTo(
-        this.reExportsSymbol,
-        code`export { GraphQLTypeRegistry } from "${relPath}";`
-      );
+    if (refs.graphqlTypeRegistryRef) {
+      coreFile.reExport(refs.graphqlTypeRegistryRef);
     }
   }
   /**
@@ -3900,38 +3960,29 @@ class BindingsGenerator {
     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}";`
-      );
+      if (!("filename" in typeClassRef) || !typeClassRef.exportedSymbol) continue;
+      coreFile.reExport(typeClassRef);
     }
     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}";`
-        );
-      }
+      if (!("filename" in typeClassRef) || !typeClassRef.exportedSymbol) continue;
+      const alias = conflicts.has(typeClassRef.exportedSymbol) ? `GraphQL_${typeClassRef.exportedSymbol}` : void 0;
+      coreFile.reExport(
+        typeClassRef,
+        alias
+      );
     }
   }
   /**
    * 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.
    */
   buildEntityTypeReExports(coreFile) {
-    if (this.hasRESTNormalization) {
-      const relPath = this.relativeImportPath(coreFile.filename, "types/types.ts");
-      coreFile.pushTo(this.reExportsSymbol, code`export type * from "${relPath}";`);
+    if (this.services.typeDefinition.hasTypes) {
+      coreFile.reExportTypeAll(TYPES_INDEX_PATH);
     }
   }
   buildTypeInvalidation(typesWithNormalization) {
@@ -13785,6 +13836,8 @@ export {
   NormalizedTypeGenerator,
   SINGLE_FILE,
   SINGLE_FILE_NORMALIZED,
+  TYPES_INDEX_PATH,
+  TYPES_SINGLE_FILE_PATH,
   TYPE_REGISTRY_FILE,
   TypeDefinitionService,
   TypeRegistryGenerator,