ts-procedures 1.0.0 → 1.1.0

package/src/implementations/http/express/example/server.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from 'vitest'
+import supertest from 'supertest'
+import { app } from './server.js'
+
+describe('Express Server Tests', () => {
+  describe('Public Endpoints', () => {
+    describe('POST /authenticate', () => {
+      it('should return token with valid credentials', async () => {
+        const response = await supertest(app)
+          .post('/authenticate')
+          .send({ username: 'john', password: 'secret123' })
+
+        expect(response.status).toBe(200)
+        expect(response.body).toEqual({ token: 'fake-jwt-token' })
+      })
+
+      it('should return 422 when username is missing', async () => {
+        const response = await supertest(app).post('/authenticate').send({ password: 'secret123' })
+
+        expect(response.status).toBe(422)
+        expect(response.body).toHaveProperty('error')
+      })
+
+      it('should return 422 when username is too short (minLength: 3)', async () => {
+        const response = await supertest(app)
+          .post('/authenticate')
+          .send({ username: 'ab', password: 'secret123' })
+
+        expect(response.status).toBe(422)
+        expect(response.body).toHaveProperty('error')
+      })
+
+      it('should return 422 when password is missing', async () => {
+        const response = await supertest(app).post('/authenticate').send({ username: 'john' })
+
+        expect(response.status).toBe(422)
+        expect(response.body).toHaveProperty('error')
+      })
+
+      it('should return 422 when password is too short (minLength: 6)', async () => {
+        const response = await supertest(app)
+          .post('/authenticate')
+          .send({ username: 'john', password: '12345' })
+
+        expect(response.status).toBe(422)
+        expect(response.body).toHaveProperty('error')
+      })
+
+      it('should return 422 when body is empty', async () => {
+        const response = await supertest(app).post('/authenticate').send({})
+
+        expect(response.status).toBe(422)
+        expect(response.body).toHaveProperty('error')
+      })
+    })
+  })
+
+  describe('Protected Endpoints', () => {
+    describe('GET /users/user-profile/:id', () => {
+      it('should return 401 when no authorization header is provided', async () => {
+        const response = await supertest(app).get('/users/user-profile/123')
+
+        expect(response.status).toBe(401)
+        expect(response.body).toEqual({ error: 'Unauthorized' })
+      })
+
+      it('should return 401 when authorization token is invalid', async () => {
+        const response = await supertest(app)
+          .get('/users/user-profile/123')
+          .set('Authorization', 'invalid-token')
+
+        expect(response.status).toBe(401)
+        expect(response.body).toEqual({ error: 'Unauthorized' })
+      })
+
+      it('should return user profile with valid token', async () => {
+        const response = await supertest(app)
+          .get('/users/user-profile/123')
+          .set('Authorization', 'valid-token')
+
+        expect(response.status).toBe(200)
+        expect(response.body).toEqual({
+          user: {
+            id: '123',
+            name: 'Jane Doe',
+            email: 'test@gmail.com',
+          },
+        })
+      })
+
+      it('should return user profile with different id from path', async () => {
+        const response = await supertest(app)
+          .get('/users/user-profile/abc')
+          .set('Authorization', 'valid-token')
+
+        expect(response.status).toBe(200)
+        expect(response.body).toEqual({
+          user: {
+            id: 'abc',
+            name: 'Jane Doe',
+            email: 'test@gmail.com',
+          },
+        })
+      })
+    })
+  })
+
+  describe('Response Structure', () => {
+    it('authenticate returns correct token structure', async () => {
+      const response = await supertest(app)
+        .post('/authenticate')
+        .send({ username: 'testuser', password: 'password123' })
+
+      expect(response.status).toBe(200)
+      expect(response.body).toHaveProperty('token')
+      expect(typeof response.body.token).toBe('string')
+    })
+
+    it('user profile returns correct nested user object with id, name, email', async () => {
+      const response = await supertest(app)
+        .get('/users/user-profile/test-id')
+        .set('Authorization', 'valid-token')
+
+      expect(response.status).toBe(200)
+      expect(response.body).toHaveProperty('user')
+      expect(response.body.user).toHaveProperty('id', 'test-id')
+      expect(response.body.user).toHaveProperty('name')
+      expect(response.body.user).toHaveProperty('email')
+      expect(typeof response.body.user.name).toBe('string')
+      expect(typeof response.body.user.email).toBe('string')
+    })
+  })
+})

package/src/implementations/http/express/example/server.ts

@@ -0,0 +1,67 @@
+import express from 'express'
+import {
+  PublicFactory,
+  ProtectedFactory
+} from './factories.js'
+import { registerExpressRoutes } from '../index.js'
+
+// Import procedures for their side effects (they register with the factories)
+import './procedures/auth.js'
+import './procedures/users.js'
+
+const authTokenService = (authToken: string) => {
+  // Dummy implementation - replace with real token validation logic
+  return {
+    isValid: authToken === 'valid-token',
+    userId: authToken === 'valid-token' ? 'user-123' : null,
+  }
+}
+
+export const app = express()
+app.use(express.json())
+
+registerExpressRoutes(
+  app,
+  {
+    getContext:async (req, res) => {
+      return {
+        ipAddress:'',
+        requestId:'',
+        headers:{},
+      }
+    }
+  },
+  PublicFactory.getProcedures()
+)
+
+registerExpressRoutes(
+  app,
+  {
+    getContext:async (req, res) => {
+      const authServiceResult = authTokenService(req.headers['authorization']?.toString() || '')
+
+      if (authServiceResult.isValid) {
+        return {
+          userId:authServiceResult.userId!,
+          ipAddress:'',
+          requestId:'',
+          headers:{}
+        }
+      }
+
+      res.status(401).json({
+        error: 'Unauthorized'
+      })
+      throw new Error('Unauthorized')
+    }
+  },
+  ProtectedFactory.getProcedures()
+)
+
+// Only start server when run directly (not when imported for testing)
+const isMainModule = import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, '/') || '')
+if (isMainModule) {
+  app.listen(4841, () => {
+    console.log('Server is running on http://localhost:4841')
+  })
+}