chore: reworking CLI + import specifiers

codegen.ts

@@ -1,22 +1,78 @@
-import { run } from "./codegen/mod.ts";
+import { codegen } from "./codegen/mod.ts";
+import { Config } from "./config/mod.ts";
 import { parse } from "./deps/std/flags.ts";
+import * as path from "./deps/std/path.ts";
+import { unimplemented } from "./deps/std/testing/asserts.ts";
+import * as M from "./frame_metadata/mod.ts";
+import { proxyClient } from "./rpc/providers/proxy.ts";
+import * as U from "./util/mod.ts";
 
 const args = parse(Deno.args, {
-  string: ["metadata", "output"],
+  string: ["src", "out", "import"],
   boolean: ["help"],
+  default: {
+    import: "deno",
+  },
   alias: {
-    metadata: ["m"],
-    output: ["out", "o"],
+    src: ["s"],
+    out: ["o"],
     help: ["h", "?"],
   },
 });
 
-if (args.help) {
-  console.log("Usage: codegen --metadata <file> --output <dir>");
-  Deno.exit(0);
+if (args.help) help();
+if (!args.src) fail();
+if (!args.out) fail();
+
+await codegen({
+  importSpecifier: args.import === "npm"
+    ? "capi"
+    : args.import === "deno"
+    ? "https://deno.land/x/capi/mod.ts"
+    : args.import,
+  metadata: await getMetadata(args.src),
+  outDir: args.out,
+}).write();
+
+async function getMetadata(src: string): Promise<M.Metadata> {
+  if (src.startsWith("ws")) {
+    const client = U.throwIfError(await proxyClient(new Config(() => src, undefined!)));
+    const metadata = U.throwIfError(await client.call("state_getMetadata", []));
+    U.throwIfError(await client.close());
+    if (metadata.error) fail();
+    return M.fromPrefixedHex(metadata.result);
+  } else if (path.isAbsolute(src)) {
+    return await loadMetadata(src);
+  } else {
+    try {
+      return await loadMetadata(path.fromFileUrl(src));
+    } catch (_e) {
+      unimplemented();
+    }
+  }
 }
 
-if (!args.metadata) throw new Error("Must specify metadata file");
-if (!args.output) throw new Error("Must specify output dir");
+async function loadMetadata(src: string) {
+  const ext = path.extname(src);
+  switch (ext) {
+    case ".scale": {
+      return M.fromPrefixedHex(await Deno.readTextFile(src));
+    }
+    case ".json": {
+      return unimplemented();
+    }
+    default:
+      fail();
+  }
+}
 
-run(args.metadata, args.output);
+// TODO: error message + correct usage suggestion
+function fail(): never {
+  Deno.exit();
+}
+
+// TODO: do we handle help differently depending on what flags were specified?
+function help(): never {
+  console.log("Usage: codegen --metadata <file> --output <dir>");
+  Deno.exit();
+}

codegen/Files.ts

@@ -0,0 +1,36 @@
+import { tsFormatter } from "../deps/dprint.ts";
+import * as path from "../deps/std/path.ts";
+import { S } from "./utils.ts";
+
+export type File = { getContent: () => S };
+export class Files extends Map<string, File> {
+  constructor(readonly outDir: string) {
+    super();
+  }
+
+  write = async () => {
+    const errors = [];
+    try {
+      await Deno.remove(this.outDir, { recursive: true });
+    } catch (e) {
+      if (!(e instanceof Deno.errors.NotFound)) {
+        throw e;
+      }
+    }
+    await Deno.mkdir(this.outDir, { recursive: true });
+    for (const [relativePath, file] of this.entries()) {
+      const outputPath = path.join(this.outDir, relativePath);
+      const content = S.toString(file.getContent());
+      try {
+        const formatted = tsFormatter.formatText("gen.ts", content);
+        await Deno.writeTextFile(outputPath, formatted);
+      } catch (e) {
+        await Deno.writeTextFile(outputPath, content);
+        errors.push(e);
+      }
+    }
+    if (errors.length) {
+      throw errors;
+    }
+  };
+}

codegen/codecVisitor.ts

@@ -1,28 +1,30 @@
+import * as path from "../deps/std/path.ts";
 import * as M from "../frame_metadata/mod.ts";
-import { Decl, Files, getCodecPath, getName, getRawCodecPath, importSource, S } from "./utils.ts";
+import { Files } from "./Files.ts";
+import { CodegenProps } from "./mod.ts";
+import { Decl, getCodecPath, getName, getRawCodecPath, S } from "./utils.ts";
 
 export function createCodecVisitor(
-  tys: M.Ty[],
+  props: CodegenProps,
   decls: Decl[],
   typeVisitor: M.TyVisitor<S>,
   files: Files,
 ) {
-  ["import { $, $null, $era } from", S.string(importSource)];
+  const { tys } = props.metadata;
   const namespaceImports = new Set<string>();
   const codecs: S[] = [];
-
   files.set("codecs.ts", {
     getContent: () => [
       "\n",
       [
         "import { ChainError, BitSequence, Era, $, $era, $null } from",
-        S.string(importSource),
+        S.string(path.relative(props.outDir, props.importSpecifier)),
       ],
       [`import type * as t from "./mod.ts"`],
       ...codecs,
       [
         "export const _all: $.AnyCodec[] =",
-        S.array(tys.map((ty) => getName(getRawCodecPath(ty)))),
+        S.array(props.metadata.tys.map((ty) => getName(getRawCodecPath(ty)))),
       ],
     ],
   });

codegen/mod.ts

@@ -1,71 +1,41 @@
-import { tsFormatter } from "../deps/dprint.ts";
 import * as path from "../deps/std/path.ts";
 import * as M from "../frame_metadata/mod.ts";
 import { createCodecVisitor } from "./codecVisitor.ts";
+import { Files } from "./Files.ts";
 import { genMetadata } from "./genMetadata.ts";
 import { createTypeVisitor } from "./typeVisitor.ts";
-import { Decl, Files, importSource, printDecls, S } from "./utils.ts";
+import { Decl, printDecls, S } from "./utils.ts";
 
-export async function run(metadataFile: string, outputDir: string) {
-  const metadata = M.fromPrefixedHex(await Deno.readTextFile(metadataFile));
-  const output = codegen(metadata);
-  await writeOutput(outputDir, output);
+export interface CodegenProps {
+  metadata: M.Metadata;
+  importSpecifier: string;
+  outDir: string;
 }
 
-export async function writeOutput(outputDir: string, output: Files) {
-  const errors = [];
-  try {
-    await Deno.remove(outputDir, { recursive: true });
-  } catch (e) {
-    if (!(e instanceof Deno.errors.NotFound)) {
-      throw e;
-    }
-  }
-  await Deno.mkdir(outputDir, { recursive: true });
-  for (const [relativePath, file] of output.entries()) {
-    const outputPath = path.join(outputDir, relativePath);
-    const content = S.toString(file.getContent());
-    try {
-      const formatted = tsFormatter.formatText("gen.ts", content);
-      await Deno.writeTextFile(outputPath, formatted);
-    } catch (e) {
-      await Deno.writeTextFile(outputPath, content);
-      errors.push(e);
-    }
-  }
-  if (errors.length) {
-    throw errors;
-  }
-}
-
-export function codegen(metadata: M.Metadata): Files {
+export function codegen(props: CodegenProps): Files {
   const decls: Decl[] = [];
-
-  const { tys } = metadata;
-
-  const files: Files = new Map();
-
+  const files = new Files(props.outDir);
   decls.push({
     path: "_",
     code: [
       "\n",
-      ["import { ChainError, BitSequence, Era, $ } from", S.string(importSource)],
+      [
+        "import { ChainError, BitSequence, Era, $ } from",
+        S.string(path.relative(props.outDir, props.importSpecifier)),
+      ],
       [`import * as _codec from "./codecs.ts"`],
       [`export { _metadata }`],
     ],
   });
-
-  const typeVisitor = createTypeVisitor(tys, decls);
-  const codecVisitor = createCodecVisitor(tys, decls, typeVisitor, files);
-
-  for (const ty of metadata.tys) {
+  const typeVisitor = createTypeVisitor(props, decls);
+  const codecVisitor = createCodecVisitor(props, decls, typeVisitor, files);
+  for (const ty of props.metadata.tys) {
     typeVisitor.visit(ty);
     codecVisitor.visit(ty);
   }
-
-  genMetadata(metadata, decls);
-
-  files.set("mod.ts", { getContent: () => printDecls(decls) });
-
+  genMetadata(props.metadata, decls);
+  files.set("mod.ts", {
+    getContent: () => printDecls(decls),
+  });
   return files;
 }

codegen/typeVisitor.ts

@@ -1,7 +1,9 @@
 import * as M from "../frame_metadata/mod.ts";
+import { CodegenProps } from "./mod.ts";
 import { Decl, getName, getPath, makeDocComment, S } from "./utils.ts";
 
-export function createTypeVisitor(tys: M.Ty[], decls: Decl[]) {
+export function createTypeVisitor(props: CodegenProps, decls: Decl[]) {
+  const { tys } = props.metadata;
   return new M.TyVisitor<S>(tys, {
     unitStruct(ty) {
       return addTypeDecl(ty, "null");

codegen/utils.ts

@@ -1,10 +1,5 @@
 import * as M from "../frame_metadata/mod.ts";
 
-export const importSource = new URL("../mod.ts", import.meta.url).toString();
-
-export type File = { getContent: () => S };
-export type Files = Map<string, File>;
-
 export type S = string | number | S[];
 
 export namespace S {

deno.jsonc

@@ -9,7 +9,7 @@
   },
   "lint": {
     "files": {
-      "exclude": ["**/mod.generated.js", "target"],
+      "exclude": ["target"],
       "include": ["."]
     },
     "rules": {
@@ -37,7 +37,6 @@
     "test": "deno task run test_ctx.ts deno test -A --no-check=remote -L=info --ignore=target --parallel",
     "test:update": "deno task test -- -- --update",
     "mdbook:watch": "mdbook watch -o",
-    "bench": "deno bench -A --no-check=remote --unstable",
-    "typegen": "deno task run typegen/typegen.ts"
+    "bench": "deno bench -A --no-check=remote --unstable"
   }
 }

test_util/codegen.ts

@@ -9,13 +9,16 @@ const memo = new Map<TestConfig, Promise<CodegenModule>>();
 export function importCodegen(config: TestConfig) {
   return U.getOr(memo, config, async () => {
     const metadata = U.throwIfError(await C.run(C.metadata(config)));
-    const outputDir = path.join(
+    const outDir = path.join(
       path.dirname(path.fromFileUrl(import.meta.url)),
       "../target/codegen/",
       config.runtimeName,
     );
-    const output = gen.codegen(metadata);
-    await gen.writeOutput(outputDir, output);
-    return await import(path.toFileUrl(path.join(outputDir, "mod.ts")).toString());
+    await gen.codegen({
+      importSpecifier: "./mod.ts",
+      metadata,
+      outDir,
+    }).write();
+    return await import(path.toFileUrl(path.join(outDir, "mod.ts")).toString());
   });
 }

words.txt

@@ -186,3 +186,4 @@ tostring
 framesystem
 statemigration
 xxhash
+chainspec