import type {
RelayClientDeviceRecord,
RelayDeviceRegistrationRequest,
} from "@t3tools/contracts/relay";
import * as Context from "effect/Context";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import { and, eq } from "drizzle-orm";
import { sql } from "drizzle-orm";
import * as RelayDb from "../db.ts";
import { relayLiveActivities, relayMobileDevices } from "../persistence/schema.ts";
export class DeviceRegistrationPersistenceError extends Schema.TaggedError<DeviceRegistrationPersistenceError>()(
"DeviceRegistrationPersistenceError",
{
userId: Schema.String,
deviceId: Schema.String,
stage: Schema.Literals(["claim-push-token", "claim-push-to-start-token", "upsert-device"]),
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Failed to persist mobile device registration for ${this.userId}/${this.deviceId} during ${this.stage}.`;
}
}
export class DeviceUnregistrationPersistenceError extends Schema.TaggedError<DeviceUnregistrationPersistenceError>()(
"DeviceUnregistrationPersistenceError",
{
userId: Schema.String,
deviceId: Schema.String,
stage: Schema.Literals(["delete-live-activity", "delete-device"]),
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Failed to unregister mobile device ${this.userId}/${this.deviceId} during ${this.stage}.`;
}
}
export class DeviceListPersistenceError extends Schema.TaggedError<DeviceListPersistenceError>()(
"DeviceListPersistenceError",
{
userId: Schema.String,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Failed to list mobile devices for ${this.userId}.`;
}
}
export class Devices extends Context.Service<
Devices,
{
readonly register: (input: {
readonly userId: string;
readonly registration: RelayDeviceRegistrationRequest;
}) => Effect.Effect<void, DeviceRegistrationPersistenceError>;
readonly unregister: (input: {
readonly userId: string;
readonly deviceId: string;
}) => Effect.Effect<void, DeviceUnregistrationPersistenceError>;
readonly listForUser: (input: {
readonly userId: string;
}) => Effect.Effect<ReadonlyArray<RelayClientDeviceRecord>, DeviceListPersistenceError>;
}
>()("t3code-relay/agentActivity/Devices") {}
const make = Effect.gen(function* () {
const db = yield* RelayDb.RelayDb;
return Devices.of({
register: Effect.fn("relay.devices.register")(function* (input) {
yield* Effect.annotateCurrentSpan({
"relay.mobile.device_id": input.registration.deviceId,
});
const updatedAt = DateTime.formatIso(yield* DateTime.now);
const registration = input.registration;
// Alchemy's lazy drizzle proxies become Effects only at yield*; Effect.all sends raw proxies into a spinning fiber.
if (registration.pushToken) {
yield* db
.update(relayMobileDevices)
.set({ pushToken: null, updatedAt })
.where(eq(relayMobileDevices.pushToken, registration.pushToken))
.pipe(
Effect.mapError(
(cause) =>
new DeviceRegistrationPersistenceError({
userId: input.userId,
deviceId: registration.deviceId,
stage: "claim-push-token",
cause,
}),
),
);
}
if (registration.pushToStartToken) {
yield* db
.update(relayMobileDevices)
.set({ pushToStartToken: null, updatedAt })
.where(eq(relayMobileDevices.pushToStartToken, registration.pushToStartToken))
.pipe(
Effect.mapError(
(cause) =>
new DeviceRegistrationPersistenceError({
userId: input.userId,
deviceId: registration.deviceId,
stage: "claim-push-to-start-token",
cause,
}),
),
);
}
yield* db
.insert(relayMobileDevices)
.values({
userId: input.userId,
deviceId: registration.deviceId,
label: registration.label,
platform: registration.platform,
iosMajorVersion: registration.iosMajorVersion ?? null,
androidApiLevel: registration.androidApiLevel ?? null,
appVersion: registration.appVersion ?? null,
bundleId: registration.bundleId ?? null,
apsEnvironment: registration.apsEnvironment ?? null,
pushToken: registration.pushToken ?? null,
pushToStartToken: registration.pushToStartToken ?? null,
preferencesJson: registration.preferences,
createdAt: updatedAt,
updatedAt,
})
.onConflictDoUpdate({
target: [relayMobileDevices.userId, relayMobileDevices.deviceId],
set: {
platform: registration.platform,
label: registration.label,
iosMajorVersion: registration.iosMajorVersion ?? null,
androidApiLevel: registration.androidApiLevel ?? null,
appVersion: registration.appVersion ?? null,
// Older builds must preserve newer routing fields on re-registration.
bundleId: sql`coalesce(excluded.bundle_id, ${relayMobileDevices.bundleId})`,
apsEnvironment: sql`coalesce(
excluded.aps_environment,
${relayMobileDevices.apsEnvironment}
)`,
pushToken: sql`coalesce(excluded.push_token, ${relayMobileDevices.pushToken})`,
pushToStartToken: sql`coalesce(
excluded.push_to_start_token,
${relayMobileDevices.pushToStartToken}
)`,
preferencesJson: registration.preferences,
updatedAt,
},
})
.pipe(
Effect.mapError(
(cause) =>
new DeviceRegistrationPersistenceError({
userId: input.userId,
deviceId: registration.deviceId,
stage: "upsert-device",
cause,
}),
),
);
}),
unregister: Effect.fn("relay.devices.unregister")(function* (input) {
yield* Effect.annotateCurrentSpan({
"relay.mobile.device_id": input.deviceId,
});
yield* db
.delete(relayLiveActivities)
.where(
and(
eq(relayLiveActivities.userId, input.userId),
eq(relayLiveActivities.deviceId, input.deviceId),
),
)
.pipe(
Effect.mapError(
(cause) =>
new DeviceUnregistrationPersistenceError({
userId: input.userId,
deviceId: input.deviceId,
stage: "delete-live-activity",
cause,
}),
),
);
yield* db
.delete(relayMobileDevices)
.where(
and(
eq(relayMobileDevices.userId, input.userId),
eq(relayMobileDevices.deviceId, input.deviceId),
),
)
.pipe(
Effect.mapError(
(cause) =>
new DeviceUnregistrationPersistenceError({
userId: input.userId,
deviceId: input.deviceId,
stage: "delete-device",
cause,
}),
),
);
}),
listForUser: Effect.fn("relay.devices.listForUser")(function* (input) {
const rows = yield* db
.select({
deviceId: relayMobileDevices.deviceId,
label: relayMobileDevices.label,
platform: relayMobileDevices.platform,
iosMajorVersion: relayMobileDevices.iosMajorVersion,
androidApiLevel: relayMobileDevices.androidApiLevel,
appVersion: relayMobileDevices.appVersion,
preferences: relayMobileDevices.preferencesJson,
updatedAt: relayMobileDevices.updatedAt,
})
.from(relayMobileDevices)
.where(eq(relayMobileDevices.userId, input.userId))
.pipe(
Effect.mapError(
(cause) => new DeviceListPersistenceError({ userId: input.userId, cause }),
),
);
return rows.map((row) => ({
deviceId: row.deviceId,
label: row.label,
platform: row.platform,
iosMajorVersion: row.iosMajorVersion,
androidApiLevel: row.androidApiLevel,
appVersion: row.appVersion,
notifications: {
enabled: row.preferences.notificationsEnabled,
notifyOnApproval: row.preferences.notifyOnApproval,
notifyOnInput: row.preferences.notifyOnInput,
notifyOnCompletion: row.preferences.notifyOnCompletion,
notifyOnFailure: row.preferences.notifyOnFailure,
},
liveActivities: {
enabled: row.preferences.liveActivitiesEnabled,
},
updatedAt: row.updatedAt,
}));
}),
});
});
export const layer = Layer.effect(Devices, make);