ajsc 1.0.0

package/src/TypescriptConverter.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect } from "vitest";
+import { TypescriptConverter } from "./TypescriptConverter.js";
+
+describe("TypeScriptLanguagePlugin", () => {
+  it("should convert strings", () => {
+    expect(new TypescriptConverter({ type: "string" }).code).toMatch("string");
+  });
+
+  it("should convert numbers", () => {
+    expect(new TypescriptConverter({ type: "number" }).code).toMatch("number");
+  });
+
+  it("should convert booleans", () => {
+    expect(new TypescriptConverter({ type: "boolean" }).code).toMatch(
+      "boolean",
+    );
+  });
+
+  it("should convert null", () => {
+    expect(new TypescriptConverter({ type: "null" }).code).toMatch("null");
+  });
+
+  it("should convert literals", () => {
+    expect(new TypescriptConverter({ const: "fixedValue" }).code).toMatch(
+      "fixedValue",
+    );
+  });
+
+  it("should convert enums", () => {
+    expect(
+      new TypescriptConverter({
+        type: "string",
+        enum: ["value1", "value2", "value3"],
+      }).code,
+    ).toMatch(`"value1" | "value2" | "value3"`);
+  });
+
+  it("should convert unions", () => {
+    expect(
+      new TypescriptConverter({ type: ["string", "number"] }).code,
+    ).toMatch(`string | number`);
+  });
+
+  it("should convert intersections", () => {
+    expect(
+      new TypescriptConverter({
+        allOf: [{ type: "string" }, { type: "number" }],
+      }).code,
+    ).toMatch(`string & number`);
+  });
+
+  it("should convert arrays", () => {
+    expect(
+      new TypescriptConverter({
+        type: "array",
+        items: { type: "string" },
+      }).code,
+    ).toMatch(`Array<string>`);
+  });
+
+  it("should convert objects", () => {
+    expect(
+      new TypescriptConverter({
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          year: { type: "number" },
+        },
+        required: ["title"],
+      }).code,
+    ).toMatch(`{ title: string; year?: number; }`);
+  });
+
+  it("should convert an array of objects", () => {
+    expect(
+      new TypescriptConverter(
+        {
+          type: "array",
+          items: {
+            anyOf: [
+              {
+                type: "object",
+                properties: {
+                  year: { type: "number" },
+                },
+                required: ["year"],
+              },
+              {
+                type: "object",
+                properties: {
+                  title: { type: "string" },
+                },
+              },
+            ],
+          },
+        },
+        {
+          inlineTypes: true,
+        },
+      ).code,
+    ).toMatch(`Array<{ year: number; } | { title?: string; }>`);
+  });
+
+  it("should convert a simple JSON schema to Typescript", () => {
+    expect(
+      new TypescriptConverter(
+        {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            age: { type: "number" },
+            contacts: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  email: { type: "string" },
+                },
+                required: ["email"],
+              },
+            },
+            profile: {
+              type: "object",
+              properties: {
+                email: { type: "string" },
+              },
+              required: ["email"],
+            },
+          },
+          required: ["name", "age"],
+        },
+        {
+          inlineTypes: true,
+        },
+      ).code.replace(/\s/g, ""),
+    ).toMatch(
+      `{
+      name: string;
+      age: number;
+      contacts?: Array<{ email: string; }>;
+      profile?: { email: string; };
+    }`.replace(/\s/g, ""),
+    );
+  });
+
+  it("should convert a named JSON schema top-level object to Typescript", () => {
+    expect(
+      new TypescriptConverter(
+        {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          title: "Person",
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            age: { type: "number" },
+            contacts: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  email: { type: "string" },
+                },
+                required: ["email"],
+              },
+            },
+            profile: {
+              type: "object",
+              properties: {
+                email: { type: "string" },
+              },
+              required: ["email"],
+            },
+          },
+          required: ["name", "age"],
+        },
+        {
+          inlineTypes: true,
+        },
+      ).code.replace(/\s/g, ""),
+    ).toEqual(
+      `{ name: string; age: number; contacts?: Array<{ email: string; }>; profile?: { email: string; }; }`.replace(
+        /\s/g,
+        "",
+      ),
+    );
+  });
+
+  it("should convert a named JSON schema top-level array to Typescript", () => {
+    expect(
+      new TypescriptConverter(
+        {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          title: "People",
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              age: { type: "number" },
+            },
+            required: ["name", "age"],
+          },
+        },
+        {
+          inlineTypes: true,
+        },
+      ).code.replace(/\s/g, ""),
+    ).toEqual(`Array<{ name: string; age: number; }>`.replace(/\s/g, ""));
+  });
+
+  it("should convert JSON schema with top-level re-used objects in Typescript", async () => {
+    expect(
+      new TypescriptConverter(
+        {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          title: "Person",
+          type: "object",
+          properties: {
+            contacts: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  email: { type: "string" },
+                },
+                required: ["email"],
+              },
+            },
+            profile: {
+              type: "object",
+              properties: {
+                email: { type: "string" },
+              },
+              required: ["email"],
+            },
+            contact: {
+              type: "object",
+              properties: {
+                email: { type: "string" },
+              },
+              required: ["email"],
+            },
+            email: {
+              type: "object",
+              properties: {
+                email: { type: "string" },
+              },
+              required: ["email"],
+            },
+          },
+          required: ["name", "age"],
+        },
+        {
+          inlineTypes: true,
+        },
+      ).code.replace(/\s/g, ""),
+    ).toEqual(
+      `{contacts?:Array<{email:string;}>;profile?:{email:string;};contact?:{email:string;};email?:{email:string;};}`.replace(
+        /\s/g,
+        "",
+      ),
+    );
+  });
+});

package/src/TypescriptConverter.ts

@@ -0,0 +1,161 @@
+import { IRNode, LanguagePlugin } from "./types.js";
+import {
+  RefTypeName,
+  RefTypes,
+  TypescriptBaseConverter,
+} from "./TypescriptBaseConverter.js";
+import { JSONSchema7Definition } from "json-schema";
+import { JSONSchemaConverter } from "./JSONSchemaConverter.js";
+import { PathUtils } from "./utils/path-utils.js";
+import { toPascalCase } from "./utils/to-pascal-case.js";
+
+/**
+ * A TypeScript language converter plugin.
+ */
+export class TypescriptConverter
+  extends TypescriptBaseConverter
+  implements LanguagePlugin
+{
+  public readonly language = "typescript";
+
+  private ir: JSONSchemaConverter;
+  private refTypes: RefTypes = [];
+
+  readonly code: string;
+
+  constructor(
+    schema: JSONSchema7Definition,
+    opts?: {
+      /**
+       * If true, referenced types will not be created for objects and instead
+       * the object type will be inlined.
+       */
+      inlineTypes?: boolean;
+    },
+  ) {
+    super();
+
+    this.ir = new JSONSchemaConverter(schema);
+
+    const code = this.generateType(this.ir.irNode, {
+      getReferencedType: opts?.inlineTypes
+        ? () => undefined
+        : this.getReferencedType.bind(this),
+    });
+
+    const rootName = this.ir.irNode.name ? this.ir.irNode.name : "Root";
+
+    this.code = `${this.refTypes
+      .map(([sig, name, { code }]) => `export type ${name} = ${code}`)
+      .join("\n")}
+      
+      ${code}`;
+  }
+
+  private getUniqueRefTypeName(
+    signature: string,
+    nodePath: string,
+  ): RefTypeName {
+    const path = PathUtils.parsePath(nodePath);
+
+    // if the path ends in "0" it's an array item
+    const isArrayItem = nodePath.split(".").slice(-1)[0] === "0";
+
+    const postFixes = [
+      "Type",
+      "Element",
+      "Schema",
+      "Object",
+      "Shape",
+      "1",
+      "2",
+      "3",
+      "4",
+      "5",
+      "6",
+    ];
+
+    if (isArrayItem) {
+      postFixes.unshift("Item");
+    } else {
+      postFixes.unshift("");
+    }
+
+    let pathsSegmentsToInclude = 1;
+    let name = "";
+    let postFixIndexToTry = 0;
+
+    while (!name) {
+      const proposedName =
+        path.slice(-pathsSegmentsToInclude).map(toPascalCase).join("") +
+        postFixes[postFixIndexToTry];
+
+      const foundSignatureMatch = this.refTypes.find(([sig, name]) => {
+        return sig === signature && name === proposedName;
+      });
+
+      if (foundSignatureMatch) {
+        return foundSignatureMatch[1];
+      }
+
+      const nameAlreadyUsed = this.refTypes.find(([_, name]) => {
+        return name === proposedName;
+      });
+
+      if (nameAlreadyUsed) {
+        pathsSegmentsToInclude++;
+
+        if (pathsSegmentsToInclude >= path.length) {
+          // we're out of unique paths, increment a postfix and start the loop again
+          postFixIndexToTry++;
+          pathsSegmentsToInclude = 1;
+
+          // absolute fallback that should never/very-rarely happen
+          if (postFixIndexToTry === postFixes.length) {
+            name = proposedName + Math.floor(Math.random() * 1000);
+          }
+        }
+      } else {
+        name = proposedName;
+      }
+    }
+
+    return name;
+  }
+
+  protected getReferencedType(ir: IRNode): string | undefined {
+    const signature = ir.signature;
+
+    if (!signature) {
+      return undefined;
+    }
+
+    const name = this.getUniqueRefTypeName(signature, ir.path);
+
+    // account for recursion, the ref type could have already been created
+    if (
+      this.refTypes.find(([sig, _name]) => sig === signature && _name === name)
+    ) {
+      return name;
+    }
+
+    // push the sig/name pair to the refTypes array for recursion to avoid duplicates
+    this.refTypes.push([
+      signature,
+      name,
+      {
+        code: "",
+      },
+    ]);
+
+    const code = this.generateObjectType(ir, {
+      getReferencedType: this.getReferencedType.bind(this),
+    });
+
+    this.refTypes.find(
+      ([sig, _name]) => sig === signature && _name === name,
+    )![2].code = code;
+
+    return name;
+  }
+}

package/src/TypescriptProcedureConverter.ts

@@ -0,0 +1,160 @@
+import { IRNode, SignatureOccurrenceValue } from "./types.js";
+import { JSONSchema7Definition } from "json-schema";
+import { JSONSchemaConverter } from "./JSONSchemaConverter.js";
+import {RefTypeName, RefTypes, TypescriptBaseConverter} from "./TypescriptBaseConverter.js";
+import { PathUtils } from "./utils/path-utils.js";
+import { toPascalCase } from "./utils/to-pascal-case.js";
+
+/**
+ * A TypeScript language converter plugin that implements namespace scoping.
+ *
+ * Referenced/Shared typings are moved to the top level of the namespace scope
+ * that is created for each IR node.
+ */
+export class TypescriptProcedureConverter extends TypescriptBaseConverter {
+  private ir: { args: JSONSchemaConverter; data: JSONSchemaConverter };
+  private refTypes: RefTypes = [];
+
+  readonly code: string;
+
+  constructor(
+    scopeName: string,
+    rpcJsonSchemas: {
+      args: JSONSchema7Definition;
+      data: JSONSchema7Definition;
+    },
+  ) {
+    super();
+
+    this.ir = {
+      args: new JSONSchemaConverter(rpcJsonSchemas.args),
+      data: new JSONSchemaConverter(rpcJsonSchemas.data),
+    };
+
+    const argsCode = this.generateObjectType(this.ir.args.irNode, {
+      getReferencedType: this.getReferencedType.bind(this),
+    });
+    const dataCode = this.generateObjectType(this.ir.data.irNode, {
+      getReferencedType: this.getReferencedType.bind(this),
+    });
+
+    this.code = `export namespace ${scopeName} {
+        export interface Args ${argsCode}
+        
+        export interface Data ${dataCode}
+        
+        ${this.refTypes
+          .map(([sig, name, { code }]) => `export type ${name} = ${code}`)
+          .join("\n")}
+    }`;
+  }
+
+  private getUniqueRefTypeName(
+    signature: string,
+    nodePath: string,
+  ): RefTypeName {
+    const path = PathUtils.parsePath(nodePath);
+
+    // if the path ends in "0" it's an array item
+    const isArrayItem = nodePath.split(".").slice(-1)[0] === "0";
+
+    const postFixes = [
+      "Type",
+      "Element",
+      "Schema",
+      "Object",
+      "Shape",
+      "1",
+      "2",
+      "3",
+      "4",
+      "5",
+      "6",
+    ];
+
+    if (isArrayItem) {
+      postFixes.unshift("Item");
+      // remove pluralization from the last segment
+      path[path.length - 1] = path[path.length - 1].replace(/s$/, "");
+    } else {
+      postFixes.unshift("");
+    }
+
+    let pathsSegmentsToInclude = 1;
+    let name = "";
+    let postFixIndexToTry = 0;
+
+    while (!name) {
+      const proposedName =
+        path.slice(-pathsSegmentsToInclude).map(toPascalCase).join("") +
+        postFixes[postFixIndexToTry];
+
+      const foundSignatureMatch = this.refTypes.find(([sig, name]) => {
+        return sig === signature && name === proposedName;
+      });
+
+      if (foundSignatureMatch) {
+        return foundSignatureMatch[1];
+      }
+
+      const nameAlreadyUsed = this.refTypes.find(([_, name]) => {
+        return name === proposedName;
+      });
+
+      if (nameAlreadyUsed) {
+        pathsSegmentsToInclude++;
+
+        if (pathsSegmentsToInclude >= path.length) {
+          // we're out of unique paths, increment a postfix and start the loop again
+          postFixIndexToTry++;
+          pathsSegmentsToInclude = 1;
+
+          // absolute fallback that should never/very-rarely happen
+          if (postFixIndexToTry === postFixes.length) {
+            name = proposedName + Math.floor(Math.random() * 1000);
+          }
+        }
+      } else {
+        name = proposedName;
+      }
+    }
+
+    return name;
+  }
+
+  protected getReferencedType(ir: IRNode): string | undefined {
+    const signature = ir.signature;
+
+    if (!signature) {
+      return undefined;
+    }
+
+    const name = this.getUniqueRefTypeName(signature, ir.path);
+
+    // account for recursion, the ref type could have already been created
+    if (
+      this.refTypes.find(([sig, _name]) => sig === signature && _name === name)
+    ) {
+      return name;
+    }
+
+    // push the sig/name pair to the refTypes array for recursion to avoid duplicates
+    this.refTypes.push([
+      signature,
+      name,
+      {
+        code: "",
+      },
+    ]);
+
+    const code = this.generateObjectType(ir, {
+      getReferencedType: this.getReferencedType.bind(this),
+    });
+
+    this.refTypes.find(
+      ([sig, _name]) => sig === signature && _name === name,
+    )![2].code = code;
+
+    return name;
+  }
+}