683 lines
25 KiB
TypeScript
683 lines
25 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import {
|
|
adminFindLegacyApiKeyById,
|
|
adminDeleteLegacyApiKeyLogsByIds,
|
|
countLegacyApiKeyLogsForKey,
|
|
countLegacyTenantApiKeyLogs,
|
|
countLegacyApiKeyLogs,
|
|
createLegacyApiKeyLog,
|
|
createLegacyApiKey,
|
|
deleteLegacyApiKey,
|
|
deleteTenantLegacyApiKeyLogsByIds,
|
|
findLegacyApiKeyByKey,
|
|
findLegacyApiKeyByAlias,
|
|
findLegacyApiKeyById,
|
|
findFirstLegacyActiveApiKey,
|
|
getAllLegacyApiKeys,
|
|
getLegacyApiKeyLogsForKey,
|
|
getLegacyApiKeysForTenant,
|
|
getLegacyApiKeyLogAdminDetails,
|
|
groupLegacyApiKeyLogs,
|
|
legacyApiKeyDetailsInclude,
|
|
rotateLegacyApiKey,
|
|
setLegacyApiKeyLogStatus,
|
|
tenantLegacyApiKeyLogScope,
|
|
updateLegacyApiKey,
|
|
deriveLegacyApiKeyHashMetadata,
|
|
backfillLegacyApiKeyHashes,
|
|
DEFAULT_LEGACY_API_KEY_HASH_BACKFILL_BATCH_SIZE,
|
|
type LegacyApiKeyHashBackfillClient,
|
|
type LegacyApiKeyLogWriterClient,
|
|
type LegacyApiKeyRotationClient,
|
|
type LegacyApiKeyReaderClient,
|
|
} from "./api-keys.server.js";
|
|
|
|
function createApiKeyHashBackfillClient(rows: Awaited<ReturnType<LegacyApiKeyHashBackfillClient["apiKey"]["findMany"]>>): LegacyApiKeyHashBackfillClient {
|
|
return {
|
|
apiKey: {
|
|
findMany: vi.fn().mockResolvedValue(rows),
|
|
update: vi.fn().mockResolvedValue({}),
|
|
},
|
|
};
|
|
}
|
|
|
|
function createApiKeyRotationClient(): LegacyApiKeyRotationClient {
|
|
return {
|
|
apiKey: {
|
|
updateMany: vi.fn().mockResolvedValue({ count: 1 }),
|
|
findFirst: vi.fn().mockImplementation(() => Promise.resolve({ id: "api_key_1", tenantId: "tenant_1", key: "rotated-secret" })),
|
|
},
|
|
};
|
|
}
|
|
|
|
function createApiKeyLogClient(): LegacyApiKeyLogWriterClient & LegacyApiKeyReaderClient {
|
|
return {
|
|
apiKey: {
|
|
create: vi.fn().mockResolvedValue({ id: "api_key_1", key: "raw-secret" }),
|
|
updateMany: vi.fn().mockResolvedValue({ count: 1 }),
|
|
findUnique: vi.fn().mockResolvedValue({ id: "api_key_1", tenantId: "tenant_1", key: "updated-secret" }),
|
|
findFirst: vi.fn().mockResolvedValue(null),
|
|
deleteMany: vi.fn().mockResolvedValue({ count: 1 }),
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
},
|
|
apiKeyLog: {
|
|
create: vi.fn().mockResolvedValue({ id: "log_1" }),
|
|
findMany: vi.fn().mockResolvedValue([]),
|
|
groupBy: vi.fn().mockResolvedValue([]),
|
|
update: vi.fn().mockResolvedValue({}),
|
|
updateMany: vi.fn().mockResolvedValue({ count: 1 }),
|
|
count: vi.fn().mockResolvedValue(3),
|
|
deleteMany: vi.fn().mockResolvedValue({ count: 2 }),
|
|
},
|
|
} as unknown as LegacyApiKeyLogWriterClient & LegacyApiKeyReaderClient;
|
|
}
|
|
|
|
describe("legacy API key log writes", () => {
|
|
it("updates status and calculates duration when a start time is provided", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.spyOn(performance, "now").mockReturnValue(25);
|
|
|
|
await setLegacyApiKeyLogStatus({ id: "log_1", tenantId: "tenant_1" }, { status: 200, startTime: 10 }, client);
|
|
|
|
expect(client.apiKeyLog.updateMany).toHaveBeenCalledWith({
|
|
where: { id: "log_1", tenantId: "tenant_1" },
|
|
data: {
|
|
status: 200,
|
|
error: undefined,
|
|
duration: 15,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("persists errors without calculating duration for synthetic failures", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await setLegacyApiKeyLogStatus({ id: "log_1", tenantId: "tenant_1" }, { status: 400, startTime: null, error: "Invalid API key" }, client);
|
|
|
|
expect(client.apiKeyLog.updateMany).toHaveBeenCalledWith({
|
|
where: { id: "log_1", tenantId: "tenant_1" },
|
|
data: {
|
|
status: 400,
|
|
error: "Invalid API key",
|
|
duration: null,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("updates status with tenant scope when provided", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(setLegacyApiKeyLogStatus({ id: "log_1", tenantId: "tenant_1" }, { status: 200, startTime: null }, client)).resolves.toEqual({
|
|
count: 1,
|
|
});
|
|
|
|
expect(client.apiKeyLog.updateMany).toHaveBeenCalledWith({
|
|
where: { id: "log_1", tenantId: "tenant_1" },
|
|
data: {
|
|
status: 200,
|
|
error: undefined,
|
|
duration: null,
|
|
},
|
|
});
|
|
expect(client.apiKeyLog.update).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects tenant-scoped status updates that miss", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.mocked(client.apiKeyLog.updateMany).mockResolvedValue({ count: 0 });
|
|
|
|
await expect(setLegacyApiKeyLogStatus({ id: "log_foreign", tenantId: "tenant_1" }, { status: 404, startTime: null }, client)).rejects.toThrow(
|
|
"API key log log_foreign not found"
|
|
);
|
|
});
|
|
|
|
it("counts tenant API key logs through the package boundary", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(countLegacyTenantApiKeyLogs("tenant_1", client)).resolves.toBe(3);
|
|
expect(client.apiKeyLog.count).toHaveBeenCalledWith({
|
|
where: tenantLegacyApiKeyLogScope("tenant_1"),
|
|
});
|
|
});
|
|
|
|
it("fetches API key lists and details through the package boundary", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const apiKey = {
|
|
id: "api_key_1",
|
|
alias: "Production",
|
|
expires: null,
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
active: true,
|
|
tenant: { id: "tenant_1", name: "Acme", slug: "acme", deactivatedReason: null },
|
|
_count: { apiKeyLogs: 0 },
|
|
};
|
|
vi.mocked(client.apiKey.findMany).mockResolvedValue([apiKey] as never);
|
|
vi.mocked(client.apiKey.findUnique).mockResolvedValue(apiKey as never);
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue(apiKey as never);
|
|
|
|
await expect(getAllLegacyApiKeys(client)).resolves.toEqual([apiKey]);
|
|
expect(client.apiKey.findMany).toHaveBeenCalledWith({
|
|
include: legacyApiKeyDetailsInclude,
|
|
orderBy: { createdAt: "desc" },
|
|
});
|
|
|
|
await expect(getLegacyApiKeysForTenant("tenant_1", client)).resolves.toEqual([apiKey]);
|
|
expect(client.apiKey.findMany).toHaveBeenCalledWith({
|
|
where: { tenantId: "tenant_1" },
|
|
include: legacyApiKeyDetailsInclude,
|
|
orderBy: { createdAt: "desc" },
|
|
});
|
|
|
|
await expect(adminFindLegacyApiKeyById("api_key_1", client)).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findUnique).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1" },
|
|
include: legacyApiKeyDetailsInclude,
|
|
});
|
|
|
|
await expect(findLegacyApiKeyById({ id: "api_key_1", tenantId: "tenant_1" }, client)).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
include: legacyApiKeyDetailsInclude,
|
|
});
|
|
|
|
await expect(findLegacyApiKeyByAlias("tenant_1", "Production", client)).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { tenantId: "tenant_1", alias: "Production" },
|
|
include: legacyApiKeyDetailsInclude,
|
|
});
|
|
});
|
|
|
|
it("fetches logs for one API key with tenant details", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(getLegacyApiKeyLogsForKey({ id: "api_key_1", tenantId: "tenant_1" }, client)).resolves.toEqual([]);
|
|
expect(client.apiKeyLog.findMany).toHaveBeenCalledWith({
|
|
where: {
|
|
apiKeyId: "api_key_1",
|
|
tenantId: "tenant_1",
|
|
},
|
|
include: {
|
|
apiKey: {
|
|
include: {
|
|
tenant: true,
|
|
},
|
|
},
|
|
},
|
|
orderBy: {
|
|
createdAt: "desc",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("counts logs for one API key through direct tenant scope", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(countLegacyApiKeyLogsForKey({ id: "api_key_1", tenantId: "tenant_1" }, client)).resolves.toBe(3);
|
|
expect(client.apiKeyLog.count).toHaveBeenCalledWith({
|
|
where: {
|
|
apiKeyId: "api_key_1",
|
|
tenantId: "tenant_1",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("groups API key logs for admin summaries", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(groupLegacyApiKeyLogs({ by: ["method", "endpoint"], where: { tenantId: "tenant_1" } }, client)).resolves.toEqual([]);
|
|
expect(client.apiKeyLog.groupBy).toHaveBeenCalledWith({
|
|
by: ["method", "endpoint"],
|
|
where: { tenantId: "tenant_1" },
|
|
_avg: { duration: true },
|
|
_count: { _all: true },
|
|
orderBy: {
|
|
_avg: { duration: "desc" },
|
|
},
|
|
});
|
|
});
|
|
|
|
it("fetches paginated API key log admin details", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(
|
|
getLegacyApiKeyLogAdminDetails(
|
|
{
|
|
take: 10,
|
|
skip: 20,
|
|
where: { tenantId: "tenant_1" },
|
|
includeTenant: true,
|
|
orderBy: { createdAt: "desc" },
|
|
},
|
|
client,
|
|
),
|
|
).resolves.toEqual([]);
|
|
expect(client.apiKeyLog.findMany).toHaveBeenCalledWith({
|
|
take: 10,
|
|
skip: 20,
|
|
where: { tenantId: "tenant_1" },
|
|
include: {
|
|
apiKey: {
|
|
select: { alias: true, tenant: { select: { id: true, name: true } } },
|
|
},
|
|
tenant: { select: { id: true, name: true, slug: true } },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
});
|
|
});
|
|
|
|
it("counts and deletes API key logs through the package boundary", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(countLegacyApiKeyLogs({ tenantId: "tenant_1" }, client)).resolves.toBe(3);
|
|
expect(client.apiKeyLog.count).toHaveBeenCalledWith({
|
|
where: { tenantId: "tenant_1" },
|
|
});
|
|
|
|
await expect(adminDeleteLegacyApiKeyLogsByIds(["log_1", "log_2"], client)).resolves.toEqual({ count: 2 });
|
|
expect(client.apiKeyLog.deleteMany).toHaveBeenCalledWith({
|
|
where: { id: { in: ["log_1", "log_2"] } },
|
|
});
|
|
|
|
await expect(deleteTenantLegacyApiKeyLogsByIds({ ids: ["log_1", "log_2"], tenantId: "tenant_1" }, client)).resolves.toEqual({ count: 2 });
|
|
expect(client.apiKeyLog.deleteMany).toHaveBeenLastCalledWith({
|
|
where: {
|
|
id: { in: ["log_1", "log_2"] },
|
|
...tenantLegacyApiKeyLogScope("tenant_1"),
|
|
},
|
|
});
|
|
});
|
|
|
|
it("fetches the first active tenant API key", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const apiKey = { id: "api_key_1", tenantId: "tenant_1", active: true };
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue(apiKey as never);
|
|
|
|
await expect(findFirstLegacyActiveApiKey("tenant_1", client)).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: {
|
|
tenantId: "tenant_1",
|
|
active: true,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("creates API keys with deterministic hash metadata and returns plaintext only once", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const expires = new Date("2026-05-01T00:00:00.000Z");
|
|
const key = "api_test_plaintext_secret";
|
|
const expectedMetadata = deriveLegacyApiKeyHashMetadata(key, "hash-secret");
|
|
|
|
await expect(
|
|
createLegacyApiKey(
|
|
{
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
alias: "Production",
|
|
expires,
|
|
active: false,
|
|
key,
|
|
},
|
|
client,
|
|
"hash-secret",
|
|
),
|
|
).resolves.toEqual({ id: "api_key_1", key });
|
|
|
|
expect(client.apiKey.create).toHaveBeenCalledWith({
|
|
data: expect.objectContaining({
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
alias: "Production",
|
|
expires,
|
|
active: false,
|
|
key,
|
|
keyHash: expectedMetadata.keyHash,
|
|
keyPrefix: "api_test",
|
|
keyLastFour: "cret",
|
|
keyVersion: 1,
|
|
}),
|
|
});
|
|
expect(vi.mocked(client.apiKey.create).mock.calls[0]?.[0].data.hashedAt).toBeInstanceOf(Date);
|
|
});
|
|
|
|
it("derives stable and distinct API key hashes", () => {
|
|
const hashedAt = new Date("2026-05-07T12:30:00.000Z");
|
|
const first = deriveLegacyApiKeyHashMetadata("api_test_plaintext_secret", "hash-secret", hashedAt);
|
|
const second = deriveLegacyApiKeyHashMetadata("api_test_plaintext_secret", "hash-secret", hashedAt);
|
|
const different = deriveLegacyApiKeyHashMetadata("api_test_plaintext_other", "hash-secret", hashedAt);
|
|
|
|
expect(first).toEqual(second);
|
|
expect(first.keyHash).not.toBe(different.keyHash);
|
|
expect(first).toMatchObject({
|
|
keyPrefix: "api_test",
|
|
keyLastFour: "cret",
|
|
hashedAt,
|
|
keyVersion: 1,
|
|
});
|
|
});
|
|
|
|
it("backfills legacy plaintext API key hash metadata in a bounded batch", async () => {
|
|
const hashedAt = new Date("2026-05-07T13:00:00.000Z");
|
|
const client = createApiKeyHashBackfillClient([
|
|
{ id: "api_key_1", key: "api_test_plaintext_secret", keyHash: null, hashedAt: null },
|
|
{ id: "api_key_2", key: "api_test_plaintext_other", keyHash: null, hashedAt: null },
|
|
]);
|
|
|
|
await expect(backfillLegacyApiKeyHashes({ batchSize: 2, hashSecret: "hash-secret", now: hashedAt, client })).resolves.toEqual({
|
|
scanned: 2,
|
|
updated: 2,
|
|
skipped: 0,
|
|
failed: 0,
|
|
failures: [],
|
|
});
|
|
|
|
expect(client.apiKey.findMany).toHaveBeenCalledWith({
|
|
take: 2,
|
|
where: { OR: [{ keyHash: null }, { hashedAt: null }] },
|
|
select: { id: true, key: true, keyHash: true, hashedAt: true },
|
|
orderBy: { createdAt: "asc" },
|
|
});
|
|
expect(client.apiKey.update).toHaveBeenNthCalledWith(1, {
|
|
where: { id: "api_key_1" },
|
|
data: deriveLegacyApiKeyHashMetadata("api_test_plaintext_secret", "hash-secret", hashedAt),
|
|
});
|
|
expect(client.apiKey.update).toHaveBeenNthCalledWith(2, {
|
|
where: { id: "api_key_2" },
|
|
data: deriveLegacyApiKeyHashMetadata("api_test_plaintext_other", "hash-secret", hashedAt),
|
|
});
|
|
});
|
|
|
|
it("uses the default backfill batch size and skips guarded rows", async () => {
|
|
const existingHash = deriveLegacyApiKeyHashMetadata("api_test_already_hashed", "hash-secret");
|
|
const client = createApiKeyHashBackfillClient([
|
|
{ id: "api_key_empty", key: "", keyHash: null, hashedAt: null },
|
|
{ id: "api_key_hashed", key: "api_test_already_hashed", keyHash: existingHash.keyHash, hashedAt: null },
|
|
{ id: "api_key_timestamped", key: "api_test_timestamped", keyHash: null, hashedAt: existingHash.hashedAt },
|
|
]);
|
|
|
|
await expect(backfillLegacyApiKeyHashes({ client })).resolves.toEqual({
|
|
scanned: 3,
|
|
updated: 0,
|
|
skipped: 3,
|
|
failed: 0,
|
|
failures: [],
|
|
});
|
|
|
|
expect(client.apiKey.findMany).toHaveBeenCalledWith(expect.objectContaining({ take: DEFAULT_LEGACY_API_KEY_HASH_BACKFILL_BATCH_SIZE }));
|
|
expect(client.apiKey.update).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("records per-row backfill failures by id only and continues the batch", async () => {
|
|
const leakedSecret = "api_test_plaintext_secret";
|
|
const client = createApiKeyHashBackfillClient([
|
|
{ id: "api_key_fails", key: leakedSecret, keyHash: null, hashedAt: null },
|
|
{ id: "api_key_succeeds", key: "api_test_plaintext_other", keyHash: null, hashedAt: null },
|
|
]);
|
|
vi.mocked(client.apiKey.update)
|
|
.mockRejectedValueOnce(new Error(`unique constraint leaked ${leakedSecret}`))
|
|
.mockResolvedValueOnce({});
|
|
|
|
const result = await backfillLegacyApiKeyHashes({ hashSecret: "hash-secret", now: new Date("2026-05-07T13:00:00.000Z"), client });
|
|
|
|
expect(result).toEqual({
|
|
scanned: 2,
|
|
updated: 1,
|
|
skipped: 0,
|
|
failed: 1,
|
|
failures: [{ id: "api_key_fails", error: "Error" }],
|
|
});
|
|
expect(JSON.stringify(result)).not.toContain(leakedSecret);
|
|
expect(client.apiKey.update).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("rotates API keys with new plaintext and persisted hash metadata", async () => {
|
|
const client = createApiKeyRotationClient();
|
|
const oldMetadata = deriveLegacyApiKeyHashMetadata("old-secret", "hash-secret");
|
|
|
|
const rotated = await rotateLegacyApiKey({ id: "api_key_1", tenantId: "tenant_1" }, client, "hash-secret");
|
|
|
|
expect(rotated.key).toEqual(expect.any(String));
|
|
expect(rotated.key).not.toBe("old-secret");
|
|
expect(client.apiKey.updateMany).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
data: expect.objectContaining({
|
|
key: rotated.key,
|
|
keyHash: deriveLegacyApiKeyHashMetadata(rotated.key, "hash-secret").keyHash,
|
|
keyPrefix: rotated.key.slice(0, 8),
|
|
keyLastFour: rotated.key.slice(-4),
|
|
keyVersion: 1,
|
|
}),
|
|
});
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
});
|
|
expect(vi.mocked(client.apiKey.updateMany).mock.calls[0]?.[0].data.keyHash).not.toBe(oldMetadata.keyHash);
|
|
expect(vi.mocked(client.apiKey.updateMany).mock.calls[0]?.[0].data.hashedAt).toBeInstanceOf(Date);
|
|
});
|
|
|
|
it("redacts generated plaintext from rotation update errors", async () => {
|
|
const client = createApiKeyRotationClient();
|
|
vi.mocked(client.apiKey.updateMany).mockRejectedValue(new Error("database unavailable"));
|
|
|
|
await expect(rotateLegacyApiKey({ id: "api_key_1", tenantId: "tenant_1" }, client, "hash-secret")).rejects.toThrow("database unavailable");
|
|
|
|
const generatedKey = vi.mocked(client.apiKey.updateMany).mock.calls[0]?.[0].data.key;
|
|
await expect(rotateLegacyApiKey({ id: "api_key_1", tenantId: "tenant_1" }, client, "hash-secret")).rejects.not.toThrow(generatedKey);
|
|
});
|
|
|
|
it("keeps rotated API key validation hash-first and rejects old plaintext after persistence", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const oldKey = "api_test_old_plaintext";
|
|
const newKey = "api_test_new_plaintext";
|
|
const apiKey = {
|
|
id: "api_key_1",
|
|
alias: "Production",
|
|
expires: null,
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
active: true,
|
|
scopes: ["public_api:read"],
|
|
tenant: { id: "tenant_1", name: "Acme", slug: "acme", deactivatedReason: null },
|
|
};
|
|
vi.mocked(client.apiKey.findFirst).mockImplementation(({ where }) => {
|
|
if ("keyHash" in where && where.keyHash === deriveLegacyApiKeyHashMetadata(newKey, "hash-secret").keyHash) {
|
|
return Promise.resolve(apiKey) as never;
|
|
}
|
|
return Promise.resolve(null) as never;
|
|
});
|
|
|
|
await expect(findLegacyApiKeyByKey(newKey, client, "hash-secret")).resolves.toBe(apiKey);
|
|
await expect(findLegacyApiKeyByKey(oldKey, client, "hash-secret")).resolves.toBeNull();
|
|
expect(client.apiKey.findFirst).toHaveBeenNthCalledWith(1, {
|
|
where: { keyHash: deriveLegacyApiKeyHashMetadata(newKey, "hash-secret").keyHash },
|
|
select: expect.any(Object),
|
|
});
|
|
expect(client.apiKey.findFirst).toHaveBeenNthCalledWith(2, expect.objectContaining({
|
|
where: { keyHash: deriveLegacyApiKeyHashMetadata(oldKey, "hash-secret").keyHash },
|
|
}));
|
|
});
|
|
|
|
it("updates API keys and reloads the persisted record", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const expires = new Date("2026-05-01T00:00:00.000Z");
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue({ id: "api_key_1", tenantId: "tenant_1", key: "updated-secret" } as never);
|
|
|
|
await expect(
|
|
updateLegacyApiKey(
|
|
"api_key_1",
|
|
{
|
|
tenantId: "tenant_1",
|
|
alias: "Production",
|
|
expires,
|
|
active: true,
|
|
},
|
|
client,
|
|
),
|
|
).resolves.toEqual({ id: "api_key_1", tenantId: "tenant_1", key: "updated-secret" });
|
|
|
|
expect(client.apiKey.updateMany).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
data: {
|
|
tenantId: "tenant_1",
|
|
alias: "Production",
|
|
expires,
|
|
active: true,
|
|
},
|
|
});
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
});
|
|
});
|
|
|
|
it("deletes API keys through the package boundary", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue({ id: "api_key_1", tenantId: "tenant_1", key: "deleted-secret" } as never);
|
|
await expect(deleteLegacyApiKey({ id: "api_key_1", tenantId: "tenant_1" }, client)).resolves.toEqual({ id: "api_key_1", tenantId: "tenant_1", key: "deleted-secret" });
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
});
|
|
expect(client.apiKey.deleteMany).toHaveBeenCalledWith({
|
|
where: { id: "api_key_1", tenantId: "tenant_1" },
|
|
});
|
|
});
|
|
|
|
it("returns null when no tenant id is provided for first active API key lookup", async () => {
|
|
const client = createApiKeyLogClient();
|
|
|
|
await expect(findFirstLegacyActiveApiKey(null, client)).resolves.toBeNull();
|
|
expect(client.apiKey.findFirst).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("finds tenant API keys by hash without selecting the secret back out", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const apiKey = {
|
|
id: "api_key_1",
|
|
alias: "Production",
|
|
expires: null,
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
active: true,
|
|
scopes: ["public_api:read"],
|
|
tenant: { id: "tenant_1", name: "Acme", slug: "acme", deactivatedReason: null },
|
|
};
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue(apiKey);
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client, "hash-secret", { allowPlaintextFallback: true })).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledTimes(1);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { keyHash: deriveLegacyApiKeyHashMetadata("raw-secret", "hash-secret").keyHash },
|
|
select: {
|
|
id: true,
|
|
alias: true,
|
|
expires: true,
|
|
tenantId: true,
|
|
createdByUserId: true,
|
|
active: true,
|
|
scopes: true,
|
|
tenant: { select: { id: true, name: true, slug: true, deactivatedReason: true } },
|
|
},
|
|
});
|
|
});
|
|
|
|
it("creates API key logs from normalized request data", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const data = {
|
|
tenantId: "tenant_1",
|
|
apiKeyId: "api_key_1",
|
|
endpoint: "/v1/usage",
|
|
ip: "127.0.0.1",
|
|
method: "GET",
|
|
params: "tenantId=tenant_1",
|
|
status: 200,
|
|
};
|
|
|
|
await expect(createLegacyApiKeyLog(data, client)).resolves.toEqual({ id: "log_1" });
|
|
expect(client.apiKeyLog.create).toHaveBeenCalledWith({
|
|
data,
|
|
});
|
|
});
|
|
|
|
it("falls back to legacy raw-key lookup when hash lookup misses", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const apiKey = {
|
|
id: "api_key_1",
|
|
alias: "Production",
|
|
expires: null,
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
active: true,
|
|
scopes: ["public_api:read"],
|
|
tenant: { id: "tenant_1", name: "Acme", slug: "acme", deactivatedReason: null },
|
|
};
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValueOnce(null).mockResolvedValueOnce(apiKey);
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client, "hash-secret", { allowPlaintextFallback: true })).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findFirst).toHaveBeenNthCalledWith(1, {
|
|
where: { keyHash: deriveLegacyApiKeyHashMetadata("raw-secret", "hash-secret").keyHash },
|
|
select: expect.any(Object),
|
|
});
|
|
expect(client.apiKey.findFirst).toHaveBeenNthCalledWith(2, {
|
|
where: { key: "raw-secret" },
|
|
select: expect.any(Object),
|
|
});
|
|
});
|
|
|
|
it("can disable legacy raw-key fallback after cutover", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue(null);
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client, "hash-secret", { allowPlaintextFallback: false })).resolves.toBeNull();
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledTimes(1);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { keyHash: deriveLegacyApiKeyHashMetadata("raw-secret", "hash-secret").keyHash },
|
|
select: expect.any(Object),
|
|
});
|
|
});
|
|
|
|
it("does not fall back to raw-key lookup when hash lookup fails and fallback is disabled", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.mocked(client.apiKey.findFirst).mockRejectedValueOnce(new Error("hash index unavailable"));
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client, "hash-secret", { allowPlaintextFallback: false })).resolves.toBeNull();
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("falls back to legacy raw-key lookup when hash lookup fails", async () => {
|
|
const client = createApiKeyLogClient();
|
|
const apiKey = {
|
|
id: "api_key_1",
|
|
alias: "Production",
|
|
expires: null,
|
|
tenantId: "tenant_1",
|
|
createdByUserId: "user_1",
|
|
active: true,
|
|
scopes: ["public_api:read"],
|
|
tenant: { id: "tenant_1", name: "Acme", slug: "acme", deactivatedReason: null },
|
|
};
|
|
vi.mocked(client.apiKey.findFirst).mockRejectedValueOnce(new Error("hash index unavailable")).mockResolvedValueOnce(apiKey);
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client, "hash-secret", { allowPlaintextFallback: true })).resolves.toBe(apiKey);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("keeps legacy raw-key fallback disabled by default", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.mocked(client.apiKey.findFirst).mockResolvedValue(null);
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client, "hash-secret")).resolves.toBeNull();
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledTimes(1);
|
|
expect(client.apiKey.findFirst).toHaveBeenCalledWith({
|
|
where: { keyHash: deriveLegacyApiKeyHashMetadata("raw-secret", "hash-secret").keyHash },
|
|
select: expect.any(Object),
|
|
});
|
|
});
|
|
|
|
it("preserves legacy null behavior when both API key lookups fail", async () => {
|
|
const client = createApiKeyLogClient();
|
|
vi.mocked(client.apiKey.findFirst).mockRejectedValue(new Error("database unavailable"));
|
|
|
|
await expect(findLegacyApiKeyByKey("raw-secret", client)).resolves.toBeNull();
|
|
});
|
|
});
|