Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/device-tokens.server.ts
T

193 lines
6.1 KiB
TypeScript

/**
* Server-side helpers for the DeviceToken Prisma model (Phase 08 #65).
*
* The Web Push register-device endpoint upserts on the unique
* `token` column, the push-worker job filters by `revokedAt IS NULL`
* for fan-out, and the cron prune script revokes rows older than 90d.
*
* Keeping these functions narrow and prisma-shape-only lets unit tests
* inject a stub client without pulling in `@prisma/client` at all.
*/
import { getDbClient, type DbClient } from "./client.server.js";
export type DevicePlatform = "web";
export type PushProvider = "webpush";
const DEVICE_PLATFORMS = new Set<DevicePlatform>(["web"]);
const PUSH_PROVIDERS = new Set<PushProvider>(["webpush"]);
export function parseDevicePlatform(value: unknown): DevicePlatform | null {
return typeof value === "string" && DEVICE_PLATFORMS.has(value as DevicePlatform) ? (value as DevicePlatform) : null;
}
export function parsePushProvider(value: unknown): PushProvider | null {
return typeof value === "string" && PUSH_PROVIDERS.has(value as PushProvider) ? (value as PushProvider) : null;
}
/** Default provider for a given platform when the client omits it. */
export function defaultPushProviderFor(platform: DevicePlatform): PushProvider {
void platform;
return "webpush";
}
export type DeviceTokenRecord = {
id: string;
createdAt: Date;
updatedAt: Date;
userId: string;
tenantId: string | null;
platform: string;
token: string;
pushProvider: string;
appVersion: string | null;
lastSeenAt: Date;
revokedAt: Date | null;
};
export type DeviceTokenClient = {
deviceToken: {
upsert(args: {
where: { token: string; userId: string };
create: {
userId: string;
tenantId: string | null;
platform: DevicePlatform;
token: string;
pushProvider: PushProvider;
appVersion?: string | null;
};
update: {
tenantId: string | null;
platform: DevicePlatform;
pushProvider: PushProvider;
appVersion?: string | null;
lastSeenAt: Date;
revokedAt: null;
};
}): Promise<DeviceTokenRecord>;
update(args: {
where: { token: string; userId: string; tenantId: string | null };
data: { revokedAt: Date };
}): Promise<DeviceTokenRecord>;
updateMany(args: {
where: { userId: string; revokedAt: null };
data: { revokedAt: Date };
}): Promise<{ count: number }>;
findMany(args: {
where: { userId?: string; tenantId?: string; revokedAt?: null };
orderBy?: { createdAt: "desc" | "asc" };
take?: number;
}): Promise<readonly DeviceTokenRecord[]>;
findUnique(args: { where: { token: string } }): Promise<DeviceTokenRecord | null>;
};
};
export type RegisterDeviceTokenInput = {
userId: string;
tenantId: string | null;
platform: DevicePlatform;
token: string;
pushProvider?: PushProvider;
appVersion?: string | null;
};
/**
* Idempotent upsert keyed by `token`. Re-registration of the same token
* (typical on app cold-start) just bumps `lastSeenAt` and clears any
* prior `revokedAt`.
*/
export async function registerDeviceToken(
input: RegisterDeviceTokenInput,
client: DeviceTokenClient = getDbClient() as unknown as DeviceTokenClient,
): Promise<DeviceTokenRecord> {
const provider = input.pushProvider ?? defaultPushProviderFor(input.platform);
const now = new Date();
return client.deviceToken.upsert({
// Keep the globally unique token bound to its authenticated owner. If the
// same token already belongs to another user, the filtered update cannot
// match and the create path fails closed on the unique constraint.
where: { token: input.token, userId: input.userId },
create: {
userId: input.userId,
tenantId: input.tenantId,
platform: input.platform,
token: input.token,
pushProvider: provider,
appVersion: input.appVersion ?? null,
},
update: {
tenantId: input.tenantId,
platform: input.platform,
pushProvider: provider,
appVersion: input.appVersion ?? null,
lastSeenAt: now,
revokedAt: null,
},
});
}
/**
* Mark a single token revoked. Called when the push provider responds
* with `Unregistered` / `InvalidRegistration` so the next fan-out pass
* skips this token.
*/
export async function revokeDeviceToken(
input: { token: string; userId: string; tenantId: string | null },
client: DeviceTokenClient = getDbClient() as unknown as DeviceTokenClient,
): Promise<DeviceTokenRecord | null> {
try {
return await client.deviceToken.update({
where: {
token: input.token,
userId: input.userId,
tenantId: input.tenantId,
},
data: { revokedAt: new Date() },
});
} catch {
return null;
}
}
/** Revoke all active tokens for a user (logout / password-change hook). */
export async function revokeDeviceTokensForUser(
userId: string,
client: DeviceTokenClient = getDbClient() as unknown as DeviceTokenClient,
): Promise<number> {
const { count } = await client.deviceToken.updateMany({
where: { userId, revokedAt: null },
data: { revokedAt: new Date() },
});
return count;
}
/**
* List active tokens for fan-out. Scoped by user (always required) plus
* optional tenant. Returns at most `take` tokens, newest first.
*/
export async function listActiveDeviceTokens(
args: { userId: string; tenantId?: string; take?: number },
client: DeviceTokenClient = getDbClient() as unknown as DeviceTokenClient,
): Promise<readonly DeviceTokenRecord[]> {
return client.deviceToken.findMany({
where: {
userId: args.userId,
...(args.tenantId ? { tenantId: args.tenantId } : {}),
revokedAt: null,
},
orderBy: { createdAt: "desc" },
take: args.take ?? 100,
});
}
export async function findDeviceTokenByToken(
token: string,
client: DeviceTokenClient = getDbClient() as unknown as DeviceTokenClient,
): Promise<DeviceTokenRecord | null> {
return client.deviceToken.findUnique({ where: { token } });
}
// Re-export DbClient so call-sites in the API / worker can keep their
// type assertion narrow without needing an extra import path.
export type { DbClient };