ajsc 1.0.11 → 3.0.0

package/src/TypescriptConverter.test.ts

@@ -1,275 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { TypescriptConverter } from "./TypescriptConverter.js";
-import { JSONSchemaConverter } from "./JSONSchemaConverter.js";
-import { Type } from "@sinclair/typebox";
-
-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: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-          },
-        },
-        {
-          inlineTypes: true,
-        },
-      ).code.replace(/\s/g, ""),
-    ).toEqual("Array<{name:string;}>".replace(/\s/g, ""));
-  });
-
-  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

@@ -1,161 +0,0 @@
-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

@@ -1,180 +0,0 @@
-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 | undefined;
-    data: JSONSchemaConverter | undefined;
-  };
-  private refTypes: RefTypes = [];
-
-  readonly code: string;
-
-  constructor(
-    scopeName: string,
-    rpcJsonSchemas: {
-      args: JSONSchema7Definition | undefined;
-      data: JSONSchema7Definition | undefined;
-    },
-  ) {
-    super();
-
-    this.ir = {
-      args: rpcJsonSchemas.args
-        ? new JSONSchemaConverter(rpcJsonSchemas.args)
-        : undefined,
-      data: rpcJsonSchemas.data
-        ? new JSONSchemaConverter(rpcJsonSchemas.data)
-        : undefined,
-    };
-
-    const argsCode = this.ir.args
-      ? this.generateType(this.ir.args.irNode, {
-          getReferencedType: this.getReferencedType.bind(this),
-        })
-      : undefined;
-
-    const dataCode = this.ir.data
-      ? this.generateType(this.ir.data.irNode, {
-          getReferencedType: this.getReferencedType.bind(this),
-        })
-      : undefined;
-
-    // use 'type' instead of 'interface' for the generated types because we can get `{} & {}` or `Record<string,string>`
-    this.code = `export namespace ${scopeName} {
-        ${this.refTypes
-          .map(([sig, name, { code }]) => `export type ${name} = ${code}`)
-          .join("\n")}
-          
-        export type Args = ${argsCode ? argsCode : "unknown"}
-        
-        export type Data = ${dataCode ? dataCode : "unknown"}
-    }`;
-  }
-
-  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 if applicable
-      if (path[path.length - 1]) {
-        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;
-  }
-}