Rust http gateway

serverless/account-service/typescript/functions/service/__tests__/sanity.spec.ts

@@ -1,109 +1,109 @@
-import { Account } from "../src/Account";
-import { InMemoryDb } from "../src/InMemoryDb";
-import { InternalServer } from "../src/InternalServer";
-import { Status } from "../src/Status";
-describe('InternalServer', () => {
-  let server: InternalServer;
-  let db: InMemoryDb;
+import { Account } from "../src/types/Account";
+import { FunctionManager } from "../src/functions/FunctionManager";
+import { HttpResponse, IRepository, InMemoryDb, RepositoryBase } from "serverless-utils";
+describe("InternalServer", () => {
+  let manager: FunctionManager;
+  let accountRepo: IRepository<Account>;
 
   beforeEach(() => {
-    db = new InMemoryDb();
-    server = new InternalServer(db, 'adminKey');
+    const db = new InMemoryDb();
+    accountRepo = new RepositoryBase<Account>(db, "name");
+    manager = new FunctionManager(accountRepo, "adminKey");
   });
 
-  describe('verify', () => {
-    it('should return 404 when wrong adminKey is used', async () => {
-      const response = await server.verify('test', 'key', 'wrongKey');
-      expect(response).toEqual(Status.NotFound());
+  describe("verify", () => {
+    it("should return 404 when wrong adminKey is used", async () => {
+      const response = await manager.verify("test", "key", "wrongKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should return 404 when account is not found', async () => {
-      const response = await server.verify('test', 'key', 'adminKey');
-      expect(response).toEqual(Status.NotFound());
+    it("should return 404 when account is not found", async () => {
+      const response = await manager.verify("test", "key", "adminKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should return 200 when account is found and key matches', async () => {
-      const account: Account = { name: 'test', apiKey: 'key', isDeleted: false };
-      await db.save('user', 'test', account);
+    it("should return 200 when account is found and key matches", async () => {
+      const account: Account = { name: "test", apiKey: "key", isDeleted: false };
+      await accountRepo.save(account);
 
-      const response = await server.verify('test', 'key', 'adminKey');
-      expect(response).toEqual(Status.Ok({ message: 'Verified.' }));
+      const response = await manager.verify("test", "key", "adminKey");
+      expect(response).toEqual(HttpResponse.Ok({ message: "Verified." }));
     });
   });
 
-  describe('create', () => {
-    it('should return 404 when wrong adminKey is used', async () => {
-      const response = await server.create('test', 'wrongKey');
-      expect(response).toEqual(Status.NotFound());
+  describe("create", () => {
+    it("should return 404 when wrong adminKey is used", async () => {
+      const response = await manager.create("test", "wrongKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should create account and return 200 when correct adminKey is used', async () => {
-      const response = await server.create('test', 'adminKey');
+    it("should create account and return 200 when correct adminKey is used", async () => {
+      const response = await manager.create("test", "adminKey");
       expect(response.statusCode).toBe(200);
 
       const body = (response as any).body;
-      expect(body).toHaveProperty('message', 'Account created.');
-      expect(body).toHaveProperty('apiKey');
+      expect(body).toHaveProperty("message", "Account created.");
+      expect(body).toHaveProperty("apiKey");
 
-      const account = await db.read<Account>('user', 'test');
-      expect(account).toHaveProperty('name', 'test');
-      expect(account).toHaveProperty('apiKey', body.apiKey);
+      const account = await accountRepo.read("test");
+      expect(account).toHaveProperty("name", "test");
+      expect(account).toHaveProperty("apiKey", body.apiKey);
     });
   });
 
-  describe('delete', () => {
-    it('should return 404 when wrong adminKey is used', async () => {
-      const response = await server.delete('test', 'wrongKey');
-      expect(response).toEqual(Status.NotFound());
+  describe("delete", () => {
+    it("should return 404 when wrong adminKey is used", async () => {
+      const response = await manager.delete("test", "wrongKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should mark account as deleted and return 200 when correct adminKey is used', async () => {
-      const account: Account = { name: 'test', apiKey: 'key', isDeleted: false };
-      await db.save('user', 'test', account);
+    it("should mark account as deleted and return 200 when correct adminKey is used", async () => {
+      const account: Account = { name: "test", apiKey: "key", isDeleted: false };
+      await accountRepo.save(account);
 
-      const response = await server.delete('test', 'adminKey');
-      expect(response).toEqual(Status.Ok(undefined));
+      const response = await manager.delete("test", "adminKey");
+      expect(response).toEqual(HttpResponse.Ok(undefined));
 
-      const deletedAccount = await db.read<Account>('user', 'test');
-      expect(deletedAccount).toHaveProperty('isDeleted', true);
+      const deletedAccount = await accountRepo.read("test");
+      expect(deletedAccount).toHaveProperty("isDeleted", true);
     });
   });
 
-  describe('restore', () => {
-    it('should return 404 when wrong adminKey is used', async () => {
-      const response = await server.restore('test', 'wrongKey');
-      expect(response).toEqual(Status.NotFound());
+  describe("restore", () => {
+    it("should return 404 when wrong adminKey is used", async () => {
+      const response = await manager.restore("test", "wrongKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should mark account as not deleted and return 200 when correct adminKey is used', async () => {
-      const account: Account = { name: 'test', apiKey: 'key', isDeleted: true };
-      await db.save('user', 'test', account);
+    it("should mark account as not deleted and return 200 when correct adminKey is used", async () => {
+      const account: Account = { name: "test", apiKey: "key", isDeleted: true };
+      await accountRepo.save(account);
 
-      const response = await server.restore('test', 'adminKey');
-      expect(response).toEqual(Status.Ok(undefined));
+      const response = await manager.restore("test", "adminKey");
+      expect(response).toEqual(HttpResponse.Ok(undefined));
 
-      const restoredAccount = await db.read<Account>('user', 'test');
-      expect(restoredAccount).toHaveProperty('isDeleted', false);
+      const restoredAccount = await accountRepo.read("test");
+      expect(restoredAccount).toHaveProperty("isDeleted", false);
     });
   });
 
-  describe('get', () => {
-    it('should return 404 when wrong adminKey is used', async () => {
-      const response = await server.get('test', 'wrongKey');
-      expect(response).toEqual(Status.NotFound());
+  describe("get", () => {
+    it("should return 404 when wrong adminKey is used", async () => {
+      const response = await manager.get("test", "wrongKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should return 404 when account is not found', async () => {
-      const response = await server.get('test', 'adminKey');
-      expect(response).toEqual(Status.NotFound());
+    it("should return 404 when account is not found", async () => {
+      const response = await manager.get("test", "adminKey");
+      expect(response).toEqual(HttpResponse.NotFound());
     });
 
-    it('should return account and 200 when correct adminKey is used and account exists', async () => {
-      const account: Account = { name: 'test', apiKey: 'key', isDeleted: false };
-      await db.save('user', 'test', account);
+    it("should return account and 200 when correct adminKey is used and account exists", async () => {
+      const account: Account = { name: "test", apiKey: "key", isDeleted: false };
+      await accountRepo.save(account);
 
-      const response = await server.get('test', 'adminKey');
-      expect(response).toEqual(Status.Ok(account));
+      const response = await manager.get("test", "adminKey");
+      expect(response).toEqual(HttpResponse.Ok(account));
     });
   });
 });

serverless/account-service/typescript/functions/service/package.json

@@ -16,11 +16,13 @@
     "test": "jest --passWithNoTests --runInBand --detectOpenHandles --verbose"
   },
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "3.254.0"
+    "@aws-sdk/client-dynamodb": "3.254.0",
+    "@polywrap/result": "^0.10.1",
+    "serverless-utils": "file:../../../../utils/serverless-utils"
   },
   "devDependencies": {
-    "@types/node": "16.11.11",
     "@types/jest": "26.0.8",
+    "@types/node": "16.11.11",
     "jest": "27.1.1",
     "ts-jest": "27.0.5",
     "ts-node": "10.3.0",