Merge pull request #1642 from pmcelhaney/copilot/change-objects-to-maps

Convert internal plain objects to Maps

Author: pmcelhaney

.changeset/change-objects-to-maps.md

@@ -0,0 +1,8 @@
+---
+"counterfact": patch
+---
+
+Refactor internal plain objects to Maps where appropriate:
+- `Directory.directories` and `Directory.files` in `module-tree.ts` are now `Map<string, Directory>` and `Map<string, File>`
+- `ParameterTypes` inner types in `dispatcher.ts` are now `Map<string, string>`
+- `castParameters` in `registry.ts` now accepts `Map<string, string>` for parameter types

src/server/dispatcher.ts

@@ -47,24 +47,12 @@ function parseCookies(cookieHeader: string): Record<string, string> {
 }
 
 interface ParameterTypes {
-  body: {
-    [key: string]: string;
-  };
-  cookie: {
-    [key: string]: string;
-  };
-  formData: {
-    [key: string]: string;
-  };
-  header: {
-    [key: string]: string;
-  };
-  path: {
-    [key: string]: string;
-  };
-  query: {
-    [key: string]: string;
-  };
+  body: Map<string, string>;
+  cookie: Map<string, string>;
+  formData: Map<string, string>;
+  header: Map<string, string>;
+  path: Map<string, string>;
+  query: Map<string, string>;
 }
 
 export interface OpenApiDocument {
@@ -124,12 +112,12 @@ export class Dispatcher {
     parameters: OpenApiParameters[] | undefined,
   ): ParameterTypes {
     const types: ParameterTypes = {
-      body: {},
-      cookie: {},
-      formData: {},
-      header: {},
-      path: {},
-      query: {},
+      body: new Map(),
+      cookie: new Map(),
+      formData: new Map(),
+      header: new Map(),
+      path: new Map(),
+      query: new Map(),
     };
 
     if (!parameters) {
@@ -140,8 +128,10 @@ export class Dispatcher {
       const type = parameter?.type;
 
       if (type !== undefined) {
-        types[parameter.in][parameter.name] =
-          type === "integer" ? "number" : type;
+        types[parameter.in].set(
+          parameter.name,
+          type === "integer" ? "number" : type,
+        );
       }
     }
 

src/server/module-tree.ts

@@ -13,8 +13,8 @@ interface File {
 }
 
 interface Directory {
-  directories: { [key: string]: Directory };
-  files: { [key: string]: File };
+  directories: Map<string, Directory>;
+  files: Map<string, File>;
   isWildcard: boolean;
   name: string;
   rawName: string;
@@ -34,8 +34,8 @@ function isDirectory(test: Directory | undefined): test is Directory {
 
 export class ModuleTree {
   public readonly root: Directory = {
-    directories: {},
-    files: {},
+    directories: new Map(),
+    files: new Map(),
     isWildcard: false,
     name: "",
     rawName: "",
@@ -52,20 +52,25 @@ export class ModuleTree {
       return directory;
     }
 
-    const isNewDirectory =
-      directory.directories[segment.toLowerCase()] === undefined;
+    const isNewDirectory = !directory.directories.has(segment.toLowerCase());
 
-    const nextDirectory = (directory.directories[segment.toLowerCase()] ??= {
-      directories: {},
-      files: {},
-      isWildcard: segment.startsWith("{"),
-      name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
-      rawName: segment,
-    });
+    if (isNewDirectory) {
+      directory.directories.set(segment.toLowerCase(), {
+        directories: new Map(),
+        files: new Map(),
+        isWildcard: segment.startsWith("{"),
+        name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
+        rawName: segment,
+      });
+    }
+
+    const nextDirectory = directory.directories.get(
+      segment.toLowerCase(),
+    ) as Directory;
 
     if (isNewDirectory && segment.startsWith("{")) {
-      const ambiguousWildcardDirectories = Object.values(
-        directory.directories,
+      const ambiguousWildcardDirectories = Array.from(
+        directory.directories.values(),
       ).filter((subdirectory) => subdirectory.isWildcard);
 
       if (ambiguousWildcardDirectories.length > 1) {
@@ -97,16 +102,16 @@ export class ModuleTree {
       );
     }
 
-    targetDirectory.files[filename] = {
+    targetDirectory.files.set(filename, {
       isWildcard: filename.startsWith("{"),
       module,
       name: filename.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
       rawName: filename,
-    };
+    });
 
     if (filename.startsWith("{")) {
-      const ambiguousWildcardFiles = Object.values(
-        targetDirectory.files,
+      const ambiguousWildcardFiles = Array.from(
+        targetDirectory.files.values(),
       ).filter((file) => file.isWildcard);
 
       if (ambiguousWildcardFiles.length > 1) {
@@ -136,13 +141,13 @@ export class ModuleTree {
     }
 
     if (remainingSegments.length === 0) {
-      delete directory.files[segment.toLowerCase()];
+      directory.files.delete(segment.toLowerCase());
 
       return;
     }
 
     this.removeModuleFromDirectory(
-      directory.directories[segment.toLowerCase()],
+      directory.directories.get(segment.toLowerCase()),
       remainingSegments,
     );
   }
@@ -165,16 +170,17 @@ export class ModuleTree {
     method: string,
   ): Match | undefined {
     function normalizedSegment(segment: string, directory: Directory) {
-      for (const file in directory.files) {
+      for (const file of directory.files.keys()) {
         if (file.toLowerCase() === segment.toLowerCase()) {
           return file;
         }
       }
       return "";
     }
 
-    const exactMatchFile =
-      directory.files[normalizedSegment(segment, directory)];
+    const exactMatchFile = directory.files.get(
+      normalizedSegment(segment, directory),
+    );
 
     // If the URL segment literally matches a file key (e.g., requesting "/{x}"
     // as a literal URL value), exactMatchFile may be a wildcard file. In that
@@ -187,7 +193,7 @@ export class ModuleTree {
       };
     }
 
-    const wildcardFiles = Object.values(directory.files).filter(
+    const wildcardFiles = Array.from(directory.files.values()).filter(
       (file) => file.isWildcard && this.fileModuleDefined(file, method),
     );
 
@@ -265,7 +271,7 @@ export class ModuleTree {
       );
     }
 
-    const exactMatch = directory.directories[segment.toLowerCase()];
+    const exactMatch = directory.directories.get(segment.toLowerCase());
 
     if (isDirectory(exactMatch)) {
       return this.matchWithinDirectory(
@@ -277,9 +283,9 @@ export class ModuleTree {
       );
     }
 
-    const wildcardDirectories = Object.values(directory.directories).filter(
-      (subdirectory) => subdirectory.isWildcard,
-    );
+    const wildcardDirectories = Array.from(
+      directory.directories.values(),
+    ).filter((subdirectory) => subdirectory.isWildcard);
 
     const wildcardMatches: Match[] = [];
 
@@ -323,11 +329,11 @@ export class ModuleTree {
     const routes: Route[] = [];
 
     function traverse(directory: Directory, path: string) {
-      Object.values(directory.directories).forEach((subdirectory) => {
+      directory.directories.forEach((subdirectory) => {
         traverse(subdirectory, `${path}/${subdirectory.rawName}`);
       });
 
-      Object.values(directory.files).forEach((file) => {
+      directory.files.forEach((file) => {
         const methods: [string, string][] = Object.entries(file.module).map(
           ([method, implementation]) => [method, String(implementation)],
         );

src/server/registry.ts

@@ -114,12 +114,12 @@ function castParameter(value: string | number | boolean, type: string) {
 
 function castParameters(
   parameters: { [key: string]: string | number | boolean } = {},
-  parameterTypes: { [key: string]: string } = {},
+  parameterTypes: Map<string, string> = new Map(),
 ) {
   const copy: { [key: string]: boolean | number | string } = {};
 
   Object.entries(parameters).forEach(([key, value]) => {
-    copy[key] = castParameter(value, parameterTypes?.[key] ?? "string");
+    copy[key] = castParameter(value, parameterTypes.get(key) ?? "string");
   });
 
   return copy;
@@ -184,9 +184,9 @@ export class Registry {
     httpRequestMethod: HttpMethods,
     url: string,
     parameterTypes: {
-      header?: { [key: string]: string };
-      path?: { [key: string]: string };
-      query?: { [key: string]: string };
+      header?: Map<string, string>;
+      path?: Map<string, string>;
+      query?: Map<string, string>;
     } = {},
   ) {
     const handler = this.handler(url, httpRequestMethod);