public commit

app/__test__/data/DataController.spec.ts

@@ -0,0 +1,235 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+
+import { Guard } from "../../src/auth";
+import { parse } from "../../src/core/utils";
+import {
+   Entity,
+   type EntityData,
+   EntityManager,
+   ManyToOneRelation,
+   type MutatorResponse,
+   type RepositoryResponse,
+   TextField
+} from "../../src/data";
+import { DataController } from "../../src/data/api/DataController";
+import { dataConfigSchema } from "../../src/data/data-schema";
+import { disableConsoleLog, enableConsoleLog, getDummyConnection } from "../helper";
+
+const { dummyConnection, afterAllCleanup } = getDummyConnection();
+beforeAll(() => disableConsoleLog(["log", "warn"]));
+afterAll(async () => (await afterAllCleanup()) && enableConsoleLog());
+
+const dataConfig = parse(dataConfigSchema, {});
+describe("[data] DataController", async () => {
+   test("repoResult", async () => {
+      const em = new EntityManager<any>([], dummyConnection);
+      const ctx: any = { em, guard: new Guard() };
+      const controller = new DataController(ctx, dataConfig);
+
+      const res = controller.repoResult({
+         entity: null as any,
+         data: [] as any,
+         sql: "",
+         parameters: [] as any,
+         result: [] as any,
+         meta: {
+            total: 0,
+            count: 0,
+            items: 0
+         }
+      });
+
+      expect(res).toEqual({
+         meta: {
+            total: 0,
+            count: 0,
+            items: 0
+         },
+         data: []
+      });
+   });
+
+   test("mutatorResult", async () => {
+      const em = new EntityManager([], dummyConnection);
+      const ctx: any = { em, guard: new Guard() };
+      const controller = new DataController(ctx, dataConfig);
+
+      const res = controller.mutatorResult({
+         entity: null as any,
+         data: [] as any,
+         sql: "",
+         parameters: [] as any,
+         result: [] as any
+      });
+
+      expect(res).toEqual({
+         data: []
+      });
+   });
+
+   describe("getController", async () => {
+      const users = new Entity("users", [
+         new TextField("name", { required: true }),
+         new TextField("bio")
+      ]);
+      const posts = new Entity("posts", [new TextField("content")]);
+      const em = new EntityManager([users, posts], dummyConnection, [
+         new ManyToOneRelation(posts, users)
+      ]);
+
+      await em.schema().sync({ force: true });
+
+      const fixtures = {
+         users: [
+            { name: "foo", bio: "bar" },
+            { name: "bar", bio: null },
+            { name: "baz", bio: "!!!" }
+         ],
+         posts: [
+            { content: "post 1", users_id: 1 },
+            { content: "post 2", users_id: 2 }
+         ]
+      };
+
+      const ctx: any = { em, guard: new Guard() };
+      const controller = new DataController(ctx, dataConfig);
+      const app = controller.getController();
+
+      test("entityExists", async () => {
+         expect(controller.entityExists("users")).toBe(true);
+         expect(controller.entityExists("posts")).toBe(true);
+         expect(controller.entityExists("settings")).toBe(false);
+      });
+
+      // @todo: update
+      test("/ (get info)", async () => {
+         const res = await app.request("/");
+         const data = (await res.json()) as any;
+         const entities = Object.keys(data.entities);
+         const relations = Object.values(data.relations).map((r: any) => r.type);
+
+         expect(entities).toEqual(["users", "posts"]);
+         expect(relations).toEqual(["n:1"]);
+      });
+
+      test("/:entity (insert one)", async () => {
+         //console.log("app.routes", app.routes);
+         // create users
+         for await (const _user of fixtures.users) {
+            const res = await app.request("/users", {
+               method: "POST",
+               body: JSON.stringify(_user)
+            });
+            //console.log("res", { _user }, res);
+            const result = (await res.json()) as MutatorResponse;
+            const { id, ...data } = result.data as any;
+
+            expect(res.status).toBe(201);
+            expect(res.ok).toBe(true);
+            expect(data as any).toEqual(_user);
+         }
+
+         // create posts
+         for await (const _post of fixtures.posts) {
+            const res = await app.request("/posts", {
+               method: "POST",
+               body: JSON.stringify(_post)
+            });
+            const result = (await res.json()) as MutatorResponse;
+            const { id, ...data } = result.data as any;
+
+            expect(res.status).toBe(201);
+            expect(res.ok).toBe(true);
+            expect(data as any).toEqual(_post);
+         }
+      });
+
+      test("/:entity (read many)", async () => {
+         const res = await app.request("/users");
+         const data = (await res.json()) as RepositoryResponse;
+
+         expect(data.meta.total).toBe(3);
+         expect(data.meta.count).toBe(3);
+         expect(data.meta.items).toBe(3);
+         expect(data.data.length).toBe(3);
+         expect(data.data[0].name).toBe("foo");
+      });
+
+      test("/:entity/query (func query)", async () => {
+         const res = await app.request("/users/query", {
+            method: "POST",
+            headers: {
+               "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+               where: { bio: { $isnull: 1 } }
+            })
+         });
+         const data = (await res.json()) as RepositoryResponse;
+
+         expect(data.meta.total).toBe(3);
+         expect(data.meta.count).toBe(1);
+         expect(data.meta.items).toBe(1);
+         expect(data.data.length).toBe(1);
+         expect(data.data[0].name).toBe("bar");
+      });
+
+      test("/:entity (read many, paginated)", async () => {
+         const res = await app.request("/users?limit=1&offset=2");
+         const data = (await res.json()) as RepositoryResponse;
+
+         expect(data.meta.total).toBe(3);
+         expect(data.meta.count).toBe(3);
+         expect(data.meta.items).toBe(1);
+         expect(data.data.length).toBe(1);
+         expect(data.data[0].name).toBe("baz");
+      });
+
+      test("/:entity/:id (read one)", async () => {
+         const res = await app.request("/users/3");
+         const data = (await res.json()) as RepositoryResponse<EntityData>;
+         console.log("data", data);
+
+         expect(data.meta.total).toBe(3);
+         expect(data.meta.count).toBe(1);
+         expect(data.meta.items).toBe(1);
+         expect(data.data).toEqual({ id: 3, ...fixtures.users[2] });
+      });
+
+      test("/:entity (update one)", async () => {
+         const res = await app.request("/users/3", {
+            method: "PATCH",
+            body: JSON.stringify({ name: "new name" })
+         });
+         const { data } = (await res.json()) as MutatorResponse;
+
+         expect(res.ok).toBe(true);
+         expect(data as any).toEqual({ id: 3, ...fixtures.users[2], name: "new name" });
+      });
+
+      test("/:entity/:id/:reference (read references)", async () => {
+         const res = await app.request("/users/1/posts");
+         const data = (await res.json()) as RepositoryResponse;
+         console.log("data", data);
+
+         expect(data.meta.total).toBe(2);
+         expect(data.meta.count).toBe(1);
+         expect(data.meta.items).toBe(1);
+         expect(data.data.length).toBe(1);
+         expect(data.data[0].content).toBe("post 1");
+      });
+
+      test("/:entity/:id (delete one)", async () => {
+         const res = await app.request("/posts/2", {
+            method: "DELETE"
+         });
+         const { data } = (await res.json()) as RepositoryResponse<EntityData>;
+         expect(data).toEqual({ id: 2, ...fixtures.posts[1] });
+
+         // verify
+         const res2 = await app.request("/posts");
+         const data2 = (await res2.json()) as RepositoryResponse;
+         expect(data2.meta.total).toBe(1);
+      });
+   });
+});