Reorganize repo structure and standards references
This commit is contained in:
1 parent
3cb93a81be
commit
be2054274d
5885 files changed
+2588
-195
No files matched your search
+238
@@ -0,0 +1,238 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import {
|
||||
assertClientCoversTenantScopedModels,
|
||||
createPrismaRestoreRunner,
|
||||
createPrismaSnapshotRunner,
|
||||
prismaModelAccessor,
|
||||
type PrismaLikeClient,
|
||||
} from "./prisma-runner.js";
|
||||
import { TENANT_SCOPED_MODELS } from "./models.js";
|
||||
import type { ModelScalarTypeMap } from "./json-codec.js";
|
||||
|
||||
describe("prismaModelAccessor", () => {
|
||||
it("lowercases the first character", () => {
|
||||
expect(prismaModelAccessor("TenantUser")).toBe("tenantUser");
|
||||
expect(prismaModelAccessor("Row")).toBe("row");
|
||||
expect(prismaModelAccessor("TenantSettingsRow")).toBe("tenantSettingsRow");
|
||||
});
|
||||
});
|
||||
|
||||
describe("createPrismaSnapshotRunner", () => {
|
||||
it("paginates by id cursor and yields every row exactly once", async () => {
|
||||
const rows = Array.from({ length: 5 }, (_, i) => ({ id: `r${i + 1}`, tenantId: "t1", v: i }));
|
||||
const calls: Array<Record<string, unknown>> = [];
|
||||
const client: PrismaLikeClient = {
|
||||
tenantUser: {
|
||||
findMany: async (args: Record<string, unknown>) => {
|
||||
calls.push(args);
|
||||
const take = args.take as number;
|
||||
const skip = (args.skip as number | undefined) ?? 0;
|
||||
const cursor = args.cursor as { id?: string } | undefined;
|
||||
let startIdx = 0;
|
||||
if (cursor?.id) {
|
||||
startIdx = rows.findIndex((r) => r.id === cursor.id) + skip;
|
||||
}
|
||||
return rows.slice(startIdx, startIdx + take);
|
||||
},
|
||||
},
|
||||
};
|
||||
const runner = createPrismaSnapshotRunner(client);
|
||||
const out: Array<Record<string, unknown>> = [];
|
||||
for await (const r of runner.findManyByTenant("TenantUser", "tenantId", "t1", 2)) {
|
||||
out.push(r);
|
||||
}
|
||||
expect(out.map((r) => r.id)).toEqual(["r1", "r2", "r3", "r4", "r5"]);
|
||||
// First page: no cursor; subsequent pages must include cursor + skip=1.
|
||||
expect(calls[0]?.cursor).toBeUndefined();
|
||||
expect(calls[1]?.cursor).toEqual({ id: "r2" });
|
||||
expect(calls[1]?.skip).toBe(1);
|
||||
});
|
||||
|
||||
it("uses tenantId as the cursor for TenantSettingsRow", async () => {
|
||||
const calls: Array<Record<string, unknown>> = [];
|
||||
const client: PrismaLikeClient = {
|
||||
tenantSettingsRow: {
|
||||
findMany: async (args: Record<string, unknown>) => {
|
||||
calls.push(args);
|
||||
if ((args.cursor as { tenantId?: string } | undefined)?.tenantId === "t1") return [];
|
||||
return [{ tenantId: "t1", foo: "bar" }];
|
||||
},
|
||||
},
|
||||
};
|
||||
const runner = createPrismaSnapshotRunner(client);
|
||||
const out: Array<Record<string, unknown>> = [];
|
||||
for await (const r of runner.findManyByTenant("TenantSettingsRow", "tenantId", "t1", 100)) {
|
||||
out.push(r);
|
||||
}
|
||||
expect(out).toEqual([{ tenantId: "t1", foo: "bar" }]);
|
||||
expect(calls[0]?.orderBy).toEqual({ tenantId: "asc" });
|
||||
});
|
||||
|
||||
it("throws when the client has no delegate for the model", async () => {
|
||||
const client: PrismaLikeClient = {};
|
||||
const runner = createPrismaSnapshotRunner(client);
|
||||
const iter = runner.findManyByTenant("TenantUser", "tenantId", "t1", 100);
|
||||
await expect((async () => {
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
for await (const _ of iter) {
|
||||
/* unreachable */
|
||||
}
|
||||
})()).rejects.toThrow(/no delegate for model "TenantUser"/u);
|
||||
});
|
||||
});
|
||||
|
||||
describe("createPrismaRestoreRunner", () => {
|
||||
it("calls createMany with skipDuplicates and returns the written count", async () => {
|
||||
let received: Record<string, unknown> | undefined;
|
||||
const client: PrismaLikeClient = {
|
||||
tenantUser: {
|
||||
createMany: async (args: Record<string, unknown>) => {
|
||||
received = args;
|
||||
return { count: (args.data as unknown[]).length };
|
||||
},
|
||||
},
|
||||
};
|
||||
const types = new Map<string, ModelScalarTypeMap>();
|
||||
const runner = createPrismaRestoreRunner(client, types);
|
||||
const result = await runner.createMany("TenantUser", [
|
||||
{ id: "tu1", tenantId: "t2", userId: "u1" },
|
||||
{ id: "tu2", tenantId: "t2", userId: "u2" },
|
||||
]);
|
||||
expect(result.written).toBe(2);
|
||||
expect(received?.skipDuplicates).toBe(true);
|
||||
expect((received?.data as unknown[]).length).toBe(2);
|
||||
});
|
||||
|
||||
it("decodes coded scalar fields before passing rows to Prisma", async () => {
|
||||
let received: Array<Record<string, unknown>> | undefined;
|
||||
const client: PrismaLikeClient = {
|
||||
collabDoc: {
|
||||
createMany: async (args: Record<string, unknown>) => {
|
||||
received = args.data as Array<Record<string, unknown>>;
|
||||
return { count: received.length };
|
||||
},
|
||||
},
|
||||
};
|
||||
const types = new Map<string, ModelScalarTypeMap>([
|
||||
[
|
||||
"CollabDoc",
|
||||
{
|
||||
modelName: "CollabDoc",
|
||||
fields: new Map([
|
||||
["createdAt", "DateTime"],
|
||||
["ydocState", "Bytes"],
|
||||
]),
|
||||
},
|
||||
],
|
||||
]);
|
||||
const runner = createPrismaRestoreRunner(client, types);
|
||||
const base64 = Buffer.from("hi").toString("base64");
|
||||
await runner.createMany("CollabDoc", [
|
||||
{ id: "c1", tenantId: "t1", createdAt: "2026-05-24T12:00:00.000Z", ydocState: base64 },
|
||||
]);
|
||||
const row = received![0]!;
|
||||
expect(row.createdAt).toBeInstanceOf(Date);
|
||||
expect(Buffer.isBuffer(row.ydocState)).toBe(true);
|
||||
expect((row.ydocState as Buffer).toString()).toBe("hi");
|
||||
});
|
||||
|
||||
it("findManyByIds delegates to findMany with where.id.in", async () => {
|
||||
let received: Record<string, unknown> | undefined;
|
||||
const client: PrismaLikeClient = {
|
||||
user: {
|
||||
findMany: async (args: Record<string, unknown>) => {
|
||||
received = args;
|
||||
return [{ id: "u1" }, { id: "u2" }];
|
||||
},
|
||||
},
|
||||
};
|
||||
const runner = createPrismaSnapshotRunner(client);
|
||||
const rows = await runner.findManyByIds!("User", ["u1", "u2"]);
|
||||
expect(rows).toHaveLength(2);
|
||||
expect(received).toEqual({ where: { id: { in: ["u1", "u2"] } } });
|
||||
});
|
||||
|
||||
it("findManyByIds returns [] without calling Prisma for an empty id list", async () => {
|
||||
let invoked = false;
|
||||
const client: PrismaLikeClient = {
|
||||
user: {
|
||||
findMany: async () => {
|
||||
invoked = true;
|
||||
return [];
|
||||
},
|
||||
},
|
||||
};
|
||||
const runner = createPrismaSnapshotRunner(client);
|
||||
const rows = await runner.findManyByIds!("User", []);
|
||||
expect(rows).toEqual([]);
|
||||
expect(invoked).toBe(false);
|
||||
});
|
||||
|
||||
it("upsertManyById creates fresh rows and reports updated=N for pre-existing ids", async () => {
|
||||
const existing = new Set(["u_exists"]);
|
||||
const createdRows: Array<Record<string, unknown>> = [];
|
||||
const client: PrismaLikeClient = {
|
||||
user: {
|
||||
findUnique: async (args: { where: { id: string } }) => {
|
||||
return existing.has(args.where.id) ? { id: args.where.id } : null;
|
||||
},
|
||||
create: async (args: { data: Record<string, unknown> }) => {
|
||||
createdRows.push(args.data);
|
||||
return args.data;
|
||||
},
|
||||
},
|
||||
};
|
||||
const runner = createPrismaRestoreRunner(client, new Map());
|
||||
const result = await runner.upsertManyById!("User", [
|
||||
{ id: "u_exists", email: "old@x" },
|
||||
{ id: "u_new", email: "new@x" },
|
||||
]);
|
||||
expect(result).toEqual({ created: 1, updated: 1 });
|
||||
expect(createdRows).toHaveLength(1);
|
||||
expect(createdRows[0]?.id).toBe("u_new");
|
||||
});
|
||||
|
||||
it("upsertManyById throws when a row has no string id", async () => {
|
||||
const client: PrismaLikeClient = {
|
||||
user: {
|
||||
findUnique: async () => null,
|
||||
create: async (args: { data: Record<string, unknown> }) => args.data,
|
||||
},
|
||||
};
|
||||
const runner = createPrismaRestoreRunner(client, new Map());
|
||||
await expect(runner.upsertManyById!("User", [{ email: "x@y" }])).rejects.toThrow(
|
||||
/has no string id/u,
|
||||
);
|
||||
});
|
||||
|
||||
it("returns { written: 0 } for an empty row list without calling Prisma", async () => {
|
||||
let invoked = false;
|
||||
const client: PrismaLikeClient = {
|
||||
tenantUser: {
|
||||
createMany: async () => {
|
||||
invoked = true;
|
||||
return { count: 99 };
|
||||
},
|
||||
},
|
||||
};
|
||||
const runner = createPrismaRestoreRunner(client, new Map());
|
||||
const result = await runner.createMany("TenantUser", []);
|
||||
expect(result.written).toBe(0);
|
||||
expect(invoked).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("assertClientCoversTenantScopedModels", () => {
|
||||
it("passes for a client exposing every accessor", () => {
|
||||
const client: PrismaLikeClient = {};
|
||||
for (const { model } of TENANT_SCOPED_MODELS) {
|
||||
client[prismaModelAccessor(model)] = { findMany: () => Promise.resolve([]) };
|
||||
}
|
||||
expect(() => assertClientCoversTenantScopedModels(client)).not.toThrow();
|
||||
});
|
||||
|
||||
it("throws listing the missing models when accessors are absent", () => {
|
||||
const client: PrismaLikeClient = {};
|
||||
expect(() => assertClientCoversTenantScopedModels(client)).toThrow(/missing accessors/u);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user