feat(typescript): support inlined types (and initialize an AST)

generators/typescript/codegen/package.json

@@ -25,17 +25,20 @@
     "organize-imports": "organize-imports-cli tsconfig.json",
     "depcheck": "depcheck"
   },
-  "devDependencies": {
+  "dependencies": {
     "@fern-api/core-utils": "workspace:*",
     "@fern-api/generator-commons": "workspace:*",
-    "@fern-fern/ir-sdk": "53.8.0",
+    "@fern-fern/ir-sdk": "53.14.0"
+  },
+  "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node": "^18.7.18",
     "depcheck": "^1.4.6",
     "eslint": "^8.56.0",
     "organize-imports-cli": "^0.10.0",
     "prettier": "^2.7.1",
     "typescript": "4.6.4",
-    "vitest": "^2.0.5"
+    "vitest": "^2.0.5",
+    "zod": "^3.22.3"
   }
 }

generators/typescript/codegen/src/ast/AstNode.ts

@@ -0,0 +1,18 @@
+import { AbstractAstNode } from "@fern-api/generator-commons";
+import { Writer } from "./Writer";
+import * as prettier from "prettier";
+
+export abstract class AstNode extends AbstractAstNode {
+    /**
+     * Writes the node to a string.
+     */
+    public toString(): string {
+        const writer = new Writer();
+        this.write(writer);
+        return writer.toString();
+    }
+
+    public toStringFormatted(): string {
+        return prettier.format(this.toString(), { parser: "typescript", tabWidth: 4, printWidth: 120 });
+    }
+}

generators/typescript/codegen/src/ast/CodeBlock.ts

@@ -1,21 +1,18 @@
-import { CodeBlock as CommonCodeBlock } from "@fern-api/generator-commons";
-import { AstNode, Writer } from "../typescript";
+import { AbstractAstNode, CodeBlock as CommonCodeBlock } from "@fern-api/generator-commons";
+import { Writer } from "./Writer";
 
 export declare namespace CodeBlock {
     /* Write arbitrary code */
     type Args = CommonCodeBlock.Arg<Writer>;
 }
 
-export class CodeBlock extends AstNode {
-    private args: CodeBlock.Args;
-
-    public constructor(args: CodeBlock.Args) {
+export class CodeBlock extends AbstractAstNode {
+    public constructor(private readonly arg: CodeBlock.Args) {
         super();
-        this.args = args;
     }
 
     public write(writer: Writer): void {
-        const commonCodeBlock = new CommonCodeBlock(this.args);
+        const commonCodeBlock = new CommonCodeBlock(this.arg);
         return commonCodeBlock.write(writer);
     }
 }

generators/typescript/codegen/src/ast/DocString.ts

@@ -0,0 +1,21 @@
+import { AstNode } from "./AstNode";
+import { CodeBlock } from "./CodeBlock";
+import { Writer } from "./Writer";
+
+export class DocString extends AstNode {
+    public constructor(private readonly docs: string) {
+        super();
+    }
+
+    public write(writer: Writer): void {
+        if (!this.docs.includes("\n")) {
+            writer.writeLine(`/* ${this.docs} */`);
+        } else {
+            writer.writeLine(`/**`);
+            this.docs.split("\n").forEach((line) => {
+                writer.writeLine(` * ${line}`);
+            });
+            writer.writeLine(" */");
+        }
+    }
+}

generators/typescript/codegen/src/ast/Interface.ts

@@ -0,0 +1,79 @@
+import { AstNode } from "./AstNode";
+import { Writer } from "./Writer";
+import { Type } from "./Type";
+import { Reference } from "./Reference";
+import { DocString } from "./DocString";
+
+export declare namespace Interface {
+    interface Args {
+        /* Whether to export */
+        export?: boolean;
+        /* The name of the variable */
+        name: string;
+        /* Properties on the interface */
+        properties: Property[];
+        /* The interfaces that this extends */
+        extends?: Reference[];
+
+        docs?: string;
+    }
+
+    interface Property {
+        /* The name of the property */
+        name: string;
+        /* The type of the property */
+        type: Type;
+        /* Quesiton mark */
+        questionMark?: boolean;
+
+        docs?: string;
+    }
+}
+
+export class Interface extends AstNode {
+    public constructor(private readonly args: Interface.Args) {
+        super();
+    }
+
+    public write(writer: Writer): void {
+        if (this.args.docs != null) {
+            writer.writeNode(new DocString(this.args.docs));
+            writer.writeLine();
+        }
+        if (this.args.export) {
+            writer.write("export ");
+        }
+        writer.write(` interface ${this.args.name}`);
+        if (this.args.extends != null && this.args.extends.length > 0) {
+            const numBaseInterfaces = this.args.extends.length;
+
+            writer.write(` extends `);
+            this.args.extends.forEach((extend, idx) => {
+                writer.writeNode(extend);
+                if (idx < numBaseInterfaces - 1) {
+                    writer.write(", ");
+                } else {
+                    writer.write(" ");
+                }
+            });
+        }
+
+        writer.writeLine("{");
+
+        writer.indent();
+        for (const property of this.args.properties) {
+            if (property.docs != null) {
+                writer.writeNode(new DocString(property.docs));
+            }
+            writer.write(`"${property.name}\"`);
+            if (property.questionMark) {
+                writer.write("?");
+            }
+            writer.write(": ");
+            writer.writeNodeStatement(property.type);
+        }
+        writer.dedent();
+
+        writer.writeLine("}");
+    }
+}

generators/typescript/codegen/src/ast/Namespace.ts

@@ -0,0 +1,60 @@
+import { AstNode } from "./AstNode";
+import { Writer } from "./Writer";
+import { Interface } from "./Interface";
+
+export declare namespace Namespace {
+    interface Args {
+        /* Whether to export */
+        export?: boolean;
+        /* Namespace of the name */
+        name?: string;
+    }
+}
+
+export class Namespace extends AstNode {
+    /**
+     * The ordered elements inside of a namespace
+     */
+    private elements: (Interface | Namespace)[] = [];
+
+    public constructor(private readonly args: Namespace.Args) {
+        super();
+    }
+
+    public addNamespace(interface_: Namespace): void {
+        this.elements.push(interface_);
+    }
+
+    public addInterface(interface_: Interface): void {
+        this.elements.push(interface_);
+    }
+
+    public write(writer: Writer): void {
+        if (this.args.export) {
+            writer.write("export ");
+        }
+
+        let setAmbience = false;
+        if (!writer.isAmbient) {
+            writer.write("declare ");
+            writer.setAmbient(true);
+            setAmbience = true;
+        }
+
+        writer.writeLine(`namespace ${this.args.name} {`);
+
+        writer.indent();
+        for (const element of this.elements) {
+            writer.writeNode(element);
+            writer.writeLine();
+            writer.writeLine();
+        }
+        writer.dedent();
+
+        writer.writeLine(`}`);
+
+        if (setAmbience) {
+            writer.setAmbient(false);
+        }
+    }
+}

generators/typescript/codegen/src/ast/Reference.ts

@@ -0,0 +1,56 @@
+import { assertNever } from "@fern-api/core-utils";
+import { AstNode } from "./AstNode";
+import { Writer } from "./Writer";
+
+export declare namespace Reference {
+    type Args = NamedImport | ModuleImport;
+
+    interface NamedImport {
+        type: "named";
+        /* The package or path to import from  */
+        source: string;
+        /* Name of the reference to import */
+        name: string;
+    }
+
+    interface ModuleImport {
+        type: "module";
+        /* The package or path to import from  */
+        source: string;
+        /* The module to import from */
+        module: string;
+        /**
+         * The path to access the reference from the module.
+         * [module, ...name].join(".") is the reference
+         */
+        name: string[];
+    }
+}
+
+export class Reference extends AstNode {
+    private constructor(public readonly args: Reference.Args) {
+        super();
+    }
+
+    public write(writer: Writer): void {
+        writer.addReference(this);
+        switch (this.args.type) {
+            case "module":
+                writer.write([this.args.module, ...this.args.name].join("."));
+                break;
+            case "named":
+                writer.write(this.args.name);
+                break;
+            default:
+                assertNever(this.args);
+        }
+    }
+
+    public static module(import_: Omit<Reference.ModuleImport, "type">): Reference {
+        return new Reference({ ...import_, type: "module" });
+    }
+
+    public static named(import_: Omit<Reference.NamedImport, "type">): Reference {
+        return new Reference({ ...import_, type: "named" });
+    }
+}