fix(experimental): enable strict typing

06kellyjac · 06kellyjac · commit 4c2a36d16f5e · 2025-01-09T09:57:15.000Z
Removed the transforms via Mongoose as they're very hard to typecheck
diff --git a/experimental/license-inventory/package-lock.json b/experimental/license-inventory/package-lock.json
diff --git a/experimental/license-inventory/package.json b/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",
diff --git a/experimental/license-inventory/src/db/schemas/license/license.test.ts b/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);
   });
 });
diff --git a/experimental/license-inventory/src/db/schemas/license/license.ts b/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();
-        },
-      },
-    },
   },
 );
 
diff --git a/experimental/license-inventory/src/env.ts b/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>;
diff --git a/experimental/license-inventory/src/routes/api/v0/licenses.test.ts b/experimental/license-inventory/src/routes/api/v0/licenses.test.ts
@@ -40,12 +40,13 @@ describe(basePath, () => {
     const testID = '157c0c6a-5c99-4298-9529-95816da2255a';
     it('invalid id - not uuid', async () => {
       const mockLDS = genMockLicenseDataService();
-      mockLDS.getByUUID.mockResolvedValueOnce({ error: null, data: null });
+      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 () => {
diff --git a/experimental/license-inventory/src/routes/api/v0/licenses.ts b/experimental/license-inventory/src/routes/api/v0/licenses.ts
@@ -25,7 +25,7 @@ const createRouter = (licenseService: LicenseDataService) => {
       res.status(500).json({ error: 'failed to create' }).end();
       return;
     }
-    res.status(200).json({ created: data }).end();
+    res.status(201).json(data).end();
   });
 
   // READ
@@ -69,13 +69,13 @@ const createRouter = (licenseService: LicenseDataService) => {
       params: { id },
     } = parseData;
 
-    const { error } = await licenseService.patchByUUID(id, licenseData);
+    const { error, data } = await licenseService.patchByUUID(id, licenseData);
     if (error) {
       req.log.error(error);
       res.status(500).json({ error: 'failed to update' }).end();
       return;
     }
-    res.status(204).json({ status: 'ok' }).end();
+    res.status(204).json(data).end();
   });
 
   // DELETE
diff --git a/experimental/license-inventory/src/server.ts b/experimental/license-inventory/src/server.ts
@@ -2,7 +2,7 @@ import { logger } from '@/logger';
 import { connectDB } from './db/connect';
 import env from '@/env';
 import { createApp } from './app';
-import { MongoLicenseDataService } from './services/data/mongoose';
+import { MongooseLicenseDataService } from './services/data/mongoose';
 import { Database } from './db';
 
 const port = env.PORT;
@@ -21,7 +21,7 @@ const run = async () => {
     logger.info('started server', { port });
   };
 
-  const lds = new MongoLicenseDataService(db);
+  const lds = new MongooseLicenseDataService(db);
   const app = createApp(lds);
   app.listen(port, running);
 };
diff --git a/experimental/license-inventory/src/services/data/index.ts b/experimental/license-inventory/src/services/data/index.ts
@@ -1,12 +1,12 @@
 import type { AsyncResult } from '@/types';
-import type { License, LicenseCreateUpdate } from './license';
+import type { License, LicenseNoID, LicenseNoIDPartial } from './license';
 
 export interface LicenseDataService {
-  create: (licenseData: LicenseCreateUpdate) => AsyncResult<null>;
+  create: (licenseData: LicenseNoID) => AsyncResult<License>;
 
   getByUUID: (id: string) => AsyncResult<License | null>;
 
-  patchByUUID: (id: string, licenseData: LicenseCreateUpdate) => AsyncResult<null>;
+  patchByUUID: (id: string, licenseData: LicenseNoIDPartial) => AsyncResult<License>;
 
   deleteByUUID: (id: string) => AsyncResult<null>;
 
diff --git a/experimental/license-inventory/src/services/data/license.ts b/experimental/license-inventory/src/services/data/license.ts
@@ -41,5 +41,8 @@ export const license = z.object({
 });
 export type License = z.infer<typeof license>;
 
-export const licenseCreateUpdate = license.omit({ id: true });
-export type LicenseCreateUpdate = z.infer<typeof licenseCreateUpdate>;
+export const licenseNoID = license.omit({ id: true });
+export type LicenseNoID = z.infer<typeof licenseNoID>;
+
+export const licenseNoIDPartial = licenseNoID.partial();
+export type LicenseNoIDPartial = z.infer<typeof licenseNoIDPartial>;
diff --git a/experimental/license-inventory/src/services/data/mongoose/index.ts b/experimental/license-inventory/src/services/data/mongoose/index.ts
@@ -1,18 +1,18 @@
-import { LicenseDataService } from '../';
-import { Database } from '@/db';
+import { type LicenseDataService } from '../';
+import { type Database } from '@/db';
 import { v4 as uuidv4 } from 'uuid';
-import { type LicenseCreateUpdate } from '../license';
+import type { License, LicenseNoID, LicenseNoIDPartial } from '../license';
 import { trace } from '@opentelemetry/api';
 import { logger } from '@/logger';
 
-export class MongoLicenseDataService implements LicenseDataService {
+export class MongooseLicenseDataService implements LicenseDataService {
   db: Database;
 
   constructor(db: Database) {
     this.db = db;
   }
 
-  async create(licenseData: LicenseCreateUpdate) {
+  async create(licenseData: LicenseNoID) {
     try {
       if (licenseData.spdxID) {
         const spdxMatch = await this.db.License.findOne({ spdxID: licenseData.spdxID })
@@ -24,29 +24,59 @@ export class MongoLicenseDataService implements LicenseDataService {
         }
       }
       const _id = uuidv4();
-      await this.db.License.create({
-        _id,
-        ...licenseData,
-      });
-      return { error: null, data: null };
+      const insertedData = await (
+        await this.db.License.create({
+          _id,
+          ...licenseData,
+        })
+      ).toJSON();
+      const res: License = {
+        id: _id,
+        ...insertedData,
+      };
+      return { error: null, data: res };
+      // return { error: null, data: null };
     } catch (err: unknown) {
       return { error: new Error("couldn't register", { cause: err }), data: null };
     }
   }
 
   async getByUUID(id: string) {
     try {
-      const data = await (await this.db.License.findOne({ _id: id }).exec()).toJSON();
+      const dbRes = await this.db.License.findOne({ _id: id }).lean().exec();
+      if (dbRes === null) {
+        return { error: null, data: dbRes };
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { _id, __v, ...dbData } = dbRes;
+      const data: License = {
+        id: _id.toJSON(),
+        ...dbData,
+      };
       return { error: null, data };
     } catch (err: unknown) {
       return { error: new Error("couldn't find", { cause: err }), data: null };
     }
   }
 
-  async patchByUUID(id: string, details: LicenseCreateUpdate) {
+  async patchByUUID(id: string, details: LicenseNoIDPartial) {
     try {
-      await this.db.License.findOneAndUpdate({ _id: id }, details);
-      return { error: null, data: null };
+      const dbRes = await this.db.License.findOneAndUpdate({ _id: id }, details, {
+        // return new data
+        returnOriginal: false,
+      })
+        .lean()
+        .exec();
+      if (dbRes === null) {
+        return { error: new Error('no matching license'), data: null };
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { _id, __v, ...dbData } = dbRes;
+      const data: License = {
+        id: _id.toJSON(),
+        ...dbData,
+      };
+      return { error: null, data: data };
     } catch (err: unknown) {
       return { error: new Error("couldn't find and update", { cause: err }), data: null };
     }
@@ -67,7 +97,17 @@ export class MongoLicenseDataService implements LicenseDataService {
     // TODO: pagination
     const results = await this.db.License.find().exec();
     const jsonifyResultsSpan = tracer.startSpan('jsonify-results');
-    const jsonResults = await Promise.allSettled(results.map(async (doc) => doc.toJSON()));
+    const jsonResults = await Promise.allSettled(
+      results.map(async (doc) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { _id, __v, ...dbData } = doc;
+        const data: License = {
+          id: _id.toJSON(),
+          ...dbData,
+        };
+        return data;
+      }),
+    );
     const jsonOutput = jsonResults
       .filter(<T>(r: PromiseSettledResult<T>): r is PromiseFulfilledResult<T> => {
         if (r.status === 'rejected') {
diff --git a/experimental/license-inventory/src/test/globalTeardown.ts b/experimental/license-inventory/src/test/globalTeardown.ts
@@ -1,9 +1,17 @@
 import { MongoMemoryServer } from 'mongodb-memory-server-core';
 import { config } from './utils/config';
 
+declare global {
+  // eslint-disable-next-line no-var
+  var __MONGOINSTANCE: MongoMemoryServer | undefined;
+}
+
 export default async function globalTeardown() {
   if (config.Memory) {
     // Config to decide if an mongodb-memory-server instance should be used
+    if (!(global.__MONGOINSTANCE instanceof MongoMemoryServer)) {
+      throw new Error('expect MongoMemoryServer');
+    }
     const instance: MongoMemoryServer = global.__MONGOINSTANCE;
     await instance.stop();
   }
diff --git a/experimental/license-inventory/src/types.ts b/experimental/license-inventory/src/types.ts
@@ -1,14 +1,23 @@
-export type ResultError = {
+export type Result<T> =
+  | {
+      error: Error;
+      data: null;
+    }
+  | {
+      error: null;
+      data: T;
+    };
+export type AsyncResult<T> = Promise<Result<T>>;
+
+export const resultIsFailure = <T>(
+  r: Result<T>,
+): r is {
   error: Error;
   data: null;
-};
-export type ResultSuccess<T> = {
+} => r.error !== null;
+export const resultIsSuccess = <T>(
+  r: Result<T>,
+): r is {
   error: null;
   data: T;
-};
-
-export type Result<T> = ResultError | ResultSuccess<T>;
-export type AsyncResult<T> = Promise<Result<T>>;
-
-export const resultIsFailure = <T>(r: Result<T>): r is ResultError => r.error !== null;
-export const resultIsSuccess = <T>(r: Result<T>): r is ResultSuccess<T> => r.error === null;
+} => r.error === null;
diff --git a/experimental/license-inventory/tsconfig.json b/experimental/license-inventory/tsconfig.json
@@ -2,6 +2,7 @@
   "compileOnSave": false,
   "compilerOptions": {
     "target": "es2017",
+    "strict": true,
     "lib": ["ES2022", "esnext.asynciterable"],
     "typeRoots": ["node_modules/@types"],
     "allowSyntheticDefaultImports": true,
