@hexaijs/plugin-contracts-generator 0.1.1 → 0.2.0

package/README.md

@@ -150,7 +150,10 @@ export default {
 };
 ```
 
-Each matched package must have its own `application.config.ts` with `contextName` and `sourceDir`.
+Each matched directory is treated as a context with sensible defaults:
+- Context name = directory name (e.g., `packages/auth` → `auth`)
+- Source directory = `src/` (default)
+- TypeScript config = `tsconfig.json` (auto-detected if exists)
 
 ### Response Types
 
@@ -313,7 +316,7 @@ try {
 **Error hierarchy:**
 
 - `MessageParserError` (base)
-  - `ConfigurationError` → `ConfigLoadError`, `TsconfigLoadError`
+  - `ConfigurationError` → `ConfigLoadError`
   - `FileSystemError` → `FileNotFoundError`, `FileReadError`, `FileWriteError`
   - `ParseError` → `JsonParseError`
   - `ResolutionError` → `ModuleResolutionError`

package/dist/cli-CPg-O4OY.d.ts

@@ -0,0 +1,214 @@
+interface SourceFile {
+    readonly absolutePath: string;
+    readonly relativePath: string;
+    readonly packageName?: string;
+}
+type TypeRef = PrimitiveType | ArrayType | ObjectType | UnionType | IntersectionType | ReferenceType | LiteralType | TupleType | FunctionType;
+interface PrimitiveType {
+    readonly kind: 'primitive';
+    readonly name: 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'void' | 'any' | 'unknown' | 'never' | 'bigint' | 'symbol';
+}
+interface ArrayType {
+    readonly kind: 'array';
+    readonly elementType: TypeRef;
+}
+interface ObjectType {
+    readonly kind: 'object';
+    readonly fields: readonly Field[];
+}
+interface UnionType {
+    readonly kind: 'union';
+    readonly types: readonly TypeRef[];
+}
+interface IntersectionType {
+    readonly kind: 'intersection';
+    readonly types: readonly TypeRef[];
+}
+interface ReferenceType {
+    readonly kind: 'reference';
+    readonly name: string;
+    readonly typeArguments?: readonly TypeRef[];
+}
+interface LiteralType {
+    readonly kind: 'literal';
+    readonly value: string | number | boolean;
+}
+interface TupleType {
+    readonly kind: 'tuple';
+    readonly elements: readonly TypeRef[];
+}
+interface FunctionType {
+    readonly kind: 'function';
+    readonly parameters: readonly FunctionParameter[];
+    readonly returnType: TypeRef;
+}
+interface FunctionParameter {
+    readonly name: string;
+    readonly type: TypeRef;
+    readonly optional: boolean;
+}
+interface Field {
+    readonly name: string;
+    readonly type: TypeRef;
+    readonly optional: boolean;
+    readonly readonly: boolean;
+}
+type TypeDefinitionKind = 'interface' | 'type' | 'enum' | 'class';
+interface TypeDefinition {
+    readonly name: string;
+    readonly kind: TypeDefinitionKind;
+    readonly sourceFile: SourceFile;
+    readonly body: TypeRef;
+    readonly typeParameters?: readonly string[];
+    readonly exported: boolean;
+}
+interface EnumMember {
+    readonly name: string;
+    readonly value?: string | number;
+}
+interface EnumDefinition extends Omit<TypeDefinition, 'kind' | 'body'> {
+    readonly kind: 'enum';
+    readonly members: readonly EnumMember[];
+}
+interface ClassImport {
+    readonly names: readonly string[];
+    readonly source: string;
+    readonly isTypeOnly: boolean;
+    readonly isExternal: boolean;
+}
+interface ClassDefinition {
+    readonly name: string;
+    readonly kind: 'class';
+    readonly sourceFile: SourceFile;
+    readonly sourceText: string;
+    readonly imports: readonly ClassImport[];
+    readonly dependencies: readonly string[];
+    readonly baseClass?: string;
+    readonly exported: boolean;
+}
+interface MessageBase {
+    readonly name: string;
+    readonly sourceFile: SourceFile;
+    readonly fields: readonly Field[];
+    readonly baseClass?: string;
+    readonly sourceText: string;
+    readonly imports: readonly ClassImport[];
+}
+interface DomainEvent extends MessageBase {
+    readonly messageType: 'event';
+    readonly version?: number;
+    readonly context?: string;
+    readonly payloadType?: TypeRef;
+}
+interface Command extends MessageBase {
+    readonly messageType: 'command';
+    readonly resultType?: TypeRef;
+    readonly context?: string;
+    readonly payloadType?: TypeRef;
+}
+interface Query extends MessageBase {
+    readonly messageType: 'query';
+    readonly resultType?: TypeRef;
+    readonly context?: string;
+    readonly payloadType?: TypeRef;
+}
+type Message = DomainEvent | Command | Query;
+/** Used to filter which decorators the scanner should look for. */
+type MessageType = Message['messageType'];
+type ImportSource = {
+    readonly type: 'local';
+    readonly path: string;
+} | {
+    readonly type: 'external';
+    readonly package: string;
+};
+type DependencyKind = 'type' | 'value' | 'class';
+interface Dependency {
+    readonly name: string;
+    readonly source: ImportSource;
+    readonly kind: DependencyKind;
+    readonly definition?: TypeDefinition;
+}
+interface SourceLocation {
+    readonly file: string;
+    readonly message: string;
+    readonly line?: number;
+    readonly column?: number;
+}
+type ExtractionError = SourceLocation;
+type ExtractionWarning = SourceLocation;
+interface ExtractionResult {
+    readonly events: readonly DomainEvent[];
+    readonly commands: readonly Command[];
+    readonly types: readonly TypeDefinition[];
+    readonly dependencies: readonly Dependency[];
+    readonly errors: readonly ExtractionError[];
+    readonly warnings: readonly ExtractionWarning[];
+}
+/** Customizes decorator names used to identify public messages. Unspecified names use defaults. */
+interface DecoratorNames {
+    event?: string;
+    command?: string;
+    query?: string;
+}
+interface ResponseNamingConvention {
+    readonly messageSuffix: string;
+    readonly responseSuffix: string;
+}
+interface Config {
+    readonly sourceDir: string;
+    readonly outputDir: string;
+    readonly include?: readonly string[];
+    readonly exclude?: readonly string[];
+    readonly externalPackages?: Readonly<Record<string, string>>;
+    readonly decoratorNames?: DecoratorNames;
+    readonly responseNamingConventions?: readonly ResponseNamingConvention[];
+}
+declare function isPrimitiveType(type: TypeRef): type is PrimitiveType;
+declare function isArrayType(type: TypeRef): type is ArrayType;
+declare function isObjectType(type: TypeRef): type is ObjectType;
+declare function isUnionType(type: TypeRef): type is UnionType;
+declare function isIntersectionType(type: TypeRef): type is IntersectionType;
+declare function isReferenceType(type: TypeRef): type is ReferenceType;
+declare function isLiteralType(type: TypeRef): type is LiteralType;
+declare function isTupleType(type: TypeRef): type is TupleType;
+declare function isFunctionType(type: TypeRef): type is FunctionType;
+declare function isDomainEvent(message: Message): message is DomainEvent;
+declare function isCommand(message: Message): message is Command;
+
+/**
+ * Options for runWithConfig when config is provided directly.
+ */
+interface RunWithConfigOptions {
+    outputDir: string;
+    messageTypes?: MessageType[];
+    generateMessageRegistry?: boolean;
+}
+/**
+ * Plugin configuration structure for contracts generator.
+ * This is the config passed from hexai.config.ts.
+ */
+interface ContractsPluginConfig {
+    contexts: Array<{
+        name: string;
+        path: string;
+        sourceDir?: string;
+        tsconfigPath?: string;
+    }>;
+    pathAliasRewrites?: Record<string, string>;
+    externalDependencies?: Record<string, string>;
+    decoratorNames?: DecoratorNames;
+    responseNamingConventions?: ResponseNamingConvention[];
+    removeDecorators?: boolean;
+}
+declare function run(args: string[]): Promise<void>;
+/**
+ * Run contracts generator with config provided directly.
+ * This is used by the hexai CLI integration where config comes from hexai.config.ts.
+ *
+ * @param options - CLI options (outputDir, messageTypes, generateMessageRegistry)
+ * @param pluginConfig - Plugin configuration from hexai.config.ts
+ */
+declare function runWithConfig(options: RunWithConfigOptions, pluginConfig: ContractsPluginConfig): Promise<void>;
+
+export { type ArrayType as A, isObjectType as B, type Command as C, type DecoratorNames as D, type EnumDefinition as E, type Field as F, isPrimitiveType as G, isReferenceType as H, type ImportSource as I, isTupleType as J, isUnionType as K, type LiteralType as L, type MessageType as M, type RunWithConfigOptions as N, type ObjectType as O, type PrimitiveType as P, type Query as Q, type ResponseNamingConvention as R, type SourceFile as S, type TypeDefinition as T, type UnionType as U, run as V, runWithConfig as W, type DomainEvent as a, type ContractsPluginConfig as b, type ClassDefinition as c, type ClassImport as d, type Config as e, type Dependency as f, type DependencyKind as g, type EnumMember as h, type ExtractionError as i, type ExtractionResult as j, type ExtractionWarning as k, type FunctionParameter as l, type FunctionType as m, type IntersectionType as n, type Message as o, type MessageBase as p, type ReferenceType as q, type TupleType as r, type TypeDefinitionKind as s, type TypeRef as t, isArrayType as u, isCommand as v, isDomainEvent as w, isFunctionType as x, isIntersectionType as y, isLiteralType as z };

package/dist/cli.d.ts

@@ -1,36 +1,2 @@
 #!/usr/bin/env node
-import type { MessageType, DecoratorNames, ResponseNamingConvention } from "./domain/types";
-/**
- * Options for runWithConfig when config is provided directly.
- */
-export interface RunWithConfigOptions {
-    outputDir: string;
-    messageTypes?: MessageType[];
-    generateMessageRegistry?: boolean;
-}
-/**
- * Plugin configuration structure for contracts generator.
- * This is the config passed from hexai.config.ts.
- */
-export interface ContractsPluginConfig {
-    contexts: Array<{
-        name: string;
-        sourceDir: string;
-        tsconfigPath?: string;
-    }>;
-    pathAliasRewrites?: Record<string, string>;
-    externalDependencies?: Record<string, string>;
-    decoratorNames?: DecoratorNames;
-    responseNamingConventions?: ResponseNamingConvention[];
-    removeDecorators?: boolean;
-}
-export declare function run(args: string[]): Promise<void>;
-/**
- * Run contracts generator with config provided directly.
- * This is used by the hexai CLI integration where config comes from hexai.config.ts.
- *
- * @param options - CLI options (outputDir, messageTypes, generateMessageRegistry)
- * @param pluginConfig - Plugin configuration from hexai.config.ts
- */
-export declare function runWithConfig(options: RunWithConfigOptions, pluginConfig: ContractsPluginConfig): Promise<void>;
-//# sourceMappingURL=cli.d.ts.map
+export { b as ContractsPluginConfig, N as RunWithConfigOptions, V as run, W as runWithConfig } from './cli-CPg-O4OY.js';