ajsc 1.0.0

package/src/types.ts

@@ -0,0 +1,101 @@
+// A simple example of an intermediate representation for types
+export type IRType =
+  | "string"
+  | "number"
+  | "integer"
+  | "boolean"
+  | "object"
+  | "array"
+  | "null"
+  | "enum"
+  | "union"
+  | "intersection"
+  | "literal";
+
+export interface IRNode {
+  signature?: string;
+  /**
+   * The base type of the IR node.
+   */
+  type: IRType;
+
+  /**
+   * Optional name for the node (useful for objects, enums, etc.).
+   */
+  name?: string;
+
+  /**
+   * Dot notation path to the node in a runtime object.
+   * For example, "user.profile.name".
+   */
+  path: string;
+
+  /**
+   * Indicates whether this property/node is required.
+   * For object properties, this can be derived from the JSON Schema 'required' array.
+   */
+  required?: boolean;
+
+  /**
+   * For object types: a mapping of property names to their IR node definitions.
+   */
+  properties?: { [key: string]: IRNode };
+
+  /**
+   * For array types: the IR node representing the type of items in the array.
+   */
+  items?: IRNode;
+
+  /**
+   * For enum types: a list of allowed literal values.
+   */
+  values?: any[];
+
+  /**
+   * For union or intersection types: an array of candidate IR nodes.
+   * Note: This is used regardless of whether the union originated from a 'oneOf' or an 'anyOf'.
+   */
+  options?: IRNode[];
+
+  /**
+   * Additional constraints such as minimum, maximum, pattern, etc.
+   */
+  constraints?: {
+    [key: string]: any;
+    combinator?: "oneOf" | "anyOf";
+    // Value represents a enum or literal value
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maximum?: number;
+    minimum?: number;
+    value?: any;
+  };
+}
+
+export type SignatureOccurrenceValue = {
+  occurrences: { node: IRNode; nodePath: string; count: number }[];
+  signature: string;
+  total: number;
+};
+
+export type SignatureOccurrences = Map<string, SignatureOccurrenceValue>;
+
+export interface Context {
+  signatureOccurrences: SignatureOccurrences;
+}
+
+export interface LanguagePlugin {
+  /**
+   * The name of the language this plugin converts to (e.g., "typescript", "java", "python").
+   */
+  language: string;
+}
+
+// allow configuration options that affect the conversion process
+export interface ConverterOptions {
+  // For example, whether to perform strict schema validation
+  validateSchema?: boolean;
+  // Any custom transformations on the IR
+  transform?: (ir: IRNode) => IRNode;
+}

package/src/utils/path-utils.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import { PathUtils } from "./path-utils.js";
+import { SignatureOccurrenceValue } from "../types.js";
+
+describe("SignatureOccurrences", () => {
+  describe("parsePaths", () => {
+    it('should parse dot-separated paths and remove "0" segments', () => {
+      const input = ["a.b.c", "x.0.y.z", "1.2.0.3"];
+      const expected = [
+        ["a", "b", "c"],
+        ["x", "y", "z"],
+        ["1", "2", "3"],
+      ];
+      expect(PathUtils.parsePaths(input)).toEqual(expected);
+    });
+
+    it("should handle empty input", () => {
+      expect(PathUtils.parsePaths([])).toEqual([]);
+    });
+  });
+
+  describe("commonSequence", () => {
+    it("should find the longest common prefix among arrays", () => {
+      const input = [
+        ["organizations", "migration", "step", "create_regions"],
+        ["organizations", "migration", "step", "create_location_groups"],
+        ["organizations", "migration", "step", "create_locations"],
+        ["organizations", "migration", "step", "create_locations_bolos"],
+      ];
+      const expected = ["organizations", "migration", "step"];
+      expect(PathUtils.commonSequence(input)).toEqual(expected);
+    });
+
+    it("should find the longest common prefix among arrays", () => {
+      const input = [
+        ["organizations", "migration", "step", "create_regions"],
+        ["org", "migration", "step"],
+        ["organizations", "migration", "step", "create_locations"],
+        ["organizations", "migration", "step", "create_locationsam_bolos"],
+      ];
+      const expected = ["migration", "step"];
+      expect(PathUtils.commonSequence(input)).toEqual(expected);
+    });
+
+    it("should return an empty array for empty input", () => {
+      expect(PathUtils.commonSequence([])).toEqual([]);
+    });
+
+    it("should handle arrays with no common prefix", () => {
+      const input = [
+        ["a", "b", "c"],
+        ["x", "y", "z"],
+        ["1", "2", "3"],
+      ];
+      expect(PathUtils.commonSequence(input)).toEqual([]);
+    });
+  });
+
+  describe("commonSequenceReversed", () => {
+    it("should return the specified number of shared path segments", () => {
+      const input = [
+        ["organizations", "migration", "step", "create_regions"],
+        ["organizations", "migration", "step", "create_user"],
+      ];
+      const expected = ["step"];
+      expect(PathUtils.commonSequenceReversed(input)).toEqual(expected);
+    });
+    it("should return the specified number of deeply shared path segments", () => {
+      const input = [
+        ["organizations", "migration", "step", "create_regions"],
+        ["organizations", "migration", "step"],
+      ];
+      const expected = ["step"];
+      expect(PathUtils.commonSequenceReversed(input)).toEqual(expected);
+    });
+
+    it("should return the specified number of shared path segments", () => {
+      const input = [
+        ["organizations", "migration", "step", "create_regions"],
+        ["organizations", "migration", "step", "create_location_groups"],
+        ["organizations", "migration", "step", "create_locations"],
+        ["organizations", "migration", "step", "create_locations_bolos"],
+      ];
+      const expected = ["migration", "step"];
+      expect(PathUtils.commonSequenceReversed(input, 2)).toEqual(expected);
+    });
+
+    it("should return the specified number of deeply shared path segments", () => {
+      const input = [
+        ["organizations", "migration", "step", "create_regions"],
+        ["organizations", "migration", "step"],
+        ["organizations", "migration", "step", "create_user"],
+      ];
+      const expected = ["migration", "step"];
+      expect(PathUtils.commonSequenceReversed(input, 2)).toEqual(expected);
+    });
+
+    it("should handle empty input", () => {
+      expect(PathUtils.commonSequenceReversed([])).toEqual([]);
+    });
+  });
+});

package/src/utils/path-utils.ts

@@ -0,0 +1,89 @@
+export const PathUtils = {
+  /**
+   * Parses a list of dot-separated paths into an array of string arrays.
+   * Removes any "0" character segments.
+   *
+   * @param list
+   * @protected
+   */
+  parsePaths: (list: string[]): string[][] => {
+    return list.map((item) =>
+      item.split(".").filter((segment) => segment !== "0"),
+    );
+  },
+
+  parsePath: (path: string): string[] => {
+    return path.split(".").filter((segment) => segment !== "0");
+  },
+
+  /**
+   * Returns the last `count` common elements (shared path) among all given path arrays,
+   * comparing from the end (i.e. common suffix).
+   *
+   * @param paths - An array of string arrays (paths) to compare.
+   * @param count - The number of common elements (starting from the end) to return.
+   * @returns An array containing the shared path elements in original order.
+   */
+  commonSequenceReversed: (paths: string[][], count: number = 1): string[] => {
+    if (paths.length === 0) return [];
+
+    // Find the shortest path to use as the candidate guide.
+    const minPath = paths.reduce(
+      (acc, cur) => (cur.length < acc.length ? cur : acc),
+      paths[0],
+    );
+
+    // Initialize pointers for each path. They represent the index limit (exclusive) to search backwards.
+    const pointers = paths.map((path) => path.length);
+    const commonSegmentsReversed: string[] = [];
+
+    // Iterate backwards over the shortest path.
+    for (let i = minPath.length - 1; i >= 0; i--) {
+      const candidate = minPath[i];
+      let foundInAll = true;
+      // Temporarily hold the found indices for this candidate in each path.
+      const foundIndices: number[] = [];
+
+      // For each path, search for the candidate before the current pointer.
+      for (let j = 0; j < paths.length; j++) {
+        // Search up to (pointer[j] - 1) so we always look to the left of the previous found element.
+        const idx = paths[j].lastIndexOf(candidate, pointers[j] - 1);
+        if (idx === -1) {
+          foundInAll = false;
+          break;
+        }
+        foundIndices.push(idx);
+      }
+
+      // If the candidate exists in all arrays, update each pointer and record the candidate.
+      if (foundInAll) {
+        for (let j = 0; j < pointers.length; j++) {
+          pointers[j] = foundIndices[j];
+        }
+        commonSegmentsReversed.push(candidate);
+        if (commonSegmentsReversed.length === count) break;
+      }
+    }
+
+    // Reverse to restore the original order (from left-to-right).
+    return commonSegmentsReversed.reverse();
+  },
+
+  /**
+   * Returns the longest common prefix (sequence) among an array of string arrays.
+   * @param paths - An array of string arrays.
+   * @returns An array representing the common sequence.
+   */
+  commonSequence: (paths: string[][]): string[] => {
+    if (paths.length === 0) return [];
+
+    const common: string[] = [];
+    for (let i = 0; i < paths[0].length; i++) {
+      const segment = paths[0][i];
+      if (paths.every((path) => path[i] === segment)) {
+        common.push(segment);
+      }
+    }
+    return common;
+  },
+};

package/src/utils/to-pascal-case.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts a string to PascalCase.
+ * Splits on whitespace, hyphens, or underscores.
+ */
+export function toPascalCase(str: string): string {
+    return str
+        .split(/[\s-_]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}