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

package/src/inject.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import ts from 'typescript';
-import { readProgram, type Diagnostic } from './check.js';
+import { readProgram, unwrap, type Diagnostic } from './check.js';
 
 export interface GeneratedInjects {
   /** The generated file's contents. */
@@ -61,14 +61,19 @@ class InjectGenerator {
   }
 
   run(): GeneratedInjects {
+    const devOnly = devOnlyPackages(this.program);
     for (const source of this.program.getSourceFiles()) {
-      if (!this.#inProject(source)) continue;
+      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;
-      if (path.resolve(source.fileName) === this.out) continue;
-      for (const statement of source.statements) {
-        if (ts.isClassDeclaration(statement)) this.#class(statement, source);
-      }
+      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));
@@ -92,10 +97,11 @@ class InjectGenerator {
         ([specifier, names]) => `import { ${names.join(', ')} } from '${specifier}';`,
       ),
       '',
+      // A function, read when the app starts: classes in an import cycle with this file exist by then.
       this.#entries.length === 0
-        ? 'registerInjects([]);'
+        ? 'registerInjects(() => []);'
         : [
-            'registerInjects([',
+            'registerInjects(() => [',
             ...this.#entries.map((e) => `  [${e.cls}, [${e.deps.join(', ')}]],`),
             ']);',
           ].join('\n'),
@@ -111,10 +117,8 @@ 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 modifiers = ts.getCombinedModifierFlags(node);
-    if (modifiers & ts.ModifierFlags.Abstract) return;
     const hasList = node.members.some(
       (member) =>
         ts.isPropertyDeclaration(member) &&
@@ -126,14 +130,23 @@ class InjectGenerator {
       (member): member is ts.ConstructorDeclaration =>
         ts.isConstructorDeclaration(member) && member.body !== undefined,
     );
-    if (!ctor || ctor.parameters.length === 0) return;
+    if (!ctor) return;
+    // Like constructor.length: optional, defaulted and rest parameters are left out.
+    const optional = ctor.parameters.findIndex(
+      (p) =>
+        p.questionToken !== undefined ||
+        p.initializer !== undefined ||
+        p.dotDotDotToken !== undefined,
+    );
+    const required = optional === -1 ? [...ctor.parameters] : ctor.parameters.slice(0, optional);
+    if (required.length === 0) return;
 
-    const tokens = ctor.parameters.map((param) => this.#token(param, source));
+    const tokens = required.map((param) => this.#token(param, source));
     const resolved = tokens.filter((token): token is string => token !== undefined);
     if (resolved.length < tokens.length) {
       // A class none of whose parameters are injectable is not a DI class: say nothing.
       if (resolved.length === 0 && !isDecorated(node)) return;
-      const param = ctor.parameters[tokens.findIndex((token) => token === undefined)];
+      const param = required[tokens.findIndex((token) => token === undefined)];
       const which = param ? `\`${param.name.getText(source)}\`` : 'a parameter';
       this.#report(
         source,
@@ -143,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({
@@ -182,17 +204,22 @@ class InjectGenerator {
     return this.#importValue(symbol, declaration, param.type.typeName, source);
   }
 
-  /** A class, a constructor, or an injection token (which has a `description`). */
+  /** A class, a constructor, or a token made by `createToken` or `defineConfig`. */
   #canBeToken(symbol: ts.Symbol): boolean {
     if (symbol.flags & ts.SymbolFlags.Class) return true;
     const declaration = symbol.valueDeclaration;
     if (!declaration) return false;
     const type = this.#checker.getTypeOfSymbolAtLocation(symbol, declaration);
     if (type.getConstructSignatures().length > 0) return true;
-    const description = type.getProperty('description');
-    if (!description) return false;
-    const text = this.#checker.getTypeOfSymbolAtLocation(description, declaration);
-    return (text.flags & ts.TypeFlags.StringLike) !== 0;
+    if (!ts.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+    const call = unwrap(declaration.initializer);
+    if (!call || !ts.isCallExpression(call)) return false;
+    const callee = ts.isPropertyAccessExpression(call.expression)
+      ? call.expression.name.text
+      : ts.isIdentifier(call.expression)
+        ? call.expression.text
+        : undefined;
+    return callee === 'createToken' || callee === 'defineConfig';
   }
 
   #importClass(node: ts.ClassDeclaration, source: ts.SourceFile): string | undefined {
@@ -272,14 +299,14 @@ class InjectGenerator {
     return !source.isDeclarationFile && this.roots.has(path.resolve(source.fileName));
   }
 
-  #report(source: ts.SourceFile, at: ts.Node, message: string): void {
+  #report(source: ts.SourceFile, at: ts.Node, message: string, code = 'AVI201'): void {
     const { line, character } = source.getLineAndCharacterOfPosition(at.getStart(source));
     this.#diagnostics.push({
       file: source.fileName,
       line: line + 1,
       column: character + 1,
       severity: 'warning',
-      code: 'AVI201',
+      code,
       message,
     });
   }
@@ -297,3 +324,95 @@ function configTarget(type: ts.TypeNode): ts.EntityName | undefined {
 function isDecorated(node: ts.ClassDeclaration): boolean {
   return (ts.getDecorators(node) ?? []).length > 0;
 }
+
+/** 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();
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return new Set();
+    dir = parent;
+  }
+}
+
+/** 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))
+      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`;
+  }
+  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 =>
+  `${String(count)} ${noun}${count === 1 ? '' : 's'}`;

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

@@ -3,7 +3,8 @@ import path from 'node:path';
 import ts from 'typescript';
 import { formatDiagnostic, type Diagnostic } from './check.js';
 import { generateFrom, sameContent } from './client.js';
-import { INJECT_HEADER, generateInjectsFrom } from './inject.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();
     },
   };
@@ -104,7 +124,7 @@ export function clientWriter(out: string, root: string | undefined) {
 export function injectWriter(out: string) {
   return fileWriter(out, INJECT_HEADER, (program, roots, file) => {
     const result = generateInjectsFrom(program, roots, { out: file });
-    return { ...result, summary: `${String(result.classes.length)} dependency lists` };
+    return { ...result, summary: plural(result.classes.length, 'dependency list') };
   });
 }