bunsane 0.1.1 → 0.1.2

package/tests/component.test.ts

@@ -4,6 +4,7 @@ import type { ComponentDataType } from "../core/Components";
 import { Entity } from "../core/Entity";
 import App from "../core/App";
 import ComponentRegistry from "../core/ComponentRegistry";
+import db from "../database";
 
 // Test component with 'value' attribute (standard assumption)
 @Component
@@ -50,6 +51,13 @@ class BooleanComponent extends BaseComponent {
     enabled: boolean = false;
 }
 
+let app: App;
+
+beforeAll(async () => {
+    app = new App();
+    await app.waitForAppReady();
+});
+
 describe("Component Edge Cases and Attribute Handling", () => {
     describe("Component with standard 'value' attribute", () => {
         test("should correctly identify and return value property", () => {
@@ -202,4 +210,129 @@ describe("Component Edge Cases and Attribute Handling", () => {
             expect(data.value).toBe(""); // Default value
         });
     });
-});
+});
+
+describe("Component Removal from Entities", () => {
+    test("should successfully remove an existing component from an entity", () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "test" });
+
+        // Verify component is added
+        expect(entity.componentList()).toHaveLength(1);
+        expect(entity.componentList()[0]).toBeInstanceOf(ValueComponent);
+
+        // Remove the component
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(true);
+
+        // Verify component is removed
+        expect(entity.componentList()).toHaveLength(0);
+    });
+
+    test("should return false when trying to remove a non-existent component", () => {
+        const entity = Entity.Create();
+
+        // Try to remove a component that was never added
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(false);
+
+        // Entity should still have no components
+        expect(entity.componentList()).toHaveLength(0);
+    });
+
+    test("should remove only the specified component type, leaving others intact", () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "value comp" });
+        entity.add(CustomAttributeComponent, { customData: "custom comp" });
+
+        // Verify both components are added
+        expect(entity.componentList()).toHaveLength(2);
+
+        // Remove only the ValueComponent
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(true);
+
+        // Verify only CustomAttributeComponent remains
+        expect(entity.componentList()).toHaveLength(1);
+        expect(entity.componentList()[0]).toBeInstanceOf(CustomAttributeComponent);
+    });
+
+    test("should mark entity as dirty after component removal", () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "test" });
+
+        // Entity should be dirty after adding
+        expect((entity as any)._dirty).toBe(true);
+
+        // Save to make it clean
+        // Note: We can't actually save without database, but we can set it manually for test
+        entity.setDirty(false);
+        expect((entity as any)._dirty).toBe(false);
+
+        // Remove component
+        entity.remove(ValueComponent);
+
+        // Entity should be dirty again
+        expect((entity as any)._dirty).toBe(true);
+    });
+
+    test("should persist component addition and removal to database", async () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "test value" });
+
+        // Save to database
+        const saveResult = await entity.save();
+        expect(saveResult).toBe(true);
+
+        // Verify component exists in database
+        const componentsAfterAdd = await db`SELECT id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterAdd.length).toBe(1);
+        expect(componentsAfterAdd[0].data.value).toBe("test value");
+
+        // Remove the component
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(true);
+
+        // Save again to persist removal
+        const saveResult2 = await entity.save();
+        expect(saveResult2).toBe(true);
+
+        // Verify component is removed from database
+        const componentsAfterRemove = await db`SELECT id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterRemove.length).toBe(0);
+    });
+
+    test("should handle multiple component additions and removals in database", async () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "value comp" });
+        entity.add(CustomAttributeComponent, { customData: "custom comp" });
+
+        // Save to database
+        await entity.save();
+
+        // Verify both components exist
+        const componentsAfterAdd = await db`SELECT type_id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL ORDER BY type_id`;
+        expect(componentsAfterAdd.length).toBe(2);
+        const valueComp = componentsAfterAdd.find((c: any) => c.data.value === "value comp");
+        const customComp = componentsAfterAdd.find((c: any) => c.data.customData === "custom comp");
+        expect(valueComp).toBeDefined();
+        expect(customComp).toBeDefined();
+
+        // Remove one component
+        entity.remove(ValueComponent);
+        await entity.save();
+
+        // Verify only custom component remains
+        const componentsAfterRemove = await db`SELECT type_id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterRemove.length).toBe(1);
+        expect(componentsAfterRemove[0].data.customData).toBe("custom comp");
+
+        // Remove the last component
+        entity.remove(CustomAttributeComponent);
+        await entity.save();
+
+        // Verify no components remain
+        const componentsAfterRemoveAll = await db`SELECT id FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterRemoveAll.length).toBe(0);
+    });
+});

package/examples/hooks/README.md

@@ -1,228 +0,0 @@
-# Entity Lifecycle Hooks Examples
-
-This directory contains example implementations of common use cases for the Entity Lifecycle Hooks system. Each example demonstrates best practices for hook implementation, error handling, and performance optimization.
-
-## Examples Overview
-
-### 1. Audit Logging (`audit-logger.ts`)
-Demonstrates comprehensive audit logging for entity lifecycle events with different storage backends.
-
-### 2. Cache Management (`cache-manager.ts`)
-Shows how to implement intelligent cache invalidation and population using entity hooks.
-
-### 3. Search Indexing (`search-indexer.ts`)
-Illustrates real-time search index updates for entities and components.
-
-### 4. Business Rules (`business-rules.ts`)
-Examples of business rule validation and enforcement using component hooks.
-
-### 5. Notifications (`notification-service.ts`)
-Demonstrates event-driven notification systems for user actions.
-
-### 6. Data Synchronization (`data-sync.ts`)
-Shows cross-system data synchronization patterns.
-
-### 7. Metrics Collection (`metrics-collector.ts`)
-Performance monitoring and metrics collection for entity operations.
-
-### 8. Security (`security-hooks.ts`)
-Security-related hooks for access control and data protection.
-
-## Usage
-
-Each example can be used as a starting point for your own implementations. Import the example classes and register them with the hook system:
-
-```typescript
-import { AuditLogger } from "./examples/hooks/audit-logger";
-import { registerDecoratedHooks } from "bunsane";
-
-// Register example hooks
-const auditLogger = new AuditLogger();
-registerDecoratedHooks(auditLogger);
-```
-
-## Best Practices Demonstrated
-
-- **Error Isolation**: Each hook handles its own errors without affecting others
-- **Performance Optimization**: Use of filters, batching, and async operations
-- **Resource Management**: Proper cleanup and resource handling
-- **Type Safety**: Full TypeScript support with proper typing
-- **Monitoring**: Built-in metrics and logging
-- **Configuration**: Environment-based configuration
-- **Testing**: Testable hook implementations
-
-## Common Patterns
-
-### Conditional Execution
-```typescript
-@EntityHook("entity.created")
-async handleEntityCreated(event: EntityCreatedEvent) {
-    // Only process specific entity types
-    if (!event.getEntity().has(TargetComponent)) return;
-
-    // Process the entity
-    await this.processEntity(event.getEntity());
-}
-```
-
-### Batch Processing
-```typescript
-private pendingEvents: EntityCreatedEvent[] = [];
-
-@EntityHook("entity.created")
-handleEntityCreated(event: EntityCreatedEvent) {
-    this.pendingEvents.push(event);
-
-    // Process in batches to improve performance
-    if (this.pendingEvents.length >= 10) {
-        this.processBatch();
-    }
-}
-```
-
-### Error Handling
-```typescript
-@EntityHook("entity.created")
-async handleEntityCreated(event: EntityCreatedEvent) {
-    try {
-        await this.unreliableOperation();
-    } catch (error) {
-        // Log error but don't throw - preserve other hooks
-        this.logger.error("Hook execution failed:", error);
-    }
-}
-```
-
-### Resource Cleanup
-```typescript
-@EntityHook("entity.deleted")
-handleEntityDeleted(event: EntityDeletedEvent) {
-    // Clean up resources associated with the entity
-    this.cache.delete(event.getEntity().id);
-    this.pendingOperations.delete(event.getEntity().id);
-}
-```
-
-## Configuration
-
-Most examples support configuration through environment variables or constructor parameters:
-
-```typescript
-// Environment-based configuration
-const auditLogger = new AuditLogger({
-    enabled: process.env.AUDIT_ENABLED === 'true',
-    level: process.env.AUDIT_LEVEL || 'info',
-    storage: process.env.AUDIT_STORAGE || 'database'
-});
-```
-
-## Testing
-
-Each example includes testing patterns:
-
-```typescript
-describe("AuditLogger", () => {
-    let auditLogger: AuditLogger;
-
-    beforeEach(() => {
-        auditLogger = new AuditLogger();
-        registerDecoratedHooks(auditLogger);
-    });
-
-    afterEach(() => {
-        EntityHookManager.clearAllHooks();
-    });
-
-    test("should log entity creation", async () => {
-        const entity = Entity.Create();
-        await entity.save();
-
-        // Verify audit log was created
-        expect(auditLogger.getLogs()).toContain(/* expected log entry */);
-    });
-});
-```
-
-## Performance Considerations
-
-Examples demonstrate performance optimization techniques:
-
-- **Filtering**: Reduce unnecessary hook execution
-- **Batching**: Group operations for efficiency
-- **Async Processing**: Use async hooks for I/O operations
-- **Caching**: Cache frequently accessed data
-- **Timeouts**: Prevent hanging operations
-
-## Integration
-
-Examples show how to integrate with existing systems:
-
-- **Database**: Entity persistence and queries
-- **Cache**: Redis, Memcached, or in-memory caching
-- **Search**: Elasticsearch, Algolia, or custom search
-- **Queues**: Background job processing
-- **Monitoring**: Metrics collection and alerting
-- **Logging**: Structured logging with context
-
-## Customization
-
-Examples are designed to be easily customizable:
-
-```typescript
-// Extend base examples
-class CustomAuditLogger extends AuditLogger {
-    @EntityHook("entity.updated")
-    async handleCustomUpdate(event: EntityUpdatedEvent) {
-        // Custom logic
-        await super.handleEntityUpdated(event);
-
-        // Additional processing
-        await this.customProcessing(event);
-    }
-}
-```
-
-## Monitoring
-
-Examples include monitoring and health checks:
-
-```typescript
-// Health check endpoint
-app.get('/health/hooks', async (req, res) => {
-    const metrics = EntityHookManager.getMetrics();
-    const health = {
-        status: metrics.errorCount > 10 ? 'unhealthy' : 'healthy',
-        metrics,
-        timestamp: new Date().toISOString()
-    };
-
-    res.json(health);
-});
-```
-
-## Troubleshooting
-
-Common issues and solutions:
-
-1. **Hooks not executing**: Check `EntityHookManager.waitForReady()`
-2. **Performance issues**: Use `EntityHookManager.getMetrics()` to identify bottlenecks
-3. **Memory leaks**: Ensure proper cleanup in deletion hooks
-4. **Error propagation**: Handle errors gracefully to prevent hook isolation issues
-
-## Contributing
-
-When adding new examples:
-
-1. Follow the established patterns and best practices
-2. Include comprehensive error handling
-3. Add performance optimizations
-4. Provide configuration options
-5. Include tests and documentation
-6. Demonstrate integration patterns
-
-## Related Documentation
-
-- [Hooks Documentation](../HOOKS_DOCUMENTATION.md)
-- [Migration Guide](../HOOKS_MIGRATION_GUIDE.md)
-- [Performance Guide](../HOOKS_PERFORMANCE_GUIDE.md)
-- [API Reference](../HOOKS_DOCUMENTATION.md#api-reference)