chore: Compile ts programs given an entry point rather than all sources upfront (#1214)

chore: Compile ts programs given an entry point rather than all sources
upfront.

Author: jsantell

packages/js-runtime/cli/cli.ts

@@ -1,4 +1,3 @@
-import { populateArtifact, relativeToAbsolute } from "./utils.ts";
 import {
   Args,
   type Command,
@@ -7,6 +6,7 @@ import {
 } from "./interface.ts";
 import { Processor } from "./processor.ts";
 import { parseArgs } from "@std/cli/parse-args";
+import { join } from "@std/path";
 
 export class RuntimeCLI {
   private cwd: string;
@@ -16,15 +16,15 @@ export class RuntimeCLI {
     this.processor = new Processor();
   }
 
-  async parse(input: string[]): Promise<Command> {
+  parse(input: string[]): Command {
     const args = parseCLIArgs(this.cwd, input);
     if (args.help) {
       return { type: CommandType.Help };
     }
 
     const runCommand: RunCommand = {
       type: CommandType.Run,
-      source: await populateArtifact(args.files),
+      entry: args.entry,
     };
     if (args.noCheck) runCommand.noCheck = args.noCheck;
     if (args.noRun) runCommand.noRun = args.noRun;
@@ -62,14 +62,20 @@ export function parseCLIArgs(cwd: string, input: string[]): Args {
     ],
   });
 
+  const entry = (parsed["_"] ?? []).shift();
+  if (!entry) {
+    throw new Error("Missing entry.");
+  }
   return {
-    files: (parsed["_"] ?? []).map((filepath) =>
-      relativeToAbsolute(cwd, String(filepath))
-    ),
+    entry: relativeToAbsolute(cwd, String(entry)),
     help: !!parsed.help,
     verbose: !!parsed.verbose,
     noCheck: !!parsed["no-check"],
     noRun: !!parsed["no-run"],
     out: parsed.out ? relativeToAbsolute(cwd, parsed.out) : undefined,
   };
 }
+
+function relativeToAbsolute(rootDir: string, filepath: string): string {
+  return join(rootDir, filepath);
+}

packages/js-runtime/cli/interface.ts

@@ -1,12 +1,12 @@
-import { type TsArtifact } from "../interface.ts";
+import { type Program } from "../interface.ts";
 
 export enum CommandType {
   Run = "run",
   Help = "help",
 }
 
 export interface Args {
-  files: string[];
+  entry: string;
   help?: boolean;
   verbose?: boolean;
   noRun?: boolean;
@@ -21,7 +21,7 @@ export interface Command {
 
 export interface RunCommand extends Command {
   type: CommandType.Run;
-  source: TsArtifact;
+  entry: string;
   verbose?: boolean;
   noRun?: boolean;
   noCheck?: boolean;

packages/js-runtime/cli/processor.ts

@@ -1,13 +1,50 @@
-import * as path from "@std/path";
-import { Command, CommandType, RunCommand } from "./interface.ts";
-import { getTypeLibs, TypeScriptCompiler, UnsafeEvalRuntime } from "../mod.ts";
+import { RunCommand } from "./interface.ts";
+import {
+  getTypeLibs,
+  ProgramGraph,
+  Source,
+  TypeScriptCompiler,
+  UnsafeEvalRuntime,
+} from "../mod.ts";
+import { basename, dirname, join } from "@std/path";
+
+class CliProgram implements ProgramGraph {
+  private fsRoot: string;
+  private _entry: Source;
+  constructor(entryPath: string) {
+    this.fsRoot = dirname(entryPath);
+    this._entry = {
+      name: entryPath.substring(this.fsRoot.length),
+      contents: Deno.readTextFileSync(entryPath),
+    };
+  }
+
+  entry(): Source {
+    return this._entry;
+  }
+
+  resolveSource(specifier: string): Source | undefined {
+    if (specifier && specifier[0] === "/") {
+      const absPath = join(
+        this.fsRoot,
+        specifier.substring(1, specifier.length),
+      );
+      return {
+        name: specifier,
+        contents: Deno.readTextFileSync(absPath),
+      };
+    }
+    return undefined;
+  }
+}
 
 export class Processor {
   async run(command: RunCommand): Promise<any> {
+    const program = new CliProgram(command.entry);
     const compiler = new TypeScriptCompiler(await getTypeLibs());
-    const compiled = compiler.compile(command.source, {
+    const compiled = compiler.compile(program, {
       noCheck: !!command.noCheck,
-      filename: command.out ? path.basename(command.out) : undefined,
+      filename: command.out ? basename(command.out) : undefined,
     });
 
     if (command.noRun) {

packages/js-runtime/cli/utils.ts

@@ -2,7 +2,7 @@
   "name": "@commontools/js-runtime",
   "tasks": {
     "run": "deno run --allow-read --allow-env=\"TSC_*\",NODE_INSPECTOR_IPC,VSCODE_INSPECTOR_OPTIONS,NODE_ENV ./cli/mod.ts",
-    "test": "deno test --allow-read --allow-run --allow-env=\"TSC_*\",NODE_INSPECTOR_IPC,VSCODE_INSPECTOR_OPTIONS,NODE_ENV"
+    "test": "deno test --allow-read --allow-run --allow-env=\"TSC_*\",NODE_INSPECTOR_IPC,VSCODE_INSPECTOR_OPTIONS,NODE_ENV test/*.test.ts"
   },
   "imports": {
     "source-map-js": "npm:source-map-js"

packages/js-runtime/deno.json

@@ -1,4 +1,4 @@
-import { ExecutableJs, JsIsolate, JsRuntime, SourceMap } from "./interface.ts";
+import { JsIsolate, JsRuntime, JsScript, SourceMap } from "./interface.ts";
 import { SourceMapParser } from "./source-map.ts";
 
 export class UnsafeEvalJsValue {
@@ -53,7 +53,7 @@ class IsolateInternals {
 export class UnsafeEvalIsolate implements JsIsolate {
   private internals = new IsolateInternals();
   execute(
-    input: string | ExecutableJs,
+    input: string | JsScript,
   ): UnsafeEvalJsValue {
     const { js, filename, sourceMap } = typeof input === "string"
       ? { js: input, filename: "NO-NAME.js" }

packages/js-runtime/eval-runtime.ts

@@ -18,7 +18,7 @@ export interface JsValue {
 // A JS runtime context.
 export interface JsIsolate {
   // Execute `js` within this `JsIsolate`, returning the value.
-  execute(js: string | ExecutableJs): JsValue;
+  execute(js: string | JsScript): JsValue;
 }
 
 // A `JsRuntime` can host several `JsIsolate`s, capable
@@ -48,57 +48,35 @@ export interface TypeDefSource extends Source {
   contents: string;
 }
 
-// A map of filename to typescript source.
-export interface TsArtifact {
-  entry: string;
-  files: Source[];
+export interface Compiler<T> {
+  compile(input: Program | ProgramResolver, options: T): JsScript;
 }
 
-// A transformed (TypeScript) module.
-export interface JsModule {
-  // The generated JS from the source TS.
-  contents: string;
-  // Input source filename.
-  originalFilename: string;
-  // The generated source map definition.
-  sourceMap: SourceMap;
-  // The generated .d.ts source.
-  // Not currently generated, but typechecked
-  typesSrc?: string;
+// A program's entry point with a resolver to
+// resolve other sources used in the program.
+export interface ProgramResolver {
+  entry(): Source;
+  resolveSource(identifier: string): Source | undefined;
 }
 
-export const isJsModule = (value: unknown): value is JsModule =>
-  !!(typeof value === "object" && value &&
-      "originalFilename" in value &&
-      typeof value.originalFilename === "string" &&
-      "contents" in value && typeof value.contents === "string" &&
-      "sourceMap" in value && typeof value.sourceMap === "object" &&
-      value.sourceMap &&
-      "typesSrc" in value
-    ? typeof value.typesSrc === "string"
-    : true);
-
-// A collection of JS modules with an entry point.
-export interface JsArtifact {
+// An entry point and its sources for a program.
+export interface Program {
   entry: string;
-  modules: Record<string, JsModule>;
+  files: Source[];
+}
+
+export function isProgram(value: unknown): value is Program {
+  return !!value && typeof value === "object" && "entry" in value &&
+    typeof value.entry === "string" && "files" in value &&
+    Array.isArray(value.files);
 }
 
 // A ready-to-execute string of JavaScript,
 // with optional metadata.
-export interface ExecutableJs {
+export interface JsScript {
   js: string;
   sourceMap?: SourceMap;
   filename?: string;
 }
 
 export interface SourceMap extends RawSourceMap {}
-
-export const isSourceMap = (value: unknown): value is SourceMap =>
-  !!(value && typeof value === "object" &&
-    "version" in value && value.version === "3" &&
-    "file" in value && typeof value.file === "string" &&
-    "sourceRoot" in value && typeof value.sourceRoot === "string" &&
-    "sources" in value && Array.isArray(value.sources) &&
-    "names" in value && Array.isArray(value.names) &&
-    "mappings" in value && typeof value.mappings === "string");

packages/js-runtime/interface.ts

@@ -1,9 +1,12 @@
 export type {
+  Compiler,
   CompilerError,
-  ExecutableJs,
   JsIsolate,
   JsRuntime,
-  TsArtifact,
+  JsScript,
+  Program,
+  ProgramResolver as ProgramGraph,
+  Source,
 } from "./interface.ts";
 export {
   TypeScriptCompiler,
@@ -14,4 +17,4 @@ export {
   UnsafeEvalJsValue,
   UnsafeEvalRuntime,
 } from "./eval-runtime.ts";
-export { getTypeLibs } from "./utils.ts";
+export { getTypeLibs } from "./typescript/utils.ts";

packages/js-runtime/mod.ts

@@ -77,3 +77,29 @@ function mapIsEmpty(position: MappedPosition): boolean {
   return position.source === null && position.name === null &&
     position.line === null && position.column === null;
 }
+
+export const isSourceMap = (value: unknown): value is SourceMap =>
+  !!(value && typeof value === "object" &&
+    "version" in value && value.version === "3" &&
+    "file" in value && typeof value.file === "string" &&
+    "sourceRoot" in value && typeof value.sourceRoot === "string" &&
+    "sources" in value && Array.isArray(value.sources) &&
+    "names" in value && Array.isArray(value.names) &&
+    "mappings" in value && typeof value.mappings === "string");
+
+// Parses string as a `SourceMap`, or throws if unable.
+export function parseSourceMap(stringMap: string): SourceMap {
+  const sourceMap = JSON.parse(stringMap);
+  if (sourceMap && "version" in sourceMap) {
+    // TypeScript correctly generates `version` as an integer,
+    // but the `source-map-js` library's `RawSourceMap` we use
+    // elsewhere expects `version` to be a string.
+    sourceMap.version = `${sourceMap.version}`;
+  }
+  if (!isSourceMap(sourceMap)) {
+    throw new Error(
+      `Could not parse source map: ${JSON.stringify(sourceMap, null, 2)}`,
+    );
+  }
+  return sourceMap;
+}