@avijs/compiler 1.0.0-rc.4 → 1.0.0-rc.5

package/src/inject.ts

@@ -61,13 +61,19 @@ class InjectGenerator {
   }
 
   run(): GeneratedInjects {
-    // Only files the app loads: importing any other file would run its code, such as a seed script.
-    const files = this.#loaded();
-    for (const source of files) {
-      if (path.resolve(source.fileName) === this.out) continue;
-      for (const statement of source.statements) {
-        if (ts.isClassDeclaration(statement)) this.#class(statement, source);
-      }
+    const devOnly = devOnlyPackages(this.program);
+    for (const source of this.program.getSourceFiles()) {
+      if (!this.#inProject(source) || path.resolve(source.fileName) === this.out) continue;
+      // Test files are not loaded by the app, and the generated file must not import them.
+      if (/\.(test|spec)\.[cm]?tsx?$/.test(source.fileName)) continue;
+      const classes = source.statements.filter(ts.isClassDeclaration);
+      if (classes.length === 0) continue;
+      // Importing a file runs its top level. Only import files that just declare things: never an
+      // entry point, a worker or a seed script, and nothing a production install may lack.
+      const reason = runsCode(source)
+        ? 'runs code when imported (an entry point or a script)'
+        : importsDevOnly(source, devOnly);
+      for (const node of classes) this.#class(node, source, reason);
     }
 
     this.#entries.sort((a, b) => a.order.localeCompare(b.order));
@@ -111,7 +117,7 @@ class InjectGenerator {
     };
   }
 
-  #class(node: ts.ClassDeclaration, source: ts.SourceFile): void {
+  #class(node: ts.ClassDeclaration, source: ts.SourceFile, unsafe: string | undefined): void {
     if (!node.name) return;
     const hasList = node.members.some(
       (member) =>
@@ -150,6 +156,15 @@ class InjectGenerator {
       return;
     }
 
+    if (unsafe) {
+      this.#report(
+        source,
+        node.name,
+        `${node.name.text} is in a file that ${unsafe}, so inject.gen.ts cannot import it: move the class to its own file, or add static inject`,
+        'AVI203',
+      );
+      return;
+    }
     const cls = this.#importClass(node, source);
     if (!cls) return;
     this.#entries.push({
@@ -207,42 +222,6 @@ class InjectGenerator {
     return callee === 'createToken' || callee === 'defineConfig';
   }
 
-  /** The project's files the app loads: value imports followed from its entry points. */
-  #loaded(): ts.SourceFile[] {
-    const project = this.program
-      .getSourceFiles()
-      .filter(
-        (source) => this.#inProject(source) && !/\.(test|spec)\.[cm]?tsx?$/.test(source.fileName),
-      );
-    const entries = project.filter((source) => startsApp(source));
-    if (entries.length === 0) {
-      const first = project[0];
-      if (first) {
-        this.#report(
-          first,
-          first,
-          'No app entry found (AviFactory.create, register, createAvi, runWorker or cluster): no dependency lists inferred',
-          'AVI202',
-        );
-      }
-      return [];
-    }
-    const seen = new Set<ts.SourceFile>(entries);
-    const queue = [...entries];
-    for (let source = queue.shift(); source; source = queue.shift()) {
-      for (const specifier of valueImports(source)) {
-        const file = this.#checker
-          .getSymbolAtLocation(specifier)
-          ?.declarations?.find(ts.isSourceFile);
-        if (file && !seen.has(file) && this.#inProject(file)) {
-          seen.add(file);
-          queue.push(file);
-        }
-      }
-    }
-    return [...seen];
-  }
-
   #importClass(node: ts.ClassDeclaration, source: ts.SourceFile): string | undefined {
     const symbol = node.name && this.#checker.getSymbolAtLocation(node.name);
     const name = symbol && this.#exportName(symbol, source);
@@ -346,78 +325,93 @@ function isDecorated(node: ts.ClassDeclaration): boolean {
   return (ts.getDecorators(node) ?? []).length > 0;
 }
 
-/** Whether a file starts an app: `AviFactory.create`, `.register`, `createAvi`, `runWorker`, `cluster`. */
-function startsApp(source: ts.SourceFile): boolean {
-  let found = false;
-  const visit = (node: ts.Node): void => {
-    if (found) return;
-    if (ts.isCallExpression(node)) {
-      const callee = node.expression;
-      const name = ts.isIdentifier(callee)
-        ? callee.text
-        : ts.isPropertyAccessExpression(callee)
-          ? callee.name.text
-          : undefined;
-      const owner =
-        ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression)
-          ? callee.expression.text
-          : undefined;
-      if (
-        name === 'createAvi' ||
-        name === 'runWorker' ||
-        name === 'cluster' ||
-        name === 'register' ||
-        (name === 'create' && owner === 'AviFactory')
-      ) {
-        found = true;
-        return;
+/** Whether a file does more than declare things when imported: a call, a loop, a top-level await. */
+function runsCode(source: ts.SourceFile): boolean {
+  const awaits = (node: ts.Node): boolean =>
+    ts.isAwaitExpression(node) ||
+    (!ts.isFunctionLike(node) && !ts.isClassLike(node) && ts.forEachChild(node, awaits) === true);
+  return source.statements.some((statement) => {
+    if (
+      ts.isImportDeclaration(statement) ||
+      ts.isImportEqualsDeclaration(statement) ||
+      ts.isExportDeclaration(statement) ||
+      ts.isClassDeclaration(statement) ||
+      ts.isFunctionDeclaration(statement) ||
+      ts.isInterfaceDeclaration(statement) ||
+      ts.isTypeAliasDeclaration(statement) ||
+      ts.isEnumDeclaration(statement) ||
+      ts.isModuleDeclaration(statement) ||
+      ts.isEmptyStatement(statement)
+    ) {
+      return false;
+    }
+    if (ts.isVariableStatement(statement) || ts.isExportAssignment(statement)) {
+      return awaits(statement);
+    }
+    // 'use strict' and other directives.
+    if (ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression))
+      return false;
+    return true;
+  });
+}
+
+/** Packages the project only has as devDependencies, from the package.json next to its tsconfig. */
+function devOnlyPackages(program: ts.Program): Set<string> {
+  const config = program.getCompilerOptions()['configFilePath'];
+  let dir = typeof config === 'string' ? path.dirname(config) : program.getCurrentDirectory();
+  for (;;) {
+    const file = path.join(dir, 'package.json');
+    if (ts.sys.fileExists(file)) {
+      try {
+        const pkg = JSON.parse(ts.sys.readFile(file) ?? '{}') as Record<
+          string,
+          Record<string, string> | undefined
+        >;
+        const runtime = new Set([
+          ...Object.keys(pkg['dependencies'] ?? {}),
+          ...Object.keys(pkg['peerDependencies'] ?? {}),
+          ...Object.keys(pkg['optionalDependencies'] ?? {}),
+        ]);
+        return new Set(
+          Object.keys(pkg['devDependencies'] ?? {}).filter((name) => !runtime.has(name)),
+        );
+      } catch {
+        return new Set();
       }
     }
-    ts.forEachChild(node, visit);
-  };
-  visit(source);
-  return found;
+    const parent = path.dirname(dir);
+    if (parent === dir) return new Set();
+    dir = parent;
+  }
 }
 
-/** Module specifiers a file loads at runtime: imports and re-exports that are not type-only. */
-function valueImports(source: ts.SourceFile): ts.StringLiteral[] {
-  const found: ts.StringLiteral[] = [];
+/** Why a file cannot be imported in production: it imports a package from devDependencies. */
+function importsDevOnly(source: ts.SourceFile, devOnly: ReadonlySet<string>): string | undefined {
   for (const statement of source.statements) {
-    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
-      const clause = statement.importClause;
-      if (clause?.phaseModifier === ts.SyntaxKind.TypeKeyword) continue;
-      const named = clause?.namedBindings;
-      const allTypes =
-        clause !== undefined &&
-        clause.name === undefined &&
-        named !== undefined &&
-        ts.isNamedImports(named) &&
-        named.elements.length > 0 &&
-        named.elements.every((element) => element.isTypeOnly);
-      if (!allTypes) found.push(statement.moduleSpecifier);
-    } else if (
-      ts.isExportDeclaration(statement) &&
-      !statement.isTypeOnly &&
-      statement.moduleSpecifier &&
-      ts.isStringLiteral(statement.moduleSpecifier)
-    ) {
-      found.push(statement.moduleSpecifier);
-    }
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const clause = statement.importClause;
+    // Type-only imports are erased.
+    if (clause && (clause.getText(source).startsWith('type ') || isTypeOnlyClause(clause)))
+      continue;
+    const specifier = statement.moduleSpecifier.text;
+    const name = specifier.startsWith('@')
+      ? specifier.split('/').slice(0, 2).join('/')
+      : specifier.split('/')[0];
+    if (name && devOnly.has(name)) return `imports ${name}, a devDependency`;
   }
-  // import('...') loads too.
-  const visit = (node: ts.Node): void => {
-    if (
-      ts.isCallExpression(node) &&
-      node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-      node.arguments[0] &&
-      ts.isStringLiteral(node.arguments[0])
-    ) {
-      found.push(node.arguments[0]);
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(source);
-  return found;
+  return undefined;
+}
+
+function isTypeOnlyClause(clause: ts.ImportClause): boolean {
+  const named = clause.namedBindings;
+  return (
+    clause.name === undefined &&
+    named !== undefined &&
+    ts.isNamedImports(named) &&
+    named.elements.length > 0 &&
+    named.elements.every((element) => element.isTypeOnly)
+  );
 }
 
 export const plural = (count: number, noun: string): string =>

package/src/outputs.ts

@@ -0,0 +1,143 @@
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+
+/** Lists the files `avi build` and `avi dev` compiled into an output folder. */
+const MARKER = '.avi-build';
+const OUTPUT = /\.(?:[cm]?js|d\.[cm]?ts|map)$/;
+
+interface OutputFolder {
+  /** The real path. */
+  readonly out: string;
+  /** The configured path, as the compiler writes to it. */
+  readonly configured: string;
+  readonly key: (relative: string) => string;
+}
+
+/**
+ * The output folder, when it is safe to clean: a real folder inside the project, reached without
+ * links, not hidden or `node_modules`.
+ */
+function outputFolder(outDir: string | undefined, projectDir: string): OutputFolder | undefined {
+  if (!outDir || !existsSync(outDir)) return undefined;
+  let out: string;
+  let root: string;
+  try {
+    out = realpathSync.native(outDir);
+    root = realpathSync.native(projectDir);
+  } catch {
+    return undefined;
+  }
+  const ignoreCase = !ts.sys.useCaseSensitiveFileNames;
+  const key = (relative: string) => (ignoreCase ? relative.toLowerCase() : relative);
+  const inside = path.relative(root, out);
+  // A link between the project and the output folder changes the path inside the project. Links
+  // above the project (macOS /var, Windows short names) do not matter.
+  const configured = path.relative(path.resolve(projectDir), path.resolve(outDir));
+  if (key(inside) !== key(configured)) return undefined;
+  if (!inside || inside.startsWith('..') || path.isAbsolute(inside)) return undefined;
+  if (inside.split(path.sep).some((part) => part.startsWith('.') || part === 'node_modules')) {
+    return undefined;
+  }
+  return { out, configured: path.resolve(outDir), key };
+}
+
+/** Paths by their place in the output folder: the real and configured paths may differ above it. */
+function relativeTo(folder: OutputFolder, written: Iterable<string>): string[] {
+  return [...written]
+    .map((file) => path.relative(folder.configured, file))
+    .filter((relative) => relative && !relative.startsWith('..') && !path.isAbsolute(relative))
+    .map((relative) => relative.split(path.sep).join('/'));
+}
+
+/**
+ * Deletes the files an earlier build wrote to `outDir` and this one did not, such as a deleted
+ * module's tests. Nothing else in the folder is touched: hand-written files, a bundler's assets.
+ */
+export function removeStale(
+  outDir: string | undefined,
+  projectDir: string,
+  written: Iterable<string>,
+): void {
+  const folder = outputFolder(outDir, projectDir);
+  if (!folder) return;
+  const { out, key } = folder;
+  const current = relativeTo(folder, written).sort();
+  const keep = new Set(current.map(key));
+  for (const relative of readMarker(out)) {
+    if (keep.has(key(relative)) || !OUTPUT.test(relative)) continue;
+    const file = path.resolve(out, relative);
+    const within = path.relative(out, file);
+    if (!within || within.startsWith('..') || path.isAbsolute(within)) continue;
+    let stat;
+    try {
+      stat = lstatSync(file);
+    } catch {
+      continue;
+    }
+    // Only a plain file: never a link, and never through one.
+    const dir = path.dirname(file);
+    if (!stat.isFile() || key(realpathSync.native(dir)) !== key(dir)) continue;
+    rmSync(file);
+    removeEmptyDirs(path.dirname(file), out);
+  }
+  writeMarker(out, current);
+}
+
+/**
+ * Adds files a watch build wrote to the list, without removing anything: it only emits what
+ * changed. The next full build removes the ones whose source is gone.
+ */
+export function recordOutputs(
+  outDir: string | undefined,
+  projectDir: string,
+  written: Iterable<string>,
+): void {
+  const folder = outputFolder(outDir, projectDir);
+  if (!folder) return;
+  const files = new Map(readMarker(folder.out).map((file) => [folder.key(file), file]));
+  const before = files.size;
+  for (const file of relativeTo(folder, written)) files.set(folder.key(file), file);
+  if (files.size === before && existsSync(path.join(folder.out, MARKER))) return;
+  writeMarker(folder.out, [...files.values()].sort());
+}
+
+function writeMarker(out: string, files: string[]): void {
+  writeFileSync(
+    path.join(out, MARKER),
+    `${JSON.stringify({ note: 'Written by avi build and avi dev: the files they compiled here, so the next build can remove the ones whose source is gone.', files }, null, 2)}\n`,
+  );
+}
+
+function readMarker(out: string): string[] {
+  try {
+    const parsed = JSON.parse(readFileSync(path.join(out, MARKER), 'utf8')) as {
+      files?: unknown;
+    };
+    return Array.isArray(parsed.files)
+      ? parsed.files.filter((file): file is string => typeof file === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+function removeEmptyDirs(dir: string, stop: string): void {
+  for (
+    let current = dir;
+    current !== stop && current.startsWith(stop);
+    current = path.dirname(current)
+  ) {
+    if (readdirSync(current).length > 0) return;
+    rmdirSync(current);
+  }
+}

package/src/watch.ts

@@ -4,6 +4,7 @@ import ts from 'typescript';
 import { formatDiagnostic, type Diagnostic } from './check.js';
 import { generateFrom, sameContent } from './client.js';
 import { INJECT_HEADER, generateInjectsFrom, plural } from './inject.js';
+import { recordOutputs } from './outputs.js';
 
 export interface WatchProjectOptions {
   /** Path to tsconfig.json. */
@@ -31,10 +32,20 @@ export interface ProjectWatcher {
  */
 export function watchProject(options: WatchProjectOptions): ProjectWatcher {
   const emit = options.emit ?? true;
+  // What each build emits goes on avi build's list, so it can remove outputs of deleted files.
+  const projectDir = path.dirname(path.resolve(options.project));
+  const emitted = new Set<string>();
+  const system: ts.System = {
+    ...ts.sys,
+    writeFile: (file, text, bom) => {
+      ts.sys.writeFile(file, text, bom);
+      emitted.add(path.resolve(file));
+    },
+  };
   const host = ts.createWatchCompilerHost(
     path.resolve(options.project),
     emit ? { preserveWatchOutput: true } : { noEmit: true },
-    ts.sys,
+    system,
     ts.createEmitAndSemanticDiagnosticsBuilderProgram,
     undefined,
     // Without emit the only output is the generated files'; tsc's status lines would be noise.
@@ -42,8 +53,11 @@ export function watchProject(options: WatchProjectOptions): ProjectWatcher {
   );
 
   let generatedErrors = 0;
+  // A file event can still start a build after close(); it must not write or report.
+  let closed = false;
   const status = host.onWatchStatusChange?.bind(host);
   host.onWatchStatusChange = (diagnostic, newLine, compilerOptions, errorCount) => {
+    if (closed) return;
     status?.(diagnostic, newLine, compilerOptions, errorCount);
     if (errorCount !== undefined) options.onBuild?.(errorCount + generatedErrors);
   };
@@ -51,6 +65,7 @@ export function watchProject(options: WatchProjectOptions): ProjectWatcher {
   const writers = generatedWriters(options);
   const build = host.afterProgramCreate?.bind(host);
   host.afterProgramCreate = (builder) => {
+    if (closed) return;
     const program = builder.getProgram();
     const results = writers.map((writer) => ({ out: writer.out, ...writer.write(program) }));
     generatedErrors = results.reduce((sum, result) => sum + result.errors, 0);
@@ -62,11 +77,16 @@ export function watchProject(options: WatchProjectOptions): ProjectWatcher {
     // report its stale errors. A file outside the program starts nothing, so build now.
     if (results.some((result) => result.written && program.getSourceFile(result.out))) return;
     build?.(builder);
+    if (emitted.size > 0) {
+      recordOutputs(program.getCompilerOptions().outDir, projectDir, emitted);
+      emitted.clear();
+    }
   };
 
   const watcher = ts.createWatchProgram(host);
   return {
     close: () => {
+      closed = true;
       watcher.close();
     },
   };