mirror of
https://github.com/bknd-io/bknd/
synced 2026-08-02 08:06:00 +00:00
dswbx
0a93a4a16c
- Added type definitions for entity data in DataApi, improving type safety across CRUD operations. - Introduced new test cases in DataApi.spec.ts to validate the behavior of read and create operations, ensuring correct data handling and response types. - Updated various files to accommodate the new type definitions and ensure compatibility with existing functionality.
367 lines
13 KiB
TypeScript
367 lines
13 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it, expectTypeOf } from "bun:test";
|
|
import { Guard } from "../../src/auth/authorize/Guard";
|
|
import { DataApi } from "../../src/data/api/DataApi";
|
|
import { DataController } from "../../src/data/api/DataController";
|
|
import { dataConfigSchema } from "../../src/data/data-schema";
|
|
import * as proto from "../../src/data/prototype";
|
|
import { schemaToEm } from "../helper";
|
|
import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
|
|
import { parse } from "core/utils/schema";
|
|
import type { Generated } from "kysely";
|
|
|
|
beforeAll(disableConsoleLog);
|
|
afterAll(enableConsoleLog);
|
|
|
|
const dataConfig = parse(dataConfigSchema, {});
|
|
describe("DataApi", () => {
|
|
it("should switch to post for long url reads", async () => {
|
|
const api = new DataApi();
|
|
|
|
const get = api.readMany("a".repeat(300), { select: ["id", "name"] });
|
|
expect(get.request.method).toBe("GET");
|
|
expect(new URL(get.request.url).pathname).toBe(`/api/data/entity/${"a".repeat(300)}`);
|
|
|
|
const post = api.readMany("a".repeat(1000), { select: ["id", "name"] });
|
|
expect(post.request.method).toBe("POST");
|
|
expect(new URL(post.request.url).pathname).toBe(`/api/data/entity/${"a".repeat(1000)}/query`);
|
|
});
|
|
|
|
it("returns result", async () => {
|
|
const schema = proto.em({
|
|
posts: proto.entity("posts", { title: proto.text() }),
|
|
});
|
|
const em = schemaToEm(schema);
|
|
await em.schema().sync({ force: true });
|
|
|
|
const payload = [{ title: "foo" }, { title: "bar" }, { title: "baz" }];
|
|
await em.mutator("posts").insertMany(payload);
|
|
|
|
const ctx: any = { em, guard: new Guard() };
|
|
const controller = new DataController(ctx, dataConfig);
|
|
const app = controller.getController();
|
|
|
|
{
|
|
const res = (await app.request("/entity/posts")) as Response;
|
|
const { data } = (await res.json()) as any;
|
|
expect(data.length).toEqual(3);
|
|
}
|
|
|
|
// @ts-ignore tests
|
|
const api = new DataApi({ basepath: "/", queryLengthLimit: 50 }, app.request as typeof fetch);
|
|
{
|
|
const req = api.readMany("posts", { select: ["title"] });
|
|
expect(req.request.method).toBe("GET");
|
|
const res = await req;
|
|
expect(res.data).toEqual(payload as any);
|
|
}
|
|
|
|
{
|
|
const req = api.readMany("posts", {
|
|
select: ["title"],
|
|
limit: 100000,
|
|
offset: 0,
|
|
sort: "id",
|
|
});
|
|
expect(req.request.method).toBe("POST");
|
|
const res = await req;
|
|
expect(res.data).toEqual(payload as any);
|
|
}
|
|
|
|
{
|
|
// make sure sort is working
|
|
const req = await api.readMany("posts", {
|
|
select: ["title"],
|
|
sort: "-id",
|
|
});
|
|
expect(req.data).toEqual(payload.reverse() as any);
|
|
}
|
|
});
|
|
|
|
it("updates many", async () => {
|
|
const schema = proto.em({
|
|
posts: proto.entity("posts", { title: proto.text(), count: proto.number() }),
|
|
});
|
|
const em = schemaToEm(schema);
|
|
await em.schema().sync({ force: true });
|
|
|
|
const payload = [
|
|
{ title: "foo", count: 0 },
|
|
{ title: "bar", count: 0 },
|
|
{ title: "baz", count: 0 },
|
|
{ title: "bla", count: 2 },
|
|
];
|
|
await em.mutator("posts").insertMany(payload);
|
|
|
|
const ctx: any = { em, guard: new Guard() };
|
|
const controller = new DataController(ctx, dataConfig);
|
|
const app = controller.getController();
|
|
|
|
// @ts-ignore tests
|
|
const api = new DataApi({ basepath: "/" }, app.request as typeof fetch);
|
|
{
|
|
const req = api.readMany("posts", {
|
|
select: ["title", "count"],
|
|
});
|
|
const res = await req;
|
|
expect(res.data).toEqual(payload as any);
|
|
}
|
|
|
|
{
|
|
// update with empty where
|
|
expect(() => api.updateMany("posts", {}, { count: 1 })).toThrow();
|
|
expect(() => api.updateMany("posts", undefined, { count: 1 })).toThrow();
|
|
}
|
|
|
|
{
|
|
// update
|
|
const req = await api.updateMany("posts", { count: 0 }, { count: 1 });
|
|
expect(req.res.status).toBe(200);
|
|
}
|
|
|
|
{
|
|
// compare
|
|
const res = await api.readMany("posts", {
|
|
select: ["title", "count"],
|
|
});
|
|
expect(res.map((p) => p.count)).toEqual([1, 1, 1, 2]);
|
|
}
|
|
});
|
|
|
|
it("refines", async () => {
|
|
const schema = proto.em({
|
|
posts: proto.entity("posts", { title: proto.text() }),
|
|
});
|
|
const em = schemaToEm(schema);
|
|
await em.schema().sync({ force: true });
|
|
|
|
const payload = [{ title: "foo" }, { title: "bar" }, { title: "baz" }];
|
|
await em.mutator("posts").insertMany(payload);
|
|
|
|
const ctx: any = { em, guard: new Guard() };
|
|
const controller = new DataController(ctx, dataConfig);
|
|
const app = controller.getController();
|
|
|
|
const api = new DataApi({ basepath: "/" }, app.request as typeof fetch);
|
|
const normalOne = api.readOne("posts", 1);
|
|
const normal = api.readMany("posts", { select: ["title"], where: { title: "baz" } });
|
|
expect((await normal).data).toEqual([{ title: "baz" }] as any);
|
|
|
|
// refine
|
|
const refined = normal.refine((data) => data[0]);
|
|
expect((await refined).data).toEqual({ title: "baz" } as any);
|
|
|
|
// one
|
|
const oneBy = api.readOneBy("posts", { where: { title: "baz" }, select: ["title"] });
|
|
const oneByRes = await oneBy;
|
|
expect(oneByRes.data).toEqual({ title: "baz" } as any);
|
|
expect(oneByRes.body.meta.items).toEqual(1);
|
|
});
|
|
|
|
it("exists/count", async () => {
|
|
const schema = proto.em({
|
|
posts: proto.entity("posts", { title: proto.text() }),
|
|
});
|
|
const em = schemaToEm(schema);
|
|
await em.schema().sync({ force: true });
|
|
|
|
const payload = [{ title: "foo" }, { title: "bar" }, { title: "baz" }];
|
|
await em.mutator("posts").insertMany(payload);
|
|
|
|
const ctx: any = { em, guard: new Guard() };
|
|
const controller = new DataController(ctx, dataConfig);
|
|
const app = controller.getController();
|
|
|
|
const api = new DataApi({ basepath: "/" }, app.request as typeof fetch);
|
|
|
|
const exists = api.exists("posts", { id: 1 });
|
|
expect((await exists).exists).toBeTrue();
|
|
|
|
expect((await api.count("posts")).count).toEqual(3);
|
|
});
|
|
|
|
it("creates many", async () => {
|
|
const schema = proto.em({
|
|
posts: proto.entity("posts", { title: proto.text(), count: proto.number() }),
|
|
});
|
|
const em = schemaToEm(schema);
|
|
await em.schema().sync({ force: true });
|
|
|
|
const payload = [
|
|
{ title: "foo", count: 0 },
|
|
{ title: "bar", count: 0 },
|
|
{ title: "baz", count: 0 },
|
|
{ title: "bla", count: 2 },
|
|
];
|
|
|
|
const ctx: any = { em, guard: new Guard() };
|
|
const controller = new DataController(ctx, dataConfig);
|
|
const app = controller.getController();
|
|
|
|
// @ts-ignore tests
|
|
const api = new DataApi({ basepath: "/" }, app.request as typeof fetch);
|
|
|
|
{
|
|
// create many
|
|
const res = await api.createMany("posts", payload);
|
|
expect(res.data?.length).toEqual(4);
|
|
expect(res.ok).toBeTrue();
|
|
}
|
|
|
|
{
|
|
const req = api.readMany("posts", {
|
|
select: ["title", "count"],
|
|
});
|
|
const res = await req;
|
|
expect(res.data).toEqual(payload as any);
|
|
}
|
|
|
|
{
|
|
// create with empty
|
|
expect(() => api.createMany("posts", [])).toThrow();
|
|
}
|
|
});
|
|
|
|
describe("types", async () => {
|
|
const schema = proto.em(
|
|
{
|
|
posts: proto.entity("posts", { title: proto.text(), count: proto.number() }),
|
|
comments: proto.entity("comments", { text: proto.text() }),
|
|
},
|
|
(fn, s) => {
|
|
fn.relation(s.comments).manyToOne(s.posts);
|
|
},
|
|
);
|
|
const em = schemaToEm(schema);
|
|
await em.schema().sync({ force: true });
|
|
|
|
const data = {
|
|
posts: [
|
|
{ title: "foo", count: 0 },
|
|
{ title: "bar", count: 0 },
|
|
{ title: "baz", count: 0 },
|
|
{ title: "bla", count: 2 },
|
|
],
|
|
comments: [
|
|
{ text: "comment1", posts_id: 1 },
|
|
{ text: "comment2", posts_id: 1 },
|
|
{ text: "comment3", posts_id: 2 },
|
|
],
|
|
};
|
|
|
|
const ctx: any = { em, guard: new Guard() };
|
|
const controller = new DataController(ctx, dataConfig);
|
|
const app = controller.getController();
|
|
|
|
type Posts = {
|
|
id: Generated<number>;
|
|
title?: string;
|
|
count?: number;
|
|
comments?: Comments[];
|
|
};
|
|
type Comments = {
|
|
id: Generated<number>;
|
|
text?: string;
|
|
posts_id?: number;
|
|
posts?: Posts;
|
|
};
|
|
type DB = {
|
|
posts: Posts;
|
|
comments: Comments;
|
|
};
|
|
|
|
const api = new DataApi<DB>({ basepath: "/" }, app.request);
|
|
for (const [entity, payload] of Object.entries(data)) {
|
|
await api.createMany(entity as any, payload);
|
|
}
|
|
|
|
it("readOne", async () => {
|
|
const result = await api.readOne("posts", 1);
|
|
const expected = { id: 1, title: "foo", count: 0 } as any;
|
|
expect(result.res).toBeInstanceOf(Response);
|
|
expect(result.data).toEqual(expected);
|
|
expect(result.body.meta.items).toEqual(1);
|
|
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Posts | null>();
|
|
|
|
{
|
|
// not found
|
|
const result = await api.readOne("posts", 0);
|
|
expect(result.res.status).toEqual(404);
|
|
expect(result.data).toBeNull();
|
|
expect(result.body.meta.items).toEqual(0);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Posts | null>();
|
|
}
|
|
});
|
|
|
|
it("readOneBy", async () => {
|
|
const result = await api.readOneBy("posts", { where: { title: "foo" } });
|
|
const expected = { id: 1, title: "foo", count: 0 } as any;
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toEqual(expected);
|
|
// @ts-expect-error body data is typed same as data...
|
|
expect(result.body.data).toEqual([expected]); // should be array
|
|
expect(result.body.meta.items).toEqual(1);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Posts | null>();
|
|
|
|
{
|
|
// not found
|
|
const result = await api.readOneBy("posts", { where: { title: "not found" } });
|
|
// since we're filtering, the result is okay, but empty
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toBeNull();
|
|
// @ts-expect-error body data is typed same as data...
|
|
expect(result.body.data).toEqual([]);
|
|
expect(result.body.meta.items).toEqual(0);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Posts | null>();
|
|
}
|
|
});
|
|
|
|
it("readMany", async () => {
|
|
const result = await api.readMany("posts", { where: { title: "foo" } });
|
|
const expected = [{ id: 1, title: "foo", count: 0 }] as any;
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toEqual(expected);
|
|
expect(result.body.data).toEqual(expected);
|
|
expect(result.body.meta.items).toEqual(1);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Posts[]>();
|
|
|
|
{
|
|
// not found
|
|
const result = await api.readMany("posts", { where: { title: "not found" } });
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toEqual([]);
|
|
expect(result.body.meta.items).toEqual(0);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Posts[]>();
|
|
}
|
|
});
|
|
|
|
it("readManyByReference", async () => {
|
|
const result = await api.readManyByReference("posts", 1, "comments");
|
|
const expected = [
|
|
{ id: 1, text: "comment1", posts_id: 1 },
|
|
{ id: 2, text: "comment2", posts_id: 1 },
|
|
] as any;
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toEqual(expected);
|
|
expect(result.body.meta.items).toEqual(2);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Comments[]>();
|
|
|
|
{
|
|
// empty
|
|
const result = await api.readManyByReference("posts", 3, "comments");
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toEqual([]);
|
|
expect(result.body.meta.items).toEqual(0);
|
|
expectTypeOf<(typeof result)["data"]>().toEqualTypeOf<Comments[]>();
|
|
}
|
|
|
|
{
|
|
// non existing (expected, since only 1 query is performed)
|
|
const result = await api.readManyByReference("posts", 100, "comments");
|
|
expect(result.res.status).toEqual(200);
|
|
expect(result.data).toEqual([]);
|
|
}
|
|
});
|
|
});
|
|
});
|