@hexaijs/plugin-contracts-generator 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -1,34 +1,8 @@
-import { D as DecoratorNames, M as MessageType, R as ResponseNamingConvention, S as SourceFile, a as DomainEvent, C as Command, Q as Query, T as TypeDefinition, b as ContractsPluginConfig } from './cli-CPg-O4OY.js';
-export { A as ArrayType, c as ClassDefinition, d as ClassImport, e as Config, f as Dependency, g as DependencyKind, E as EnumDefinition, h as EnumMember, i as ExtractionError, j as ExtractionResult, k as ExtractionWarning, F as Field, l as FunctionParameter, m as FunctionType, I as ImportSource, n as IntersectionType, L as LiteralType, o as Message, p as MessageBase, O as ObjectType, P as PrimitiveType, q as ReferenceType, r as TupleType, s as TypeDefinitionKind, t as TypeRef, U as UnionType, u as isArrayType, v as isCommand, w as isDomainEvent, x as isFunctionType, y as isIntersectionType, z as isLiteralType, B as isObjectType, G as isPrimitiveType, H as isReferenceType, J as isTupleType, K as isUnionType } from './cli-CPg-O4OY.js';
-export { PublicCommand, PublicCommandOptions, PublicEvent, PublicEventOptions, PublicQuery, PublicQueryOptions } from './decorators/index.js';
+import { F as FileSystem, D as DecoratorNames, M as MessageType, R as ResponseNamingConvention, S as SourceFile, a as DomainEvent, C as Command, Q as Query, T as TypeDefinition, b as ContextConfig, I as InputContextConfig, c as ContractsPluginConfig } from './cli-DajurpEQ.js';
+export { A as ArrayType, d as ClassDefinition, e as ClassImport, f as Config, g as Dependency, h as DependencyKind, E as EnumDefinition, i as EnumMember, j as ExtractionError, k as ExtractionResult, l as ExtractionWarning, m as Field, n as FileStats, o as FunctionParameter, p as FunctionType, q as ImportSource, r as IntersectionType, L as LiteralType, s as Message, t as MessageBase, O as ObjectType, P as PrimitiveType, u as ReferenceType, v as TupleType, w as TypeDefinitionKind, x as TypeRef, U as UnionType, y as isArrayType, z as isCommand, B as isDomainEvent, G as isFunctionType, H as isIntersectionType, J as isLiteralType, K as isObjectType, N as isPrimitiveType, V as isReferenceType, W as isTupleType, X as isUnionType, Y as nodeFileSystem } from './cli-DajurpEQ.js';
+export { PublicCommand, PublicCommandOptions, PublicEvent, PublicEventOptions, PublicQuery, PublicQueryOptions } from '@hexaijs/contracts/decorators';
 import { HexaiCliPlugin } from '@hexaijs/cli';
 
-interface FileStats {
-    isDirectory(): boolean;
-    isFile(): boolean;
-}
-interface FileSystem {
-    readFile(path: string): Promise<string>;
-    readdir(path: string): Promise<string[]>;
-    writeFile(path: string, content: string): Promise<void>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<FileStats>;
-}
-declare class NodeFileSystem implements FileSystem {
-    readFile(path: string): Promise<string>;
-    readdir(path: string): Promise<string[]>;
-    writeFile(path: string, content: string): Promise<void>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<FileStats>;
-}
-declare const nodeFileSystem: NodeFileSystem;
-
 interface ScannerOptions {
     exclude?: string[];
     fileSystem?: FileSystem;
@@ -78,48 +52,6 @@ declare class Parser {
     private buildTypeDefinition;
 }
 
-interface InputContextConfig {
-    readonly name: string;
-    readonly path: string;
-    readonly sourceDir?: string;
-    readonly tsconfigPath?: string;
-    readonly responseNamingConventions?: readonly ResponseNamingConvention[];
-}
-/**
- * Encapsulates context configuration with path resolution capabilities.
- * Created via factory method to ensure proper initialization.
- */
-declare class ContextConfig {
-    private readonly fs;
-    private readonly tsconfig;
-    readonly name: string;
-    readonly sourceDir: string;
-    readonly responseNamingConventions?: readonly ResponseNamingConvention[];
-    private constructor();
-    /**
-     * Factory method to create ContextConfig with properly loaded tsconfig.
-     */
-    static create(input: InputContextConfig, configDir: string, fs?: FileSystem): Promise<ContextConfig>;
-    private static loadTsconfig;
-    /**
-     * Creates a ContextConfig without async loading (for cases where tsconfig is not needed
-     * or already handled externally).
-     */
-    static createSync(name: string, sourceDir: string, fs?: FileSystem, responseNamingConventions?: readonly ResponseNamingConvention[]): ContextConfig;
-    /**
-     * Resolves a module specifier (path alias) to actual file path.
-     * Only handles non-relative imports (path aliases).
-     *
-     * @param moduleSpecifier - The import path to resolve (e.g., "@/utils/helper")
-     * @returns Object with resolvedPath (null if external) and isExternal flag
-     */
-    resolvePath(moduleSpecifier: string): Promise<{
-        resolvedPath: string | null;
-        isExternal: boolean;
-    }>;
-    private tryResolveWithExtensions;
-}
-
 interface ImportInfo {
     moduleSpecifier: string;
     resolvedPath: string | null;
@@ -324,17 +256,13 @@ interface ContractsConfig {
 interface ConfigLoaderOptions {
     fileSystem?: FileSystem;
 }
+declare function resolveContextEntries(entries: readonly (string | InputContextConfig)[], configDir: string, fs?: FileSystem): Promise<ContextConfig[]>;
 declare class ConfigLoader {
     private readonly fs;
     constructor(options?: ConfigLoaderOptions);
     load(configPath: string): Promise<ContractsConfig>;
     private loadTypeScriptConfig;
     private extractContractsConfig;
-    private resolveContexts;
-    private resolveStringContext;
-    private expandGlobPattern;
-    private createObjectContext;
-    private matchGlobPattern;
 }
 
 interface RegistryGeneratorOptions {
@@ -548,4 +476,4 @@ interface ProcessContextResult {
 }
 declare function processContext(options: ProcessContextOptions): Promise<ProcessContextResult>;
 
-export { type AnalyzeOptions, Command, ConfigLoadError, ConfigLoader, ConfigurationError, ConsoleLogger, type ConsoleLoggerOptions, ContextConfig, type ContextMessages, type ContractsConfig, ContractsPipeline, DomainEvent, FileCopier, FileGraphResolver, FileNotFoundError, FileReadError, type FileStats, type FileSystem, FileSystemError, FileWriteError, type GenerateOptions, type InputContextConfig, JsonParseError, type LogLevel, type Logger, MessageParserError, ModuleResolutionError, ParseError, type ParseResult, type ParsedMessages, Parser, type PipelineDependencies, type PipelineOptions, type PipelineResult, type ProcessContextOptions, type ProcessContextResult, type ReexportFile, ReexportGenerator, type ReexportGeneratorOptions, RegistryGenerator, type RegistryGeneratorOptions, ResolutionError, type RewrittenImport, Scanner, type ScannerOptions, SourceFile, TypeDefinition, cliPlugin, nodeFileSystem, noopLogger, processContext };
+export { type AnalyzeOptions, Command, ConfigLoadError, ConfigLoader, ConfigurationError, ConsoleLogger, type ConsoleLoggerOptions, ContextConfig, type ContextMessages, type ContractsConfig, ContractsPipeline, DomainEvent, FileCopier, FileGraphResolver, FileNotFoundError, FileReadError, FileSystem, FileSystemError, FileWriteError, type GenerateOptions, InputContextConfig, JsonParseError, type LogLevel, type Logger, MessageParserError, ModuleResolutionError, ParseError, type ParseResult, type ParsedMessages, Parser, type PipelineDependencies, type PipelineOptions, type PipelineResult, type ProcessContextOptions, type ProcessContextResult, type ReexportFile, ReexportGenerator, type ReexportGeneratorOptions, RegistryGenerator, type RegistryGeneratorOptions, ResolutionError, type RewrittenImport, Scanner, type ScannerOptions, SourceFile, TypeDefinition, cliPlugin, noopLogger, processContext, resolveContextEntries };

package/dist/index.js

@@ -1,11 +1,11 @@
-import 'reflect-metadata';
+export { PublicCommand, PublicEvent, PublicQuery } from '@hexaijs/contracts/decorators';
 import { glob } from 'glob';
 import { readFile, readdir, writeFile, mkdir, access, stat } from 'fs/promises';
 import { constants } from 'fs';
 import * as ts6 from 'typescript';
 import ts6__default from 'typescript';
 import * as path3 from 'path';
-import path3__default, { resolve, dirname, basename, relative, join } from 'path';
+import path3__default, { resolve, dirname, join, relative, basename } from 'path';
 import { minimatch } from 'minimatch';
 import { fileURLToPath } from 'url';
 
@@ -54,27 +54,6 @@ function isDomainEvent(message) {
 function isCommand(message) {
   return message.messageType === "command";
 }
-var PUBLIC_EVENT_METADATA = /* @__PURE__ */ Symbol("publicEvent");
-var PUBLIC_COMMAND_METADATA = /* @__PURE__ */ Symbol("publicCommand");
-var PUBLIC_QUERY_METADATA = /* @__PURE__ */ Symbol("publicQuery");
-function PublicEvent(options = {}) {
-  return (target) => {
-    Reflect.defineMetadata(PUBLIC_EVENT_METADATA, options, target);
-    return target;
-  };
-}
-function PublicCommand(options = {}) {
-  return (target) => {
-    Reflect.defineMetadata(PUBLIC_COMMAND_METADATA, options, target);
-    return target;
-  };
-}
-function PublicQuery(options = {}) {
-  return (target) => {
-    Reflect.defineMetadata(PUBLIC_QUERY_METADATA, options, target);
-    return target;
-  };
-}
 
 // src/errors.ts
 var MessageParserError = class extends Error {
@@ -1773,6 +1752,90 @@ var ContextConfig = class _ContextConfig {
 
 // src/config-loader.ts
 var SUPPORTED_GLOB_PARTS_COUNT = 2;
+async function resolveContextEntries(entries, configDir, fs = nodeFileSystem) {
+  const contexts = [];
+  for (let i = 0; i < entries.length; i++) {
+    const item = entries[i];
+    if (typeof item === "string") {
+      const resolved = await resolveStringEntry(item, configDir, fs);
+      contexts.push(...resolved);
+    } else {
+      const contextConfig = await createObjectContext(item, i, configDir, fs);
+      contexts.push(contextConfig);
+    }
+  }
+  return contexts;
+}
+async function resolveStringEntry(contextPath, configDir, fs) {
+  if (contextPath.includes("*")) {
+    return expandGlobPattern(contextPath, configDir, fs);
+  }
+  const basePath = resolve(configDir, contextPath);
+  const name = basename(basePath);
+  return [await ContextConfig.create(
+    { name, path: contextPath },
+    configDir,
+    fs
+  )];
+}
+async function expandGlobPattern(pattern, configDir, fs) {
+  const packageDirs = await matchGlobPattern(pattern, configDir, fs);
+  return Promise.all(
+    packageDirs.map((dir) => {
+      const name = basename(dir);
+      const relativePath = relative(configDir, dir);
+      return ContextConfig.create(
+        { name, path: relativePath },
+        configDir,
+        fs
+      );
+    })
+  );
+}
+async function createObjectContext(ctx, index, configDir, fs) {
+  if (!ctx.name || typeof ctx.name !== "string") {
+    throw new ConfigLoadError(
+      `Invalid context at index ${index}: missing 'name'`
+    );
+  }
+  if (!ctx.path || typeof ctx.path !== "string") {
+    throw new ConfigLoadError(
+      `Invalid context at index ${index}: missing 'path'`
+    );
+  }
+  return ContextConfig.create(ctx, configDir, fs);
+}
+async function matchGlobPattern(pattern, configDir, fs) {
+  const globParts = pattern.split("*");
+  if (globParts.length !== SUPPORTED_GLOB_PARTS_COUNT) {
+    throw new ConfigLoadError(
+      `Invalid glob pattern: "${pattern}". Only single wildcard patterns like "packages/*" are supported.`
+    );
+  }
+  const [prefix, suffix] = globParts;
+  const baseDir = resolve(configDir, prefix);
+  if (!await fs.exists(baseDir)) {
+    return [];
+  }
+  const entries = await fs.readdir(baseDir);
+  const matchedDirs = [];
+  for (const entry of entries) {
+    const fullPath = resolve(baseDir, entry);
+    const stats = await fs.stat(fullPath);
+    if (!stats.isDirectory()) {
+      continue;
+    }
+    if (suffix) {
+      const suffixPath = resolve(fullPath, suffix.replace(/^\//, ""));
+      if (await fs.exists(suffixPath)) {
+        matchedDirs.push(fullPath);
+      }
+    } else {
+      matchedDirs.push(fullPath);
+    }
+  }
+  return matchedDirs.sort();
+}
 var ConfigLoader = class {
   fs;
   constructor(options = {}) {
@@ -1805,7 +1868,7 @@ var ConfigLoader = class {
     if (!contracts.contexts || !Array.isArray(contracts.contexts)) {
       throw new ConfigLoadError("Missing 'contracts.contexts' in config");
     }
-    const contexts = await this.resolveContexts(contracts.contexts, configDir);
+    const contexts = await resolveContextEntries(contracts.contexts, configDir, this.fs);
     if (contexts.length === 0) {
       throw new ConfigLoadError("No contexts found from 'contexts'");
     }
@@ -1819,90 +1882,6 @@ var ConfigLoader = class {
       removeDecorators: contracts.removeDecorators ?? true
     };
   }
-  async resolveContexts(contextsConfig, configDir) {
-    const contexts = [];
-    for (let i = 0; i < contextsConfig.length; i++) {
-      const item = contextsConfig[i];
-      if (typeof item === "string") {
-        const resolvedContexts = await this.resolveStringContext(item, configDir);
-        contexts.push(...resolvedContexts);
-      } else {
-        const contextConfig = await this.createObjectContext(item, i, configDir);
-        contexts.push(contextConfig);
-      }
-    }
-    return contexts;
-  }
-  async resolveStringContext(contextPath, configDir) {
-    if (contextPath.includes("*")) {
-      return this.expandGlobPattern(contextPath, configDir);
-    }
-    const basePath = resolve(configDir, contextPath);
-    const name = basename(basePath);
-    return [await ContextConfig.create(
-      { name, path: contextPath },
-      configDir,
-      this.fs
-    )];
-  }
-  async expandGlobPattern(pattern, configDir) {
-    const packageDirs = await this.matchGlobPattern(pattern, configDir);
-    return Promise.all(
-      packageDirs.map((dir) => {
-        const name = basename(dir);
-        const relativePath = relative(configDir, dir);
-        return ContextConfig.create(
-          { name, path: relativePath },
-          configDir,
-          this.fs
-        );
-      })
-    );
-  }
-  async createObjectContext(ctx, index, configDir) {
-    if (!ctx.name || typeof ctx.name !== "string") {
-      throw new ConfigLoadError(
-        `Invalid context at index ${index}: missing 'name'`
-      );
-    }
-    if (!ctx.path || typeof ctx.path !== "string") {
-      throw new ConfigLoadError(
-        `Invalid context at index ${index}: missing 'path'`
-      );
-    }
-    return ContextConfig.create(ctx, configDir, this.fs);
-  }
-  async matchGlobPattern(pattern, configDir) {
-    const globParts = pattern.split("*");
-    if (globParts.length !== SUPPORTED_GLOB_PARTS_COUNT) {
-      throw new ConfigLoadError(
-        `Invalid glob pattern: "${pattern}". Only single wildcard patterns like "packages/*" are supported.`
-      );
-    }
-    const [prefix, suffix] = globParts;
-    const baseDir = resolve(configDir, prefix);
-    if (!await this.fs.exists(baseDir)) {
-      return [];
-    }
-    const entries = await this.fs.readdir(baseDir);
-    const matchedDirs = [];
-    for (const entry of entries) {
-      const fullPath = resolve(baseDir, entry);
-      const stats = await this.fs.stat(fullPath);
-      if (!stats.isDirectory()) {
-        continue;
-      }
-      if (suffix) {
-        const suffixPath = resolve(fullPath, suffix.replace(/^\//, ""));
-        if (await this.fs.exists(suffixPath)) {
-          matchedDirs.push(fullPath);
-        }
-      } else {
-        matchedDirs.push(fullPath);
-      }
-    }
-    return matchedDirs.sort();
-  }
 };
 
 // src/registry-generator.ts
@@ -2453,9 +2432,12 @@ Config file format:
   export default {
     contracts: {
       contexts: [
+        "packages/*",                    // glob: auto-discover all contexts
+        "packages/auth",                 // string: name inferred from directory
         {
           name: "lecture",
-          sourceDir: "packages/lecture/src",
+          path: "packages/lecture",       // required: base directory
+          sourceDir: "src",              // optional, default: "src"
         },
       ],
       pathAliasRewrites: {
@@ -2541,19 +2523,10 @@ async function run(args) {
   }
 }
 async function toContractsConfig(pluginConfig) {
-  const contexts = await Promise.all(
-    pluginConfig.contexts.map(
-      (ctx) => ContextConfig.create(
-        {
-          name: ctx.name,
-          path: ctx.path,
-          sourceDir: ctx.sourceDir,
-          tsconfigPath: ctx.tsconfigPath
-        },
-        process.cwd(),
-        nodeFileSystem
-      )
-    )
+  const contexts = await resolveContextEntries(
+    pluginConfig.contexts,
+    process.cwd(),
+    nodeFileSystem
   );
   return {
     contexts,
@@ -2739,6 +2712,6 @@ async function processContext(options) {
   });
 }
 
-export { ConfigLoadError, ConfigLoader, ConfigurationError, ConsoleLogger, ContextConfig, ContractsPipeline, FileCopier, FileGraphResolver, FileNotFoundError, FileReadError, FileSystemError, FileWriteError, JsonParseError, MessageParserError, ModuleResolutionError, ParseError, Parser, PublicCommand, PublicEvent, PublicQuery, ReexportGenerator, RegistryGenerator, ResolutionError, Scanner, cliPlugin, isArrayType, isCommand, isDomainEvent, isFunctionType, isIntersectionType, isLiteralType, isObjectType, isPrimitiveType, isReferenceType, isTupleType, isUnionType, nodeFileSystem, noopLogger, processContext };
+export { ConfigLoadError, ConfigLoader, ConfigurationError, ConsoleLogger, ContextConfig, ContractsPipeline, FileCopier, FileGraphResolver, FileNotFoundError, FileReadError, FileSystemError, FileWriteError, JsonParseError, MessageParserError, ModuleResolutionError, ParseError, Parser, ReexportGenerator, RegistryGenerator, ResolutionError, Scanner, cliPlugin, isArrayType, isCommand, isDomainEvent, isFunctionType, isIntersectionType, isLiteralType, isObjectType, isPrimitiveType, isReferenceType, isTupleType, isUnionType, nodeFileSystem, noopLogger, processContext, resolveContextEntries };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map