feat: resolving merge conflicts

Author: April-Bates-Dev

.eslintrc.js renamed to .eslintrc.cjs

@@ -1,4 +1,4 @@
-import { Contract } from "../../types";
+import { Contract } from "../../types.js";
 export interface PersonRegisteredContract extends Contract {
   "detail-type": "PersonRegisteredContract";
   detail: {

example-architecture/events/contracts/personRegisteredContractV1.ts

@@ -1,4 +1,4 @@
-import { Contract } from "../../types";
+import { Contract } from "../../types.js";
 export interface PersonRegisteredContract extends Contract {
   "detail-type": "PersonRegisteredContract";
   detail: {

example-architecture/events/contracts/personRegisteredContractV2.ts

@@ -1,4 +1,4 @@
-import { Contract } from "../../types";
+import { Contract } from "../../types.js";
 export interface Test extends Contract {
   "detail-type": "Test";
   detail: {

example-architecture/events/contracts/testContractV1.ts

@@ -47,4 +47,4 @@
     "mock-fs": "^5.2.0",
     "vite-tsconfig-paths": "^4.2.0"
   }
-}
+}

package.json

@@ -1,13 +1,15 @@
-import { describe, expect, it, afterEach } from "vitest";
-import { generateDocumentation } from "../generateDocs";
+import { existsSync, readFileSync } from "fs";
+import { readdir } from "fs/promises";
 import path from "path";
+
 import { rimraf } from "rimraf";
-import { readdir } from "fs/promises";
-import { existsSync, readFileSync } from "fs";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { generateDocumentation } from "../generateDocs.js";
 
 const testContractsPath = path.join(
   process.cwd(),
-  "/src/__tests__/fixtures/contracts"
+  "/src/__tests__/fixtures/contracts",
 );
 const testDocsPath = path.join(process.cwd(), "/src/__tests__/fixtures/docs");
 
@@ -21,37 +23,37 @@ describe("Create documentation for contract types, standardised for use with eve
 
   it("Creates documentation without error when passed valid contract types", async () => {
     await generateDocumentation(testContractsPath, testDocsPath);
-    var savedVersionedDocs = readFileSync(
+    const savedVersionedDocs = readFileSync(
       path.join(
         testDocsPath,
-        "/PersonRegisteredContract/versioned/1/schema.json"
+        "/PersonRegisteredContract/versioned/1/schema.json",
       ),
       {
         encoding: "utf8",
-      }
+      },
     );
     expect(savedVersionedDocs).toMatch(/("const": "PersonRegisteredContract")/);
     expect(savedVersionedDocs).toMatch(/("const": 1)/);
     expect(
       existsSync(
         path.join(
           testDocsPath,
-          "/PersonRegisteredContract/versioned/1/index.md"
-        )
-      )
+          "/PersonRegisteredContract/versioned/1/index.md",
+        ),
+      ),
     ).toStrictEqual(true);
-    var savedUnversionedDocs = readFileSync(
+    const savedUnversionedDocs = readFileSync(
       path.join(testDocsPath, "/PersonRegisteredContract/schema.json"),
       {
         encoding: "utf8",
-      }
+      },
     );
     expect(savedUnversionedDocs).toMatch(
-      /("const": "PersonRegisteredContract")/i
+      /("const": "PersonRegisteredContract")/i,
     );
     expect(savedUnversionedDocs).toMatch(/("const": 2)/i);
     expect(
-      existsSync(path.join(testDocsPath, "/PersonRegisteredContract/index.md"))
+      existsSync(path.join(testDocsPath, "/PersonRegisteredContract/index.md")),
     ).toStrictEqual(true);
   });
 });

src/__tests__/generateDocs.integration.test.ts

@@ -1,32 +1,35 @@
-import { MockedFunction, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, type MockedFunction, vi } from "vitest";
+
 import {
-  generateDocumentation, getUnversionedDocumentationFilePath, getVersionedDocumentationFilePath,
-} from "../generateDocs";
-import { generateAllContractInformation } from "../helpers/generateAllContractInformation";
-import { writeDocumentation } from "../helpers/writeDocumentation";
+  generateDocumentation,
+  getUnversionedDocumentationFilePath,
+  getVersionedDocumentationFilePath,
+} from "../generateDocs.js";
+import { generateAllContractInformation } from "../helpers/generateAllContractInformation.js";
+import { writeDocumentation } from "../helpers/writeDocumentation.js";
 
 describe("Given a generate docs script", () => {
   describe("With function getUnversionedDocumentationFilePath to generate filepaths", () => {
-    it("Returns a filepath based on its input", async () => {
+    it("Returns a filepath based on its input", () => {
       expect(
         getUnversionedDocumentationFilePath(
           "mockPathToDocumentationFolder",
-          "mockDetailType"
-        )
+          "mockDetailType",
+        ),
       ).toStrictEqual("mockPathToDocumentationFolder/mockDetailType");
     });
   });
 
   describe("With function getVersionedDocumentationFilePath to generate filepaths", () => {
-    it("Returns a filepath based on input", async () => {
+    it("Returns a filepath based on input", () => {
       expect(
         getVersionedDocumentationFilePath(
           "mockPathToDocumentationFolder",
           "mockDetailType",
-          100
-        )
+          100,
+        ),
       ).toStrictEqual(
-        "mockPathToDocumentationFolder/mockDetailType/versioned/100"
+        "mockPathToDocumentationFolder/mockDetailType/versioned/100",
       );
     });
   });
@@ -68,11 +71,11 @@ describe("Given a generate docs script", () => {
       });
       await generateDocumentation(
         "mockPathToContractsFolder",
-        "mockPathToDocumentationFolder"
+        "mockPathToDocumentationFolder",
       );
       expect(mockWriteDocumentation).toBeCalledWith(
         mockSchemaDetails,
-        `mockPathToDocumentationFolder/mockDetailTypeConst/versioned/10`
+        `mockPathToDocumentationFolder/mockDetailTypeConst/versioned/10`,
       );
     });
 
@@ -83,11 +86,11 @@ describe("Given a generate docs script", () => {
       });
       await generateDocumentation(
         "mockPathToContractsFolder",
-        "mockPathToDocumentationFolder"
+        "mockPathToDocumentationFolder",
       );
       expect(mockWriteDocumentation).toBeCalledWith(
         mockSchemaDetails,
-        `mockPathToDocumentationFolder/mockDetailTypeConst`
+        `mockPathToDocumentationFolder/mockDetailTypeConst`,
       );
     });
   });

src/__tests__/generateDocs.test.ts

@@ -1,16 +1,17 @@
-import { MockedFunction, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, type MockedFunction, vi } from "vitest";
+
 import {
   generateAllContractInformation,
   getContractFileNames,
   getUpdatedNewestVersionRecord,
-} from "../../helpers/generateAllContractInformation";
-import { generateSchemaDetails } from "../../helpers/generateSchemaDetails";
+} from "../../helpers/generateAllContractInformation.js";
+import { generateSchemaDetails } from "../../helpers/generateSchemaDetails.js";
 
 const { mockReaddir } = vi.hoisted(() => ({
   mockReaddir: vi.fn(),
 }));
 
-vi.mock("fs/promises", async () => {
+vi.mock("fs/promises", () => {
   return {
     readdir: mockReaddir,
   };
@@ -70,20 +71,24 @@ describe("Given a generate docs script", () => {
         getUpdatedNewestVersionRecord(
           { testContract: 10 },
           "testContract2",
-          100
-        )
+          100,
+        ),
       ).toStrictEqual({ testContract: 10, testContract2: 100 });
     });
 
     it("Returns an updated record if we have a newer version of the contract", () => {
       expect(
-        getUpdatedNewestVersionRecord({ testContract: 10 }, "testContract", 100)
+        getUpdatedNewestVersionRecord(
+          { testContract: 10 },
+          "testContract",
+          100,
+        ),
       ).toStrictEqual({ testContract: 100 });
     });
 
     it("Returns the same record if we do not have a newer contract or a new contract type", () => {
       expect(
-        getUpdatedNewestVersionRecord({ testContract: 10 }, "testContract", 1)
+        getUpdatedNewestVersionRecord({ testContract: 10 }, "testContract", 1),
       ).toStrictEqual({ testContract: 10 });
     });
   });
@@ -92,7 +97,7 @@ describe("Given a generate docs script", () => {
     it("Returns an array of all schemas and the record of the newest version if input is valid", async () => {
       mockReaddir.mockResolvedValueOnce(["singleMockContractFileName"]);
       expect(
-        await generateAllContractInformation("mockPathToContractsFolder")
+        await generateAllContractInformation("mockPathToContractsFolder"),
       ).toStrictEqual({
         allSchemaDetails: [mockSchemaDetails],
         newestVersionsRecord: { mockDetailTypeConst: 100 },
@@ -104,10 +109,10 @@ describe("Given a generate docs script", () => {
         "mockContractFileNameOne",
         "mockContractFileNameTwo",
       ]);
-      expect(
-        async () => await generateAllContractInformation("mockPathToContractsFolder")
+      await expect(
+        generateAllContractInformation("mockPathToContractsFolder"),
       ).rejects.toThrow(
-        "Contracts types error. Multiple mockDetailTypeConst contracts have been assigned the same version."
+        "Contracts types error. Multiple mockDetailTypeConst contracts have been assigned the same version.",
       );
     });
   });

src/__tests__/helpers/generateAllContractInformation.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it } from "vitest";
 
-import { isInvalidDirectoryName, isValidJsonSchemaContract } from "../../helpers/utils";
+import {
+  isInvalidDirectoryName,
+  isValidJsonSchemaContract,
+} from "../../helpers/utils.js";
 
 const invalidDetailTypeSchema: object = {
   "detail-type": {
@@ -58,8 +61,8 @@ describe("Given a set of utils functions", () => {
           createJsonObject({
             ...validDetailVersionSchema,
             ...validDetailTypeSchema,
-          })
-        )
+          }),
+        ),
       ).toStrictEqual(true);
     });
 
@@ -68,8 +71,8 @@ describe("Given a set of utils functions", () => {
         isValidJsonSchemaContract(
           createJsonObject({
             ...validDetailTypeSchema,
-          })
-        )
+          }),
+        ),
       ).toStrictEqual(false);
     });
 
@@ -78,8 +81,8 @@ describe("Given a set of utils functions", () => {
         isValidJsonSchemaContract(
           createJsonObject({
             ...validDetailVersionSchema,
-          })
-        )
+          }),
+        ),
       ).toStrictEqual(false);
     });
 
@@ -89,8 +92,8 @@ describe("Given a set of utils functions", () => {
           createJsonObject({
             ...validDetailVersionSchema,
             ...invalidDetailTypeSchema,
-          })
-        )
+          }),
+        ),
       ).toStrictEqual(false);
     });
 
@@ -100,8 +103,8 @@ describe("Given a set of utils functions", () => {
           createJsonObject({
             ...invalidDetailVersionSchema,
             ...validDetailTypeSchema,
-          })
-        )
+          }),
+        ),
       ).toStrictEqual(false);
     });
 
@@ -112,26 +115,26 @@ describe("Given a set of utils functions", () => {
             createJsonObject({
               ...validDetailVersionSchema,
               ...validDetailTypeSchema,
-            })
-          )
-        )
+            }),
+          ),
+        ),
       ).toStrictEqual(false);
     });
   });
 
   describe("With function isInvalidDirectoryName to get check if a string is a valid directory name", () => {
     it.each(["test", "testName", "TESTNAME123", "test-name", "test_name"])(
       "Function returns true if we have passed it a valid directory name without spaces",
-      async (directoryName) => {
+      (directoryName) => {
         expect(isInvalidDirectoryName(directoryName)).toStrictEqual(false);
-      }
+      },
     );
 
     it.each(["test name", "test?name", "test*name", ".", ".."])(
       "Function returns false if we have passed it a invalid directory name",
-      async (directoryName) => {
+      (directoryName) => {
         expect(isInvalidDirectoryName(directoryName)).toStrictEqual(true);
-      }
+      },
     );
   });
 });

src/__tests__/helpers/utils.test.ts

@@ -1,11 +1,12 @@
 import { describe, expect, it, vi } from "vitest";
-import { writeIndexFile } from "../../helpers/writeIndexFile";
+
+import { writeIndexFile } from "../../helpers/writeIndexFile.js";
 
 const { mockWriteFile } = vi.hoisted(() => ({
   mockWriteFile: vi.fn(),
 }));
 
-vi.mock("fs/promises", async () => {
+vi.mock("fs/promises", () => {
   return {
     writeFile: mockWriteFile,
   };
@@ -32,14 +33,10 @@ const mockEventMarkdown =
 describe("Given a write index file helper", () => {
   describe("Which creates an index markdown file from a template", () => {
     it("The writeFile function is called with the expected input", async () => {
-      const result = await writeIndexFile(
-        "mockDocsPath",
-        "mockDetailType",
-        100
-      );
+      await writeIndexFile("mockDocsPath", "mockDetailType", 100);
       expect(mockWriteFile).toBeCalledWith(
         "mockDocsPath/index.md",
-        mockEventMarkdown
+        mockEventMarkdown,
       );
     });
   });