11262405331

Committed 09 Oct 2024 08:17PM UTC coverage: 82.619% (-0.2%) from 82.82%

Build # 11262405331

Build Type

Pull #1074

github

Committed by

dethell

Commit Message

fix(server): Add logic to module-tree to handle multiple wildcard files under the same directory

Pull Request Pull Request #1074: fix(server): Add support for directories with multiple wildcard children

Run Details

1051 of 1181 branches covered (88.99%)

Branch coverage included in aggregate %.

36 of 43 new or added lines in 3 files covered. (83.72%)

8 existing lines in 1 file now uncovered.

3284 of 4066 relevant lines covered (80.77%)

47.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.22

/src/server/module-tree.ts

import type { Module } from "./registry.js";

interface Route {
  methods: { [key: string]: string };
  path: string;
}

interface File {
  isWildcard: boolean;
  module: Module;
  name: string;
  rawName: string;
}

interface Directory {
  directories: { [key: string]: Directory };
  files: { [key: string]: File };
  isWildcard: boolean;
  name: string;
  rawName: string;
}

interface Match {
  matchedPath: string;
  module: Module;
  pathVariables: { [key: string]: string };
}

function isDirectory(test: Directory | undefined): test is Directory {
  return test !== undefined;
}

export class ModuleTree {
  public readonly root: Directory = {
    directories: {},
    files: {},
    isWildcard: false,
    name: "",
    rawName: "",
  };

  private addModuleToDirectory(
    directory: Directory | undefined,
    segments: string[],
    module: Module,
  ) {
    if (directory === undefined) {
      return;
    }

    const [segment, ...remainingSegments] = segments;

    if (segment === undefined) {
      throw new Error("segments array is empty");
    }

    if (remainingSegments.length === 0) {
      directory.files[segment.toLowerCase()] = {
        isWildcard: segment.startsWith("{"),
        module,
        name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
        rawName: segment,
      };

      return;
    }

    directory.directories[segment.toLowerCase()] ??= {
      directories: {},
      files: {},
      isWildcard: segment.startsWith("{"),
      name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
      rawName: segment,
    };
    this.addModuleToDirectory(
      directory.directories[segment.toLocaleLowerCase()],
      remainingSegments,
      module,
    );
  }

  public add(url: string, module: Module) {
    this.addModuleToDirectory(this.root, url.split("/").slice(1), module);
  }

  private removeModuleFromDirectory(
    directory: Directory | undefined,
    segments: string[],
  ) {
    if (!isDirectory(directory)) {
      return;
    }

    const [segment, ...remainingSegments] = segments;

    if (segment === undefined) {
      return;
    }

    if (remainingSegments.length === 0) {
      delete directory.files[segment.toLowerCase()];

      return;
    }

    this.removeModuleFromDirectory(
      directory.directories[segment.toLowerCase()],
      remainingSegments,
    );
  }

  public remove(url: string) {
    const segments = url.split("/").slice(1);

    this.removeModuleFromDirectory(this.root, segments);
  }

  private fileModuleDefined(file: File, method: string) {
    switch (method) {
      case "DELETE":
        return file.module.DELETE !== undefined;
      case "GET":
        return file.module.GET !== undefined;
      case "HEAD":
        return file.module.HEAD !== undefined;
      case "OPTIONS":
        return file.module.OPTIONS !== undefined;
      case "PATCH":
        return file.module.PATCH !== undefined;
      case "POST":
        return file.module.POST !== undefined;
      case "PUT":
        return file.module.PUT !== undefined;
      case "TRACE":
        return file.module.TRACE !== undefined;
      default:
        return false;
    }
  }

  private buildMatch(
    directory: Directory,
    segment: string,
    pathVariables: { [key: string]: string },
    matchedPath: string,
    method: string,
  ) {
    const match =
      directory.files[segment.toLowerCase()] ??
      Object.values(directory.files).find((file) => file.isWildcard && this.fileModuleDefined(file, method));

    if (match === undefined) {
      return undefined;
    }

    if (match.isWildcard) {
      return {
        ...match,

        matchedPath: `${matchedPath}/${match.rawName}`,

        pathVariables: {
          ...pathVariables,
          [match.name]: segment,
        },
      };
    }

    return {
      ...match,

      matchedPath: `${matchedPath}/${match.rawName}`,

      pathVariables,
    };
  }

  private matchWithinDirectory(
    directory: Directory,
    segments: string[],
    pathVariables: { [key: string]: string },
    matchedPath: string,
    method: string,
  ): Match | undefined {
    if (segments.length === 0) {
      return undefined;
    }

    const [segment, ...remainingSegments] = segments;

    if (segment === undefined) {
      throw new Error(
        "segment cannot be undefined but TypeScript doesn't know that",
      );
    }

    if (
      remainingSegments.length === 0 ||
      (remainingSegments.length === 1 && remainingSegments[0] === "")
    ) {
      return this.buildMatch(directory, segment, pathVariables, matchedPath, method);
    }

    const exactMatch = directory.directories[segment.toLowerCase()];

    if (isDirectory(exactMatch)) {
      return this.matchWithinDirectory(
        exactMatch,
        remainingSegments,
        pathVariables,
        `${matchedPath}/${segment}`,
        method,
      );
    }

    const wildcardDirectories = Object.values(directory.directories).filter(
      (subdirectory) => subdirectory.isWildcard,
    );

    for (const wildcardDirectory of wildcardDirectories) {
      const match = this.matchWithinDirectory(
        wildcardDirectory,
        remainingSegments,
        {
          ...pathVariables,
          [wildcardDirectory.name]: segment,
        },
        `${matchedPath}/${wildcardDirectory.rawName}`,
        method,
      );

      if (match !== undefined) {
        return match;
      }
    }

    return undefined;
  }

  public match(url: string, method: string) {
    return this.matchWithinDirectory(
      this.root,
      url.split("/").slice(1),
      {},
      "",
      method,
    );
  }

  public get routes(): Route[] {
    const routes: Route[] = [];

    function traverse(directory: Directory, path: string) {
      Object.values(directory.directories).forEach((subdirectory) => {
        traverse(subdirectory, `${path}/${subdirectory.rawName}`);
      });

      Object.values(directory.files).forEach((file) => {
        const methods: [string, string][] = Object.entries(file.module).map(
          ([method, implementation]) => [method, String(implementation)],
        );

        routes.push({
          methods: Object.fromEntries(methods),
          path: `${path}/${file.rawName}`,
        });
      });
    }

    function stripBrackets(string: string) {
      return string.replaceAll(/\{|\}/gu, "");
    }

    traverse(this.root, "");

    return routes.sort((first, second) =>
      stripBrackets(first.path).localeCompare(stripBrackets(second.path)),
    );
  }
}

1	import type { Module } from "./registry.js";	2✔
2		2✔
3	interface Route {	2✔
4	methods: { [key: string]: string };	2✔
5	path: string;	2✔
6	}	2✔
7		2✔
8	interface File {	2✔
9	isWildcard: boolean;	2✔
10	module: Module;	2✔
11	name: string;	2✔
12	rawName: string;	2✔
13	}	2✔
14		2✔
15	interface Directory {	2✔
16	directories: { [key: string]: Directory };	2✔
17	files: { [key: string]: File };	2✔
18	isWildcard: boolean;	2✔
19	name: string;	2✔
20	rawName: string;	2✔
21	}	2✔
22		2✔
23	interface Match {	2✔
24	matchedPath: string;	2✔
25	module: Module;	2✔
26	pathVariables: { [key: string]: string };	2✔
27	}	2✔
28		2✔
29	function isDirectory(test: Directory \| undefined): test is Directory {	104✔
30	return test !== undefined;	104✔
31	}	104✔
32		2✔
33	export class ModuleTree {	2✔
34	public readonly root: Directory = {	122✔
35	directories: {},	122✔
36	files: {},	122✔
37	isWildcard: false,	122✔
38	name: "",	122✔
39	rawName: "",	122✔
40	};	122✔
41		122✔
42	private addModuleToDirectory(	122✔
43	directory: Directory \| undefined,	254✔
44	segments: string[],	254✔
45	module: Module,	254✔
46	) {	254✔
47	if (directory === undefined) {	254!
48	return;	×
49	}	×
50		254✔
51	const [segment, ...remainingSegments] = segments;	254✔
52		254✔
53	if (segment === undefined) {	254!
54	throw new Error("segments array is empty");	×
55	}	×
56		254✔
57	if (remainingSegments.length === 0) {	254✔
58	directory.files[segment.toLowerCase()] = {	154✔
59	isWildcard: segment.startsWith("{"),	154✔
60	module,	154✔
61	name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),	154✔
62	rawName: segment,	154✔
63	};	154✔
64		154✔
65	return;	154✔
66	}	154✔
67		100✔
68	directory.directories[segment.toLowerCase()] ??= {	100✔
69	directories: {},	100✔
70	files: {},	100✔
71	isWildcard: segment.startsWith("{"),	100✔
72	name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),	100✔
73	rawName: segment,	100✔
74	};	100✔
75	this.addModuleToDirectory(	100✔
76	directory.directories[segment.toLocaleLowerCase()],	100✔
77	remainingSegments,	100✔
78	module,	100✔
79	);	100✔
80	}	100✔
81		122✔
82	public add(url: string, module: Module) {	122✔
83	this.addModuleToDirectory(this.root, url.split("/").slice(1), module);	154✔
84	}	154✔
85		122✔
86	private removeModuleFromDirectory(	122✔
87	directory: Directory \| undefined,	8✔
88	segments: string[],	8✔
89	) {	8✔
90	if (!isDirectory(directory)) {	8!
91	return;	×
92	}	×
93		8✔
94	const [segment, ...remainingSegments] = segments;	8✔
95		8✔
96	if (segment === undefined) {	8!
97	return;	×
98	}	×
99		8✔
100	if (remainingSegments.length === 0) {	8✔
101	delete directory.files[segment.toLowerCase()];	6✔
102		6✔
103	return;	6✔
104	}	6✔
105		2✔
106	this.removeModuleFromDirectory(	2✔
107	directory.directories[segment.toLowerCase()],	2✔
108	remainingSegments,	2✔
109	);	2✔
110	}	2✔
111		122✔
112	public remove(url: string) {	122✔
113	const segments = url.split("/").slice(1);	6✔
114		6✔
115	this.removeModuleFromDirectory(this.root, segments);	6✔
116	}	6✔
117		122✔
118	private fileModuleDefined(file: File, method: string) {	122✔
119	switch (method) {	30✔
120	case "DELETE":	30!
NEW 121	return file.module.DELETE !== undefined;	×
122	case "GET":	30✔
123	return file.module.GET !== undefined;	28✔
124	case "HEAD":	30!
NEW UNCOV 125	return file.module.HEAD !== undefined;	×
126	case "OPTIONS":	30!
NEW 127	return file.module.OPTIONS !== undefined;	×
128	case "PATCH":	30!
NEW UNCOV 129	return file.module.PATCH !== undefined;	×
130	case "POST":	30!
NEW 131	return file.module.POST !== undefined;	×
132	case "PUT":	30✔
133	return file.module.PUT !== undefined;	2✔
134	case "TRACE":	30!
NEW UNCOV 135	return file.module.TRACE !== undefined;	×
136	default:	30!
NEW UNCOV 137	return false;	×
138	}	30✔
139	}	30✔
140		122✔
141	private buildMatch(	122✔
142	directory: Directory,	206✔
143	segment: string,	206✔
144	pathVariables: { [key: string]: string },	206✔
145	matchedPath: string,	206✔
146	method: string,	206✔
147	) {	206✔
148	const match =	206✔
149	directory.files[segment.toLowerCase()] ??	206✔
150	Object.values(directory.files).find((file) => file.isWildcard && this.fileModuleDefined(file, method));	48✔
151		206✔
152	if (match === undefined) {	206✔
153	return undefined;	20✔
154	}	20✔
155		186✔
156	if (match.isWildcard) {	206✔
157	return {	28✔
158	...match,	28✔
159		28✔
160	matchedPath: `${matchedPath}/${match.rawName}`,	28✔
161		28✔
162	pathVariables: {	28✔
163	...pathVariables,	28✔
164	[match.name]: segment,	28✔
165	},	28✔
166	};	28✔
167	}	28✔
168		158✔
169	return {	158✔
170	...match,	158✔
171		158✔
172	matchedPath: `${matchedPath}/${match.rawName}`,	158✔
173		158✔
174	pathVariables,	158✔
175	};	158✔
176	}	158✔
177		122✔
178	private matchWithinDirectory(	122✔
179	directory: Directory,	302✔
180	segments: string[],	302✔
181	pathVariables: { [key: string]: string },	302✔
182	matchedPath: string,	302✔
183	method: string,	302✔
184	): Match \| undefined {	302✔
185	if (segments.length === 0) {	302!
186	return undefined;	×
187	}	×
188		302✔
189	const [segment, ...remainingSegments] = segments;	302✔
190		302✔
191	if (segment === undefined) {	302!
UNCOV 192	throw new Error(	×
UNCOV 193	"segment cannot be undefined but TypeScript doesn't know that",	×
UNCOV 194	);	×
UNCOV 195	}	×
196		302✔
197	if (	302✔
198	remainingSegments.length === 0 \|\|	302✔
199	(remainingSegments.length === 1 && remainingSegments[0] === "")	98✔
200	) {	302✔
201	return this.buildMatch(directory, segment, pathVariables, matchedPath, method);	206✔
202	}	206✔
203		96✔
204	const exactMatch = directory.directories[segment.toLowerCase()];	96✔
205		96✔
206	if (isDirectory(exactMatch)) {	246✔
207	return this.matchWithinDirectory(	64✔
208	exactMatch,	64✔
209	remainingSegments,	64✔
210	pathVariables,	64✔
211	`${matchedPath}/${segment}`,	64✔
212	method,	64✔
213	);	64✔
214	}	64✔
215		32✔
216	const wildcardDirectories = Object.values(directory.directories).filter(	32✔
217	(subdirectory) => subdirectory.isWildcard,	32✔
218	);	32✔
219		32✔
220	for (const wildcardDirectory of wildcardDirectories) {	216✔
221	const match = this.matchWithinDirectory(	30✔
222	wildcardDirectory,	30✔
223	remainingSegments,	30✔
224	{	30✔
225	...pathVariables,	30✔
226	[wildcardDirectory.name]: segment,	30✔
227	},	30✔
228	`${matchedPath}/${wildcardDirectory.rawName}`,	30✔
229	method,	30✔
230	);	30✔
231		30✔
232	if (match !== undefined) {	30✔
233	return match;	20✔
234	}	20✔
235	}	30✔
236		12✔
237	return undefined;	12✔
238	}	12✔
239		122✔
240	public match(url: string, method: string) {	122✔
241	return this.matchWithinDirectory(	208✔
242	this.root,	208✔
243	url.split("/").slice(1),	208✔
244	{},	208✔
245	"",	208✔
246	method,	208✔
247	);	208✔
248	}	208✔
249		122✔
250	public get routes(): Route[] {	122✔
251	const routes: Route[] = [];	4✔
252		4✔
253	function traverse(directory: Directory, path: string) {	4✔
254	Object.values(directory.directories).forEach((subdirectory) => {	18✔
255	traverse(subdirectory, `${path}/${subdirectory.rawName}`);	14✔
256	});	14✔
257		18✔
258	Object.values(directory.files).forEach((file) => {	18✔
259	const methods: [string, string][] = Object.entries(file.module).map(	26✔
260	([method, implementation]) => [method, String(implementation)],	26✔
261	);	26✔
262		26✔
263	routes.push({	26✔
264	methods: Object.fromEntries(methods),	26✔
265	path: `${path}/${file.rawName}`,	26✔
266	});	26✔
267	});	26✔
268	}	18✔
269		4✔
270	function stripBrackets(string: string) {	4✔
271	return string.replaceAll(/\{\|\}/gu, "");	100✔
272	}	100✔
273		4✔
274	traverse(this.root, "");	4✔
275		4✔
276	return routes.sort((first, second) =>	4✔
277	stripBrackets(first.path).localeCompare(stripBrackets(second.path)),	50✔
278	);	4✔
279	}	4✔
280	}	122✔

pmcelhaney / counterfact / 11262405331

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous