8897864621

Committed 30 Apr 2024 03:54PM UTC coverage: 87.547% (+0.8%) from 86.763%

Build # 8897864621

Build Type

Pull #875

github

Committed by

pmcelhaney

Commit Message

don't need to import a .d.ts file

Pull Request Pull Request #875: reload dependent modules

Run Details

927 of 1018 branches covered (91.06%)

Branch coverage included in aggregate %.

107 of 108 new or added lines in 3 files covered. (99.07%)

18 existing lines in 1 file now uncovered.

3017 of 3487 relevant lines covered (86.52%)

43.4 hits per line

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

87.93

/src/server/module-loader.ts

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:typescript-generator: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 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}`,
      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);

        dependencies.add(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> {
    const moduleKind = await determineModuleKind(this.basePath);

    this.uncachedImport =
      moduleKind === "module" ? uncachedImport : uncachedRequire;

    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 (!["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 {
      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
      const endpoint = (await this.uncachedImport(pathName)) as
        | ContextModule
        | Module;

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

      if (basename(pathName).startsWith("_.context")) {
        if (isContextModule(endpoint)) {
          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(),
          );
        }
      } 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;
      }

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

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

pmcelhaney / counterfact / 8897864621

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