ajsc 5.0.3 → 5.2.0

package/dist/TypescriptConverter.composites.advanced.test.js

@@ -0,0 +1,924 @@
+import { describe, it, expect } from "vitest";
+import { TypescriptConverter } from "./TypescriptConverter.js";
+describe("TypescriptConverter - unions and intersections with shared ancestor type merging", () => {
+    it("should merge enum unions with same name under shared ancestor", () => {
+        expect(new TypescriptConverter({
+            type: "object",
+            properties: {
+                timeLog: {
+                    type: "array",
+                    items: {
+                        anyOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    action: {
+                                        type: "string",
+                                        enum: ["startshift", "endshift"],
+                                    },
+                                },
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    action: {
+                                        type: "string",
+                                        enum: ["startbreak", "endbreak"],
+                                    },
+                                    break: {
+                                        type: "object",
+                                        properties: {
+                                            durationMin: {
+                                                type: "number",
+                                            },
+                                            mandatory: {
+                                                type: "boolean",
+                                            },
+                                            paid: {
+                                                type: "boolean",
+                                            },
+                                            startsAfterShiftHrs: {
+                                                type: "number",
+                                            },
+                                            type: {
+                                                type: "string",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        }, { enumStyle: "enum" }).code).toMatch(`export enum Action { Startshift = "startshift", Endshift = "endshift", Startbreak = "startbreak", Endbreak = "endbreak" }`);
+    });
+    it("should merge type unions with shared ancestor", () => {
+        expect(new TypescriptConverter({
+            type: "object",
+            properties: {
+                status: {
+                    anyOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                color: {
+                                    type: "string",
+                                },
+                                timeframe: {
+                                    type: "string",
+                                    enum: ["past"],
+                                },
+                                title: {
+                                    type: "string",
+                                    enum: ["completed", "missed"],
+                                },
+                            },
+                            required: ["timeframe", "title"],
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                color: {
+                                    type: "string",
+                                },
+                                timeframe: {
+                                    type: "string",
+                                    enum: ["current"],
+                                },
+                                title: {
+                                    type: "string",
+                                    enum: [
+                                        "ended",
+                                        "inprogress",
+                                        "notended",
+                                        "notstarted",
+                                        "onbreak",
+                                    ],
+                                },
+                            },
+                            required: ["timeframe", "title"],
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                color: {
+                                    type: "string",
+                                },
+                                timeframe: {
+                                    type: "string",
+                                    enum: ["future"],
+                                },
+                            },
+                            required: ["timeframe"],
+                        },
+                    ],
+                },
+            },
+        }, { enumStyle: "enum" }).code).toContain(`export enum Timeframe { Past = "past", Current = "current", Future = "future" }\nexport enum Title { Completed = "completed", Missed = "missed", Ended = "ended", Inprogress = "inprogress", Notended = "notended", Notstarted = "notstarted", Onbreak = "onbreak" }\nexport type Status = { color?: string; timeframe: Timeframe; title?: Title; };\n\nexport type Root = { status?: Status; };\n`);
+    });
+    it("should merge enum + literal properties across union options", () => {
+        expect(new TypescriptConverter({
+            type: "object",
+            properties: {
+                item: {
+                    anyOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                kind: { const: "book" },
+                                shared: { type: "string" },
+                            },
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                kind: {
+                                    type: "string",
+                                    enum: ["dvd", "cd"],
+                                },
+                                shared: { type: "string" },
+                            },
+                        },
+                    ],
+                },
+            },
+        }, { enumStyle: "enum" }).code).toMatch(`export enum Kind { Book = "book", Dvd = "dvd", Cd = "cd" }`);
+    });
+    it("should preserve union when options have incompatible property types", () => {
+        const code = new TypescriptConverter({
+            type: "object",
+            properties: {
+                field: {
+                    anyOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                value: { type: "string" },
+                                name: { type: "string" },
+                            },
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                value: { type: "number" },
+                                name: { type: "string" },
+                            },
+                        },
+                    ],
+                },
+            },
+        }, { enumStyle: "enum" }).code;
+        // Should remain as a union because "value" has incompatible types
+        expect(code).toMatch(/Field \| FieldType/);
+    });
+    it("should preserve discriminated unions as separate types", () => {
+        const code = new TypescriptConverter({
+            type: "object",
+            properties: {
+                shape: {
+                    anyOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                kind: { const: "circle" },
+                                radius: { type: "number" },
+                            },
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                kind: { const: "square" },
+                                side: { type: "number" },
+                            },
+                        },
+                    ],
+                },
+            },
+        }, { enumStyle: "enum" }).code;
+        // Discriminated union: "kind" has distinct const per option with
+        // option-specific properties — should NOT be merged, but enhanced with
+        // discriminator-derived names and consolidated enum
+        expect(code).toContain('export enum Kind { Circle = "circle", Square = "square" }');
+        expect(code).toMatch(/CircleShape \| SquareShape/);
+        expect(code).toContain('kind?: Kind.Circle');
+        expect(code).toContain('kind?: Kind.Square');
+    });
+    it("should merge with union-style enums (default enumStyle)", () => {
+        const code = new TypescriptConverter({
+            type: "object",
+            properties: {
+                event: {
+                    anyOf: [
+                        {
+                            type: "object",
+                            properties: {
+                                type: {
+                                    type: "string",
+                                    enum: ["click", "hover"],
+                                },
+                                x: { type: "number" },
+                            },
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                type: {
+                                    type: "string",
+                                    enum: ["scroll", "resize"],
+                                },
+                                x: { type: "number" },
+                            },
+                        },
+                    ],
+                },
+            },
+        }).code;
+        // With default enumStyle ("union"), merged enums appear as string literal unions
+        expect(code).toMatch(`"click" | "hover" | "scroll" | "resize"`);
+    });
+    it("should handle nested anyOf merging (bottom-up)", () => {
+        const code = new TypescriptConverter({
+            type: "object",
+            properties: {
+                outer: {
+                    type: "array",
+                    items: {
+                        anyOf: [
+                            {
+                                type: "object",
+                                properties: {
+                                    tag: {
+                                        type: "string",
+                                        enum: ["a"],
+                                    },
+                                    inner: {
+                                        anyOf: [
+                                            {
+                                                type: "object",
+                                                properties: {
+                                                    level: {
+                                                        type: "string",
+                                                        enum: ["low"],
+                                                    },
+                                                },
+                                            },
+                                            {
+                                                type: "object",
+                                                properties: {
+                                                    level: {
+                                                        type: "string",
+                                                        enum: ["high"],
+                                                    },
+                                                },
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
+                            {
+                                type: "object",
+                                properties: {
+                                    tag: {
+                                        type: "string",
+                                        enum: ["b"],
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        }, { enumStyle: "enum" }).code;
+        // Inner anyOf should be merged first (bottom-up), producing a merged Level enum
+        expect(code).toMatch(`export enum Level { Low = "low", High = "high" }`);
+        // Outer anyOf should also be merged (tag is shared)
+        expect(code).toMatch(`export enum Tag { A = "a", B = "b" }`);
+    });
+    it('should handle unions of an advanced type', () => {
+        const code = new TypescriptConverter({
+            type: "object",
+            properties: {
+                activity: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            activityTypeTags: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        color: {
+                                            type: "string",
+                                        },
+                                        id: {
+                                            type: "string",
+                                        },
+                                        level: {
+                                            type: "number",
+                                            description: "The level is an indicator for visual UI and also a sudo rating of the importance of a Tag.\n        This value is also used in business logic that correlates a PrioritySchema value.\n        ",
+                                            maximum: 3,
+                                        },
+                                        organizationId: {
+                                            type: "string",
+                                        },
+                                        relations: {
+                                            type: "array",
+                                            items: {
+                                                type: "string",
+                                            },
+                                        },
+                                        regionIds: {
+                                            type: "array",
+                                            items: {
+                                                type: "string",
+                                            },
+                                        },
+                                        title: {
+                                            type: "string",
+                                        },
+                                    },
+                                    required: ["title"],
+                                    additionalProperties: false,
+                                },
+                            },
+                            detail: {
+                                anyOf: [
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "bolo",
+                                            },
+                                            boloId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "boloId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "user-geo-fence",
+                                            },
+                                            userId: {
+                                                type: "string",
+                                            },
+                                            type: {
+                                                type: "string",
+                                                enum: ["arrive", "depart"],
+                                            },
+                                        },
+                                        required: ["scope", "userId", "type"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "user-status",
+                                            },
+                                            userId: {
+                                                type: "string",
+                                            },
+                                            fromStatus: {
+                                                type: "object",
+                                                properties: {
+                                                    autoClearStaleUserMin: {
+                                                        type: "number",
+                                                    },
+                                                    color: {
+                                                        type: "string",
+                                                    },
+                                                    expireDate: {
+                                                        type: "string",
+                                                    },
+                                                    endDate: {
+                                                        type: "string",
+                                                    },
+                                                    geoTracking: {
+                                                        type: "boolean",
+                                                    },
+                                                    id: {
+                                                        type: "string",
+                                                    },
+                                                    priority: {
+                                                        type: "number",
+                                                    },
+                                                    setAtDate: {
+                                                        type: "string",
+                                                    },
+                                                    shiftId: {
+                                                        type: "string",
+                                                    },
+                                                    statusReminderInterval: {
+                                                        type: "number",
+                                                    },
+                                                    title: {
+                                                        type: "string",
+                                                    },
+                                                },
+                                                required: ["setAtDate", "title"],
+                                                additionalProperties: false,
+                                            },
+                                            toStatus: {
+                                                type: "object",
+                                                properties: {
+                                                    autoClearStaleUserMin: {
+                                                        type: "number",
+                                                    },
+                                                    color: {
+                                                        type: "string",
+                                                    },
+                                                    expireDate: {
+                                                        type: "string",
+                                                    },
+                                                    endDate: {
+                                                        type: "string",
+                                                    },
+                                                    geoTracking: {
+                                                        type: "boolean",
+                                                    },
+                                                    id: {
+                                                        type: "string",
+                                                    },
+                                                    priority: {
+                                                        type: "number",
+                                                    },
+                                                    setAtDate: {
+                                                        type: "string",
+                                                    },
+                                                    shiftId: {
+                                                        type: "string",
+                                                    },
+                                                    statusReminderInterval: {
+                                                        type: "number",
+                                                    },
+                                                    title: {
+                                                        type: "string",
+                                                    },
+                                                },
+                                                required: ["setAtDate", "title"],
+                                                additionalProperties: false,
+                                            },
+                                        },
+                                        required: ["scope", "userId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "passdown",
+                                            },
+                                            passDownId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "passDownId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "event",
+                                            },
+                                            eventId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "eventId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "event-assignment-user-status",
+                                            },
+                                            eventId: {
+                                                type: "string",
+                                            },
+                                            fromStatus: {
+                                                type: "object",
+                                                properties: {
+                                                    abbreviation: {
+                                                        type: "string",
+                                                    },
+                                                    color: {
+                                                        type: "string",
+                                                    },
+                                                    setAtDate: {
+                                                        type: "string",
+                                                    },
+                                                    title: {
+                                                        type: "string",
+                                                    },
+                                                },
+                                                required: ["setAtDate", "title"],
+                                                additionalProperties: false,
+                                            },
+                                            toStatus: {
+                                                type: "object",
+                                                properties: {
+                                                    abbreviation: {
+                                                        type: "string",
+                                                    },
+                                                    color: {
+                                                        type: "string",
+                                                    },
+                                                    setAtDate: {
+                                                        type: "string",
+                                                    },
+                                                    title: {
+                                                        type: "string",
+                                                    },
+                                                },
+                                                required: ["setAtDate", "title"],
+                                                additionalProperties: false,
+                                            },
+                                        },
+                                        required: ["scope", "eventId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "location-checkpoint-scan",
+                                            },
+                                            checkpointScanId: {
+                                                type: "string",
+                                            },
+                                            checkpointTourRunId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "checkpointScanId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "location-checkpoint-tour",
+                                            },
+                                            checkpointTourId: {
+                                                type: "string",
+                                            },
+                                            checkpointTourRunId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: [
+                                            "scope",
+                                            "checkpointTourId",
+                                            "checkpointTourRunId",
+                                        ],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "location-log-entry",
+                                            },
+                                            entryId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "entryId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "patrol-route",
+                                            },
+                                            patrolRouteId: {
+                                                type: "string",
+                                            },
+                                            patrolRouteRunId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "patrolRouteId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "patrol-route-visit",
+                                            },
+                                            patrolRouteRunId: {
+                                                type: "string",
+                                            },
+                                            patrolRouteId: {
+                                                type: "string",
+                                            },
+                                            patrolRouteVisitId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: [
+                                            "scope",
+                                            "patrolRouteRunId",
+                                            "patrolRouteId",
+                                            "patrolRouteVisitId",
+                                        ],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "report",
+                                            },
+                                            reportId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "reportId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "report-status",
+                                            },
+                                            reportId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "reportId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "shift",
+                                            },
+                                            shiftId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "shiftId"],
+                                        additionalProperties: false,
+                                    },
+                                    {
+                                        type: "object",
+                                        properties: {
+                                            scope: {
+                                                type: "string",
+                                                const: "user-sos",
+                                            },
+                                            userId: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["scope", "userId"],
+                                        additionalProperties: false,
+                                    },
+                                ],
+                            },
+                            description: {
+                                type: "string",
+                            },
+                            locationId: {
+                                anyOf: [
+                                    {
+                                        type: "string",
+                                    },
+                                    {
+                                        type: "array",
+                                        items: {
+                                            type: "string",
+                                        },
+                                    },
+                                ],
+                            },
+                            organizationId: {
+                                type: "string",
+                            },
+                            regionIds: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                },
+                            },
+                            subTitle: {
+                                type: "string",
+                            },
+                            timestamp: {
+                                type: "string",
+                            },
+                            title: {
+                                type: "string",
+                            },
+                            user: {
+                                type: "object",
+                                properties: {
+                                    avatarUrl: {
+                                        type: "string",
+                                    },
+                                    displayName: {
+                                        type: "string",
+                                    },
+                                    id: {
+                                        type: "string",
+                                    },
+                                    idNumber: {
+                                        type: "string",
+                                    },
+                                    lastGeoLocation: {
+                                        type: "object",
+                                        properties: {
+                                            accuracy: {
+                                                type: "number",
+                                            },
+                                            coords: {
+                                                type: "object",
+                                                properties: {
+                                                    lat: {
+                                                        type: "number",
+                                                    },
+                                                    lng: {
+                                                        type: "number",
+                                                    },
+                                                },
+                                                required: ["lat", "lng"],
+                                                additionalProperties: false,
+                                            },
+                                            device: {
+                                                type: "object",
+                                                properties: {
+                                                    name: {
+                                                        type: "string",
+                                                    },
+                                                    os: {
+                                                        type: "string",
+                                                    },
+                                                    permissions: {
+                                                        type: "object",
+                                                        properties: {
+                                                            backgroundSync: {
+                                                                type: "boolean",
+                                                            },
+                                                            bluetooth: {
+                                                                type: "boolean",
+                                                            },
+                                                            camera: {
+                                                                type: "boolean",
+                                                            },
+                                                            geolocation: {
+                                                                type: "boolean",
+                                                            },
+                                                            backgroundGeolocation: {
+                                                                type: "boolean",
+                                                            },
+                                                            microphone: {
+                                                                type: "boolean",
+                                                            },
+                                                            nfc: {
+                                                                type: "boolean",
+                                                            },
+                                                            notifications: {
+                                                                type: "boolean",
+                                                            },
+                                                            physicalActivity: {
+                                                                type: "boolean",
+                                                            },
+                                                        },
+                                                        additionalProperties: false,
+                                                    },
+                                                    type: {
+                                                        description: "'browser', 'mobile', 'tablet', 'other', 'unknown'",
+                                                        type: "string",
+                                                    },
+                                                    uuid: {
+                                                        type: "string",
+                                                    },
+                                                },
+                                                required: ["name", "type", "uuid"],
+                                                additionalProperties: false,
+                                            },
+                                            relativeLocation: {
+                                                type: "object",
+                                                properties: {
+                                                    locationId: {
+                                                        type: "string",
+                                                    },
+                                                    status: {
+                                                        type: "string",
+                                                        enum: ["inside", "near"],
+                                                    },
+                                                },
+                                                required: ["locationId", "status"],
+                                                additionalProperties: false,
+                                            },
+                                            timestamp: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["accuracy", "coords", "device", "timestamp"],
+                                        additionalProperties: false,
+                                    },
+                                    status: {
+                                        type: "object",
+                                        properties: {
+                                            autoClearStaleUserMin: {
+                                                type: "number",
+                                            },
+                                            color: {
+                                                type: "string",
+                                            },
+                                            expireDate: {
+                                                type: "string",
+                                            },
+                                            endDate: {
+                                                type: "string",
+                                            },
+                                            geoTracking: {
+                                                type: "boolean",
+                                            },
+                                            id: {
+                                                type: "string",
+                                            },
+                                            priority: {
+                                                type: "number",
+                                            },
+                                            setAtDate: {
+                                                type: "string",
+                                            },
+                                            shiftId: {
+                                                type: "string",
+                                            },
+                                            statusReminderInterval: {
+                                                type: "number",
+                                            },
+                                            title: {
+                                                type: "string",
+                                            },
+                                        },
+                                        required: ["setAtDate", "title"],
+                                        additionalProperties: false,
+                                    },
+                                },
+                                required: ["id"],
+                                additionalProperties: false,
+                            },
+                        },
+                        required: ["detail", "regionIds", "timestamp", "title"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["activity"],
+            additionalProperties: false,
+        }, { enumStyle: 'enum' }).code;
+        // Single consolidated Scope enum with all 15 values
+        expect(code).toContain('export enum Scope { Bolo = "bolo", UserGeoFence = "user-geo-fence", UserStatus = "user-status", Passdown = "passdown", Event = "event", EventAssignmentUserStatus = "event-assignment-user-status", LocationCheckpointScan = "location-checkpoint-scan", LocationCheckpointTour = "location-checkpoint-tour", LocationLogEntry = "location-log-entry", PatrolRoute = "patrol-route", PatrolRouteVisit = "patrol-route-visit", Report = "report", ReportStatus = "report-status", Shift = "shift", UserSos = "user-sos" }');
+        // Discriminator-derived variant names
+        expect(code).toContain('BoloDetail');
+        expect(code).toContain('UserGeoFenceDetail');
+        expect(code).toContain('UserStatusDetail');
+        expect(code).toContain('EventAssignmentUserStatusDetail');
+        expect(code).toContain('PatrolRouteVisitDetail');
+        // Enum member references (not standalone single-value enums)
+        expect(code).toContain('Scope.Bolo');
+        expect(code).toContain('Scope.UserGeoFence');
+        expect(code).toContain('Scope.UserSos');
+        // No duplicate types: identical 11-property status structures share one type
+        // (fromStatus, toStatus, and user.status all reference the same type)
+        const fromStatusMatches = code.match(/export type FromStatus = /g);
+        expect(fromStatusMatches).toHaveLength(1);
+        // The 4-property status structure (event-assignment variants) also deduped
+        const detailFromStatusMatches = code.match(/export type DetailFromStatus = /g);
+        expect(detailFromStatusMatches).toHaveLength(1);
+        // No single-value scope enums (should be consolidated)
+        expect(code).not.toMatch(/export enum \w*Scope\d/);
+    });
+});
+//# sourceMappingURL=TypescriptConverter.composites.advanced.test.js.map