sailfork / t3code-github / infra/ relay/ src/ agentActivity/ apnsDeliveryJobs.ts

import {
  RelayAgentActivityAggregateState,
  RelayAgentAwarenessPhase,
} from "@t3tools/contracts/relay";
import { stableStringify } from "@t3tools/shared/relaySigning";
import * as Mac from "effect/crypto/Mac";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Base64Url from "effect/encoding/Base64Url";
import * as Option from "effect/Option";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";

const MAX_JOB_AGE_MS = 10 * 60 * 1_000;
const APNS_DELIVERY_JOB_SIGNING_ALGORITHM = "hmac-sha256";

const ApnsDeliveryKindSchema = Schema.Literals([
  "live_activity_update",
  "live_activity_end",
  "push_notification",
]);
const LiveActivityStartOrUpdateKindSchema = Schema.Literals(["live_activity_update"]);
const LiveActivityKindSchema = Schema.Literals(["live_activity_update", "live_activity_end"]);

const ApnsDeliveryJobContext = {
  jobId: Schema.String,
  userId: Schema.String,
  deviceId: Schema.String,
};

export const ApnsNotificationPayload = Schema.Struct({
  title: Schema.String,
  body: Schema.String,
  environmentId: Schema.String,
  threadId: Schema.String,
  deepLink: Schema.String,
  phase: Schema.optional(RelayAgentAwarenessPhase),
  updatedAt: Schema.optional(Schema.String),
});
export type ApnsNotificationPayload = typeof ApnsNotificationPayload.Type;

export const ApnsLiveActivityAlert = Schema.Struct({
  title: Schema.String,
  body: Schema.String,
});
export type ApnsLiveActivityAlert = typeof ApnsLiveActivityAlert.Type;

export const ApnsDeliveryJobPayload = Schema.Struct({
  version: Schema.Literal(1),
  jobId: Schema.String,
  kind: ApnsDeliveryKindSchema,
  target: Schema.Struct({
    userId: Schema.String,
    deviceId: Schema.String,
    token: Schema.String,
    bundleId: Schema.optional(Schema.NullOr(Schema.String)),
    apsEnvironment: Schema.optional(Schema.NullOr(Schema.Literals(["sandbox", "production"]))),
  }),
  aggregate: Schema.NullOr(RelayAgentActivityAggregateState),
  notification: Schema.NullOr(ApnsNotificationPayload),
  alert: Schema.optional(Schema.NullOr(ApnsLiveActivityAlert)),
  createdAt: Schema.String,
  expiresAt: Schema.String,
});
export type ApnsDeliveryJobPayload = typeof ApnsDeliveryJobPayload.Type;

export const SignedApnsDeliveryJob = Schema.Struct({
  algorithm: Schema.Literal(APNS_DELIVERY_JOB_SIGNING_ALGORITHM),
  payload: ApnsDeliveryJobPayload,
  signature: Schema.String,
});
export type SignedApnsDeliveryJob = typeof SignedApnsDeliveryJob.Type;

export class ApnsDeliveryJobQueuePayloadInvalid extends Schema.TaggedError<ApnsDeliveryJobQueuePayloadInvalid>()(
  "ApnsDeliveryJobQueuePayloadInvalid",
  {
    receivedType: Schema.String,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Invalid APNs delivery queue job with ${this.receivedType} payload.`;
  }
}

export class ApnsDeliveryJobLiveActivityAggregateMissing extends Schema.TaggedError<ApnsDeliveryJobLiveActivityAggregateMissing>()(
  "ApnsDeliveryJobLiveActivityAggregateMissing",
  {
    ...ApnsDeliveryJobContext,
    kind: LiveActivityStartOrUpdateKindSchema,
  },
) {
  override get message(): string {
    return `APNs ${this.kind.replaceAll("_", " ")} job ${this.jobId} requires an aggregate.`;
  }
}

export class ApnsDeliveryJobLiveActivityNotificationUnexpected extends Schema.TaggedError<ApnsDeliveryJobLiveActivityNotificationUnexpected>()(
  "ApnsDeliveryJobLiveActivityNotificationUnexpected",
  {
    ...ApnsDeliveryJobContext,
    kind: LiveActivityKindSchema,
  },
) {
  override get message(): string {
    return `APNs ${this.kind.replaceAll("_", " ")} job ${this.jobId} must not carry a push notification payload.`;
  }
}

export class ApnsDeliveryJobPushNotificationMissing extends Schema.TaggedError<ApnsDeliveryJobPushNotificationMissing>()(
  "ApnsDeliveryJobPushNotificationMissing",
  ApnsDeliveryJobContext,
) {
  override get message(): string {
    return `APNs push notification job ${this.jobId} requires a notification payload.`;
  }
}

export class ApnsDeliveryJobPushNotificationAggregateUnexpected extends Schema.TaggedError<ApnsDeliveryJobPushNotificationAggregateUnexpected>()(
  "ApnsDeliveryJobPushNotificationAggregateUnexpected",
  ApnsDeliveryJobContext,
) {
  override get message(): string {
    return `APNs push notification job ${this.jobId} must not carry aggregate state.`;
  }
}

export class ApnsDeliveryJobCreatedAtInvalid extends Schema.TaggedError<ApnsDeliveryJobCreatedAtInvalid>()(
  "ApnsDeliveryJobCreatedAtInvalid",
  {
    ...ApnsDeliveryJobContext,
    kind: ApnsDeliveryKindSchema,
    createdAt: Schema.String,
  },
) {
  override get message(): string {
    return `APNs delivery job ${this.jobId} has invalid creation time ${this.createdAt}.`;
  }
}

export class ApnsDeliveryJobExpiresAtInvalid extends Schema.TaggedError<ApnsDeliveryJobExpiresAtInvalid>()(
  "ApnsDeliveryJobExpiresAtInvalid",
  {
    ...ApnsDeliveryJobContext,
    kind: ApnsDeliveryKindSchema,
    expiresAt: Schema.String,
  },
) {
  override get message(): string {
    return `APNs delivery job ${this.jobId} has invalid expiry ${this.expiresAt}.`;
  }
}

export class ApnsDeliveryJobTimeWindowInvalid extends Schema.TaggedError<ApnsDeliveryJobTimeWindowInvalid>()(
  "ApnsDeliveryJobTimeWindowInvalid",
  {
    ...ApnsDeliveryJobContext,
    kind: ApnsDeliveryKindSchema,
    createdAt: Schema.String,
    expiresAt: Schema.String,
  },
) {
  override get message(): string {
    return `APNs delivery job ${this.jobId} has invalid time window ${this.createdAt} to ${this.expiresAt}.`;
  }
}

export class ApnsDeliveryJobTimeWindowTooLong extends Schema.TaggedError<ApnsDeliveryJobTimeWindowTooLong>()(
  "ApnsDeliveryJobTimeWindowTooLong",
  {
    ...ApnsDeliveryJobContext,
    kind: ApnsDeliveryKindSchema,
    createdAt: Schema.String,
    expiresAt: Schema.String,
  },
) {
  override get message(): string {
    return `APNs delivery job ${this.jobId} time window ${this.createdAt} to ${this.expiresAt} is too long.`;
  }
}

export class ApnsDeliveryJobSignatureInvalid extends Schema.TaggedError<ApnsDeliveryJobSignatureInvalid>()(
  "ApnsDeliveryJobSignatureInvalid",
  {
    ...ApnsDeliveryJobContext,
    kind: ApnsDeliveryKindSchema,
  },
) {
  override get message(): string {
    return `Invalid signature for APNs delivery job ${this.jobId}.`;
  }
}

export const ApnsDeliveryJobInvalid = Schema.Union([
  ApnsDeliveryJobQueuePayloadInvalid,
  ApnsDeliveryJobLiveActivityAggregateMissing,
  ApnsDeliveryJobLiveActivityNotificationUnexpected,
  ApnsDeliveryJobPushNotificationMissing,
  ApnsDeliveryJobPushNotificationAggregateUnexpected,
  ApnsDeliveryJobCreatedAtInvalid,
  ApnsDeliveryJobExpiresAtInvalid,
  ApnsDeliveryJobTimeWindowInvalid,
  ApnsDeliveryJobTimeWindowTooLong,
  ApnsDeliveryJobSignatureInvalid,
]);
export type ApnsDeliveryJobInvalid = typeof ApnsDeliveryJobInvalid.Type;

export class ApnsDeliveryJobExpired extends Schema.TaggedError<ApnsDeliveryJobExpired>()(
  "ApnsDeliveryJobExpired",
  {
    ...ApnsDeliveryJobContext,
    kind: ApnsDeliveryKindSchema,
    expiresAt: Schema.String,
  },
) {
  override get message(): string {
    return `APNs delivery job ${this.jobId} expired at ${this.expiresAt}.`;
  }
}

export const ApnsDeliveryJobVerificationError = Schema.Union([
  ApnsDeliveryJobInvalid,
  ApnsDeliveryJobExpired,
]);
export type ApnsDeliveryJobVerificationError = typeof ApnsDeliveryJobVerificationError.Type;

export function makeApnsDeliveryJobPayload(input: {
  readonly kind: ApnsDeliveryJobPayload["kind"];
  readonly userId: string;
  readonly deviceId: string;
  readonly token: string;
  readonly bundleId?: string | null | undefined;
  readonly apsEnvironment?: "sandbox" | "production" | null | undefined;
  readonly aggregate: ApnsDeliveryJobPayload["aggregate"];
  readonly notification?: ApnsNotificationPayload | null;
  readonly alert?: ApnsLiveActivityAlert | null | undefined;
  readonly createdAt: string;
  readonly expiresAt: string;
  readonly jobId: string;
}): ApnsDeliveryJobPayload {
  return {
    version: 1,
    jobId: input.jobId,
    kind: input.kind,
    target: {
      userId: input.userId,
      deviceId: input.deviceId,
      token: input.token,
      ...(input.bundleId ? { bundleId: input.bundleId } : {}),
      ...(input.apsEnvironment ? { apsEnvironment: input.apsEnvironment } : {}),
    },
    aggregate: input.aggregate,
    notification: input.notification ?? null,
    // Omit absent fields to preserve signatures from older relay builds.
    ...(input.alert ? { alert: input.alert } : {}),
    createdAt: input.createdAt,
    expiresAt: input.expiresAt,
  };
}

export function expiresAtForJob(createdAtMs: number): string {
  return DateTime.formatIso(Option.getOrThrow(DateTime.make(createdAtMs + MAX_JOB_AGE_MS)));
}

function validatePayloadShape(payload: ApnsDeliveryJobPayload): ApnsDeliveryJobInvalid | null {
  switch (payload.kind) {
    case "live_activity_update":
      if (payload.aggregate === null) {
        return new ApnsDeliveryJobLiveActivityAggregateMissing({
          jobId: payload.jobId,
          kind: payload.kind,
          userId: payload.target.userId,
          deviceId: payload.target.deviceId,
        });
      }
      if (payload.notification !== null) {
        return new ApnsDeliveryJobLiveActivityNotificationUnexpected({
          jobId: payload.jobId,
          kind: payload.kind,
          userId: payload.target.userId,
          deviceId: payload.target.deviceId,
        });
      }
      return null;
    case "live_activity_end":
      if (payload.notification !== null) {
        return new ApnsDeliveryJobLiveActivityNotificationUnexpected({
          jobId: payload.jobId,
          kind: payload.kind,
          userId: payload.target.userId,
          deviceId: payload.target.deviceId,
        });
      }
      return null;
    case "push_notification":
      if (payload.notification === null) {
        return new ApnsDeliveryJobPushNotificationMissing({
          jobId: payload.jobId,
          userId: payload.target.userId,
          deviceId: payload.target.deviceId,
        });
      }
      if (payload.aggregate !== null) {
        return new ApnsDeliveryJobPushNotificationAggregateUnexpected({
          jobId: payload.jobId,
          userId: payload.target.userId,
          deviceId: payload.target.deviceId,
        });
      }
      return null;
  }
}

const signingKey = (secret: Redacted.Redacted<string>) =>
  Mac.key(Mac.hmacSha256, new TextEncoder().encode(Redacted.value(secret)));

const payloadBytes = (payload: ApnsDeliveryJobPayload) =>
  new TextEncoder().encode(stableStringify(payload));

export const signApnsDeliveryJob = Effect.fn("relay.apns_delivery_jobs.sign")(function* (input: {
  readonly secret: Redacted.Redacted<string>;
  readonly payload: ApnsDeliveryJobPayload;
}) {
  const mac = yield* Mac.Mac;
  const signature = yield* signingKey(input.secret).pipe(
    Effect.flatMap((key) => mac.sign(key, payloadBytes(input.payload))),
    Effect.orDie,
  );
  return {
    algorithm: APNS_DELIVERY_JOB_SIGNING_ALGORITHM,
    payload: input.payload,
    signature: Base64Url.encode(signature),
  } satisfies SignedApnsDeliveryJob;
});

export const verifySignedApnsDeliveryJob = Effect.fn("relay.apns_delivery_jobs.verify")(
  function* (input: {
    readonly secret: Redacted.Redacted<string>;
    readonly job: SignedApnsDeliveryJob;
    readonly nowMs: number;
  }) {
    const payload = input.job.payload;
    const invalid = validateSignedJobWindow(payload, input.nowMs);
    if (invalid !== null) {
      return yield* invalid;
    }
    const tag = Base64Url.decode(input.job.signature);
    const mac = yield* Mac.Mac;
    const verified =
      Result.isSuccess(tag) &&
      (yield* signingKey(input.secret).pipe(
        Effect.flatMap((key) => mac.verify(key, tag.success, payloadBytes(payload))),
        Effect.orDie,
      ));
    if (!verified) {
      return yield* new ApnsDeliveryJobSignatureInvalid({
        jobId: payload.jobId,
        kind: payload.kind,
        userId: payload.target.userId,
        deviceId: payload.target.deviceId,
      });
    }
    return payload;
  },
);

function validateSignedJobWindow(
  payload: ApnsDeliveryJobPayload,
  nowMs: number,
): ApnsDeliveryJobVerificationError | null {
  const invalidPayload = validatePayloadShape(payload);
  if (invalidPayload !== null) {
    return invalidPayload;
  }
  const createdAt = DateTime.make(payload.createdAt);
  if (Option.isNone(createdAt)) {
    return new ApnsDeliveryJobCreatedAtInvalid({
      jobId: payload.jobId,
      kind: payload.kind,
      userId: payload.target.userId,
      deviceId: payload.target.deviceId,
      createdAt: payload.createdAt,
    });
  }
  const expiresAt = DateTime.make(payload.expiresAt);
  if (Option.isNone(expiresAt)) {
    return new ApnsDeliveryJobExpiresAtInvalid({
      jobId: payload.jobId,
      kind: payload.kind,
      userId: payload.target.userId,
      deviceId: payload.target.deviceId,
      expiresAt: payload.expiresAt,
    });
  }
  const createdAtMs = createdAt.value.epochMilliseconds;
  const expiresAtMs = expiresAt.value.epochMilliseconds;
  if (expiresAtMs <= createdAtMs) {
    return new ApnsDeliveryJobTimeWindowInvalid({
      jobId: payload.jobId,
      kind: payload.kind,
      userId: payload.target.userId,
      deviceId: payload.target.deviceId,
      createdAt: payload.createdAt,
      expiresAt: payload.expiresAt,
    });
  }
  if (expiresAtMs - createdAtMs > MAX_JOB_AGE_MS) {
    return new ApnsDeliveryJobTimeWindowTooLong({
      jobId: payload.jobId,
      kind: payload.kind,
      userId: payload.target.userId,
      deviceId: payload.target.deviceId,
      createdAt: payload.createdAt,
      expiresAt: payload.expiresAt,
    });
  }
  if (expiresAtMs <= nowMs) {
    return new ApnsDeliveryJobExpired({
      jobId: payload.jobId,
      kind: payload.kind,
      userId: payload.target.userId,
      deviceId: payload.target.deviceId,
      expiresAt: payload.expiresAt,
    });
  }
  return null;
}