@ironbackend/core 1.0.0

package/dist/styles/event-driven.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cqrs = exports.eventDriven = void 0;
+/**
+ * Event-Driven Backend Architecture
+ * Components communicate through events, asynchronously
+ */
+exports.eventDriven = {
+    id: 'event-driven',
+    name: 'Event-Driven Backend',
+    description: 'System components communicate through events. Actions trigger events; handlers react to events asynchronously. Enables loose coupling and high scalability.',
+    whenToUse: [
+        'High throughput with eventual consistency acceptable',
+        'Multiple services reacting to same business events',
+        'Audit trail required for all state changes',
+        'Decoupling producers from consumers',
+        'Need to replay events for debugging or recovery',
+        'Complex workflows with multiple steps'
+    ],
+    whenNotToUse: [
+        'Strong consistency required everywhere',
+        'Simple request-response patterns sufficient',
+        'Team lacks event sourcing experience',
+        'Debugging complexity unacceptable',
+        'Real-time synchronous responses needed',
+        'Small, simple domains'
+    ],
+    corePrinciples: [
+        'Events are immutable facts about what happened',
+        'Publishers do not know their subscribers',
+        'Handlers must be idempotent',
+        'Event ordering matters within aggregate boundaries',
+        'Events carry enough data for handlers to act',
+        'Eventual consistency is the norm'
+    ],
+    folderStructure: {
+        name: 'src',
+        type: 'folder',
+        children: [
+            {
+                name: 'events',
+                type: 'folder',
+                description: 'Event infrastructure',
+                children: [
+                    { name: 'definitions', type: 'folder', description: 'Event schemas/types' },
+                    { name: 'publishers', type: 'folder', description: 'Event publishing logic' },
+                    { name: 'handlers', type: 'folder', description: 'Event handlers' },
+                    { name: 'store', type: 'folder', description: 'Event persistence' }
+                ]
+            },
+            {
+                name: 'aggregates',
+                type: 'folder',
+                description: 'Event-sourced domain aggregates'
+            },
+            {
+                name: 'projections',
+                type: 'folder',
+                description: 'Read models built from events'
+            },
+            {
+                name: 'sagas',
+                type: 'folder',
+                description: 'Long-running processes / process managers'
+            },
+            {
+                name: 'api',
+                type: 'folder',
+                description: 'External interfaces',
+                children: [
+                    { name: 'commands', type: 'folder', description: 'Write operations' },
+                    { name: 'queries', type: 'folder', description: 'Read operations' }
+                ]
+            },
+            {
+                name: 'infrastructure',
+                type: 'folder',
+                children: [
+                    { name: 'messaging', type: 'folder', description: 'Message broker integration' },
+                    { name: 'event-store', type: 'folder', description: 'Event storage implementation' }
+                ]
+            }
+        ]
+    },
+    commonPitfalls: [
+        'Non-idempotent handlers - same event processed twice should have same result',
+        'Missing event versioning strategy - events schema will evolve',
+        'Tight coupling through event payload - events should be self-contained',
+        'Ignoring event ordering requirements - order matters within aggregate',
+        'No dead letter handling - failed events need a home',
+        'Synchronous event handling - defeats the purpose',
+        'Events without correlation IDs - hard to trace'
+    ],
+    aiInstructions: `When generating code for Event-Driven Backend:
+
+EVENT STRUCTURE:
+- Every event has: id, type, timestamp, version, correlationId, payload
+- Event names in past tense: OrderCreated, PaymentProcessed
+- Events are immutable once published
+- Include event version for schema evolution
+
+HANDLERS:
+- All handlers MUST be idempotent
+- Store processed event IDs to detect duplicates
+- Handle events asynchronously
+- Log event processing start/end
+
+PUBLISHING:
+- Commands return immediately after emitting events
+- Publisher does not wait for handlers
+- Use transactional outbox for reliability
+
+PROJECTIONS:
+- Read models built by projecting events
+- Queries read from projections, never event store
+- Projections can be rebuilt from events
+
+SAGAS:
+- Coordinate multi-step processes
+- Listen for events, issue commands
+- Handle compensation for failures`
+};
+/**
+ * CQRS Architecture Style
+ * Separate models for reading and writing data
+ */
+exports.cqrs = {
+    id: 'cqrs',
+    name: 'CQRS',
+    description: 'Command Query Responsibility Segregation. Separate models for reading and writing data. Commands mutate state; queries return state without modification.',
+    whenToUse: [
+        'Read and write patterns differ significantly',
+        'Read-heavy workloads with complex queries',
+        'Different scaling needs for reads vs writes',
+        'Eventual consistency acceptable for reads',
+        'Need to optimize read and write models independently',
+        'Complex reporting requirements'
+    ],
+    whenNotToUse: [
+        'Simple CRUD with 1:1 read/write ratio',
+        'Strong consistency required for reads',
+        'Small data volumes with simple queries',
+        'Team unfamiliar with eventual consistency',
+        'Added complexity not justified'
+    ],
+    corePrinciples: [
+        'Commands never return data (void or acknowledgment only)',
+        'Queries never modify state',
+        'Write model optimized for consistency, read model for queries',
+        'Keep write model normalized, denormalize read models',
+        'Read and write models can use different databases',
+        'Synchronization between models is explicit'
+    ],
+    folderStructure: {
+        name: 'src',
+        type: 'folder',
+        children: [
+            {
+                name: 'write',
+                type: 'folder',
+                description: 'Command/write side',
+                children: [
+                    {
+                        name: 'commands',
+                        type: 'folder',
+                        children: [
+                            { name: 'handlers', type: 'folder', description: 'Command handlers' },
+                            { name: 'validators', type: 'folder', description: 'Command validation' }
+                        ]
+                    },
+                    {
+                        name: 'domain',
+                        type: 'folder',
+                        children: [
+                            { name: 'aggregates', type: 'folder', description: 'Write model aggregates' },
+                            { name: 'events', type: 'folder', description: 'Domain events' }
+                        ]
+                    },
+                    { name: 'repositories', type: 'folder', description: 'Write repositories' }
+                ]
+            },
+            {
+                name: 'read',
+                type: 'folder',
+                description: 'Query/read side',
+                children: [
+                    {
+                        name: 'queries',
+                        type: 'folder',
+                        children: [
+                            { name: 'handlers', type: 'folder', description: 'Query handlers' },
+                            { name: 'dto', type: 'folder', description: 'Query response DTOs' }
+                        ]
+                    },
+                    { name: 'models', type: 'folder', description: 'Denormalized read models' },
+                    { name: 'projectors', type: 'folder', description: 'Build read models from events' }
+                ]
+            },
+            {
+                name: 'sync',
+                type: 'folder',
+                description: 'Write → Read synchronization'
+            },
+            {
+                name: 'api',
+                type: 'folder',
+                children: [
+                    { name: 'command-endpoints', type: 'folder', description: 'POST/PUT/DELETE' },
+                    { name: 'query-endpoints', type: 'folder', description: 'GET' }
+                ]
+            }
+        ]
+    },
+    commonPitfalls: [
+        'Returning data from command handlers - commands return void or ID only',
+        'Querying write model for reads - always use read models',
+        'Missing synchronization between models - define explicit sync',
+        'Over-complicating simple domains - CQRS adds complexity',
+        'Expecting immediate consistency - reads can be stale',
+        'Tight coupling between write and read models'
+    ],
+    aiInstructions: `When generating code for CQRS:
+
+COMMANDS:
+- Command handlers return void or command ID only
+- Validate command before processing
+- Emit events after successful command processing
+- Commands are imperative: CreateOrder, UpdateUser
+
+QUERIES:
+- Query handlers are pure functions, no side effects
+- Queries return rich, denormalized DTOs
+- Optimize read models for specific query patterns
+- Queries are questions: GetOrderById, ListUserOrders
+
+SEPARATION:
+- Write model: normalized, consistent, optimized for writes
+- Read model: denormalized, eventually consistent, optimized for reads
+- Can use different databases for each
+
+SYNCHRONIZATION:
+- Projectors listen to events from write side
+- Update read models when events occur
+- Handle out-of-order events gracefully
+- Design for rebuild capability`
+};
+//# sourceMappingURL=event-driven.js.map

package/dist/styles/event-driven.js.map

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

package/dist/styles/hexagonal.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitectureStyle } from '../types.js';
+/**
+ * Hexagonal Architecture (Ports & Adapters)
+ * Application core surrounded by ports and adapters
+ */
+export declare const hexagonal: ArchitectureStyle;
+//# sourceMappingURL=hexagonal.d.ts.map

package/dist/styles/hexagonal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagonal.d.ts","sourceRoot":"","sources":["../../src/styles/hexagonal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,iBA+IvB,CAAC"}

package/dist/styles/hexagonal.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexagonal = void 0;
+/**
+ * Hexagonal Architecture (Ports & Adapters)
+ * Application core surrounded by ports and adapters
+ */
+exports.hexagonal = {
+    id: 'hexagonal',
+    name: 'Hexagonal Architecture',
+    description: 'Application core surrounded by ports (interfaces) and adapters (implementations). Core has zero dependencies on external world. Also known as Ports & Adapters.',
+    whenToUse: [
+        'Long-lived systems requiring technology swaps',
+        'Heavy external integrations (multiple DBs, APIs, queues)',
+        'Test-driven development priority',
+        'Complex business logic requiring isolation',
+        'Need to support multiple input channels (HTTP, CLI, events)',
+        'Expect infrastructure changes over system lifetime'
+    ],
+    whenNotToUse: [
+        'Rapid prototyping needed - too much ceremony',
+        'Simple CRUD with minimal business logic',
+        'Team unfamiliar with DDD concepts',
+        'Small, short-lived projects',
+        'Single integration point unlikely to change'
+    ],
+    corePrinciples: [
+        'Domain and application core have no external dependencies',
+        'Ports define what the application needs (driven) or provides (driving)',
+        'Adapters implement ports for specific technologies',
+        'Dependency inversion: adapters depend on ports, not vice versa',
+        'Core is testable without any infrastructure',
+        'Technology decisions deferred to adapters'
+    ],
+    folderStructure: {
+        name: 'src',
+        type: 'folder',
+        children: [
+            {
+                name: 'core',
+                type: 'folder',
+                description: 'Framework-free application core',
+                children: [
+                    {
+                        name: 'domain',
+                        type: 'folder',
+                        children: [
+                            { name: 'entities', type: 'folder', description: 'Domain entities' },
+                            { name: 'value-objects', type: 'folder', description: 'Value objects' },
+                            { name: 'events', type: 'folder', description: 'Domain events' },
+                            { name: 'services', type: 'folder', description: 'Domain services' }
+                        ]
+                    },
+                    {
+                        name: 'application',
+                        type: 'folder',
+                        children: [
+                            {
+                                name: 'ports',
+                                type: 'folder',
+                                children: [
+                                    { name: 'inbound', type: 'folder', description: 'Driving ports (use cases)' },
+                                    { name: 'outbound', type: 'folder', description: 'Driven ports (repositories, gateways)' }
+                                ]
+                            },
+                            { name: 'services', type: 'folder', description: 'Application services' },
+                            { name: 'use-cases', type: 'folder', description: 'Use case implementations' }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'adapters',
+                type: 'folder',
+                description: 'Technology-specific implementations',
+                children: [
+                    {
+                        name: 'inbound',
+                        type: 'folder',
+                        description: 'Driving adapters (entry points)',
+                        children: [
+                            { name: 'http', type: 'folder', description: 'REST/GraphQL controllers' },
+                            { name: 'grpc', type: 'folder', description: 'gRPC handlers' },
+                            { name: 'cli', type: 'folder', description: 'CLI commands' },
+                            { name: 'events', type: 'folder', description: 'Event consumers' }
+                        ]
+                    },
+                    {
+                        name: 'outbound',
+                        type: 'folder',
+                        description: 'Driven adapters (external resources)',
+                        children: [
+                            { name: 'persistence', type: 'folder', description: 'Database repositories' },
+                            { name: 'messaging', type: 'folder', description: 'Message queue clients' },
+                            { name: 'external-apis', type: 'folder', description: 'Third-party API clients' }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'config',
+                type: 'folder',
+                description: 'Application configuration',
+                children: [
+                    { name: 'dependency-injection', type: 'folder', description: 'DI container setup' }
+                ]
+            }
+        ]
+    },
+    commonPitfalls: [
+        'Leaking adapter types into core - core must not import from adapters',
+        'Over-engineering simple operations - not every operation needs full port/adapter',
+        'Ports that mirror database schemas - ports defined by application needs',
+        'Missing adapter for testing - always create in-memory adapters',
+        'Putting business logic in adapters - all logic belongs in core',
+        'Confusing driving and driven ports'
+    ],
+    aiInstructions: `When generating code for Hexagonal Architecture:
+
+CORE ISOLATION:
+- Core (domain + application) imports NOTHING from adapters
+- Use cases implement inbound ports, call outbound ports
+- All framework/library code lives in adapters
+- Core is pure TypeScript/Java/Python with no frameworks
+
+PORTS:
+- Inbound ports: interfaces that USE CASES implement
+- Outbound ports: interfaces that ADAPTERS implement
+- Port interfaces defined by application needs, not technology
+- Example outbound: UserRepository, EmailGateway, PaymentGateway
+
+ADAPTERS:
+- Inbound adapters call use cases (HTTP controller → use case)
+- Outbound adapters implement ports (PostgresUserRepository implements UserRepository)
+- Create in-memory adapters for testing
+
+DEPENDENCY INJECTION:
+- Wire adapters to ports in composition root
+- Core knows interfaces, not implementations
+- Swap adapters without changing core
+
+TESTING:
+- Test core with in-memory adapters only
+- Integration tests use real adapters`
+};
+//# sourceMappingURL=hexagonal.js.map

package/dist/styles/hexagonal.js.map

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

package/dist/styles/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * IronBackend Architecture Styles
+ * Export all architecture style definitions
+ */
+import { cleanMonolith } from './clean-monolith.js';
+import { modularMonolith } from './modular-monolith.js';
+import { hexagonal } from './hexagonal.js';
+import { eventDriven, cqrs } from './event-driven.js';
+import { microservicesSync, microservicesAsync } from './microservices.js';
+import { serverless, readHeavy, automation } from './specialized.js';
+import type { ArchitectureStyle } from '../types.js';
+/**
+ * All available architecture styles
+ */
+export declare const styles: Record<string, ArchitectureStyle>;
+/**
+ * Get a style by ID
+ */
+export declare function getStyle(id: string): ArchitectureStyle | undefined;
+/**
+ * Get all style IDs
+ */
+export declare function getStyleIds(): string[];
+/**
+ * Find styles matching criteria
+ */
+export declare function findStyles(criteria: {
+    teamSize?: 'small' | 'medium' | 'large';
+    complexity?: 'low' | 'medium' | 'high';
+    scalability?: 'single' | 'horizontal';
+}): ArchitectureStyle[];
+export { cleanMonolith, modularMonolith, hexagonal, eventDriven, cqrs, microservicesSync, microservicesAsync, serverless, readHeavy, automation, };
+//# sourceMappingURL=index.d.ts.map

package/dist/styles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/styles/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAWpD,CAAC;AAEF;;GAEG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAElE;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,EAAE,CAEtC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IACxC,UAAU,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACvC,WAAW,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;CACzC,GAAG,iBAAiB,EAAE,CAiBtB;AAGD,OAAO,EACH,aAAa,EACb,eAAe,EACf,SAAS,EACT,WAAW,EACX,IAAI,EACJ,iBAAiB,EACjB,kBAAkB,EAClB,UAAU,EACV,SAAS,EACT,UAAU,GACb,CAAC"}

package/dist/styles/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * IronBackend Architecture Styles
+ * Export all architecture style definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.automation = exports.readHeavy = exports.serverless = exports.microservicesAsync = exports.microservicesSync = exports.cqrs = exports.eventDriven = exports.hexagonal = exports.modularMonolith = exports.cleanMonolith = exports.styles = void 0;
+exports.getStyle = getStyle;
+exports.getStyleIds = getStyleIds;
+exports.findStyles = findStyles;
+const clean_monolith_js_1 = require("./clean-monolith.js");
+Object.defineProperty(exports, "cleanMonolith", { enumerable: true, get: function () { return clean_monolith_js_1.cleanMonolith; } });
+const modular_monolith_js_1 = require("./modular-monolith.js");
+Object.defineProperty(exports, "modularMonolith", { enumerable: true, get: function () { return modular_monolith_js_1.modularMonolith; } });
+const hexagonal_js_1 = require("./hexagonal.js");
+Object.defineProperty(exports, "hexagonal", { enumerable: true, get: function () { return hexagonal_js_1.hexagonal; } });
+const event_driven_js_1 = require("./event-driven.js");
+Object.defineProperty(exports, "eventDriven", { enumerable: true, get: function () { return event_driven_js_1.eventDriven; } });
+Object.defineProperty(exports, "cqrs", { enumerable: true, get: function () { return event_driven_js_1.cqrs; } });
+const microservices_js_1 = require("./microservices.js");
+Object.defineProperty(exports, "microservicesSync", { enumerable: true, get: function () { return microservices_js_1.microservicesSync; } });
+Object.defineProperty(exports, "microservicesAsync", { enumerable: true, get: function () { return microservices_js_1.microservicesAsync; } });
+const specialized_js_1 = require("./specialized.js");
+Object.defineProperty(exports, "serverless", { enumerable: true, get: function () { return specialized_js_1.serverless; } });
+Object.defineProperty(exports, "readHeavy", { enumerable: true, get: function () { return specialized_js_1.readHeavy; } });
+Object.defineProperty(exports, "automation", { enumerable: true, get: function () { return specialized_js_1.automation; } });
+/**
+ * All available architecture styles
+ */
+exports.styles = {
+    'clean-monolith': clean_monolith_js_1.cleanMonolith,
+    'modular-monolith': modular_monolith_js_1.modularMonolith,
+    'hexagonal': hexagonal_js_1.hexagonal,
+    'event-driven': event_driven_js_1.eventDriven,
+    'cqrs': event_driven_js_1.cqrs,
+    'microservices-sync': microservices_js_1.microservicesSync,
+    'microservices-async': microservices_js_1.microservicesAsync,
+    'serverless': specialized_js_1.serverless,
+    'read-heavy': specialized_js_1.readHeavy,
+    'automation': specialized_js_1.automation,
+};
+/**
+ * Get a style by ID
+ */
+function getStyle(id) {
+    return exports.styles[id];
+}
+/**
+ * Get all style IDs
+ */
+function getStyleIds() {
+    return Object.keys(exports.styles);
+}
+/**
+ * Find styles matching criteria
+ */
+function findStyles(criteria) {
+    // Simple heuristic-based filtering
+    return Object.values(exports.styles).filter(style => {
+        if (criteria.teamSize === 'small') {
+            return ['clean-monolith', 'serverless', 'automation'].includes(style.id);
+        }
+        if (criteria.teamSize === 'large') {
+            return ['modular-monolith', 'microservices-sync', 'microservices-async'].includes(style.id);
+        }
+        if (criteria.complexity === 'low') {
+            return ['clean-monolith', 'serverless'].includes(style.id);
+        }
+        if (criteria.complexity === 'high') {
+            return ['hexagonal', 'event-driven', 'cqrs'].includes(style.id);
+        }
+        return true;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/styles/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/styles/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA6BH,4BAEC;AAKD,kCAEC;AAKD,gCAqBC;AA9DD,2DAAoD;AAkEhD,8FAlEK,iCAAa,OAkEL;AAjEjB,+DAAwD;AAkEpD,gGAlEK,qCAAe,OAkEL;AAjEnB,iDAA2C;AAkEvC,0FAlEK,wBAAS,OAkEL;AAjEb,uDAAsD;AAkElD,4FAlEK,6BAAW,OAkEL;AACX,qFAnEkB,sBAAI,OAmElB;AAlER,yDAA2E;AAmEvE,kGAnEK,oCAAiB,OAmEL;AACjB,mGApEwB,qCAAkB,OAoExB;AAnEtB,qDAAqE;AAoEjE,2FApEK,2BAAU,OAoEL;AACV,0FArEiB,0BAAS,OAqEjB;AACT,2FAtE4B,2BAAU,OAsE5B;AAnEd;;GAEG;AACU,QAAA,MAAM,GAAsC;IACrD,gBAAgB,EAAE,iCAAa;IAC/B,kBAAkB,EAAE,qCAAe;IACnC,WAAW,EAAE,wBAAS;IACtB,cAAc,EAAE,6BAAW;IAC3B,MAAM,EAAE,sBAAI;IACZ,oBAAoB,EAAE,oCAAiB;IACvC,qBAAqB,EAAE,qCAAkB;IACzC,YAAY,EAAE,2BAAU;IACxB,YAAY,EAAE,0BAAS;IACvB,YAAY,EAAE,2BAAU;CAC3B,CAAC;AAEF;;GAEG;AACH,SAAgB,QAAQ,CAAC,EAAU;IAC/B,OAAO,cAAM,CAAC,EAAE,CAAC,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,SAAgB,WAAW;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,cAAM,CAAC,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAC,QAI1B;IACG,mCAAmC;IACnC,OAAO,MAAM,CAAC,MAAM,CAAC,cAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;QACxC,IAAI,QAAQ,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAChC,OAAO,CAAC,gBAAgB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC7E,CAAC;QACD,IAAI,QAAQ,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAChC,OAAO,CAAC,kBAAkB,EAAE,oBAAoB,EAAE,qBAAqB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAChG,CAAC;QACD,IAAI,QAAQ,CAAC,UAAU,KAAK,KAAK,EAAE,CAAC;YAChC,OAAO,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,QAAQ,CAAC,UAAU,KAAK,MAAM,EAAE,CAAC;YACjC,OAAO,CAAC,WAAW,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/styles/microservices.d.ts

@@ -0,0 +1,12 @@
+import type { ArchitectureStyle } from '../types.js';
+/**
+ * Microservices (Synchronous) Architecture
+ * Distributed services communicating via HTTP/gRPC
+ */
+export declare const microservicesSync: ArchitectureStyle;
+/**
+ * Microservices (Asynchronous) Architecture
+ * Services communicating via message queues and events
+ */
+export declare const microservicesAsync: ArchitectureStyle;
+//# sourceMappingURL=microservices.d.ts.map

package/dist/styles/microservices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microservices.d.ts","sourceRoot":"","sources":["../../src/styles/microservices.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAsH/B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAkGhC,CAAC"}