@living-architecture/riviere-builder 0.2.1

package/README.md

@@ -0,0 +1,11 @@
+# builder
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build builder` to build the library.
+
+## Running unit tests
+
+Run `nx test builder` to execute the unit tests via [Vitest](https://vitest.dev/).

package/dist/builder-assertions.d.ts

@@ -0,0 +1,5 @@
+import type { CustomTypeDefinition, DomainMetadata } from '@living-architecture/riviere-schema';
+export declare function assertDomainExists(domains: Record<string, DomainMetadata>, domain: string): void;
+export declare function assertCustomTypeExists(customTypes: Record<string, CustomTypeDefinition>, customTypeName: string): void;
+export declare function assertRequiredPropertiesProvided(customTypes: Record<string, CustomTypeDefinition>, customTypeName: string, metadata: Record<string, unknown> | undefined): void;
+//# sourceMappingURL=builder-assertions.d.ts.map

package/dist/builder-assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-assertions.d.ts","sourceRoot":"","sources":["../src/builder-assertions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAA;AAG/F,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAIhG;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACjD,cAAc,EAAE,MAAM,GACrB,IAAI,CAKN;AAED,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACjD,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC5C,IAAI,CAaN"}

package/dist/builder-assertions.js

@@ -0,0 +1,24 @@
+import { CustomTypeNotFoundError, DomainNotFoundError } from './errors';
+export function assertDomainExists(domains, domain) {
+    if (!domains[domain]) {
+        throw new DomainNotFoundError(domain);
+    }
+}
+export function assertCustomTypeExists(customTypes, customTypeName) {
+    if (!customTypes[customTypeName]) {
+        const definedTypes = Object.keys(customTypes);
+        throw new CustomTypeNotFoundError(customTypeName, definedTypes);
+    }
+}
+export function assertRequiredPropertiesProvided(customTypes, customTypeName, metadata) {
+    const typeDefinition = customTypes[customTypeName];
+    if (!typeDefinition?.requiredProperties) {
+        return;
+    }
+    const requiredKeys = Object.keys(typeDefinition.requiredProperties);
+    const providedKeys = metadata ? Object.keys(metadata) : [];
+    const missingKeys = requiredKeys.filter((key) => !providedKeys.includes(key));
+    if (missingKeys.length > 0) {
+        throw new Error(`Missing required properties for '${customTypeName}': ${missingKeys.join(', ')}`);
+    }
+}

package/dist/builder-test-fixtures.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderOptions } from './builder';
+export declare function createValidOptions(): BuilderOptions;
+export declare function createSourceLocation(): {
+    repository: string;
+    filePath: string;
+};
+//# sourceMappingURL=builder-test-fixtures.d.ts.map

package/dist/builder-test-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-test-fixtures.d.ts","sourceRoot":"","sources":["../src/builder-test-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAE/C,wBAAgB,kBAAkB,IAAI,cAAc,CAQnD;AAED,wBAAgB,oBAAoB;;;EAEnC"}

package/dist/builder-test-fixtures.js

@@ -0,0 +1,12 @@
+export function createValidOptions() {
+    return {
+        sources: [{ repository: 'test/repo', commit: 'abc123' }],
+        domains: {
+            orders: { description: 'Order domain', systemType: 'domain' },
+            shipping: { description: 'Shipping domain', systemType: 'domain' },
+        },
+    };
+}
+export function createSourceLocation() {
+    return { repository: 'test/repo', filePath: 'src/test.ts' };
+}

package/dist/builder.d.ts

@@ -0,0 +1,485 @@
+import type { APIComponent, CustomComponent, CustomTypeDefinition, DomainOpComponent, EventComponent, EventHandlerComponent, ExternalLink, GraphMetadata, Link, RiviereGraph, SourceInfo, UIComponent, UseCaseComponent } from '@living-architecture/riviere-schema';
+import { RiviereQuery, type ValidationResult } from '@living-architecture/riviere-query';
+import type { APIInput, BuilderOptions, BuilderStats, BuilderWarning, CustomInput, CustomTypeInput, DomainInput, DomainOpInput, EnrichmentInput, EventHandlerInput, EventInput, ExternalLinkInput, LinkInput, NearMatchMismatch, NearMatchOptions, NearMatchQuery, NearMatchResult, UIInput, UseCaseInput } from './types';
+export type { APIInput, BuilderOptions, BuilderStats, BuilderWarning, CustomInput, CustomTypeInput, DomainInput, DomainOpInput, EnrichmentInput, EventHandlerInput, EventInput, ExternalLinkInput, LinkInput, NearMatchMismatch, NearMatchOptions, NearMatchQuery, NearMatchResult, UIInput, UseCaseInput, };
+interface BuilderMetadata extends Omit<GraphMetadata, 'sources' | 'customTypes'> {
+    sources: SourceInfo[];
+    customTypes: Record<string, CustomTypeDefinition>;
+}
+interface BuilderGraph extends Omit<RiviereGraph, 'metadata' | 'externalLinks'> {
+    metadata: BuilderMetadata;
+    externalLinks: ExternalLink[];
+}
+/**
+ * Programmatically construct Rivière architecture graphs.
+ *
+ * RiviereBuilder provides a fluent API for creating graphs, adding components,
+ * linking them together, and exporting valid JSON conforming to the Rivière schema.
+ *
+ * @example
+ * ```typescript
+ * import { RiviereBuilder } from '@living-architecture/riviere-builder'
+ *
+ * const builder = RiviereBuilder.new({
+ *   sources: [{ type: 'git', url: 'https://github.com/org/repo' }],
+ *   domains: { orders: { description: 'Order management' } }
+ * })
+ *
+ * const api = builder.addApi({
+ *   name: 'Create Order',
+ *   domain: 'orders',
+ *   module: 'checkout',
+ *   apiType: 'REST',
+ *   sourceLocation: { file: 'src/api/orders.ts', line: 10 }
+ * })
+ *
+ * const graph = builder.build()
+ * ```
+ */
+export declare class RiviereBuilder {
+    graph: BuilderGraph;
+    private constructor();
+    /**
+     * Restores a builder from a previously serialized graph.
+     *
+     * Use this to continue building a graph that was saved mid-construction,
+     * or to modify an existing graph.
+     *
+     * @param graph - A valid RiviereGraph object to resume from
+     * @returns A new RiviereBuilder instance with the graph state restored
+     * @throws If the graph is missing required sources
+     *
+     * @example
+     * ```typescript
+     * const json = await fs.readFile('draft.json', 'utf-8')
+     * const graph = JSON.parse(json)
+     * const builder = RiviereBuilder.resume(graph)
+     * builder.addApi({ ... })
+     * ```
+     */
+    static resume(graph: RiviereGraph): RiviereBuilder;
+    /**
+     * Creates a new builder with initial configuration.
+     *
+     * @param options - Configuration including sources and domains
+     * @returns A new RiviereBuilder instance
+     * @throws If sources array is empty
+     * @throws If domains object is empty
+     *
+     * @example
+     * ```typescript
+     * const builder = RiviereBuilder.new({
+     *   name: 'My System',
+     *   sources: [{ type: 'git', url: 'https://github.com/org/repo' }],
+     *   domains: {
+     *     orders: { description: 'Order management' },
+     *     users: { description: 'User accounts' }
+     *   }
+     * })
+     * ```
+     */
+    static new(options: BuilderOptions): RiviereBuilder;
+    /**
+     * Adds an additional source repository to the graph.
+     *
+     * @param source - Source repository information
+     *
+     * @example
+     * ```typescript
+     * builder.addSource({
+     *   type: 'git',
+     *   url: 'https://github.com/org/another-repo'
+     * })
+     * ```
+     */
+    addSource(source: SourceInfo): void;
+    /**
+     * Adds a new domain to the graph.
+     *
+     * @param input - Domain name and description
+     * @throws If domain with same name already exists
+     *
+     * @example
+     * ```typescript
+     * builder.addDomain({
+     *   name: 'payments',
+     *   description: 'Payment processing'
+     * })
+     * ```
+     */
+    addDomain(input: DomainInput): void;
+    /**
+     * Adds a UI component to the graph.
+     *
+     * @param input - UI component properties including route and source location
+     * @returns The created UI component with generated ID
+     * @throws If the specified domain does not exist
+     *
+     * @example
+     * ```typescript
+     * const ui = builder.addUI({
+     *   name: 'Order List',
+     *   domain: 'orders',
+     *   module: 'dashboard',
+     *   route: '/orders',
+     *   sourceLocation: { file: 'src/pages/OrderList.tsx', line: 15 }
+     * })
+     * ```
+     */
+    addUI(input: UIInput): UIComponent;
+    /**
+     * Adds an API component to the graph.
+     *
+     * @param input - API component properties including type, method, and path
+     * @returns The created API component with generated ID
+     * @throws If the specified domain does not exist
+     *
+     * @example
+     * ```typescript
+     * const api = builder.addApi({
+     *   name: 'Create Order',
+     *   domain: 'orders',
+     *   module: 'checkout',
+     *   apiType: 'REST',
+     *   httpMethod: 'POST',
+     *   path: '/api/orders',
+     *   sourceLocation: { file: 'src/api/orders.ts', line: 25 }
+     * })
+     * ```
+     */
+    addApi(input: APIInput): APIComponent;
+    /**
+     * Adds a UseCase component to the graph.
+     *
+     * @param input - UseCase component properties
+     * @returns The created UseCase component with generated ID
+     * @throws If the specified domain does not exist
+     *
+     * @example
+     * ```typescript
+     * const useCase = builder.addUseCase({
+     *   name: 'Place Order',
+     *   domain: 'orders',
+     *   module: 'checkout',
+     *   sourceLocation: { file: 'src/usecases/PlaceOrder.ts', line: 10 }
+     * })
+     * ```
+     */
+    addUseCase(input: UseCaseInput): UseCaseComponent;
+    /**
+     * Adds a DomainOp component to the graph.
+     *
+     * DomainOp represents domain operations that change entity state.
+     * Can be enriched later with state changes and business rules.
+     *
+     * @param input - DomainOp component properties including operation name
+     * @returns The created DomainOp component with generated ID
+     * @throws If the specified domain does not exist
+     *
+     * @example
+     * ```typescript
+     * const domainOp = builder.addDomainOp({
+     *   name: 'Confirm Order',
+     *   domain: 'orders',
+     *   module: 'fulfillment',
+     *   operationName: 'confirmOrder',
+     *   entity: 'Order',
+     *   sourceLocation: { file: 'src/domain/Order.ts', line: 45 }
+     * })
+     * ```
+     */
+    addDomainOp(input: DomainOpInput): DomainOpComponent;
+    /**
+     * Adds an Event component to the graph.
+     *
+     * @param input - Event component properties including event name
+     * @returns The created Event component with generated ID
+     * @throws If the specified domain does not exist
+     *
+     * @example
+     * ```typescript
+     * const event = builder.addEvent({
+     *   name: 'Order Placed',
+     *   domain: 'orders',
+     *   module: 'checkout',
+     *   eventName: 'OrderPlaced',
+     *   sourceLocation: { file: 'src/events/OrderPlaced.ts', line: 5 }
+     * })
+     * ```
+     */
+    addEvent(input: EventInput): EventComponent;
+    /**
+     * Adds an EventHandler component to the graph.
+     *
+     * @param input - EventHandler component properties including subscribed events
+     * @returns The created EventHandler component with generated ID
+     * @throws If the specified domain does not exist
+     *
+     * @example
+     * ```typescript
+     * const handler = builder.addEventHandler({
+     *   name: 'Send Confirmation Email',
+     *   domain: 'notifications',
+     *   module: 'email',
+     *   subscribedEvents: ['OrderPlaced'],
+     *   sourceLocation: { file: 'src/handlers/OrderConfirmation.ts', line: 10 }
+     * })
+     * ```
+     */
+    addEventHandler(input: EventHandlerInput): EventHandlerComponent;
+    /**
+     * Defines a custom component type for the graph.
+     *
+     * Custom types allow extending the schema with domain-specific component kinds.
+     * Must be defined before adding custom components of that type.
+     *
+     * @param input - Custom type definition with required and optional properties
+     * @throws If a custom type with the same name already exists
+     *
+     * @example
+     * ```typescript
+     * builder.defineCustomType({
+     *   name: 'MessageQueue',
+     *   description: 'Async message queue',
+     *   requiredProperties: {
+     *     queueName: { type: 'string', description: 'Queue identifier' }
+     *   }
+     * })
+     * ```
+     */
+    defineCustomType(input: CustomTypeInput): void;
+    /**
+     * Adds a Custom component to the graph.
+     *
+     * Custom components use types defined via defineCustomType().
+     * Validates that the custom type exists and required properties are provided.
+     *
+     * @param input - Custom component properties including type name and metadata
+     * @returns The created Custom component with generated ID
+     * @throws If the specified domain does not exist
+     * @throws If the custom type has not been defined
+     * @throws If required properties for the custom type are missing
+     *
+     * @example
+     * ```typescript
+     * const queue = builder.addCustom({
+     *   customTypeName: 'MessageQueue',
+     *   name: 'Order Events Queue',
+     *   domain: 'orders',
+     *   module: 'messaging',
+     *   sourceLocation: { file: 'src/queues/orders.ts', line: 5 },
+     *   metadata: { queueName: 'order-events' }
+     * })
+     * ```
+     */
+    addCustom(input: CustomInput): CustomComponent;
+    /**
+     * Enriches a DomainOp component with additional domain details.
+     *
+     * Adds state changes and business rules to an existing DomainOp.
+     * Multiple enrichments accumulate rather than replace.
+     *
+     * @param id - The component ID to enrich
+     * @param enrichment - State changes and business rules to add
+     * @throws If the component does not exist
+     * @throws If the component is not a DomainOp type
+     *
+     * @example
+     * ```typescript
+     * builder.enrichComponent('orders:fulfillment:domainop:confirm-order', {
+     *   entity: 'Order',
+     *   stateChanges: [{ entity: 'Order', from: 'pending', to: 'confirmed' }],
+     *   businessRules: ['Order must have valid payment']
+     * })
+     * ```
+     */
+    enrichComponent(id: string, enrichment: EnrichmentInput): void;
+    private componentNotFoundError;
+    private validateDomainExists;
+    private validateCustomType;
+    private validateRequiredProperties;
+    private generateComponentId;
+    private registerComponent;
+    /**
+     * Finds components similar to a query for error recovery.
+     *
+     * Returns fuzzy matches when an exact component lookup fails,
+     * enabling actionable error messages with "Did you mean...?" suggestions.
+     *
+     * @param query - Search criteria including partial ID, name, type, or domain
+     * @param options - Optional matching thresholds and limits
+     * @returns Array of similar components with similarity scores
+     *
+     * @example
+     * ```typescript
+     * const matches = builder.nearMatches({ name: 'Place Ordr' })
+     * // [{ component: {...}, score: 0.9, mismatches: [...] }]
+     * ```
+     */
+    nearMatches(query: NearMatchQuery, options?: NearMatchOptions): NearMatchResult[];
+    /**
+     * Creates a link between two components in the graph.
+     *
+     * Source component must exist; target validation is deferred to build().
+     * Use linkExternal() for connections to external systems.
+     *
+     * @param input - Link properties including source, target, and type
+     * @returns The created link
+     * @throws If the source component does not exist
+     *
+     * @example
+     * ```typescript
+     * const link = builder.link({
+     *   from: 'orders:checkout:api:create-order',
+     *   to: 'orders:checkout:usecase:place-order',
+     *   type: 'sync'
+     * })
+     * ```
+     */
+    link(input: LinkInput): Link;
+    /**
+     * Creates a link from a component to an external system.
+     *
+     * Use this for connections to systems outside the graph,
+     * such as third-party APIs or external databases.
+     *
+     * @param input - External link properties including target system info
+     * @returns The created external link
+     * @throws If the source component does not exist
+     *
+     * @example
+     * ```typescript
+     * const link = builder.linkExternal({
+     *   from: 'orders:payments:usecase:process-payment',
+     *   target: { name: 'Stripe API', domain: 'payments' },
+     *   type: 'sync'
+     * })
+     * ```
+     */
+    linkExternal(input: ExternalLinkInput): ExternalLink;
+    /**
+     * Returns non-fatal issues found in the graph.
+     *
+     * Warnings indicate potential problems that don't prevent building,
+     * such as orphaned components or unused domains.
+     *
+     * @returns Array of warning objects with type and message
+     *
+     * @example
+     * ```typescript
+     * const warnings = builder.warnings()
+     * for (const w of warnings) {
+     *   console.log(`${w.type}: ${w.message}`)
+     * }
+     * ```
+     */
+    warnings(): BuilderWarning[];
+    /**
+     * Returns statistics about the current graph state.
+     *
+     * @returns Counts of components by type, domains, and links
+     *
+     * @example
+     * ```typescript
+     * const stats = builder.stats()
+     * console.log(`Components: ${stats.componentCount}`)
+     * console.log(`Links: ${stats.linkCount}`)
+     * ```
+     */
+    stats(): BuilderStats;
+    /**
+     * Runs full validation on the graph.
+     *
+     * Checks for dangling references, orphans, and schema compliance.
+     * Called automatically by build().
+     *
+     * @returns Validation result with valid flag and error details
+     *
+     * @example
+     * ```typescript
+     * const result = builder.validate()
+     * if (!result.valid) {
+     *   for (const error of result.errors) {
+     *     console.error(error.message)
+     *   }
+     * }
+     * ```
+     */
+    validate(): ValidationResult;
+    /**
+     * Returns IDs of components with no incoming or outgoing links.
+     *
+     * @returns Array of orphaned component IDs
+     *
+     * @example
+     * ```typescript
+     * const orphans = builder.orphans()
+     * if (orphans.length > 0) {
+     *   console.warn('Orphaned components:', orphans)
+     * }
+     * ```
+     */
+    orphans(): string[];
+    /**
+     * Returns a RiviereQuery instance for the current graph state.
+     *
+     * Enables querying mid-construction without affecting builder state.
+     *
+     * @returns RiviereQuery instance for the current graph
+     *
+     * @example
+     * ```typescript
+     * const query = builder.query()
+     * const apis = query.componentsByType('API')
+     * ```
+     */
+    query(): RiviereQuery;
+    /**
+     * Serializes the current graph state as a JSON string.
+     *
+     * Does not validate. Use for saving drafts mid-construction
+     * that can be resumed later with RiviereBuilder.resume().
+     *
+     * @returns JSON string representation of the graph
+     *
+     * @example
+     * ```typescript
+     * const json = builder.serialize()
+     * await fs.writeFile('draft.json', json)
+     * ```
+     */
+    serialize(): string;
+    /**
+     * Validates and returns the completed graph.
+     *
+     * @returns Valid RiviereGraph object
+     * @throws If validation fails with error details
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const graph = builder.build()
+     *   console.log('Graph built successfully')
+     * } catch (error) {
+     *   console.error('Build failed:', error.message)
+     * }
+     * ```
+     */
+    build(): RiviereGraph;
+    /**
+     * Validates the graph and writes it to a file.
+     *
+     * @param path - Absolute or relative file path to write
+     * @throws If validation fails
+     * @throws If the directory does not exist
+     * @throws If write fails
+     *
+     * @example
+     * ```typescript
+     * await builder.save('./output/architecture.json')
+     * ```
+     */
+    save(path: string): Promise<void>;
+    private sourceNotFoundError;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"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"}