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
+467
@@ -0,0 +1,467 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { mkdtemp, rm } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
import { tmpdir } from "node:os";
|
||||
import { Readable } from "node:stream";
|
||||
import { mockClient } from "aws-sdk-client-mock";
|
||||
import { GetObjectCommand, ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
|
||||
import { Upload } from "@aws-sdk/lib-storage";
|
||||
import { runTenantSnapshot, type PrismaRunner } from "./snapshot.js";
|
||||
import {
|
||||
isGlobalsRestoreMode,
|
||||
runTenantRestore,
|
||||
type PrismaRestoreRunner,
|
||||
} from "./restore.js";
|
||||
|
||||
class FakeSourcePrisma implements PrismaRunner {
|
||||
constructor(
|
||||
private readonly rows: Record<string, Record<string, unknown>[]>,
|
||||
private readonly globals: Record<string, Record<string, unknown>[]> = {},
|
||||
) {}
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
async *findManyByTenant(
|
||||
modelName: string,
|
||||
tenantField: string,
|
||||
tenantId: string,
|
||||
pageSize: number,
|
||||
): AsyncIterable<Record<string, unknown>> {
|
||||
void tenantField;
|
||||
void tenantId;
|
||||
void pageSize;
|
||||
const list = this.rows[modelName] ?? [];
|
||||
for (const r of list) yield r;
|
||||
}
|
||||
async findManyByIds(modelName: string, ids: readonly string[]): Promise<Record<string, unknown>[]> {
|
||||
const list = this.globals[modelName] ?? [];
|
||||
return list.filter((r) => typeof r.id === "string" && ids.includes(r.id as string));
|
||||
}
|
||||
}
|
||||
|
||||
class FakeTargetPrisma implements PrismaRestoreRunner {
|
||||
readonly writes: Record<string, Record<string, unknown>[]> = {};
|
||||
/** Rows that already exist on the target — used by upsertManyById to simulate prior state. */
|
||||
readonly preExisting: Record<string, Set<string>> = {};
|
||||
async createMany(modelName: string, rows: Record<string, unknown>[]): Promise<{ written: number }> {
|
||||
this.writes[modelName] = (this.writes[modelName] ?? []).concat(rows);
|
||||
return { written: rows.length };
|
||||
}
|
||||
async upsertManyById(
|
||||
modelName: string,
|
||||
rows: Record<string, unknown>[],
|
||||
): Promise<{ created: number; updated: number }> {
|
||||
const existing = this.preExisting[modelName] ?? new Set<string>();
|
||||
let created = 0;
|
||||
let updated = 0;
|
||||
for (const row of rows) {
|
||||
const id = row.id as string;
|
||||
if (existing.has(id)) {
|
||||
updated += 1;
|
||||
continue;
|
||||
}
|
||||
this.writes[modelName] = (this.writes[modelName] ?? []).concat(row);
|
||||
created += 1;
|
||||
}
|
||||
return { created, updated };
|
||||
}
|
||||
}
|
||||
|
||||
/** Variant without upsertManyById — exercises the legacy-runner fallback. */
|
||||
class LegacyTargetPrisma implements PrismaRestoreRunner {
|
||||
readonly writes: Record<string, Record<string, unknown>[]> = {};
|
||||
async createMany(modelName: string, rows: Record<string, unknown>[]): Promise<{ written: number }> {
|
||||
this.writes[modelName] = (this.writes[modelName] ?? []).concat(rows);
|
||||
return { written: rows.length };
|
||||
}
|
||||
}
|
||||
|
||||
class PartialWriteTargetPrisma extends FakeTargetPrisma {
|
||||
constructor(private readonly partialModel: string) {
|
||||
super();
|
||||
}
|
||||
|
||||
override async createMany(modelName: string, rows: Record<string, unknown>[]): Promise<{ written: number }> {
|
||||
this.writes[modelName] = (this.writes[modelName] ?? []).concat(rows);
|
||||
return { written: modelName === this.partialModel ? Math.max(0, rows.length - 1) : rows.length };
|
||||
}
|
||||
}
|
||||
|
||||
describe("runTenantRestore", () => {
|
||||
let workdir: string;
|
||||
|
||||
beforeEach(async () => {
|
||||
workdir = await mkdtemp(join(tmpdir(), "tenant-restore-test-"));
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
await rm(workdir, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
it("recognizes supported globals restore modes", () => {
|
||||
expect(isGlobalsRestoreMode("upsert")).toBe(true);
|
||||
expect(isGlobalsRestoreMode("skip")).toBe(true);
|
||||
expect(isGlobalsRestoreMode("error")).toBe(true);
|
||||
expect(isGlobalsRestoreMode("merge")).toBe(false);
|
||||
expect(isGlobalsRestoreMode("")).toBe(false);
|
||||
});
|
||||
|
||||
it("round-trips a snapshot through restore with FK-remapped tenantId", async () => {
|
||||
// 1. Snapshot from FakeSourcePrisma.
|
||||
const sourcePrisma = new FakeSourcePrisma({
|
||||
TenantUser: [
|
||||
{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 },
|
||||
{ id: "tu2", tenantId: "tenant_a", userId: "u2", type: 1, joined: 1, status: 1 },
|
||||
],
|
||||
TenantUserInvitation: [
|
||||
{ id: "inv1", tenantId: "tenant_a", email: "x@y.io", firstName: "X", lastName: "Y" },
|
||||
],
|
||||
});
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await runTenantSnapshot({
|
||||
tenantId: "tenant_a",
|
||||
profile: "full-anonymized",
|
||||
prisma: sourcePrisma,
|
||||
output: { kind: "local", path: snapshotPath },
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
|
||||
// 2. Restore into FakeTargetPrisma.
|
||||
const target = new FakeTargetPrisma();
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
|
||||
expect(result.manifest.sourceTenantId).toBe("tenant_a");
|
||||
const tuEntry = result.perModel.find((m) => m.model === "TenantUser");
|
||||
expect(tuEntry).toEqual({ model: "TenantUser", written: 2, expected: 2 });
|
||||
// All rows should have the new tenantId.
|
||||
expect(target.writes.TenantUser).toHaveLength(2);
|
||||
for (const row of target.writes.TenantUser) {
|
||||
expect(row.tenantId).toBe("tenant_a_clone");
|
||||
}
|
||||
// Anonymization preserved on the way in.
|
||||
expect(target.writes.TenantUserInvitation?.[0]?.email).toMatch(/@anonymized\.test$/u);
|
||||
});
|
||||
|
||||
it("aborts when the operator answers 'no' to the confirmation prompt", async () => {
|
||||
const sourcePrisma = new FakeSourcePrisma({
|
||||
TenantUser: [{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 }],
|
||||
});
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await runTenantSnapshot({
|
||||
tenantId: "tenant_a",
|
||||
profile: "full-anonymized",
|
||||
prisma: sourcePrisma,
|
||||
output: { kind: "local", path: snapshotPath },
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
|
||||
const target = new FakeTargetPrisma();
|
||||
const { Readable } = await import("node:stream");
|
||||
const { Writable } = await import("node:stream");
|
||||
const stdin = Readable.from(["n\n"]);
|
||||
const stdout = new Writable({ write: (_c, _e, cb) => cb() });
|
||||
await expect(
|
||||
runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: false,
|
||||
stdin: stdin as NodeJS.ReadableStream,
|
||||
stdout,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
}),
|
||||
).rejects.toThrow(/Aborted/u);
|
||||
});
|
||||
|
||||
it("refuses to run in production without --allow-production-restore", async () => {
|
||||
const prev = process.env.NODE_ENV;
|
||||
process.env.NODE_ENV = "production";
|
||||
try {
|
||||
await expect(
|
||||
runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: "/nonexistent.tar.gz",
|
||||
prisma: new FakeTargetPrisma(),
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
}),
|
||||
).rejects.toThrow(/production/u);
|
||||
} finally {
|
||||
process.env.NODE_ENV = prev;
|
||||
}
|
||||
});
|
||||
|
||||
it("rejects malformed s3 sources before attempting a restore", async () => {
|
||||
await expect(
|
||||
runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: "s3://bucket-only",
|
||||
prisma: new FakeTargetPrisma(),
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
}),
|
||||
).rejects.toThrow(/Invalid --source/u);
|
||||
});
|
||||
|
||||
it("restores storage objects under the target tenant prefix", async () => {
|
||||
const sourcePrisma = new FakeSourcePrisma({
|
||||
TenantUser: [{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 }],
|
||||
});
|
||||
const sourceS3 = mockClient(S3Client as never);
|
||||
sourceS3.on(ListObjectsV2Command as never).callsFake(() => ({
|
||||
Contents: [{ Key: "tenants/tenant_a/uploads/file.txt", Size: 11, ETag: '"etag"' }],
|
||||
IsTruncated: false,
|
||||
}));
|
||||
sourceS3.on(GetObjectCommand as never).callsFake(() => ({
|
||||
Body: Readable.from([Buffer.from("hello world")]),
|
||||
}));
|
||||
|
||||
const snapshotPath = join(workdir, "snap-with-storage.tar.gz");
|
||||
await runTenantSnapshot({
|
||||
tenantId: "tenant_a",
|
||||
profile: "full-anonymized",
|
||||
prisma: sourcePrisma,
|
||||
output: { kind: "local", path: snapshotPath },
|
||||
s3Client: sourceS3 as unknown as S3Client,
|
||||
storageBucket: "app-storage",
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
|
||||
const uploadedKeys: string[] = [];
|
||||
const origDone = Upload.prototype.done;
|
||||
Upload.prototype.done = vi.fn(function (this: Upload) {
|
||||
const params = this["params"] as { Key?: string };
|
||||
if (params.Key) uploadedKeys.push(params.Key);
|
||||
return Promise.resolve({ ETag: '"uploaded"' });
|
||||
}) as never;
|
||||
try {
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_b",
|
||||
source: snapshotPath,
|
||||
prisma: new FakeTargetPrisma(),
|
||||
storageBucket: "target-storage",
|
||||
s3Client: new S3Client({ region: "us-east-1" }),
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
|
||||
expect(result.storageObjectsUploaded).toBe(1);
|
||||
expect(uploadedKeys).toEqual(["tenants/tenant_b/uploads/file.txt"]);
|
||||
} finally {
|
||||
Upload.prototype.done = origDone;
|
||||
}
|
||||
});
|
||||
|
||||
it("warns when tenant-scoped model writes do not match manifest counts", async () => {
|
||||
const sourcePrisma = new FakeSourcePrisma({
|
||||
TenantUser: [
|
||||
{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 },
|
||||
{ id: "tu2", tenantId: "tenant_a", userId: "u2", type: 1, joined: 1, status: 1 },
|
||||
],
|
||||
});
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await runTenantSnapshot({
|
||||
tenantId: "tenant_a",
|
||||
profile: "full-anonymized",
|
||||
prisma: sourcePrisma,
|
||||
output: { kind: "local", path: snapshotPath },
|
||||
includeGlobals: false,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
const warn = vi.fn();
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: new PartialWriteTargetPrisma("TenantUser"),
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn },
|
||||
});
|
||||
|
||||
expect(result.perModel.find((m) => m.model === "TenantUser")).toEqual({
|
||||
model: "TenantUser",
|
||||
written: 1,
|
||||
expected: 2,
|
||||
});
|
||||
expect(warn).toHaveBeenCalledWith(expect.stringContaining("Model TenantUser: wrote 1 rows"));
|
||||
expect(warn).toHaveBeenCalledWith(expect.stringContaining("Row-count mismatch"));
|
||||
});
|
||||
|
||||
describe("globals replay", () => {
|
||||
async function snapshotWithUsers(snapshotPath: string): Promise<void> {
|
||||
const sourcePrisma = new FakeSourcePrisma(
|
||||
{
|
||||
TenantUser: [
|
||||
{ id: "tu1", tenantId: "tenant_a", userId: "u1", type: 1, joined: 1, status: 1 },
|
||||
{ id: "tu2", tenantId: "tenant_a", userId: "u2", type: 1, joined: 1, status: 1 },
|
||||
],
|
||||
},
|
||||
{
|
||||
User: [
|
||||
{ id: "u1", email: "first@real.com", firstName: "First", lastName: "Real" },
|
||||
{ id: "u2", email: "second@real.com", firstName: "Second", lastName: "Real" },
|
||||
],
|
||||
},
|
||||
);
|
||||
await runTenantSnapshot({
|
||||
tenantId: "tenant_a",
|
||||
profile: "full-anonymized",
|
||||
prisma: sourcePrisma,
|
||||
output: { kind: "local", path: snapshotPath },
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
}
|
||||
|
||||
it("replays globals BEFORE tenant-scoped models (default upsert mode)", async () => {
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await snapshotWithUsers(snapshotPath);
|
||||
const target = new FakeTargetPrisma();
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
const userGlobal = result.globals.find((g) => g.model === "User");
|
||||
expect(userGlobal).toEqual({ model: "User", expected: 2, created: 2, existed: 0 });
|
||||
// Users landed in target.
|
||||
expect(target.writes.User).toHaveLength(2);
|
||||
// And TenantUser rows landed under the new tenantId.
|
||||
expect(target.writes.TenantUser).toHaveLength(2);
|
||||
for (const row of target.writes.TenantUser) {
|
||||
expect(row.tenantId).toBe("tenant_a_clone");
|
||||
}
|
||||
});
|
||||
|
||||
it("upsert mode reports existed=N when globals already exist on target", async () => {
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await snapshotWithUsers(snapshotPath);
|
||||
const target = new FakeTargetPrisma();
|
||||
target.preExisting.User = new Set(["u1"]); // one of two users already present
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: true,
|
||||
globalsMode: "upsert",
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
expect(result.globals.find((g) => g.model === "User")).toEqual({
|
||||
model: "User",
|
||||
expected: 2,
|
||||
created: 1,
|
||||
existed: 1,
|
||||
});
|
||||
// Only the new user landed; the existing u1 was left in place.
|
||||
expect(target.writes.User).toHaveLength(1);
|
||||
expect((target.writes.User[0] as { id: string }).id).toBe("u2");
|
||||
});
|
||||
|
||||
it("error mode aborts when a global already exists on target", async () => {
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await snapshotWithUsers(snapshotPath);
|
||||
const target = new FakeTargetPrisma();
|
||||
target.preExisting.User = new Set(["u1"]);
|
||||
await expect(
|
||||
runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: true,
|
||||
globalsMode: "error",
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
}),
|
||||
).rejects.toThrow(/--globals=error/u);
|
||||
});
|
||||
|
||||
it("skip mode falls back to createMany semantics for legacy runners", async () => {
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await snapshotWithUsers(snapshotPath);
|
||||
const target = new LegacyTargetPrisma();
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: true,
|
||||
globalsMode: "skip",
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
expect(result.globals.find((g) => g.model === "User")?.created).toBe(2);
|
||||
expect(target.writes.User).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("default upsert mode warns and falls back for legacy runners", async () => {
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await snapshotWithUsers(snapshotPath);
|
||||
const target = new LegacyTargetPrisma();
|
||||
const warn = vi.fn();
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: target,
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn },
|
||||
});
|
||||
|
||||
expect(result.globals.find((g) => g.model === "User")).toEqual({
|
||||
model: "User",
|
||||
expected: 2,
|
||||
created: 2,
|
||||
existed: 0,
|
||||
});
|
||||
expect(warn).toHaveBeenCalledWith(expect.stringContaining("does not implement upsertManyById"));
|
||||
});
|
||||
|
||||
it("skip mode reports existing globals from partial createMany writes", async () => {
|
||||
const snapshotPath = join(workdir, "snap.tar.gz");
|
||||
await snapshotWithUsers(snapshotPath);
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: new PartialWriteTargetPrisma("User"),
|
||||
yes: true,
|
||||
globalsMode: "skip",
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
|
||||
expect(result.globals.find((g) => g.model === "User")).toEqual({
|
||||
model: "User",
|
||||
expected: 2,
|
||||
created: 1,
|
||||
existed: 1,
|
||||
});
|
||||
});
|
||||
|
||||
it("legacy snapshot (no globals slice) is tolerated with a warn line", async () => {
|
||||
// Build a snapshot using a runner without findManyByIds — manifest will
|
||||
// have no `globals` array (matches pre-feature snapshots).
|
||||
const legacySource: PrismaRunner = {
|
||||
async *findManyByTenant() {
|
||||
// empty
|
||||
},
|
||||
};
|
||||
const snapshotPath = join(workdir, "legacy.tar.gz");
|
||||
await runTenantSnapshot({
|
||||
tenantId: "tenant_a",
|
||||
profile: "full-anonymized",
|
||||
prisma: legacySource,
|
||||
output: { kind: "local", path: snapshotPath },
|
||||
logger: { info: vi.fn(), warn: vi.fn() },
|
||||
});
|
||||
const warn = vi.fn();
|
||||
const result = await runTenantRestore({
|
||||
tenantId: "tenant_a_clone",
|
||||
source: snapshotPath,
|
||||
prisma: new FakeTargetPrisma(),
|
||||
yes: true,
|
||||
logger: { info: vi.fn(), warn },
|
||||
});
|
||||
expect(result.globals).toEqual([]);
|
||||
expect(warn).toHaveBeenCalledWith(expect.stringContaining("no globals slice"));
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user