@facetlayer/prism-framework 0.4.0 → 0.4.1

package/src/__tests__/PrismApp.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it } from 'vitest';
+import { PrismApp } from '../app/PrismApp.ts';
+import { ServiceDefinition } from '../ServiceDefinition.ts';
+import { EndpointDefinition } from '../web/ExpressEndpointSetup.ts';
+
+describe('PrismApp', () => {
+  describe('constructor', () => {
+    it('should create app with default values when no config provided', () => {
+      const app = new PrismApp();
+
+      expect(app.name).toBe('Prism App');
+      expect(app.description).toBe('');
+      expect(app.services).toEqual([]);
+      expect(app.listAllEndpoints()).toEqual([]);
+    });
+
+    it('should create app with empty config object', () => {
+      const app = new PrismApp({});
+
+      expect(app.name).toBe('Prism App');
+      expect(app.description).toBe('');
+      expect(app.services).toEqual([]);
+    });
+
+    it('should create app with custom name and description', () => {
+      const app = new PrismApp({
+        name: 'My API',
+        description: 'A test API',
+      });
+
+      expect(app.name).toBe('My API');
+      expect(app.description).toBe('A test API');
+    });
+
+    it('should register initial services from config', () => {
+      const endpoint: EndpointDefinition = {
+        method: 'GET',
+        path: '/test',
+        handler: async () => ({}),
+      };
+
+      const app = new PrismApp({
+        name: 'Test App',
+        services: [
+          { name: 'test-service', endpoints: [endpoint] },
+        ],
+      });
+
+      expect(app.services).toHaveLength(1);
+      expect(app.services[0].name).toBe('test-service');
+      expect(app.listAllEndpoints()).toHaveLength(1);
+    });
+  });
+
+  describe('addService', () => {
+    it('should add a service to the app', () => {
+      const app = new PrismApp({ name: 'Test App' });
+
+      const service: ServiceDefinition = {
+        name: 'users-service',
+        endpoints: [
+          { method: 'GET', path: '/users', handler: async () => [] },
+        ],
+      };
+
+      app.addService(service);
+
+      expect(app.services).toHaveLength(1);
+      expect(app.services[0].name).toBe('users-service');
+    });
+
+    it('should register endpoints from added service', () => {
+      const app = new PrismApp();
+
+      app.addService({
+        name: 'api-service',
+        endpoints: [
+          { method: 'GET', path: '/items', handler: async () => [] },
+          { method: 'POST', path: '/items', handler: async () => ({}) },
+        ],
+      });
+
+      const endpoints = app.listAllEndpoints();
+      expect(endpoints).toHaveLength(2);
+    });
+
+    it('should allow adding multiple services', () => {
+      const app = new PrismApp({ name: 'Multi-Service App' });
+
+      app.addService({ name: 'service-1', endpoints: [{ method: 'GET', path: '/s1', handler: async () => ({}) }] });
+      app.addService({ name: 'service-2', endpoints: [{ method: 'GET', path: '/s2', handler: async () => ({}) }] });
+      app.addService({ name: 'service-3', endpoints: [{ method: 'GET', path: '/s3', handler: async () => ({}) }] });
+
+      expect(app.services).toHaveLength(3);
+      expect(app.listAllEndpoints()).toHaveLength(3);
+    });
+
+    it('should allow adding service with no endpoints', () => {
+      const app = new PrismApp();
+
+      app.addService({ name: 'empty-service' });
+
+      expect(app.services).toHaveLength(1);
+      expect(app.listAllEndpoints()).toHaveLength(0);
+    });
+  });
+
+  describe('getEndpoint', () => {
+    it('should find endpoint by method and path', () => {
+      const handler = async () => ({});
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [{ method: 'GET', path: '/users', handler }],
+          },
+        ],
+      });
+
+      const endpoint = app.getEndpoint('GET', '/users');
+
+      expect(endpoint).toBeDefined();
+      expect(endpoint?.handler).toBe(handler);
+    });
+
+    it('should return undefined for non-existent endpoint', () => {
+      const app = new PrismApp();
+
+      const endpoint = app.getEndpoint('GET', '/nonexistent');
+
+      expect(endpoint).toBeUndefined();
+    });
+
+    it('should differentiate endpoints by method', () => {
+      const getHandler = async () => ({ method: 'get' });
+      const postHandler = async () => ({ method: 'post' });
+
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [
+              { method: 'GET', path: '/items', handler: getHandler },
+              { method: 'POST', path: '/items', handler: postHandler },
+            ],
+          },
+        ],
+      });
+
+      expect(app.getEndpoint('GET', '/items')?.handler).toBe(getHandler);
+      expect(app.getEndpoint('POST', '/items')?.handler).toBe(postHandler);
+    });
+  });
+
+  describe('matchEndpoint', () => {
+    it('should match exact paths', () => {
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [{ method: 'GET', path: '/users', handler: async () => ({}) }],
+          },
+        ],
+      });
+
+      const match = app.matchEndpoint('GET', '/users');
+
+      expect(match).toBeDefined();
+      expect(match?.params).toEqual({});
+    });
+
+    it('should match paths with parameters', () => {
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [{ method: 'GET', path: '/users/:userId', handler: async () => ({}) }],
+          },
+        ],
+      });
+
+      const match = app.matchEndpoint('GET', '/users/123');
+
+      expect(match).toBeDefined();
+      expect(match?.params).toEqual({ userId: '123' });
+    });
+
+    it('should match paths with multiple parameters', () => {
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [{ method: 'GET', path: '/users/:userId/posts/:postId', handler: async () => ({}) }],
+          },
+        ],
+      });
+
+      const match = app.matchEndpoint('GET', '/users/123/posts/456');
+
+      expect(match).toBeDefined();
+      expect(match?.params).toEqual({ userId: '123', postId: '456' });
+    });
+
+    it('should return undefined for non-matching paths', () => {
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [{ method: 'GET', path: '/users', handler: async () => ({}) }],
+          },
+        ],
+      });
+
+      const match = app.matchEndpoint('GET', '/posts');
+
+      expect(match).toBeUndefined();
+    });
+
+    it('should not match when method differs', () => {
+      const app = new PrismApp({
+        services: [
+          {
+            name: 'test',
+            endpoints: [{ method: 'GET', path: '/users', handler: async () => ({}) }],
+          },
+        ],
+      });
+
+      const match = app.matchEndpoint('POST', '/users');
+
+      expect(match).toBeUndefined();
+    });
+  });
+
+  describe('getAllServices', () => {
+    it('should return all registered services', () => {
+      const app = new PrismApp();
+      app.addService({ name: 'service-1' });
+      app.addService({ name: 'service-2' });
+
+      const services = app.getAllServices();
+
+      expect(services).toHaveLength(2);
+      expect(services[0].name).toBe('service-1');
+      expect(services[1].name).toBe('service-2');
+    });
+  });
+
+  describe('listAllEndpoints', () => {
+    it('should return all endpoints from all services', () => {
+      const app = new PrismApp();
+
+      app.addService({
+        name: 'service-1',
+        endpoints: [
+          { method: 'GET', path: '/a', handler: async () => ({}) },
+          { method: 'GET', path: '/b', handler: async () => ({}) },
+        ],
+      });
+
+      app.addService({
+        name: 'service-2',
+        endpoints: [
+          { method: 'GET', path: '/c', handler: async () => ({}) },
+        ],
+      });
+
+      const endpoints = app.listAllEndpoints();
+
+      expect(endpoints).toHaveLength(3);
+      expect(endpoints.map(e => e.path).sort()).toEqual(['/a', '/b', '/c']);
+    });
+  });
+});

package/src/__tests__/RequestContext.test.ts

@@ -0,0 +1,295 @@
+import {
+  RequestContext,
+  withRequestContext,
+  getCurrentRequestContext,
+} from '../RequestContext.ts';
+import { Authorization } from '../authorization/Authorization.ts';
+import { describe, expect, it, beforeEach } from 'vitest';
+
+describe('RequestContext', () => {
+  describe('withRequestContext', () => {
+    it('should run function within request context', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      const result = withRequestContext(context, () => {
+        const currentContext = getCurrentRequestContext();
+        expect(currentContext).toBe(context);
+        return 'success';
+      });
+
+      expect(result).toBe('success');
+    });
+
+    it('should return the function result', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      const result = withRequestContext(context, () => {
+        return { data: 'test', count: 42 };
+      });
+
+      expect(result).toEqual({ data: 'test', count: 42 });
+    });
+
+    it('should properly clean up context after function executes', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      withRequestContext(context, () => {
+        expect(getCurrentRequestContext()).toBe(context);
+      });
+
+      expect(getCurrentRequestContext()).toBeUndefined();
+    });
+
+    it('should handle nested contexts', () => {
+      const auth1 = new Authorization();
+      const auth2 = new Authorization();
+      const context1: RequestContext = {
+        requestId: 'req1',
+        startTime: Date.now(),
+        auth: auth1,
+      };
+      const context2: RequestContext = {
+        requestId: 'req2',
+        startTime: Date.now(),
+        auth: auth2,
+      };
+
+      withRequestContext(context1, () => {
+        expect(getCurrentRequestContext()?.requestId).toBe('req1');
+
+        withRequestContext(context2, () => {
+          expect(getCurrentRequestContext()?.requestId).toBe('req2');
+        });
+
+        expect(getCurrentRequestContext()?.requestId).toBe('req1');
+      });
+
+      expect(getCurrentRequestContext()).toBeUndefined();
+    });
+
+    it('should propagate errors thrown in the function', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      expect(() => {
+        withRequestContext(context, () => {
+          throw new Error('Test error');
+        });
+      }).toThrow('Test error');
+    });
+
+    it('should clear context even when function throws', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      try {
+        withRequestContext(context, () => {
+          throw new Error('Test error');
+        });
+      } catch (e) {
+        // Expected error
+      }
+
+      expect(getCurrentRequestContext()).toBeUndefined();
+    });
+  });
+
+  describe('getCurrentRequestContext', () => {
+    it('should return undefined when no context is set', () => {
+      expect(getCurrentRequestContext()).toBeUndefined();
+    });
+
+    it('should return the current context when inside withRequestContext', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      withRequestContext(context, () => {
+        const currentContext = getCurrentRequestContext();
+        expect(currentContext).toBeDefined();
+        expect(currentContext?.requestId).toBe('req123');
+        expect(currentContext?.auth).toBe(auth);
+      });
+    });
+
+    it('should return undefined after context exits', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      withRequestContext(context, () => {
+        // Inside context
+      });
+
+      expect(getCurrentRequestContext()).toBeUndefined();
+    });
+  });
+
+  describe('RequestContext interface', () => {
+    it('should support all required fields', () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      expect(context.requestId).toBe('req123');
+      expect(typeof context.startTime).toBe('number');
+      expect(context.auth).toBe(auth);
+      expect(context.req).toBeUndefined();
+      expect(context.res).toBeUndefined();
+    });
+
+    it('should support optional req and res fields', () => {
+      const auth = new Authorization();
+      const mockReq = {} as any;
+      const mockRes = {} as any;
+
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+        req: mockReq,
+        res: mockRes,
+      };
+
+      expect(context.req).toBe(mockReq);
+      expect(context.res).toBe(mockRes);
+    });
+  });
+
+  describe('async operations', () => {
+    it('should work with async functions', async () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'req123',
+        startTime: Date.now(),
+        auth,
+      };
+
+      const result = await withRequestContext(context, async () => {
+        const currentContext = getCurrentRequestContext();
+        expect(currentContext?.requestId).toBe('req123');
+
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
+        const stillCurrentContext = getCurrentRequestContext();
+        expect(stillCurrentContext?.requestId).toBe('req123');
+
+        return 'async success';
+      });
+
+      expect(result).toBe('async success');
+    });
+
+    it('should maintain context across async operations', async () => {
+      const auth = new Authorization();
+      const context: RequestContext = {
+        requestId: 'async-req',
+        startTime: Date.now(),
+        auth,
+      };
+
+      await withRequestContext(context, async () => {
+        expect(getCurrentRequestContext()?.requestId).toBe('async-req');
+
+        await Promise.resolve();
+        expect(getCurrentRequestContext()?.requestId).toBe('async-req');
+
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(getCurrentRequestContext()?.requestId).toBe('async-req');
+      });
+    });
+
+    it('should handle parallel async operations with different contexts', async () => {
+      const auth1 = new Authorization();
+      const auth2 = new Authorization();
+      const context1: RequestContext = {
+        requestId: 'req1',
+        startTime: Date.now(),
+        auth: auth1,
+      };
+      const context2: RequestContext = {
+        requestId: 'req2',
+        startTime: Date.now(),
+        auth: auth2,
+      };
+
+      const results = await Promise.all([
+        withRequestContext(context1, async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return getCurrentRequestContext()?.requestId;
+        }),
+        withRequestContext(context2, async () => {
+          await new Promise((resolve) => setTimeout(resolve, 5));
+          return getCurrentRequestContext()?.requestId;
+        }),
+      ]);
+
+      expect(results).toEqual(['req1', 'req2']);
+    });
+  });
+
+  describe('context isolation', () => {
+    it('should isolate contexts between different executions', () => {
+      const auth1 = new Authorization();
+      const auth2 = new Authorization();
+      const context1: RequestContext = {
+        requestId: 'req1',
+        startTime: 100,
+        auth: auth1,
+      };
+      const context2: RequestContext = {
+        requestId: 'req2',
+        startTime: 200,
+        auth: auth2,
+      };
+
+      let capturedContext1: RequestContext | undefined;
+      let capturedContext2: RequestContext | undefined;
+
+      withRequestContext(context1, () => {
+        capturedContext1 = getCurrentRequestContext();
+      });
+
+      withRequestContext(context2, () => {
+        capturedContext2 = getCurrentRequestContext();
+      });
+
+      expect(capturedContext1?.requestId).toBe('req1');
+      expect(capturedContext1?.startTime).toBe(100);
+      expect(capturedContext2?.requestId).toBe('req2');
+      expect(capturedContext2?.startTime).toBe(200);
+    });
+  });
+});