Merge pull request #854 from 06kellyjac/data_layer

refactor(experimental): abstract data layer

experimental/license-inventory/package.json

@@ -38,6 +38,7 @@
     "@types/express": "^5.0.0",
     "@types/mongoose": "^5.11.97",
     "@types/node": "^22.10.1",
+    "@types/semver": "^7.5.8",
     "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",

experimental/license-inventory/src/app.ts

@@ -1,39 +1,42 @@
 import express from 'express';
 import { logger } from '@/logger';
-import apiRouter from '@/routes/api';
+import createApiRouter from '@/routes/api';
 import pinoHTTP from 'pino-http';
 import bodyParser from 'body-parser';
 import { rateLimit } from 'express-rate-limit';
 import helmet from 'helmet';
+import { LicenseDataService } from './services/data';
 // import lusca from 'lusca';
 
 // helmet and lusca comparison
 // https://github.com/krakenjs/lusca/issues/42#issuecomment-65093906
 // TODO: integrate lusca once added sessions/auth
 
-const app = express();
+const createApp = (lds: LicenseDataService) => {
+  const app = express();
 
-const limiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  limit: 100,
-  standardHeaders: 'draft-7',
-  legacyHeaders: false,
-  // in memory store
-});
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    limit: 100,
+    standardHeaders: 'draft-7',
+    legacyHeaders: false,
+    // in memory store
+  });
 
-app.use(helmet());
-app.use(limiter);
-app.use(bodyParser.json());
-app.use(
-  pinoHTTP({
-    logger,
-    autoLogging: process.env.NODE_ENV === 'development',
-    // overrides core logger redaction
-    // please update in logger.ts
-    // redact: [],
-  }),
-);
+  app.use(helmet());
+  app.use(limiter);
+  app.use(bodyParser.json());
+  app.use(
+    pinoHTTP({
+      logger,
+      autoLogging: process.env.NODE_ENV === 'development',
+      // overrides core logger redaction
+      // please update in logger.ts
+      // redact: [],
+    }),
+  );
 
-app.use('/api', apiRouter);
-
-export { app };
+  app.use('/api', createApiRouter(lds));
+  return app;
+};
+export { createApp };

experimental/license-inventory/src/db/connect.ts

@@ -1,10 +1,10 @@
 import { AsyncResult } from '@/types';
-import mongoose from 'mongoose';
+import mongoose, { type Mongoose } from 'mongoose';
 
-export const connectDB = async (dbURI: string): AsyncResult<void> => {
+export const connectDB = async (dbURI: string): AsyncResult<Mongoose> => {
   try {
-    await mongoose.connect(dbURI);
-    return { error: null, data: null };
+    const connection = await mongoose.connect(dbURI);
+    return { error: null, data: connection };
   } catch (e: unknown) {
     if (e instanceof Error) {
       return { error: e, data: null };

experimental/license-inventory/src/db/index.ts

@@ -0,0 +1,11 @@
+import type { Mongoose, Model } from 'mongoose';
+import { licenseSchema, type LicenseSchema } from './schemas/license/license';
+
+export class Database {
+  mongoose: Mongoose;
+  License: Model<LicenseSchema>;
+  constructor(mongoose: Mongoose) {
+    this.mongoose = mongoose;
+    this.License = mongoose.model<LicenseSchema>('License', licenseSchema);
+  }
+}

experimental/license-inventory/src/db/schemas/license/license.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from '@jest/globals';
 import { License } from '@/db/collections';
-import { licenseValidation } from './license';
 import { v4 as uuidv4 } from 'uuid';
 
 // these tests require a mongodb instance
@@ -16,7 +15,7 @@ describeDB('license', () => {
 
     const insertedLicense = await License.findOne({ _id: _id });
     expect(insertedLicense).not.toBeNull();
-    expect(insertedLicense.name).toBe('hello');
+    expect(insertedLicense!.name).toBe('hello');
   });
 
   it('can insert a complex license', async () => {
@@ -37,30 +36,7 @@ describeDB('license', () => {
 
     const insertedLicense = await License.findOne({ _id: _id });
     expect(insertedLicense).not.toBeNull();
-    expect(insertedLicense.name).toBe('complex');
-    expect(insertedLicense.chooseALicenseInfo.permissions.commercialUse).toBe(true);
-  });
-
-  it('complex license conforms to output validation', async () => {
-    const _id = uuidv4();
-    await License.create({
-      _id,
-      name: 'complex2',
-      spdxID: 'sample2',
-      chooseALicenseInfo: {
-        permissions: {
-          commercialUse: true,
-        },
-        conditions: {
-          networkUseDisclose: false,
-        },
-      },
-    });
-
-    const insertedLicense = await (await License.findOne({ _id }).exec()).toJSON();
-    const { error, data } = licenseValidation.safeParse(insertedLicense);
-    expect(error).toBeUndefined();
-    expect(data.id).toBe(_id);
-    expect(!Object.keys(data).includes('_id'));
+    expect(insertedLicense!.name).toBe('complex');
+    expect(insertedLicense!.chooseALicenseInfo?.permissions?.commercialUse).toBe(true);
   });
 });

experimental/license-inventory/src/db/schemas/license/license.ts

@@ -24,27 +24,6 @@ export const licenseSchema = new Schema<LicenseSchema>(
   {
     // automatic createdAt updatedAt
     timestamps: true,
-    toObject: {
-      virtuals: true,
-      versionKey: false,
-      transform: (doc, ret) => {
-        delete ret._id;
-      },
-    },
-    toJSON: {
-      virtuals: true,
-      versionKey: false,
-      transform: (doc, ret) => {
-        delete ret._id;
-      },
-    },
-    virtuals: {
-      id: {
-        get() {
-          return this._id.toString();
-        },
-      },
-    },
   },
 );
 

experimental/license-inventory/src/env.ts

@@ -1,14 +1,16 @@
 import { z } from 'zod';
 
-const envSchema = z.object({
-  PORT: z.coerce.number().default(3000),
-  MONGO_URI: z.string(),
-});
+const envSchema = z
+  .object({
+    PORT: z.coerce.number().default(3000),
+    MONGO_URI: z.string(),
+  })
+  .required();
 
 const { error, data: env } = envSchema.safeParse(process.env);
 if (error) {
   console.error(error);
   throw new Error('failed to validate');
 }
 
-export default env;
+export default env as z.infer<typeof envSchema>;

experimental/license-inventory/src/routes/api/index.ts

@@ -1,7 +1,12 @@
 import express from 'express';
-import v0Router from './v0';
-const router = express.Router();
+import createV0Router from './v0';
+import { LicenseDataService } from '@/services/data';
 
-router.use('/v0', v0Router);
+const createRouter = (lds: LicenseDataService) => {
+  const router = express.Router();
 
-export default router;
+  router.use('/v0', createV0Router(lds));
+  return router;
+};
+
+export default createRouter;

experimental/license-inventory/src/routes/api/v0/index.ts

@@ -1,7 +1,12 @@
 import express from 'express';
-import licensesRouter from './licenses';
-const router = express.Router();
+import createLicensesRouter from './licenses';
+import { LicenseDataService } from '@/services/data';
 
-router.use('/licenses', licensesRouter);
+const createRouter = (lds: LicenseDataService) => {
+  const router = express.Router();
 
-export default router;
+  router.use('/licenses', createLicensesRouter(lds));
+  return router;
+};
+
+export default createRouter;

experimental/license-inventory/src/routes/api/v0/licenses.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, afterEach, jest } from '@jest/globals';
 import request from 'supertest';
-import { License } from '@/db/collections';
-import { app } from '@/app';
+import { v4 as uuidv4 } from 'uuid';
+import { createApp } from '@/app';
+import { genMockLicenseDataService } from '@/test/mock/db';
 
 const basePath = '/api/v0/licenses';
 const genRoute = (p: string) => basePath + p;
@@ -13,29 +14,67 @@ describe(basePath, () => {
 
   describe('GET / - list', () => {
     it('no data', async () => {
-      const execMock = jest.fn(() => Promise.resolve([]));
-      jest.spyOn(License, 'find').mockReturnValueOnce({
-        exec: execMock,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } as any);
+      const mockLDS = genMockLicenseDataService();
+      mockLDS.list.mockResolvedValueOnce({ error: null, data: [] });
+      const app = createApp(mockLDS);
       const res = await request(app).get(genRoute('/')).expect('Content-Type', /json/).expect(200);
 
       expect(res.body).toEqual([]);
     });
 
     it('one entry', async () => {
       const inputData = {
-        id: 'test',
+        id: uuidv4(),
         name: 'test',
       };
-      const execMock = jest.fn(() => Promise.resolve([{ toJSON: async () => inputData }]));
-      jest.spyOn(License, 'find').mockReturnValueOnce({
-        exec: execMock,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } as any);
+      const mockLDS = genMockLicenseDataService();
+      mockLDS.list.mockResolvedValueOnce({ error: null, data: [inputData] });
+      const app = createApp(mockLDS);
       const res = await request(app).get(genRoute('/')).expect('Content-Type', /json/).expect(200);
 
       expect(res.body).toEqual([inputData]);
     });
   });
+
+  describe(`GET /:id - read`, () => {
+    const testID = '157c0c6a-5c99-4298-9529-95816da2255a';
+    it('invalid id - not uuid', async () => {
+      const mockLDS = genMockLicenseDataService();
+      mockLDS.getByUUID.mockRejectedValueOnce(null);
+      const app = createApp(mockLDS);
+      await request(app)
+        .get(genRoute('/' + 'apache-2_0'))
+        .expect('Content-Type', /json/)
+        .expect(500);
+      expect(mockLDS.getByUUID.mock.lastCall).toBeUndefined();
+    });
+
+    it('valid id - no data', async () => {
+      const mockLDS = genMockLicenseDataService();
+      mockLDS.getByUUID.mockResolvedValueOnce({ error: null, data: null });
+      const app = createApp(mockLDS);
+      const res = await request(app)
+        .get(genRoute('/' + testID))
+        .expect('Content-Type', /json/)
+        .expect(200);
+
+      expect(res.body).toEqual({ license: null });
+    });
+
+    it('valid id - data', async () => {
+      const licenseData = {
+        id: testID,
+        name: 'test',
+      };
+      const mockLDS = genMockLicenseDataService();
+      mockLDS.getByUUID.mockResolvedValueOnce({ error: null, data: licenseData });
+      const app = createApp(mockLDS);
+      const res = await request(app)
+        .get(genRoute('/' + testID))
+        .expect('Content-Type', /json/)
+        .expect(200);
+
+      expect(res.body).toEqual({ license: licenseData });
+    });
+  });
 });