@living-architecture/riviere-query 0.2.1

package/dist/event-types.d.ts

@@ -0,0 +1,88 @@
+import type { DomainOpComponent } from '@living-architecture/riviere-schema';
+import type { EntityName, DomainName, State, OperationName, EventId, EventName, HandlerId, HandlerName } from './domain-types';
+/**
+ * A domain entity with its associated operations.
+ */
+export interface Entity {
+    /** The entity name. */
+    name: EntityName;
+    /** The domain containing the entity. */
+    domain: DomainName;
+    /** All domain operations targeting this entity. */
+    operations: DomainOpComponent[];
+}
+/**
+ * A state transition in an entity's state machine.
+ */
+export interface EntityTransition {
+    /** The state before the transition. */
+    from: State;
+    /** The state after the transition. */
+    to: State;
+    /** The operation that triggers this transition. */
+    triggeredBy: OperationName;
+}
+/**
+ * An event handler that subscribes to an event.
+ */
+export interface EventSubscriber {
+    /** The handler's component ID. */
+    handlerId: HandlerId;
+    /** The handler's name. */
+    handlerName: HandlerName;
+    /** The domain containing the handler. */
+    domain: DomainName;
+}
+/**
+ * A published event with its subscribers.
+ */
+export interface PublishedEvent {
+    /** The event component's ID. */
+    id: EventId;
+    /** The event name. */
+    eventName: EventName;
+    /** The domain that publishes the event. */
+    domain: DomainName;
+    /** Event handlers subscribed to this event. */
+    handlers: EventSubscriber[];
+}
+/**
+ * A subscribed event where the source domain is known.
+ */
+export interface KnownSourceEvent {
+    /** The event name. */
+    eventName: EventName;
+    /** The domain that publishes this event. */
+    sourceDomain: DomainName;
+    /** Indicates the source is known. */
+    sourceKnown: true;
+}
+/**
+ * A subscribed event where the source domain is unknown.
+ */
+export interface UnknownSourceEvent {
+    /** The event name. */
+    eventName: EventName;
+    /** Indicates the source is unknown. */
+    sourceKnown: false;
+}
+/**
+ * A subscribed event with optional source domain information.
+ */
+export type SubscribedEventWithDomain = KnownSourceEvent | UnknownSourceEvent;
+/**
+ * Information about an event handler component.
+ */
+export interface EventHandlerInfo {
+    /** The handler's component ID. */
+    id: HandlerId;
+    /** The handler's name. */
+    handlerName: HandlerName;
+    /** The domain containing the handler. */
+    domain: DomainName;
+    /** List of event names this handler subscribes to. */
+    subscribedEvents: EventName[];
+    /** Subscribed events with source domain information. */
+    subscribedEventsWithDomain: SubscribedEventWithDomain[];
+}
+//# sourceMappingURL=event-types.d.ts.map

package/dist/event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../src/event-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAC5E,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,KAAK,EACL,aAAa,EACb,OAAO,EACP,SAAS,EACT,SAAS,EACT,WAAW,EACZ,MAAM,gBAAgB,CAAA;AAEvB;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,uBAAuB;IACvB,IAAI,EAAE,UAAU,CAAA;IAChB,wCAAwC;IACxC,MAAM,EAAE,UAAU,CAAA;IAClB,mDAAmD;IACnD,UAAU,EAAE,iBAAiB,EAAE,CAAA;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,IAAI,EAAE,KAAK,CAAA;IACX,sCAAsC;IACtC,EAAE,EAAE,KAAK,CAAA;IACT,mDAAmD;IACnD,WAAW,EAAE,aAAa,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,SAAS,EAAE,SAAS,CAAA;IACpB,0BAA0B;IAC1B,WAAW,EAAE,WAAW,CAAA;IACxB,yCAAyC;IACzC,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,EAAE,EAAE,OAAO,CAAA;IACX,sBAAsB;IACtB,SAAS,EAAE,SAAS,CAAA;IACpB,2CAA2C;IAC3C,MAAM,EAAE,UAAU,CAAA;IAClB,+CAA+C;IAC/C,QAAQ,EAAE,eAAe,EAAE,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sBAAsB;IACtB,SAAS,EAAE,SAAS,CAAA;IACpB,4CAA4C;IAC5C,YAAY,EAAE,UAAU,CAAA;IACxB,qCAAqC;IACrC,WAAW,EAAE,IAAI,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sBAAsB;IACtB,SAAS,EAAE,SAAS,CAAA;IACpB,uCAAuC;IACvC,WAAW,EAAE,KAAK,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,gBAAgB,GAAG,kBAAkB,CAAA;AAE7E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,EAAE,EAAE,SAAS,CAAA;IACb,0BAA0B;IAC1B,WAAW,EAAE,WAAW,CAAA;IACxB,yCAAyC;IACzC,MAAM,EAAE,UAAU,CAAA;IAClB,sDAAsD;IACtD,gBAAgB,EAAE,SAAS,EAAE,CAAA;IAC7B,wDAAwD;IACxD,0BAA0B,EAAE,yBAAyB,EAAE,CAAA;CACxD"}

package/dist/event-types.js

@@ -0,0 +1 @@
+export {};

package/dist/external-system-queries.d.ts

@@ -0,0 +1,13 @@
+import type { RiviereGraph } from '@living-architecture/riviere-schema';
+import type { ExternalDomain } from './domain-types';
+/**
+ * Returns external domains that components connect to.
+ *
+ * Each external target from externalLinks becomes a separate ExternalDomain entry,
+ * with aggregated connection counts and source domains.
+ *
+ * @param graph - The RiviereGraph to query
+ * @returns Array of ExternalDomain objects, sorted alphabetically by name
+ */
+export declare function queryExternalDomains(graph: RiviereGraph): ExternalDomain[];
+//# sourceMappingURL=external-system-queries.d.ts.map

package/dist/external-system-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-system-queries.d.ts","sourceRoot":"","sources":["../src/external-system-queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAmDpD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,cAAc,EAAE,CAQ1E"}

package/dist/external-system-queries.js

@@ -0,0 +1,54 @@
+import { parseDomainName } from './domain-types';
+function buildComponentDomainMap(graph) {
+    const componentDomains = new Map();
+    for (const component of graph.components) {
+        componentDomains.set(component.id, component.domain);
+    }
+    return componentDomains;
+}
+function aggregateExternalDomains(externalLinks, componentDomains) {
+    const domains = new Map();
+    for (const extLink of externalLinks) {
+        const sourceDomain = componentDomains.get(extLink.source);
+        if (sourceDomain === undefined)
+            continue;
+        const existing = domains.get(extLink.target.name);
+        if (existing === undefined) {
+            domains.set(extLink.target.name, {
+                sourceDomains: new Set([sourceDomain]),
+                connectionCount: 1,
+            });
+        }
+        else {
+            existing.sourceDomains.add(sourceDomain);
+            existing.connectionCount += 1;
+        }
+    }
+    return domains;
+}
+function convertToExternalDomains(domains) {
+    return Array.from(domains.entries())
+        .map(([name, acc]) => ({
+        name,
+        sourceDomains: Array.from(acc.sourceDomains).map((d) => parseDomainName(d)),
+        connectionCount: acc.connectionCount,
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Returns external domains that components connect to.
+ *
+ * Each external target from externalLinks becomes a separate ExternalDomain entry,
+ * with aggregated connection counts and source domains.
+ *
+ * @param graph - The RiviereGraph to query
+ * @returns Array of ExternalDomain objects, sorted alphabetically by name
+ */
+export function queryExternalDomains(graph) {
+    if (graph.externalLinks === undefined || graph.externalLinks.length === 0) {
+        return [];
+    }
+    const componentDomains = buildComponentDomainMap(graph);
+    const domains = aggregateExternalDomains(graph.externalLinks, componentDomains);
+    return convertToExternalDomains(domains);
+}

package/dist/flow-queries.d.ts

@@ -0,0 +1,17 @@
+import type { RiviereGraph, Component } from '@living-architecture/riviere-schema';
+import type { ComponentId, LinkId, Flow, SearchWithFlowResult } from './domain-types';
+export declare function findEntryPoints(graph: RiviereGraph): Component[];
+export declare function traceFlowFrom(graph: RiviereGraph, startComponentId: ComponentId): {
+    componentIds: ComponentId[];
+    linkIds: LinkId[];
+};
+export declare function queryFlows(graph: RiviereGraph): Flow[];
+/**
+ * Options for searchWithFlow.
+ */
+export interface SearchWithFlowOptions {
+    /** If true, returns all components when the query is empty. */
+    returnAllOnEmptyQuery: boolean;
+}
+export declare function searchWithFlowContext(graph: RiviereGraph, query: string, options: SearchWithFlowOptions): SearchWithFlowResult;
+//# sourceMappingURL=flow-queries.d.ts.map

package/dist/flow-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-queries.d.ts","sourceRoot":"","sources":["../src/flow-queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAqC,MAAM,qCAAqC,CAAA;AACrH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAKrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,EAAE,CAIhE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,WAAW,GAAG;IAAE,YAAY,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA8BpI;AASD,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,EAAE,CAsCtD;AAgCD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,+DAA+D;IAC/D,qBAAqB,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CA4BtB"}

package/dist/flow-queries.js

@@ -0,0 +1,127 @@
+import { parseComponentId, parseLinkId } from './domain-types';
+import { componentById, searchComponents } from './component-queries';
+import { ComponentNotFoundError } from './errors';
+export function findEntryPoints(graph) {
+    const targets = new Set(graph.links.map((link) => link.target));
+    const entryPointTypes = new Set(['UI', 'API', 'EventHandler', 'Custom']);
+    return graph.components.filter((c) => entryPointTypes.has(c.type) && !targets.has(c.id));
+}
+export function traceFlowFrom(graph, startComponentId) {
+    const component = componentById(graph, startComponentId);
+    if (!component) {
+        throw new ComponentNotFoundError(startComponentId);
+    }
+    const visited = new Set();
+    const visitedLinks = new Set();
+    const queue = [startComponentId];
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (currentId === undefined || visited.has(currentId))
+            continue;
+        visited.add(currentId);
+        for (const link of graph.links) {
+            const sourceId = parseComponentId(link.source);
+            const targetId = parseComponentId(link.target);
+            if (link.source === currentId && !visited.has(targetId)) {
+                queue.push(targetId);
+                visitedLinks.add(createLinkKey(link));
+            }
+            if (link.target === currentId && !visited.has(sourceId)) {
+                queue.push(sourceId);
+                visitedLinks.add(createLinkKey(link));
+            }
+        }
+    }
+    return { componentIds: Array.from(visited), linkIds: Array.from(visitedLinks) };
+}
+function createLinkKey(link) {
+    if (link.id !== undefined) {
+        return parseLinkId(link.id);
+    }
+    return parseLinkId(`${link.source}->${link.target}`);
+}
+export function queryFlows(graph) {
+    const componentByIdMap = new Map(graph.components.map((c) => [c.id, c]));
+    const outgoingEdges = buildOutgoingEdges(graph);
+    const externalLinksBySource = buildExternalLinksBySource(graph);
+    const traceForward = (entryPointId) => {
+        const steps = [];
+        const visited = new Set();
+        const traverse = (nodeId, depth) => {
+            if (visited.has(nodeId))
+                return;
+            visited.add(nodeId);
+            const component = componentByIdMap.get(nodeId);
+            if (!component)
+                return;
+            const edges = outgoingEdges.get(nodeId);
+            const firstEdge = edges !== undefined && edges.length > 0 ? edges[0] : undefined;
+            const linkType = firstEdge !== undefined ? firstEdge.type : undefined;
+            const externalLinks = externalLinksBySource.get(nodeId) ?? [];
+            steps.push({ component, linkType, depth, externalLinks });
+            if (edges) {
+                for (const edge of edges) {
+                    traverse(edge.target, depth + 1);
+                }
+            }
+        };
+        traverse(entryPointId, 0);
+        return steps;
+    };
+    return findEntryPoints(graph).map((entryPoint) => ({
+        entryPoint,
+        steps: traceForward(entryPoint.id),
+    }));
+}
+function buildExternalLinksBySource(graph) {
+    const externalLinks = graph.externalLinks ?? [];
+    const bySource = new Map();
+    for (const link of externalLinks) {
+        const existing = bySource.get(link.source);
+        if (existing) {
+            existing.push(link);
+        }
+        else {
+            bySource.set(link.source, [link]);
+        }
+    }
+    return bySource;
+}
+function buildOutgoingEdges(graph) {
+    const edges = new Map();
+    for (const link of graph.links) {
+        const entry = { target: link.target, type: link.type };
+        const existing = edges.get(link.source);
+        if (existing) {
+            existing.push(entry);
+        }
+        else {
+            edges.set(link.source, [entry]);
+        }
+    }
+    return edges;
+}
+export function searchWithFlowContext(graph, query, options) {
+    const trimmedQuery = query.trim().toLowerCase();
+    const isEmptyQuery = trimmedQuery === '';
+    if (isEmptyQuery) {
+        if (options.returnAllOnEmptyQuery) {
+            const allIds = graph.components.map((c) => parseComponentId(c.id));
+            return { matchingIds: allIds, visibleIds: allIds };
+        }
+        return { matchingIds: [], visibleIds: [] };
+    }
+    const matchingComponents = searchComponents(graph, query);
+    if (matchingComponents.length === 0) {
+        return { matchingIds: [], visibleIds: [] };
+    }
+    const matchingIds = matchingComponents.map((c) => parseComponentId(c.id));
+    const visibleIds = new Set();
+    for (const component of matchingComponents) {
+        const flow = traceFlowFrom(graph, parseComponentId(component.id));
+        for (const id of flow.componentIds) {
+            visibleIds.add(id);
+        }
+    }
+    return { matchingIds, visibleIds: Array.from(visibleIds) };
+}

package/dist/graph-diff.d.ts

@@ -0,0 +1,4 @@
+import type { RiviereGraph } from '@living-architecture/riviere-schema';
+import type { GraphDiff } from './domain-types';
+export declare function diffGraphs(current: RiviereGraph, other: RiviereGraph): GraphDiff;
+//# sourceMappingURL=graph-diff.d.ts.map

package/dist/graph-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-diff.d.ts","sourceRoot":"","sources":["../src/graph-diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,qCAAqC,CAAA;AACxF,OAAO,KAAK,EAAyB,SAAS,EAAU,MAAM,gBAAgB,CAAA;AAG9E,wBAAgB,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,SAAS,CAkChF"}

package/dist/graph-diff.js

@@ -0,0 +1,53 @@
+import { parseComponentId, parseLinkId } from './domain-types';
+export function diffGraphs(current, other) {
+    const thisIds = new Set(current.components.map((c) => c.id));
+    const otherIds = new Set(other.components.map((c) => c.id));
+    const otherById = new Map(other.components.map((c) => [c.id, c]));
+    const added = other.components.filter((c) => !thisIds.has(c.id));
+    const removed = current.components.filter((c) => !otherIds.has(c.id));
+    const modified = [];
+    for (const tc of current.components) {
+        const oc = otherById.get(tc.id);
+        if (oc === undefined)
+            continue;
+        const changedFields = findChangedFields(tc, oc);
+        if (changedFields.length > 0) {
+            modified.push({ id: parseComponentId(tc.id), before: tc, after: oc, changedFields });
+        }
+    }
+    const thisLinkKeys = new Set(current.links.map((l) => createLinkKey(l)));
+    const otherLinkKeys = new Set(other.links.map((l) => createLinkKey(l)));
+    const linksAdded = other.links.filter((l) => !thisLinkKeys.has(createLinkKey(l)));
+    const linksRemoved = current.links.filter((l) => !otherLinkKeys.has(createLinkKey(l)));
+    return {
+        components: { added, removed, modified },
+        links: { added: linksAdded, removed: linksRemoved },
+        stats: {
+            componentsAdded: added.length,
+            componentsRemoved: removed.length,
+            componentsModified: modified.length,
+            linksAdded: linksAdded.length,
+            linksRemoved: linksRemoved.length,
+        },
+    };
+}
+function createLinkKey(link) {
+    if (link.id !== undefined) {
+        return parseLinkId(link.id);
+    }
+    return parseLinkId(`${link.source}->${link.target}`);
+}
+function findChangedFields(before, after) {
+    const beforeEntries = new Map(Object.entries(before));
+    const afterEntries = new Map(Object.entries(after));
+    const changedFields = [];
+    const allKeys = new Set([...beforeEntries.keys(), ...afterEntries.keys()]);
+    for (const key of allKeys) {
+        if (key === 'id')
+            continue;
+        if (JSON.stringify(beforeEntries.get(key)) !== JSON.stringify(afterEntries.get(key))) {
+            changedFields.push(key);
+        }
+    }
+    return changedFields;
+}

package/dist/graph-validation.d.ts

@@ -0,0 +1,5 @@
+import type { RiviereGraph } from '@living-architecture/riviere-schema';
+import type { ComponentId, ValidationResult } from './domain-types';
+export declare function validateGraph(graph: RiviereGraph): ValidationResult;
+export declare function detectOrphanComponents(graph: RiviereGraph): ComponentId[];
+//# sourceMappingURL=graph-validation.d.ts.map

package/dist/graph-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-validation.d.ts","sourceRoot":"","sources":["../src/graph-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,qCAAqC,CAAA;AACxF,OAAO,KAAK,EAAE,WAAW,EAAmB,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAOpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,gBAAgB,CAwBnE;AA6CD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,GAAG,WAAW,EAAE,CAUzE"}

package/dist/graph-validation.js

@@ -0,0 +1,72 @@
+import { parseComponentId } from './domain-types';
+function isCustomComponent(component) {
+    return component.type === 'Custom';
+}
+export function validateGraph(graph) {
+    const errors = [];
+    const componentIds = new Set(graph.components.map((c) => c.id));
+    graph.links.forEach((link, index) => {
+        if (!componentIds.has(link.source)) {
+            errors.push({
+                path: `/links/${index}/source`,
+                message: `Link references non-existent source: ${link.source}`,
+                code: 'INVALID_LINK_SOURCE',
+            });
+        }
+        if (!componentIds.has(link.target)) {
+            errors.push({
+                path: `/links/${index}/target`,
+                message: `Link references non-existent target: ${link.target}`,
+                code: 'INVALID_LINK_TARGET',
+            });
+        }
+    });
+    errors.push(...validateCustomTypes(graph));
+    return { valid: errors.length === 0, errors };
+}
+function validateCustomTypes(graph) {
+    const errors = [];
+    const customTypes = graph.metadata.customTypes;
+    graph.components.forEach((component, index) => {
+        if (!isCustomComponent(component)) {
+            return;
+        }
+        const customTypeName = component.customTypeName;
+        if (!customTypes || !(customTypeName in customTypes)) {
+            errors.push({
+                path: `/components/${index}/customTypeName`,
+                message: `Custom type '${customTypeName}' is not defined in metadata.customTypes`,
+                code: 'INVALID_TYPE',
+            });
+            return;
+        }
+        const typeDefinition = customTypes[customTypeName];
+        const requiredProperties = typeDefinition?.requiredProperties;
+        const hasNoRequiredProperties = requiredProperties === undefined;
+        if (hasNoRequiredProperties)
+            return;
+        const requiredPropertyNames = Object.keys(requiredProperties);
+        const componentMetadata = component.metadata;
+        const missingProperties = componentMetadata
+            ? requiredPropertyNames.filter((prop) => !(prop in componentMetadata))
+            : requiredPropertyNames;
+        if (missingProperties.length > 0) {
+            errors.push({
+                path: `/components/${index}`,
+                message: `Custom component is missing required properties for type '${customTypeName}': ${missingProperties.join(', ')}`,
+                code: 'INVALID_TYPE',
+            });
+        }
+    });
+    return errors;
+}
+export function detectOrphanComponents(graph) {
+    const connectedComponentIds = new Set();
+    graph.links.forEach((link) => {
+        connectedComponentIds.add(link.source);
+        connectedComponentIds.add(link.target);
+    });
+    return graph.components
+        .filter((c) => !connectedComponentIds.has(c.id))
+        .map((c) => parseComponentId(c.id));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './RiviereQuery';
+export * from './event-types';
+export * from './domain-types';
+export * from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './RiviereQuery';
+export * from './event-types';
+export * from './domain-types';
+export * from './errors';

package/dist/riviere-graph-fixtures.d.ts

@@ -0,0 +1,37 @@
+import type { RiviereGraph, APIComponent, EventComponent, EventHandlerComponent, CustomComponent, UseCaseComponent, DomainOpComponent, SourceLocation } from '@living-architecture/riviere-schema';
+export declare const defaultSourceLocation: SourceLocation;
+export declare function createMinimalValidGraph(): RiviereGraph;
+export declare function createAPIComponent(overrides: Partial<APIComponent> & {
+    id: string;
+    name: string;
+    domain: string;
+}): APIComponent;
+export declare function createEventComponent(overrides: Partial<EventComponent> & {
+    id: string;
+    name: string;
+    domain: string;
+    eventName: string;
+}): EventComponent;
+export declare function createEventHandlerComponent(overrides: Partial<EventHandlerComponent> & {
+    id: string;
+    name: string;
+    domain: string;
+}): EventHandlerComponent;
+export declare function createCustomComponent(overrides: Partial<CustomComponent> & {
+    id: string;
+    name: string;
+    domain: string;
+    customTypeName: string;
+}): CustomComponent;
+export declare function createUseCaseComponent(overrides: Partial<UseCaseComponent> & {
+    id: string;
+    name: string;
+    domain: string;
+}): UseCaseComponent;
+export declare function createDomainOpComponent(overrides: Partial<DomainOpComponent> & {
+    id: string;
+    name: string;
+    domain: string;
+    operationName: string;
+}): DomainOpComponent;
+//# sourceMappingURL=riviere-graph-fixtures.d.ts.map

package/dist/riviere-graph-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riviere-graph-fixtures.d.ts","sourceRoot":"","sources":["../src/riviere-graph-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACf,MAAM,qCAAqC,CAAA;AAE5C,eAAO,MAAM,qBAAqB,EAAE,cAAiE,CAAA;AAErG,wBAAgB,uBAAuB,IAAI,YAAY,CAmBtD;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC9E,YAAY,CAUd;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACnG,cAAc,CAOhB;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACvF,qBAAqB,CAQvB;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACzG,eAAe,CAOjB;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClF,gBAAgB,CAOlB;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC1G,iBAAiB,CAOnB"}

package/dist/riviere-graph-fixtures.js

@@ -0,0 +1,73 @@
+export const defaultSourceLocation = { repository: 'test-repo', filePath: 'test.ts' };
+export function createMinimalValidGraph() {
+    return {
+        version: '1.0',
+        metadata: {
+            domains: { test: { description: 'Test domain', systemType: 'domain' } },
+        },
+        components: [
+            {
+                id: 'test:mod:ui:page',
+                type: 'UI',
+                name: 'Test Page',
+                domain: 'test',
+                module: 'mod',
+                route: '/test',
+                sourceLocation: defaultSourceLocation,
+            },
+        ],
+        links: [],
+    };
+}
+export function createAPIComponent(overrides) {
+    return {
+        type: 'API',
+        module: 'mod',
+        apiType: 'REST',
+        httpMethod: 'GET',
+        path: '/test',
+        sourceLocation: defaultSourceLocation,
+        ...overrides,
+    };
+}
+export function createEventComponent(overrides) {
+    return {
+        type: 'Event',
+        module: 'mod',
+        sourceLocation: defaultSourceLocation,
+        ...overrides,
+    };
+}
+export function createEventHandlerComponent(overrides) {
+    return {
+        type: 'EventHandler',
+        module: 'mod',
+        subscribedEvents: ['TestEvent'],
+        sourceLocation: defaultSourceLocation,
+        ...overrides,
+    };
+}
+export function createCustomComponent(overrides) {
+    return {
+        type: 'Custom',
+        module: 'mod',
+        sourceLocation: defaultSourceLocation,
+        ...overrides,
+    };
+}
+export function createUseCaseComponent(overrides) {
+    return {
+        type: 'UseCase',
+        module: 'mod',
+        sourceLocation: defaultSourceLocation,
+        ...overrides,
+    };
+}
+export function createDomainOpComponent(overrides) {
+    return {
+        type: 'DomainOp',
+        module: 'mod',
+        sourceLocation: defaultSourceLocation,
+        ...overrides,
+    };
+}

package/dist/stats-queries.d.ts

@@ -0,0 +1,4 @@
+import type { RiviereGraph } from '@living-architecture/riviere-schema';
+import type { GraphStats } from './domain-types';
+export declare function queryStats(graph: RiviereGraph): GraphStats;
+//# sourceMappingURL=stats-queries.d.ts.map

package/dist/stats-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats-queries.d.ts","sourceRoot":"","sources":["../src/stats-queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,qCAAqC,CAAA;AAC1F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAgB1D"}

package/dist/stats-queries.js

@@ -0,0 +1,14 @@
+export function queryStats(graph) {
+    const components = graph.components;
+    const uniqueDomains = new Set(components.map((c) => c.domain));
+    const domainOps = components.filter((c) => c.type === 'DomainOp');
+    const uniqueEntities = new Set(domainOps.filter((c) => c.entity).map((c) => c.entity));
+    return {
+        componentCount: components.length,
+        linkCount: graph.links.length,
+        domainCount: uniqueDomains.size,
+        apiCount: components.filter((c) => c.type === 'API').length,
+        entityCount: uniqueEntities.size,
+        eventCount: components.filter((c) => c.type === 'Event').length,
+    };
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@living-architecture/riviere-query",
+  "version": "0.2.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@living-architecture/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "tslib": "^2.3.0",
+    "zod": "^4.2.1",
+    "@living-architecture/riviere-schema": "0.2.0"
+  }
+}