@ironbackend/core 1.0.0

package/dist/styles/microservices.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.microservicesAsync = exports.microservicesSync = void 0;
+/**
+ * Microservices (Synchronous) Architecture
+ * Distributed services communicating via HTTP/gRPC
+ */
+exports.microservicesSync = {
+    id: 'microservices-sync',
+    name: 'Microservices (Synchronous)',
+    description: 'Distributed system of independently deployable services communicating via synchronous protocols (HTTP/gRPC). Each service owns its data exclusively.',
+    whenToUse: [
+        'Multiple teams need independent deployment cycles',
+        'Services have different scaling requirements',
+        'Technology heterogeneity required',
+        'Clear domain boundaries established',
+        'Organization structure supports service ownership',
+        'Strong DevOps/platform capabilities'
+    ],
+    whenNotToUse: [
+        'Small team (< 20 developers)',
+        'Unclear domain boundaries',
+        'Low latency critical (network overhead)',
+        'Operational maturity lacking',
+        'Simple, unified domain',
+        'Startup phase with rapid pivots'
+    ],
+    corePrinciples: [
+        'Each service owns its data exclusively',
+        'Services communicate via well-defined APIs',
+        'Backward compatibility required for API changes',
+        'Failure of one service must not cascade',
+        'Services are independently deployable',
+        'Decentralized data management'
+    ],
+    folderStructure: {
+        name: 'service-name',
+        type: 'folder',
+        description: 'Per-service structure',
+        children: [
+            {
+                name: 'src',
+                type: 'folder',
+                children: [
+                    {
+                        name: 'api',
+                        type: 'folder',
+                        children: [
+                            { name: 'controllers', type: 'folder', description: 'HTTP handlers' },
+                            { name: 'dto', type: 'folder', description: 'Request/response types' },
+                            { name: 'clients', type: 'folder', description: 'Clients for other services' }
+                        ]
+                    },
+                    { name: 'domain', type: 'folder', description: 'Service domain logic' },
+                    { name: 'application', type: 'folder', description: 'Use cases' },
+                    { name: 'infrastructure', type: 'folder', description: 'Database, external calls' }
+                ]
+            },
+            {
+                name: 'contracts',
+                type: 'folder',
+                description: 'API schemas (OpenAPI/Protobuf)'
+            },
+            {
+                name: 'tests',
+                type: 'folder',
+                children: [
+                    { name: 'unit', type: 'folder' },
+                    { name: 'integration', type: 'folder' },
+                    { name: 'contract', type: 'folder', description: 'Consumer-driven contracts' }
+                ]
+            },
+            {
+                name: 'deploy',
+                type: 'folder',
+                children: [
+                    { name: 'Dockerfile', type: 'file' },
+                    { name: 'k8s', type: 'folder', description: 'Kubernetes manifests' }
+                ]
+            }
+        ]
+    },
+    commonPitfalls: [
+        'Distributed monolith - tight coupling defeats the purpose',
+        'Missing circuit breakers - failures cascade',
+        'Synchronous chains too deep - latency compounds',
+        'Shared database between services - kills independence',
+        'No API versioning strategy - breaking changes break consumers',
+        'Missing observability - debugging is impossible',
+        'Ignoring network failures - networks are unreliable'
+    ],
+    aiInstructions: `When generating code for Sync Microservices:
+
+RESILIENCE:
+- Implement circuit breaker for ALL external service calls
+- API clients have explicit timeout (e.g., 5s) and retry policies
+- Use bulkhead pattern to isolate failures
+- Implement fallback strategies
+
+OBSERVABILITY:
+- Include correlation ID in all requests and logs
+- Add distributed tracing (OpenTelemetry)
+- Health endpoints mandatory: /health, /ready
+
+API DESIGN:
+- Version APIs from day one: /v1/resource
+- Use OpenAPI/Protobuf for contracts
+- Implement consumer-driven contract tests
+- Never break backward compatibility
+
+DATA:
+- Each service has its own database/schema
+- No cross-service database queries
+- Use API calls to get data from other services
+
+DEPLOYMENT:
+- Each service independently deployable
+- Container-ready with health checks
+- Graceful shutdown handling`
+};
+/**
+ * Microservices (Asynchronous) Architecture
+ * Services communicating via message queues and events
+ */
+exports.microservicesAsync = {
+    id: 'microservices-async',
+    name: 'Microservices (Asynchronous)',
+    description: 'Distributed services communicating primarily through message queues and events. Decoupled in time and space for high availability and throughput.',
+    whenToUse: [
+        'High throughput required',
+        'Eventual consistency acceptable',
+        'Long-running operations common',
+        'Spiky workloads with buffering needs',
+        'Need to decouple producer/consumer lifecycles',
+        'Fire-and-forget patterns common'
+    ],
+    whenNotToUse: [
+        'Immediate consistency required',
+        'Simple request-response patterns',
+        'Message infrastructure unavailable or too complex',
+        'Debugging async flows unacceptable for team',
+        'Low-latency synchronous responses needed'
+    ],
+    corePrinciples: [
+        'Messages are the contract between services',
+        'Publishers and consumers independently deployable',
+        'Messages must have schemas and versioning',
+        'Dead letter handling mandatory',
+        'Exactly-once semantics via idempotency',
+        'Message ordering guaranteed within partition'
+    ],
+    folderStructure: {
+        name: 'service-name',
+        type: 'folder',
+        children: [
+            {
+                name: 'src',
+                type: 'folder',
+                children: [
+                    { name: 'consumers', type: 'folder', description: 'Message handlers' },
+                    { name: 'producers', type: 'folder', description: 'Message publishers' },
+                    { name: 'domain', type: 'folder' },
+                    { name: 'application', type: 'folder' },
+                    {
+                        name: 'infrastructure',
+                        type: 'folder',
+                        children: [
+                            { name: 'messaging', type: 'folder', description: 'Queue configuration' }
+                        ]
+                    }
+                ]
+            },
+            {
+                name: 'contracts',
+                type: 'folder',
+                children: [
+                    { name: 'events', type: 'folder', description: 'Published event schemas' },
+                    { name: 'commands', type: 'folder', description: 'Accepted command schemas' }
+                ]
+            },
+            { name: 'tests', type: 'folder' },
+            { name: 'deploy', type: 'folder' }
+        ]
+    },
+    commonPitfalls: [
+        'Non-idempotent consumers - duplicate messages will cause issues',
+        'Missing dead letter queues - failed messages disappear',
+        'Message ordering assumptions across partitions',
+        'No schema registry - message evolution breaks consumers',
+        'Unbounded queue growth - no backpressure',
+        'Synchronous calls hidden in async flows',
+        'Missing message metadata (correlation, timestamp)'
+    ],
+    aiInstructions: `When generating code for Async Microservices:
+
+MESSAGES:
+- Every message has: id, type, timestamp, version, correlationId, payload
+- Message ID used for idempotency
+- Schema registry for message contracts (Avro, Protobuf, JSON Schema)
+
+CONSUMERS:
+- MUST be idempotent - handle duplicate messages
+- Acknowledge after successful processing
+- Implement dead letter queue handling
+- Log: message received, processing start, processing complete
+
+PRODUCERS:
+- Use transactional outbox pattern for reliability
+- Include all required metadata
+- Validate message schema before publishing
+
+RELIABILITY:
+- Configure appropriate retry policies with backoff
+- Set up dead letter queues for each consumer
+- Monitor queue depths and processing latency
+- Implement circuit breaker for downstream calls`
+};
+//# sourceMappingURL=microservices.js.map

package/dist/styles/microservices.js.map

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

package/dist/styles/modular-monolith.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitectureStyle } from '../types.js';
+/**
+ * Modular Monolith Architecture Style
+ * Monolith composed of self-contained modules with explicit boundaries
+ */
+export declare const modularMonolith: ArchitectureStyle;
+//# sourceMappingURL=modular-monolith.d.ts.map

package/dist/styles/modular-monolith.d.ts.map

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

package/dist/styles/modular-monolith.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modularMonolith = void 0;
+/**
+ * Modular Monolith Architecture Style
+ * Monolith composed of self-contained modules with explicit boundaries
+ */
+exports.modularMonolith = {
+    id: 'modular-monolith',
+    name: 'Modular Monolith',
+    description: 'Monolith composed of self-contained modules with explicit boundaries. Modules communicate through defined interfaces. Prepares for potential microservices migration.',
+    whenToUse: [
+        'Preparing for potential microservices migration',
+        'Multiple feature teams on one codebase',
+        'Need module-level isolation without distributed complexity',
+        'Complex domain with clear bounded contexts',
+        'Want benefits of modularity with deployment simplicity',
+        'Team growing beyond 15 developers'
+    ],
+    whenNotToUse: [
+        'Simple CRUD applications - overhead not justified',
+        'Single small team (< 5 developers)',
+        'No clear domain boundaries exist',
+        'Need independent scaling of components now',
+        'Different technology stacks required per component'
+    ],
+    corePrinciples: [
+        'Each module owns its data and schema exclusively',
+        'Inter-module communication via public interfaces only',
+        'No shared mutable state between modules',
+        'Module dependencies must be acyclic',
+        'Modules can be extracted to services without rewrites',
+        'Shared kernel contains only immutable, stable types'
+    ],
+    folderStructure: {
+        name: 'src',
+        type: 'folder',
+        children: [
+            {
+                name: 'modules',
+                type: 'folder',
+                description: 'Self-contained feature modules',
+                children: [
+                    {
+                        name: 'users',
+                        type: 'folder',
+                        description: 'User management module',
+                        children: [
+                            { name: 'api', type: 'folder', description: 'Module HTTP endpoints' },
+                            { name: 'application', type: 'folder', description: 'Module use cases' },
+                            { name: 'domain', type: 'folder', description: 'Module domain logic' },
+                            { name: 'infrastructure', type: 'folder', description: 'Module repositories' },
+                            { name: 'index.ts', type: 'file', description: 'Public module API' }
+                        ]
+                    },
+                    {
+                        name: 'orders',
+                        type: 'folder',
+                        description: 'Order management module',
+                        children: [
+                            { name: 'api', type: 'folder' },
+                            { name: 'application', type: 'folder' },
+                            { name: 'domain', type: 'folder' },
+                            { name: 'infrastructure', type: 'folder' },
+                            { name: 'index.ts', type: 'file', description: 'Public module API' }
+                        ]
+                    },
+                    {
+                        name: 'payments',
+                        type: 'folder',
+                        description: 'Payment processing module'
+                    }
+                ]
+            },
+            {
+                name: 'shared-kernel',
+                type: 'folder',
+                description: 'Shared domain concepts across modules',
+                children: [
+                    { name: 'types', type: 'folder', description: 'Shared immutable types' },
+                    { name: 'events', type: 'folder', description: 'Cross-module event definitions' }
+                ]
+            },
+            {
+                name: 'bootstrap',
+                type: 'folder',
+                description: 'Application initialization',
+                children: [
+                    { name: 'modules.ts', type: 'file', description: 'Module registration' },
+                    { name: 'server.ts', type: 'file', description: 'HTTP server setup' }
+                ]
+            }
+        ]
+    },
+    commonPitfalls: [
+        'Cross-module database joins - each module should query its own data',
+        'Importing internal module files directly - only import from module/index',
+        'Shared models that couple modules - duplicate if necessary',
+        'Synchronous inter-module calls creating tight coupling - use events',
+        'Module circular dependencies - refactor to shared kernel if needed',
+        'Growing shared kernel with mutable types - keep it minimal and stable'
+    ],
+    aiInstructions: `When generating code for Modular Monolith architecture:
+
+MODULE BOUNDARIES:
+- Never import from module internals, only from module/index.ts
+- Each module has its own database schema/tables
+- Modules communicate via events or public interfaces
+- No direct database queries across module boundaries
+
+PUBLIC API:
+- Module index.ts exports only public types and services
+- Keep public API minimal and stable
+- Version module interfaces if backward compatibility needed
+
+DATA OWNERSHIP:
+- Each module owns its entities completely
+- If data is needed cross-module, define events or APIs
+- Duplicate read models rather than share
+
+EVENTS:
+- Use domain events for cross-module notifications
+- Events are fire-and-forget, async
+- Event handlers in consuming module
+
+SHARED KERNEL:
+- Contains only truly shared, immutable concepts
+- Types like Money, Email, UserId can live here
+- Never put mutable entities in shared kernel`
+};
+//# sourceMappingURL=modular-monolith.js.map

package/dist/styles/modular-monolith.js.map

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

package/dist/styles/specialized.d.ts

@@ -0,0 +1,17 @@
+import type { ArchitectureStyle } from '../types.js';
+/**
+ * Serverless Backend Architecture
+ * Stateless functions triggered by events, managed infrastructure
+ */
+export declare const serverless: ArchitectureStyle;
+/**
+ * Read-Heavy API Architecture
+ * Optimized for high read-to-write ratio
+ */
+export declare const readHeavy: ArchitectureStyle;
+/**
+ * Automation / Bot Backend Architecture
+ * Scheduled jobs, workflows, integrations
+ */
+export declare const automation: ArchitectureStyle;
+//# sourceMappingURL=specialized.d.ts.map

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

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