ajsc 2.0.0 → 3.0.0

package/src/JSONSchemaConverter.ts

@@ -1,546 +0,0 @@
-import { JSONSchema7, JSONSchema7Definition } from "json-schema";
-import { ConverterOptions, IRNode, SignatureOccurrences } from "./types.js";
-
-/**
- * JSONSchemaConverter converts a JSON Schema (Draft‑07) into an
- * intermediate representation (IR) that can later be transformed
- * into target language code via a language plugin.
- *
- * This implementation now supports internal definitions via both
- * "$defs" and "definitions", and resolves local "$ref" pointers.
- */
-export class JSONSchemaConverter {
-  private ir: IRNode;
-  // The root schema is stored to support reference resolution.
-  private rootSchema: JSONSchema7Definition | null = null;
-  // Keep track of the occurrences of each schema signature and the schema/property names
-  // used to reference the signature.
-  private signatureOccurrences: SignatureOccurrences = new Map();
-
-  get irNode(): IRNode {
-    return this.ir;
-  }
-
-  get signatureOccurrencesMap(): SignatureOccurrences {
-    return this.signatureOccurrences;
-  }
-
-  constructor(
-    schema: JSONSchema7Definition,
-    private opts?: ConverterOptions,
-  ) {
-    if (typeof schema === "object") {
-      schema.title = schema.title || "Root";
-    }
-
-    // Optionally validate the schema.
-    if (this.opts?.validateSchema) {
-      this.validateSchema(schema);
-    }
-
-    // Resolve references (for now, this is a placeholder).
-    const resolvedSchema = this.resolveReferences(schema);
-
-    // Store the root schema (if it is an object) to support local $ref resolution.
-    if (typeof resolvedSchema === "object") {
-      this.rootSchema = resolvedSchema;
-    }
-
-    // Convert the resolved schema to our intermediate representation.
-    let ir = this.convertToIR(resolvedSchema);
-
-    // add calculated signature occurrences by traversing the IR for all object types
-
-    // Apply any custom IR transformation.
-    if (this.opts?.transform) {
-      ir = this.opts.transform(ir);
-    }
-
-    this.ir = ir;
-  }
-
-  private calcObjSignatureOccurrences(
-    schema: JSONSchema7Definition & {
-      type: "object";
-      properties: Record<string, JSONSchema7Definition>;
-    },
-    node: IRNode & { name: string },
-  ): string {
-    // If no path then it's the root object
-    if (!node.path) {
-      return "";
-    }
-
-    const signature = this.getSchemaSignature(schema);
-
-    if (Object.keys(node.properties ?? {}).length === 0) {
-      // empty object - can be extended with options ie: emptyObjectAsUnknown
-      return signature;
-    }
-
-    if (this.signatureOccurrences.has(signature)) {
-      const occurrences = this.signatureOccurrences.get(signature)!;
-      occurrences.total += 1;
-
-      const foundPath = occurrences.occurrences.find(
-        (x) => x.nodePath === node.path,
-      );
-      if (foundPath) {
-        foundPath.count += 1;
-      } else {
-        occurrences.occurrences.push({ node, nodePath: node.path, count: 1 });
-      }
-
-      this.signatureOccurrences.set(signature, occurrences);
-    } else {
-      this.signatureOccurrences.set(signature, {
-        total: 1,
-        occurrences: [{ node, nodePath: node.path, count: 1 }],
-        signature,
-      });
-    }
-
-    return signature;
-  }
-
-  /**
-   * Recursively converts a JSON Schema definition into an IRNode.
-   *
-   * This method now handles $ref resolution (using the root schema),
-   * combinators (oneOf, anyOf, allOf), as well as enums, const, objects,
-   * arrays, and primitives.
-   */
-  private convertSchema(
-    schema: JSONSchema7Definition,
-    ctx: {
-      path: string;
-    },
-  ): IRNode {
-    if (!schema) {
-      // Return an unknown
-      return {
-        type: "null",
-        path: ctx.path,
-      };
-    }
-    // Handle boolean schemas.
-    if (typeof schema === "boolean") {
-      if (schema === true) {
-        // A schema of 'true' accepts any value.
-        return {
-          type: "object",
-          properties: {},
-          path: ctx.path,
-        };
-      } else {
-        throw new Error(
-          "Encountered JSON Schema 'false', which is not supported.",
-        );
-      }
-    }
-
-    // If the schema contains a $ref, resolve it.
-    if (schema.$ref) {
-      const resolved = this.resolveRef(schema);
-      return this.convertSchema(resolved, ctx);
-    }
-
-    // Handle combinators.
-    if (schema.oneOf) {
-      const options = schema.oneOf.map((subSchema) =>
-        this.convertSchema(subSchema, ctx),
-      );
-      return {
-        type: "union",
-        options,
-        constraints: { combinator: "oneOf" },
-        path: ctx.path,
-      };
-    }
-    if (schema.anyOf) {
-      const options = schema.anyOf.map((subSchema) =>
-        this.convertSchema(subSchema, ctx),
-      );
-      return {
-        type: "union",
-        options,
-        constraints: { combinator: "anyOf" },
-        path: ctx.path,
-      };
-    }
-    if (schema.allOf) {
-      const options = schema.allOf.map((subSchema) =>
-        this.convertSchema(subSchema, ctx),
-      );
-      return {
-        type: "intersection",
-        options,
-        path: ctx.path,
-      };
-    }
-
-    // Handle "enum".
-    if (schema.enum) {
-      return {
-        type: "enum",
-        values: schema.enum,
-        path: ctx.path,
-      };
-    }
-
-    // Handle "const".
-    if (schema.const !== undefined) {
-      return {
-        type: "literal",
-        constraints: { value: schema.const },
-        path: ctx.path,
-      };
-    }
-
-    // Process based on the "type" keyword.
-    if (schema.type) {
-      // If multiple types are provided, treat as a union.
-      if (Array.isArray(schema.type)) {
-        const options = schema.type.map((t) =>
-          this.convertSchema({ ...schema, type: t }, ctx),
-        );
-        return {
-          type: "union",
-          options,
-          path: ctx.path,
-        };
-      } else {
-        switch (schema.type) {
-          case "object": {
-            const name = this.getTypeName(schema, ctx);
-
-            const node: IRNode & {
-              name: string;
-              properties: {};
-              type: "object";
-            } = {
-              type: "object",
-              properties: {},
-              path: ctx.path,
-              name,
-            };
-
-            if (schema.properties) {
-              for (const key in schema.properties) {
-                const propSchema = schema.properties[key];
-
-                let child = this.convertSchema(propSchema, {
-                  path: ctx.path ? `${ctx.path}.${key}` : key,
-                });
-
-                // Mark the property as required if listed in the "required" array.
-                child.required = schema.required
-                  ? schema.required.includes(key)
-                  : false;
-                node.properties![key] = child;
-              }
-            }
-
-            if (schema.additionalProperties) {
-              /**
-               * Json-schema additionalProperties have unknown keys.
-               * @example json-schema
-               * {
-               *   "additionalProperties": {
-               *     "type": "object",
-               *     "properties": {
-               *       "profile": {
-               *         "type": "string"
-               *       }
-               *     },
-               *     "required": [
-               *       "profile"
-               *     ]
-               *   },
-               *   "type": "object",
-               *   "properties": {
-               *     "id": {
-               *       "type": "string"
-               *     }
-               *   },
-               *   "required": [
-               *     "id"
-               *   ]
-               * }
-               */
-              node.additionalProperties = this.convertSchema(
-                schema.additionalProperties,
-                {
-                  // The "*" indicates an any/unknown key
-                  path: ctx.path ? `${ctx.path}.*` : "*",
-                },
-              );
-            }
-
-            if (schema.patternProperties) {
-              /**
-               * Json-schema patternProperties are not directly supported in most languages.
-               * We mark each property key as
-               * @example json-schema
-               * {
-               *   "type": "object",
-               *   "patternProperties": {
-               *     "^(.*)$": {
-               *       "type": "object",
-               *       "properties": {
-               *         "name": {
-               *           "type": "string"
-               *         },
-               *         "email": {
-               *           "type": "string"
-               *         }
-               *       },
-               *       "required": [
-               *         "name",
-               *         "email"
-               *       ]
-               *     }
-               *   }
-               * }
-               */
-              const propertySchemas = Object.values(schema.patternProperties);
-
-              if (propertySchemas.length > 1) {
-                // if multiple patternProperties, treat as a union of the property types.
-                node.additionalProperties = this.convertSchema(
-                  {
-                    anyOf: propertySchemas,
-                  },
-                  {
-                    // The "*" indicates an any/unknown key
-                    path: ctx.path ? `${ctx.path}.*` : "*",
-                  },
-                );
-              } else {
-                // else just convert the single property schema
-                node.additionalProperties = this.convertSchema(
-                  propertySchemas[0],
-                  {
-                    // The "*" indicates an any/unknown key
-                    path: ctx.path ? `${ctx.path}.*` : "*",
-                  },
-                );
-              }
-            }
-
-            node.signature = this.calcObjSignatureOccurrences(
-              schema as JSONSchema7 & {
-                type: "object";
-                properties: Record<string, JSONSchema7Definition>;
-              },
-              node,
-            );
-
-            return node;
-          }
-          case "array": {
-            const name = this.getTypeName(schema, ctx);
-
-            const node: IRNode & { name: string } = {
-              type: "array",
-              path: ctx.path,
-              name,
-            };
-
-            if (schema.items) {
-              if (Array.isArray(schema.items)) {
-                // For tuple validation, treat as a union of the item types.
-                const options = schema.items.map((item, i) =>
-                  this.convertSchema(item, ctx),
-                );
-                node.items = { type: "union", options, path: ctx.path };
-              } else {
-                node.items = this.convertSchema(schema.items, {
-                  path: ctx.path ? `${ctx.path}.0` : "0",
-                });
-              }
-            }
-            return node;
-          }
-          case "string":
-          case "number":
-          case "integer":
-          case "boolean":
-          case "null": {
-            const node: IRNode = { type: schema.type, path: ctx.path };
-            node.constraints = {};
-            if (schema.pattern) node.constraints.pattern = schema.pattern;
-            if (schema.minLength !== undefined)
-              node.constraints.minLength = schema.minLength;
-            if (schema.maxLength !== undefined)
-              node.constraints.maxLength = schema.maxLength;
-            if (schema.minimum !== undefined)
-              node.constraints.minimum = schema.minimum;
-            if (schema.maximum !== undefined)
-              node.constraints.maximum = schema.maximum;
-            return node;
-          }
-          default:
-            throw new Error(
-              `Unsupported schema type: ${schema.type} - ${JSON.stringify(schema)}`,
-            );
-        }
-      }
-    }
-
-    // Fallback: if no type is provided, assume an object.
-    return { type: "object", properties: {}, path: ctx.path };
-  }
-
-  /**
-   * Converts a JSON Schema definition to an IRNode.
-   */
-  public convertToIRSchema(schema: JSONSchema7Definition): IRNode {
-    // reset the root schema
-    this.rootSchema = null;
-
-    // Optionally validate the schema.
-    if (this.opts?.validateSchema) {
-      this.validateSchema(schema);
-    }
-
-    // Resolve references (for now, this is a placeholder).
-    const resolvedSchema = this.resolveReferences(schema);
-
-    // Store the root schema (if it is an object) to support local $ref resolution.
-    if (typeof resolvedSchema === "object") {
-      this.rootSchema = resolvedSchema;
-    }
-
-    // Convert the resolved schema to our intermediate representation.
-    let ir = this.convertToIR(resolvedSchema);
-
-    // Apply any custom IR transformation.
-    if (this.opts?.transform) {
-      ir = this.opts.transform(ir);
-    }
-
-    return ir;
-  }
-
-  private validateSchema(schema: JSONSchema7Definition): void {
-    // Implement or integrate with a JSON Schema validator if desired.
-    // For now, we assume the schema is valid.
-  }
-
-  /**
-   * A placeholder for reference resolution. In a more advanced implementation,
-   * this method might inline external references or perform more complex processing.
-   * ie: fetching a remote/url $def
-   */
-  private resolveReferences(
-    schema: JSONSchema7Definition,
-  ): JSONSchema7Definition {
-    // For this implementation, simply return the schema unchanged.
-    return schema;
-  }
-
-  private convertToIR(schema: JSONSchema7Definition): IRNode {
-    return this.convertSchema(schema, { path: "" });
-  }
-
-  private getNameFromPath(path: string): string | undefined {
-    // ignore numbers
-    const split = path.split(".").filter((x) => !x.match(/^\d+$/));
-
-    return split[split.length - 1] || undefined;
-  }
-
-  private getNextObjectSequence(): number {
-    return this.signatureOccurrences.size;
-  }
-
-  private getParentNameFromPath(path: string): string | undefined {
-    const split = path.split(".").filter((x) => !x.match(/^\d+$/));
-    // ignore numbers
-    return split[split.length - 2] || undefined;
-  }
-
-  /**
-   * Generates a unique signature for a schema.
-   * Uses a stable JSON.stringify that sorts keys to ensure that
-   * semantically equivalent schemas produce the same string.
-   */
-  private getSchemaSignature(schema: JSONSchema7Definition): string {
-    function sortKeys(obj: any): any {
-      if (typeof obj !== "object" || obj === null) return obj;
-      if (Array.isArray(obj)) return obj.map(sortKeys);
-      const sorted: any = {};
-      Object.keys(obj)
-        .sort()
-        .forEach((key) => {
-          sorted[key] = sortKeys(obj[key]);
-        });
-      return sorted;
-    }
-    return this.simpleHash(JSON.stringify(sortKeys(schema))).toString();
-  }
-
-  private getTypeName(schema: JSONSchema7, ctx: { path: string }): string {
-    return (
-      schema.title ||
-      this.getNameFromPath(ctx.path) ||
-      `Object${this.getNextObjectSequence()}`
-    );
-  }
-
-  /**
-   * Resolves a local $ref using the stored root schema.
-   *
-   * This method expects local references (starting with "#/") and uses a simple
-   * JSON Pointer resolution algorithm.
-   */
-  private resolveRef(schema: JSONSchema7): JSONSchema7Definition {
-    if (!schema.$ref) return schema as unknown as JSONSchema7Definition;
-    if (!this.rootSchema || typeof this.rootSchema !== "object") {
-      throw new Error("Root schema not available for reference resolution.");
-    }
-    const ref = schema.$ref;
-    if (!ref.startsWith("#/")) {
-      throw new Error(
-        `Only local references are supported. Encountered: ${ref}`,
-      );
-    }
-    return this.resolvePointer(ref, this.rootSchema);
-  }
-
-  /**
-   * Resolves a JSON Pointer (RFC 6901) within the given document.
-   *
-   * @param pointer A JSON Pointer string (e.g., "#/definitions/Foo" or "#/$defs/Bar")
-   * @param document The root document object.
-   */
-  private resolvePointer(pointer: string, document: any): any {
-    // Remove the leading '#' character.
-    if (pointer[0] === "#") {
-      pointer = pointer.substring(1);
-    }
-    if (!pointer) return document;
-    // Split the pointer by "/" and filter out empty parts.
-    const parts = pointer.split("/").filter((part) => part);
-    let current = document;
-    for (const part of parts) {
-      // Unescape any "~1" to "/" and "~0" to "~".
-      const unescaped = part.replace(/~1/g, "/").replace(/~0/g, "~");
-      current = current[unescaped];
-      if (current === undefined) {
-        throw new Error(`Reference "${pointer}" not found in document.`);
-      }
-    }
-    return current;
-  }
-
-  private simpleHash(str: string) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      hash = (hash << 5) - hash + str.charCodeAt(i);
-      hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-  }
-}

package/src/Typebox.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { JSONSchemaConverter } from "./JSONSchemaConverter.js";
-import { Type } from "@sinclair/typebox";
-
-describe("Typebox to IRNode Test", () => {
-  it("should convert strings", () => {
-    expect(new JSONSchemaConverter(Type.String()).irNode.type).toMatch(
-      "string",
-    );
-  });
-
-  it("should convert numbers", () => {
-    expect(new JSONSchemaConverter(Type.Number()).irNode.type).toMatch(
-      "number",
-    );
-  });
-
-  it("should convert booleans", () => {
-    expect(new JSONSchemaConverter(Type.Boolean()).irNode.type).toMatch(
-      "boolean",
-    );
-  });
-
-  it("should convert null", () => {
-    expect(new JSONSchemaConverter(Type.Null()).irNode.type).toMatch("null");
-  });
-
-  it("should convert literals", () => {
-    expect(
-      new JSONSchemaConverter(Type.Literal("fixedValue")).irNode,
-    ).toMatchObject({ type: "literal", constraints: { value: "fixedValue" } });
-  });
-
-  it("should convert enums", () => {
-    expect(
-      new JSONSchemaConverter(
-        Type.Enum({ Value1: "value1", Value2: "value2", Value3: "value3" }),
-      ).irNode,
-    ).toMatchObject({
-      type: "union",
-      options: [
-        { type: "literal", constraints: { value: "value1" } },
-        { type: "literal", constraints: { value: "value2" } },
-        { type: "literal", constraints: { value: "value3" } },
-      ],
-    });
-  });
-
-  it("should convert Record", () => {
-    expect(
-      new JSONSchemaConverter(
-        Type.Record(
-          Type.String(),
-          Type.Object({
-            name: Type.String(),
-            email: Type.String(),
-          }),
-        ),
-      ).irNode,
-    ).toMatchObject({
-      type: "object",
-      additionalProperties: {
-        type: "object",
-        properties: {
-          name: {
-            type: "string",
-            path: "*.name",
-            constraints: {},
-            required: true,
-          },
-          email: {
-            type: "string",
-            path: "*.email",
-            constraints: {},
-            required: true,
-          },
-        },
-      },
-    });
-  });
-
-  it("should convert unions", () => {
-    expect(
-      new JSONSchemaConverter(Type.Union([Type.String(), Type.Number()]))
-        .irNode,
-    ).toMatchObject({
-      type: "union",
-      options: [{ type: "string" }, { type: "number" }],
-    });
-  });
-
-  it("should convert composite unions", () => {
-    expect(
-      new JSONSchemaConverter(
-        Type.Composite([
-          Type.Object({ a: Type.String() }),
-          Type.Object({ b: Type.Number() }),
-        ]),
-      ).irNode,
-    ).toMatchObject({
-      type: "object",
-      properties: {
-        a: { type: "string", path: "a", required: true },
-        b: { type: "number", path: "b", required: true },
-      },
-    });
-  });
-
-  it("should convert intersections", () => {
-    expect(
-      new JSONSchemaConverter(Type.Intersect([Type.String(), Type.Number()]))
-        .irNode,
-    ).toMatchObject({
-      type: "intersection",
-      options: [{ type: "string" }, { type: "number" }],
-    });
-  });
-
-  it("should convert arrays", () => {
-    expect(
-      new JSONSchemaConverter(Type.Array(Type.String())).irNode,
-    ).toMatchObject({
-      type: "array",
-      items: { type: "string" },
-    });
-  });
-});