rastack 0.0.58 → 0.0.59

package/test/schema-entities.spec.ts

@@ -1,688 +0,0 @@
-import { PathsObject } from "@ts-stack/openapi-spec";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";
-import { join } from "path";
-import { generateFiles, generateFolders } from "../src/schema-entities";
-import { removeNonModelPaths } from "../src/schema/remove-non-model-paths";
-
-jest.mock("axios");
-
-describe("OpenAPI Code Generation", () => {
-    const entitiesPath = join(__dirname, "entities");
-
-    beforeEach(() => {
-        // Create the entities directory before each test
-        mkdirSync(entitiesPath, {recursive: true});
-    });
-
-    afterEach(() => {
-        // Clean up the entities directory after each test
-        rmSync(entitiesPath, {recursive: true, force: true});
-    });
-
-    it("should filter out non model paths", () => {
-        const paths: PathsObject = {
-            "/api/pet/v1": {},
-            "/api/shop/v1/pet/{petId}": {},
-            "/api/shop/v1/pet/{petId}/food": {},
-            "/health": {},
-        };
-
-        const filteredPaths = removeNonModelPaths(paths);
-        expect(filteredPaths).toEqual({
-            "/api/shop/v1/pet/{petId}": {},
-            "/api/shop/v1/pet/{petId}/food": {},
-        });
-    });
-
-    it("should generate folders", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pet/{petId}": {},
-            "/api/shop/v1/meals/{petId}": {},
-        };
-
-        await generateFolders(entitiesPath, paths);
-        expect(existsSync(join(entitiesPath, "shop"))).toBe(true);
-        expect(existsSync(join(entitiesPath, "shop", "pet"))).toBe(true);
-        expect(existsSync(join(entitiesPath, "shop", "meals"))).toBe(true);
-    });
-
-    it("should generate files", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pet/{petId}": {
-                get: {
-                    operationId: "getPetById",
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Pet",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        // folders need to be created for the files
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        expect(existsSync(join(entitiesPath, "shop", "pet", "api.ts"))).toBe(true);
-        expect(existsSync(join(entitiesPath, "shop", "pet", "index.ts"))).toBe(
-            true,
-        );
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pet", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("export function useGetPetById");
-
-        const indexFileContent = readFileSync(
-            join(entitiesPath, "shop", "pet", "index.ts"),
-            "utf-8",
-        );
-        expect(indexFileContent).toContain('export * from "./api"');
-
-        const baseIndexFileContent = readFileSync(
-            join(entitiesPath, "shop", "index.ts"),
-            "utf-8",
-        );
-        expect(baseIndexFileContent).toContain('export * from "./pet"');
-    });
-
-    it("should generate GET method with pagination", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pets": {
-                get: {
-                    operationId: "listPets",
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/PaginatedPetList",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pets", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("export function useListPets(");
-        expect(apiFileContent).toContain(
-            "useGetPaginatedQueryList<IListPetsParams, IPet>",
-        );
-    });
-
-    it("should generate GET method without pagination", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pet/{petId}": {
-                get: {
-                    operationId: "getPetById",
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Pet",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pet", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("export function useGetPetById(");
-        expect(apiFileContent).toContain(
-            "import { IGetPetByIdParams, IPet } from '@repo/schema/schema'",
-        );
-        expect(apiFileContent).toContain("useGetQuery<IGetPetByIdParams, IPet>");
-    });
-
-    it("should generate POST method", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pets": {
-                post: {
-                    operationId: "createPet",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/CreatePetRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "201": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Pet",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pets", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("export function usePostCreatePet()");
-        expect(apiFileContent).toContain(
-            "useUpdateQuery<ICreatePetParams, ICreatePetRequest, IPet>",
-        );
-    });
-
-    it("should generate PUT method", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pets/{petId}": {
-                put: {
-                    operationId: "updatePet",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/UpdatePetRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Pet",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pets", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("export function usePutUpdatePet()");
-        expect(apiFileContent).toContain(
-            "useUpdateQuery<IUpdatePetParams, IUpdatePetRequest, IPet>",
-        );
-    });
-
-    it("should generate DELETE method", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pets/{petId}": {
-                delete: {
-                    operationId: "deletePet",
-                    responses: {
-                        "204": {
-                            description: "Successful response",
-                        },
-                    },
-                },
-            },
-        };
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pets", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("export function useDeletePet()");
-        expect(apiFileContent).toContain("useDeleteQuery");
-    });
-
-    it("should generate useUpdateEventForm function", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/events/{eventId}": {
-                put: {
-                    operationId: "updateEvent",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/UpdateEventRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Event",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                patch: {
-                    operationId: "partialUpdateEvent",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/PatchedUpdateEventRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Event",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            "/api/shop/v1/events/sessions/{eventId}": {
-                put: {
-                    operationId: "updateEventSession",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/UpdateEventSessionRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/EventSession",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                patch: {
-                    operationId: "partialUpdateEventSession",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/PatchedUpdateEventSessionRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "200": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/EventSession",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            "/api/shop/v1/events": {
-                post: {
-                    operationId: "createEvent",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: "#/components/schemas/CreateEventRequest",
-                                },
-                            },
-                        },
-                    },
-                    responses: {
-                        "201": {
-                            description: "Successful response",
-                            content: {
-                                "application/json": {
-                                    schema: {
-                                        $ref: "#/components/schemas/Event",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "events", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("useUpdateEventsForm");
-        expect(apiFileContent).toContain("useUpdateEventsSessionsForm");
-    });
-});
-
-describe("Sync entity code generation", () => {
-    const entitiesPath = join(__dirname, "entities-sync");
-
-    const syncGet = (operationId: string, schema: string, sync = "local") => ({
-        operationId,
-        "x-rastack-sync": sync,
-        responses: {
-            "200": {
-                description: "Successful response",
-                content: {
-                    "application/json": {
-                        schema: {$ref: `#/components/schemas/${schema}`},
-                    },
-                },
-            },
-        },
-    });
-
-    const syncPaths: PathsObject = {
-        "/api/airports/v1/flight/": {
-            get: syncGet("listFlights", "PaginatedFlightList"),
-            post: {
-                operationId: "createFlight",
-                "x-rastack-sync": "local",
-                requestBody: {
-                    content: {
-                        "application/json": {
-                            schema: {$ref: "#/components/schemas/FlightRequest"},
-                        },
-                    },
-                },
-                responses: {
-                    "201": {
-                        description: "Created",
-                        content: {
-                            "application/json": {
-                                schema: {$ref: "#/components/schemas/Flight"},
-                            },
-                        },
-                    },
-                },
-            },
-        },
-        "/api/airports/v1/flight/{id}/": {
-            get: syncGet("getFlightById", "Flight"),
-            put: {
-                operationId: "updateFlight",
-                "x-rastack-sync": "confirmed",
-                requestBody: {
-                    content: {
-                        "application/json": {
-                            schema: {$ref: "#/components/schemas/FlightRequest"},
-                        },
-                    },
-                },
-                responses: {
-                    "200": {
-                        description: "Updated",
-                        content: {
-                            "application/json": {
-                                schema: {$ref: "#/components/schemas/Flight"},
-                            },
-                        },
-                    },
-                },
-            },
-            delete: {
-                operationId: "deleteFlight",
-                "x-rastack-sync": "local",
-                responses: {"204": {description: "Deleted"}},
-            },
-        },
-    } as any;
-
-    beforeEach(() => {
-        mkdirSync(entitiesPath, {recursive: true});
-    });
-
-    afterEach(() => {
-        rmSync(entitiesPath, {recursive: true, force: true});
-    });
-
-    it("should generate an entity descriptor and store-backed hooks", async () => {
-        await generateFolders(entitiesPath, syncPaths);
-        await generateFiles(entitiesPath, syncPaths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "airports", "flight", "api.ts"),
-            "utf-8",
-        );
-
-        expect(apiFileContent).toContain("export const flightEntity = defineEntity<IFlight>({");
-        expect(apiFileContent).toContain('app: "airports"');
-        expect(apiFileContent).toContain('model: "flight"');
-        expect(apiFileContent).toContain("from 'rastack/sync'");
-
-        // reads are store-backed
-        expect(apiFileContent).toContain("export function useListFlights(");
-        expect(apiFileContent).toContain("useEntityList<IFlight>(flightEntity, options)");
-        expect(apiFileContent).toContain("export function useGetFlightById(");
-        expect(apiFileContent).toContain("useEntityRecord<IFlight>(flightEntity,");
-
-        // create is an optimistic transaction
-        expect(apiFileContent).toContain("export function usePostCreateFlight()");
-        expect(apiFileContent).toContain('op: "create"');
-
-        // delete is optimistic
-        expect(apiFileContent).toContain("export function useDeleteFlight()");
-        expect(apiFileContent).toContain("useEntityDelete(flightEntity, {");
-    });
-
-    it("should generate a blocking hook for confirmed operations", async () => {
-        await generateFolders(entitiesPath, syncPaths);
-        await generateFiles(entitiesPath, syncPaths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "airports", "flight", "api.ts"),
-            "utf-8",
-        );
-
-        expect(apiFileContent).toContain("export function usePutUpdateFlight()");
-        expect(apiFileContent).toContain("useConfirmedMutation<IUpdateFlightParams, IFlightRequest, IFlight>({");
-        expect(apiFileContent).not.toContain('op: "update"');
-    });
-
-    it("should wire cache invalidation keys for non-sync entities", async () => {
-        const paths: PathsObject = {
-            "/api/shop/v1/pets": {
-                get: {
-                    operationId: "listPets",
-                    responses: {
-                        "200": {
-                            description: "OK",
-                            content: {
-                                "application/json": {
-                                    schema: {$ref: "#/components/schemas/PaginatedPetList"},
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            "/api/shop/v1/pets/{petId}": {
-                get: {
-                    operationId: "getPetById",
-                    responses: {
-                        "200": {
-                            description: "OK",
-                            content: {
-                                "application/json": {
-                                    schema: {$ref: "#/components/schemas/Pet"},
-                                },
-                            },
-                        },
-                    },
-                },
-                put: {
-                    operationId: "updatePet",
-                    requestBody: {
-                        content: {
-                            "application/json": {
-                                schema: {$ref: "#/components/schemas/UpdatePetRequest"},
-                            },
-                        },
-                    },
-                    responses: {
-                        "200": {
-                            description: "OK",
-                            content: {
-                                "application/json": {
-                                    schema: {$ref: "#/components/schemas/Pet"},
-                                },
-                            },
-                        },
-                    },
-                },
-                delete: {
-                    operationId: "deletePet",
-                    responses: {"204": {description: "Deleted"}},
-                },
-            },
-        };
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "shop", "pets", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("listQueryCacheKey: petsQueriesKeys.listPets");
-        expect(apiFileContent).toContain("itemQueryCacheKey: petsQueriesKeys.getPetById");
-        // non-sync entities keep the async hooks untouched
-        expect(apiFileContent).not.toContain("rastack/sync");
-    });
-});
-
-describe("Lazy sync entities", () => {
-    const entitiesPath = join(__dirname, "entities-lazy");
-
-    beforeEach(() => {
-        mkdirSync(entitiesPath, {recursive: true});
-    });
-
-    afterEach(() => {
-        rmSync(entitiesPath, {recursive: true, force: true});
-    });
-
-    it("should mark lazy entities in the generated descriptor", async () => {
-        const paths: PathsObject = {
-            "/api/airports/v1/comment/": {
-                get: {
-                    operationId: "listComments",
-                    "x-rastack-sync": "local",
-                    "x-rastack-sync-load": "lazy",
-                    responses: {
-                        "200": {
-                            description: "OK",
-                            content: {
-                                "application/json": {
-                                    schema: {$ref: "#/components/schemas/PaginatedCommentList"},
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        } as any;
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "airports", "comment", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("lazy: true,");
-        expect(apiFileContent).toContain("export const commentEntity = defineEntity<IComment>({");
-    });
-
-    it("should mark client-id entities in the generated descriptor", async () => {
-        const paths: PathsObject = {
-            "/api/airports/v1/note/": {
-                get: {
-                    operationId: "listNotes",
-                    "x-rastack-sync": "local",
-                    "x-rastack-sync-client-ids": true,
-                    responses: {
-                        "200": {
-                            description: "OK",
-                            content: {
-                                "application/json": {
-                                    schema: {$ref: "#/components/schemas/PaginatedNoteList"},
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        } as any;
-
-        await generateFolders(entitiesPath, paths);
-        await generateFiles(entitiesPath, paths);
-
-        const apiFileContent = readFileSync(
-            join(entitiesPath, "airports", "note", "api.ts"),
-            "utf-8",
-        );
-        expect(apiFileContent).toContain("clientIds: true,");
-    });
-});