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.TaggedErrorClass<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.TaggedErrorClass<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.TaggedErrorClass<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") {} export 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;       yield* Effect.all(        [          registration.pushToken            ? 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,                      }),                  ),                )            : Effect.void,          registration.pushToStartToken            ? 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,                      }),                  ),                )            : Effect.void,        ],        { discard: true },      );       yield* db        .insert(relayMobileDevices)        .values({          userId: input.userId,          deviceId: registration.deviceId,          label: registration.label,          platform: registration.platform,          iosMajorVersion: registration.iosMajorVersion,          appVersion: registration.appVersion ?? 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,            appVersion: registration.appVersion ?? null,            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* Effect.all(        [          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,                  }),              ),            ),          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,                  }),              ),            ),        ],        { discard: true },      );    }),    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,          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,        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);