Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,454 @@
import type {
AdminCalendarConnection,
AdminCalendarSyncCursor,
Prisma,
PrismaClient,
} from "../generated/prisma/client/client.js";
import type { AdminPermissionName } from "./admin-permissions.js";
import {
type AdminSalesActor,
writeAdminSalesAudit,
} from "./admin-sales-core.server.js";
const MAX_LABEL_LENGTH = 200;
const MAX_TIME_ZONE_LENGTH = 100;
const MAX_CURSOR_LENGTH = 32_768;
const MAX_BUSY_INTERVALS = 10_000;
export type ActivateAdminCalendarInput = {
readonly adminUserId: string;
readonly dataConnectionId: string;
readonly externalCalendarId: string;
readonly externalCalendarLabel?: string | null;
readonly timeZone: string;
readonly actor: AdminSalesActor;
};
export type AdminCalendarBusyInterval = {
readonly externalEventId: string;
readonly startsAt: string;
readonly endsAt: string;
readonly opaqueVersion?: string;
};
export type ApplyAdminCalendarSyncInput = {
readonly adminUserId: string;
readonly calendarConnectionId: string;
readonly externalCalendarId: string;
readonly busyIntervals: readonly AdminCalendarBusyInterval[];
readonly cursorToken?: string | null;
readonly deltaLink?: string | null;
readonly fullSync: boolean;
readonly syncedAt: Date;
};
export type AdminCalendarRepository = {
activate(
input: ActivateAdminCalendarInput
): Promise<AdminCalendarConnection>;
applySync(
input: ApplyAdminCalendarSyncInput
): Promise<AdminCalendarSyncCursor>;
requireRecovery(input: {
readonly adminUserId: string;
readonly calendarConnectionId: string;
readonly externalCalendarId: string;
readonly errorCode: string;
readonly requestedAt: Date;
}): Promise<AdminCalendarSyncCursor>;
disconnect(input: {
readonly adminUserId: string;
readonly calendarConnectionId: string;
readonly actor: AdminSalesActor;
}): Promise<AdminCalendarConnection>;
};
export function createAdminCalendarService(input: {
readonly repository: AdminCalendarRepository;
readonly authorize: (
permission: AdminPermissionName
) => Promise<void> | void;
}) {
return {
async activate(command: ActivateAdminCalendarInput) {
await input.authorize("admin_sales.booking.manage");
return input.repository.activate(normalizeActivate(command));
},
async applySync(command: ApplyAdminCalendarSyncInput) {
return input.repository.applySync(normalizeSync(command));
},
async requireRecovery(command: {
readonly adminUserId: string;
readonly calendarConnectionId: string;
readonly externalCalendarId: string;
readonly errorCode: string;
readonly requestedAt: Date;
}) {
return input.repository.requireRecovery({
adminUserId: requiredId(command.adminUserId, "adminUserId"),
calendarConnectionId: requiredId(
command.calendarConnectionId,
"calendarConnectionId"
),
externalCalendarId: requiredText(
command.externalCalendarId,
"externalCalendarId",
MAX_LABEL_LENGTH
),
errorCode: requiredText(command.errorCode, "errorCode", 120),
requestedAt: validDate(command.requestedAt, "requestedAt"),
});
},
async disconnect(command: {
readonly adminUserId: string;
readonly calendarConnectionId: string;
readonly actor: AdminSalesActor;
}) {
await input.authorize("admin_sales.booking.manage");
return input.repository.disconnect({
adminUserId: requiredId(command.adminUserId, "adminUserId"),
calendarConnectionId: requiredId(
command.calendarConnectionId,
"calendarConnectionId"
),
actor: normalizeActor(command.actor),
});
},
};
}
type AdminCalendarPrismaClient = Pick<
PrismaClient,
| "$transaction"
| "adminDataConnection"
| "adminCalendarConnection"
| "adminCalendarSyncCursor"
>;
export function createPrismaAdminCalendarRepository(
client: AdminCalendarPrismaClient
): AdminCalendarRepository {
return {
activate: (command) =>
client.$transaction(async (tx) => {
const dataConnection = await tx.adminDataConnection.findFirst({
where: {
id: command.dataConnectionId,
adminUserId: command.adminUserId,
capability: "calendar",
provider: { in: ["google_calendar", "microsoft_calendar"] },
status: { in: ["active", "degraded"] },
archivedAt: null,
},
select: { id: true },
});
if (!dataConnection) {
throw new AdminCalendarServiceError("connection_unavailable");
}
const calendar = await tx.adminCalendarConnection.upsert({
where: { dataConnectionId: command.dataConnectionId },
create: {
adminUserId: command.adminUserId,
dataConnectionId: command.dataConnectionId,
externalCalendarId: command.externalCalendarId,
externalCalendarLabel: command.externalCalendarLabel,
timeZone: command.timeZone,
status: "active",
healthMessageKey:
"admin.sales.booking.calendars.health.connected",
},
update: {
externalCalendarId: command.externalCalendarId,
externalCalendarLabel: command.externalCalendarLabel,
timeZone: command.timeZone,
status: "active",
archivedAt: null,
lastErrorCode: null,
healthMessageKey:
"admin.sales.booking.calendars.health.connected",
},
});
await tx.adminCalendarSyncCursor.upsert({
where: {
admin_calendar_cursor_external_key: {
calendarConnectionId: calendar.id,
externalCalendarId: command.externalCalendarId,
},
},
create: {
adminUserId: command.adminUserId,
calendarConnectionId: calendar.id,
externalCalendarId: command.externalCalendarId,
status: "pending",
},
update: {
adminUserId: command.adminUserId,
status: "pending",
lastErrorCode: null,
},
});
await tx.adminActivity.create({
data: {
type: "configuration_changed",
actorAdminUserId: command.actor.adminUserId,
summary: "Persönlichen Kalender verbunden",
payload: {
calendarConnectionId: calendar.id,
externalCalendarId: command.externalCalendarId,
},
},
});
await writeAdminSalesAudit(tx, {
actor: command.actor,
action: "admin.sales.calendar.connected",
targetType: "AdminCalendarConnection",
targetId: calendar.id,
after: {
dataConnectionId: command.dataConnectionId,
externalCalendarId: command.externalCalendarId,
timeZone: command.timeZone,
},
});
return calendar;
}),
applySync: (command) =>
client.$transaction(async (tx) => {
const cursor = await tx.adminCalendarSyncCursor.update({
where: {
admin_calendar_cursor_external_key: {
calendarConnectionId: command.calendarConnectionId,
externalCalendarId: command.externalCalendarId,
},
adminUserId: command.adminUserId,
},
data: {
cursorToken: command.cursorToken,
deltaLink: command.deltaLink,
busyIntervals:
command.busyIntervals as unknown as Prisma.InputJsonValue,
status: "active",
lastIncrementalSyncAt: command.syncedAt,
lastFullSyncAt: command.fullSync ? command.syncedAt : undefined,
recoveryRequestedAt: null,
lastErrorCode: null,
},
});
await tx.adminCalendarConnection.update({
where: {
id: command.calendarConnectionId,
adminUserId: command.adminUserId,
},
data: {
status: "active",
lastSyncAt: command.syncedAt,
lastErrorCode: null,
healthMessageKey:
"admin.sales.booking.calendars.health.synced",
},
});
return cursor;
}),
requireRecovery: (command) =>
client.$transaction(async (tx) => {
const cursor = await tx.adminCalendarSyncCursor.update({
where: {
admin_calendar_cursor_external_key: {
calendarConnectionId: command.calendarConnectionId,
externalCalendarId: command.externalCalendarId,
},
adminUserId: command.adminUserId,
},
data: {
cursorToken: null,
deltaLink: null,
status: "recovery_required",
recoveryRequestedAt: command.requestedAt,
lastErrorCode: command.errorCode,
},
});
await tx.adminCalendarConnection.update({
where: {
id: command.calendarConnectionId,
adminUserId: command.adminUserId,
},
data: {
status: "degraded",
lastErrorCode: command.errorCode,
healthMessageKey:
"admin.sales.booking.calendars.health.recoveryRequired",
},
});
return cursor;
}),
disconnect: (command) =>
client.$transaction(async (tx) => {
const disconnected = await tx.adminCalendarConnection.update({
where: {
id: command.calendarConnectionId,
adminUserId: command.adminUserId,
},
data: {
status: "revoked",
archivedAt: new Date(),
healthMessageKey:
"admin.sales.booking.calendars.health.disconnected",
},
});
await tx.adminActivity.create({
data: {
type: "configuration_changed",
actorAdminUserId: command.actor.adminUserId,
summary: "Persönlichen Kalender getrennt",
payload: { calendarConnectionId: disconnected.id },
},
});
await writeAdminSalesAudit(tx, {
actor: command.actor,
action: "admin.sales.calendar.disconnected",
targetType: "AdminCalendarConnection",
targetId: disconnected.id,
after: { status: "revoked" },
});
return disconnected;
}),
};
}
function normalizeActivate(
input: ActivateAdminCalendarInput
): ActivateAdminCalendarInput {
return {
adminUserId: requiredId(input.adminUserId, "adminUserId"),
dataConnectionId: requiredId(
input.dataConnectionId,
"dataConnectionId"
),
externalCalendarId: requiredText(
input.externalCalendarId,
"externalCalendarId",
MAX_LABEL_LENGTH
),
externalCalendarLabel: optionalText(
input.externalCalendarLabel,
MAX_LABEL_LENGTH
),
timeZone: normalizeTimeZone(input.timeZone),
actor: normalizeActor(input.actor),
};
}
function normalizeSync(
input: ApplyAdminCalendarSyncInput
): ApplyAdminCalendarSyncInput {
if (input.busyIntervals.length > MAX_BUSY_INTERVALS) {
throw new AdminCalendarServiceError("busy_snapshot_too_large");
}
const busyIntervals = input.busyIntervals.map((interval) => {
const startsAt = validDate(new Date(interval.startsAt), "startsAt");
const endsAt = validDate(new Date(interval.endsAt), "endsAt");
if (endsAt <= startsAt) {
throw new AdminCalendarServiceError("invalid_busy_interval");
}
return Object.freeze({
externalEventId: requiredText(
interval.externalEventId,
"externalEventId",
MAX_LABEL_LENGTH
),
startsAt: startsAt.toISOString(),
endsAt: endsAt.toISOString(),
opaqueVersion: optionalText(interval.opaqueVersion, 1_000) ?? undefined,
});
});
if (Boolean(input.cursorToken) === Boolean(input.deltaLink)) {
throw new AdminCalendarServiceError("invalid_provider_cursor");
}
return {
adminUserId: requiredId(input.adminUserId, "adminUserId"),
calendarConnectionId: requiredId(
input.calendarConnectionId,
"calendarConnectionId"
),
externalCalendarId: requiredText(
input.externalCalendarId,
"externalCalendarId",
MAX_LABEL_LENGTH
),
busyIntervals,
cursorToken: optionalText(input.cursorToken, MAX_CURSOR_LENGTH),
deltaLink: optionalText(input.deltaLink, MAX_CURSOR_LENGTH),
fullSync: input.fullSync,
syncedAt: validDate(input.syncedAt, "syncedAt"),
};
}
function normalizeActor(actor: AdminSalesActor): AdminSalesActor {
return {
...actor,
adminUserId: requiredId(actor.adminUserId, "actor.adminUserId"),
reason: requiredText(actor.reason, "actor.reason", 500),
};
}
function normalizeTimeZone(value: string): string {
const timeZone = requiredText(value, "timeZone", MAX_TIME_ZONE_LENGTH);
try {
new Intl.DateTimeFormat("de-DE", { timeZone }).format(new Date());
} catch {
throw new AdminCalendarServiceError("invalid_time_zone");
}
return timeZone;
}
function requiredId(value: string, field: string): string {
return requiredText(value, field, 191);
}
function requiredText(value: string, field: string, max: number): string {
const normalized = value.trim();
if (!normalized || normalized.length > max) {
throw new AdminCalendarServiceError("invalid_input", field);
}
return normalized;
}
function optionalText(
value: string | null | undefined,
max: number
): string | null {
if (value == null || !value.trim()) return null;
const normalized = value.trim();
if (normalized.length > max) {
throw new AdminCalendarServiceError("invalid_input");
}
return normalized;
}
function validDate(value: Date, field: string): Date {
if (!Number.isFinite(value.getTime())) {
throw new AdminCalendarServiceError("invalid_input", field);
}
return value;
}
export class AdminCalendarServiceError extends Error {
constructor(
readonly code:
| "invalid_input"
| "invalid_time_zone"
| "connection_unavailable"
| "invalid_provider_cursor"
| "invalid_busy_interval"
| "busy_snapshot_too_large",
readonly field?: string
) {
super(code);
this.name = "AdminCalendarServiceError";
}
}