10324095158

Committed 09 Aug 2024 06:37PM UTC coverage: 82.443% (-0.03%) from 82.471%

Build # 10324095158

Build Type

Pull #1016

github

Committed by

pmcelhaney

Commit Message

upgrading yarn and rebuilding yarn.lock seems to have fixed the string-width issue

Pull Request Pull Request #1016: Upgrade eslint-config-hardcore

Run Details

1001 of 1114 branches covered (89.86%)

Branch coverage included in aggregate %.

40 of 60 new or added lines in 20 files covered. (66.67%)

1 existing line in 1 file now uncovered.

3291 of 4092 relevant lines covered (80.43%)

41.92 hits per line

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

85.48

/src/server/module-loader.ts

/* eslint-disable n/no-sync */
import { once } from "node:events";
import { existsSync } from "node:fs";
import fs from "node:fs/promises";
import nodePath, { basename, dirname } from "node:path";

import { type FSWatcher, watch } from "chokidar";
import createDebug from "debug";

import { CHOKIDAR_OPTIONS } from "./constants.js";
import { type Context, ContextRegistry } from "./context-registry.js";
import { determineModuleKind } from "./determine-module-kind.js";
import { ModuleDependencyGraph } from "./module-dependency-graph.js";
import type { Module, Registry } from "./registry.js";
import { uncachedImport } from "./uncached-import.js";

const { uncachedRequire } = await import("./uncached-require.cjs");

const debug = createDebug("counterfact:server:module-loader");

interface ContextModule {
  Context: Context;
}

function isContextModule(
  module: ContextModule | Module,
): module is ContextModule {
  return "Context" in module && typeof module.Context === "function";
}

export class ModuleLoader extends EventTarget {
  private readonly basePath: string;

  public readonly registry: Registry;

  private watcher: FSWatcher | undefined;

  private readonly contextRegistry: ContextRegistry;

  private readonly dependencyGraph = new ModuleDependencyGraph();

  private readonly uncachedImport: (moduleName: string) => Promise<unknown> =
    // eslint-disable-next-line @typescript-eslint/require-await
    async function (moduleName: string) {
      throw new Error(`uncachedImport not set up; importing ${moduleName}`);
    };

  public constructor(
    basePath: string,
    registry: Registry,
    contextRegistry = new ContextRegistry(),
  ) {
    super();
    this.basePath = basePath.replaceAll("\\", "/");
    this.registry = registry;
    this.contextRegistry = contextRegistry;
  }

  public async watch(): Promise<void> {
    this.watcher = watch(
      `${this.basePath}/**/*.{js,mjs,ts,mts,cjs,cts}`,
      CHOKIDAR_OPTIONS,
    ).on(
      "all",
      // eslint-disable-next-line max-statements
      (eventName: string, pathNameOriginal: string) => {
        const pathName = pathNameOriginal.replaceAll("\\", "/");

        if (pathName.includes("$.context") && eventName === "add") {
          process.stdout.write(
            `\n\n!!! The file at ${pathName} needs a minor update.\n    See https://github.com/pmcelhaney/counterfact/blob/main/docs/context-change.md\n\n\n`,
          );

          return;
        }

        if (!["add", "change", "unlink"].includes(eventName)) {
          return;
        }

        const parts = nodePath.parse(pathName.replace(this.basePath, ""));
        const url = `/${parts.dir}/${parts.name}`
          .replaceAll("\\", "/")
          .replaceAll(/\/+/gu, "/");

        if (eventName === "unlink") {
          this.registry.remove(url);
          this.dispatchEvent(new Event("remove"));
        }

        const dependencies = this.dependencyGraph.dependentsOf(pathName);

        void this.loadEndpoint(pathName);

        for (const dependency of dependencies) {
          void this.loadEndpoint(dependency);
        }
      },
    );
    await once(this.watcher, "ready");
  }

  public async stopWatching(): Promise<void> {
    await this.watcher?.close();
  }

  public async load(directory = ""): Promise<void> {
    if (
      !existsSync(nodePath.join(this.basePath, directory).replaceAll("\\", "/"))
    ) {
      throw new Error(`Directory does not exist ${this.basePath}`);
    }

    const files = await fs.readdir(
      nodePath.join(this.basePath, directory).replaceAll("\\", "/"),
      {
        withFileTypes: true,
      },
    );

    const imports = files.flatMap(async (file): Promise<void> => {
      const extension = file.name.split(".").at(-1);

      if (file.isDirectory()) {
        await this.load(
          nodePath.join(directory, file.name).replaceAll("\\", "/"),
        );

        return;
      }

      if (!["cjs", "cts", "js", "mjs", "mts", "ts"].includes(extension ?? "")) {
        return;
      }

      const fullPath = nodePath
        .join(this.basePath, directory, file.name)
        .replaceAll("\\", "/");

      await this.loadEndpoint(fullPath);
    });

    await Promise.all(imports);
  }

  // eslint-disable-next-line max-statements
  private async loadEndpoint(pathName: string) {
    debug("importing module: %s", pathName);

    const directory = dirname(pathName.slice(this.basePath.length)).replaceAll(
      "\\",
      "/",
    );

    const url = `/${nodePath.join(
      directory,
      nodePath.parse(basename(pathName)).name,
    )}`
      .replaceAll("\\", "/")
      .replaceAll(/\/+/gu, "/");

    this.dependencyGraph.load(pathName);

    try {
      const doImport =
        (await determineModuleKind(pathName)) === "commonjs"
          ? uncachedRequire
          : uncachedImport;

      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
      const endpoint = (await doImport(pathName)) as ContextModule | Module;

      this.dispatchEvent(new Event("add"));

      if (basename(pathName).startsWith("_.context")) {
        if (isContextModule(endpoint)) {
          const loadContext = (path: string) => this.contextRegistry.find(path);

          this.contextRegistry.update(
            directory,

            // @ts-expect-error TS says Context has no constructable signatures but that's not true?
            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
            new endpoint.Context({
              loadContext,
            }),
          );
        }
      } else {
        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
        this.registry.add(url, endpoint as Module);
      }
    } catch (error: unknown) {
      if (
        String(error) ===
        "SyntaxError: Identifier 'Context' has already been declared"
      ) {
        // Not sure why Node throws this error. It doesn't seem to matter.
        return;
      }

      throw error;

      process.stdout.write(`\nError loading ${pathName}:\n${String(error)}\n`);
    }
  }
}

1	/* eslint-disable n/no-sync */	2✔
2	import { once } from "node:events";	2✔
3	import { existsSync } from "node:fs";	2✔
4	import fs from "node:fs/promises";	2✔
5	import nodePath, { basename, dirname } from "node:path";	2✔
6		2✔
7	import { type FSWatcher, watch } from "chokidar";	2✔
8	import createDebug from "debug";	2✔
9		2✔
10	import { CHOKIDAR_OPTIONS } from "./constants.js";	2✔
11	import { type Context, ContextRegistry } from "./context-registry.js";	2✔
12	import { determineModuleKind } from "./determine-module-kind.js";	2✔
13	import { ModuleDependencyGraph } from "./module-dependency-graph.js";	2✔
14	import type { Module, Registry } from "./registry.js";	2✔
15	import { uncachedImport } from "./uncached-import.js";	2✔
16		2✔
17	const { uncachedRequire } = await import("./uncached-require.cjs");	2✔
18		2✔
19	const debug = createDebug("counterfact:server:module-loader");	2✔
20		2✔
21	interface ContextModule {	2✔
22	Context: Context;	2✔
23	}	2✔
24		2✔
25	function isContextModule(	12✔
26	module: ContextModule \| Module,	12✔
27	): module is ContextModule {	12✔
28	return "Context" in module && typeof module.Context === "function";	12✔
29	}	12✔
30		2✔
31	export class ModuleLoader extends EventTarget {	2✔
32	private readonly basePath: string;	12✔
33		12✔
34	public readonly registry: Registry;	12✔
35		12✔
36	private watcher: FSWatcher \| undefined;	12✔
37		12✔
38	private readonly contextRegistry: ContextRegistry;	12✔
39		12✔
40	private readonly dependencyGraph = new ModuleDependencyGraph();	12✔
41		12✔
42	private readonly uncachedImport: (moduleName: string) => Promise<unknown> =	12✔
43	// eslint-disable-next-line @typescript-eslint/require-await	12✔
44	async function (moduleName: string) {	12✔
45	throw new Error(`uncachedImport not set up; importing ${moduleName}`);	×
46	};	×
47		12✔
48	public constructor(	12✔
49	basePath: string,	12✔
50	registry: Registry,	12✔
51	contextRegistry = new ContextRegistry(),	12✔
52	) {	12✔
53	super();	12✔
54	this.basePath = basePath.replaceAll("\\", "/");	12✔
55	this.registry = registry;	12✔
56	this.contextRegistry = contextRegistry;	12✔
57	}	12✔
58		12✔
59	public async watch(): Promise<void> {	12✔
60	this.watcher = watch(	4✔
61	`${this.basePath}/*/.{js,mjs,ts,mts,cjs,cts}`,	4✔
62	CHOKIDAR_OPTIONS,	4✔
63	).on(	4✔
64	"all",	4✔
65	// eslint-disable-next-line max-statements	4✔
66	(eventName: string, pathNameOriginal: string) => {	4✔
67	const pathName = pathNameOriginal.replaceAll("\\", "/");	2✔
68		2✔
69	if (pathName.includes("$.context") && eventName === "add") {	2!
70	process.stdout.write(	×
71	`\n\n!!! The file at ${pathName} needs a minor update.\n See https://github.com/pmcelhaney/counterfact/blob/main/docs/context-change.md\n\n\n`,	×
72	);	×
NEW 73		×
74	return;	×
75	}	×
76		2✔
77	if (!["add", "change", "unlink"].includes(eventName)) {	2!
78	return;	×
79	}	×
80		2✔
81	const parts = nodePath.parse(pathName.replace(this.basePath, ""));	2✔
82	const url = `/${parts.dir}/${parts.name}`	2✔
83	.replaceAll("\\", "/")	2✔
84	.replaceAll(/\/+/gu, "/");	2✔
85		2✔
86	if (eventName === "unlink") {	2✔
87	this.registry.remove(url);	2✔
88	this.dispatchEvent(new Event("remove"));	2✔
89	}	2✔
90		2✔
91	const dependencies = this.dependencyGraph.dependentsOf(pathName);	2✔
92		2✔
93	void this.loadEndpoint(pathName);	2✔
94		2✔
95	for (const dependency of dependencies) {	2!
96	void this.loadEndpoint(dependency);	×
97	}	×
98	},	2✔
99	);	4✔
100	await once(this.watcher, "ready");	4✔
101	}	4✔
102		12✔
103	public async stopWatching(): Promise<void> {	12✔
104	await this.watcher?.close();	4✔
105	}	4✔
106		12✔
107	public async load(directory = ""): Promise<void> {	12✔
108	if (	22✔
109	!existsSync(nodePath.join(this.basePath, directory).replaceAll("\\", "/"))	22✔
110	) {	22!
111	throw new Error(`Directory does not exist ${this.basePath}`);	×
112	}	×
113		22✔
114	const files = await fs.readdir(	22✔
115	nodePath.join(this.basePath, directory).replaceAll("\\", "/"),	22✔
116	{	22✔
117	withFileTypes: true,	22✔
118	},	22✔
119	);	22✔
120		22✔
121	const imports = files.flatMap(async (file): Promise<void> => {	22✔
122	const extension = file.name.split(".").at(-1);	44✔
123		44✔
124	if (file.isDirectory()) {	44✔
125	await this.load(	10✔
126	nodePath.join(directory, file.name).replaceAll("\\", "/"),	10✔
127	);	10✔
128		10✔
129	return;	10✔
130	}	10✔
131		34✔
132	if (!["cjs", "cts", "js", "mjs", "mts", "ts"].includes(extension ?? "")) {	44✔
133	return;	14✔
134	}	14✔
135		20✔
136	const fullPath = nodePath	20✔
137	.join(this.basePath, directory, file.name)	20✔
138	.replaceAll("\\", "/");	20✔
139		20✔
140	await this.loadEndpoint(fullPath);	20✔
141	});	20✔
142		22✔
143	await Promise.all(imports);	22✔
144	}	22✔
145		12✔
146	// eslint-disable-next-line max-statements	12✔
147	private async loadEndpoint(pathName: string) {	12✔
148	debug("importing module: %s", pathName);	22✔
149		22✔
150	const directory = dirname(pathName.slice(this.basePath.length)).replaceAll(	22✔
151	"\\",	22✔
152	"/",	22✔
153	);	22✔
154		22✔
155	const url = `/${nodePath.join(	22✔
156	directory,	22✔
157	nodePath.parse(basename(pathName)).name,	22✔
158	)}`	22✔
159	.replaceAll("\\", "/")	22✔
160	.replaceAll(/\/+/gu, "/");	22✔
161		22✔
162	this.dependencyGraph.load(pathName);	22✔
163		22✔
164	try {	22✔
165	const doImport =	22✔
166	(await determineModuleKind(pathName)) === "commonjs"	22!
167	? uncachedRequire	×
168	: uncachedImport;	22✔
169		22✔
170	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions	22✔
171	const endpoint = (await doImport(pathName)) as ContextModule \| Module;	22✔
172		22✔
173	this.dispatchEvent(new Event("add"));	22✔
174		22✔
175	if (basename(pathName).startsWith("_.context")) {	22✔
176	if (isContextModule(endpoint)) {	12✔
177	const loadContext = (path: string) => this.contextRegistry.find(path);	12✔
178		12✔
179	this.contextRegistry.update(	12✔
180	directory,	12✔
181		12✔
182	// @ts-expect-error TS says Context has no constructable signatures but that's not true?	12✔
183	// eslint-disable-next-line @typescript-eslint/no-unsafe-argument	12✔
184	new endpoint.Context({	12✔
185	loadContext,	12✔
186	}),	12✔
187	);	12✔
188	}	12✔
189	} else {	22✔
190	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions	10✔
191	this.registry.add(url, endpoint as Module);	10✔
192	}	10✔
193	} catch (error: unknown) {	22!
194	if (	×
195	String(error) ===	×
196	"SyntaxError: Identifier 'Context' has already been declared"	×
197	) {	×
198	// Not sure why Node throws this error. It doesn't seem to matter.	×
199	return;	×
200	}	×
201		×
202	throw error;	×
203		×
204	process.stdout.write(`\nError loading ${pathName}:\n${String(error)}\n`);	×
205	}	×
206	}	22✔
207	}	12✔

pmcelhaney / counterfact / 10324095158

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