Class EmailTemplateAdminService

constructor

• new EmailTemplateAdminService(
      __namedParameters: {
          cache: EmailTemplateCache;
          db: B2bDatabase;
          emailSendCore: EmailSendCore;
          internalEventPublisher: InternalEventPublisher | null;
      },
  ): EmailTemplateAdminService

  Parameters

  • __namedParameters: {
        cache: EmailTemplateCache;
        db: B2bDatabase;
        emailSendCore: EmailSendCore;
        internalEventPublisher: InternalEventPublisher | null;
    }

    • cache: EmailTemplateCache

    • db: B2bDatabase

    • emailSendCore: EmailSendCore

      Email send core (recipient dedupe → template resolution → render → SES). Injected for sendTest — admin test sends go through the same pipeline as the lambda's event-driven sends.

    • internalEventPublisher: InternalEventPublisher | null

      Publishes notification.emailTemplate.*; null for the import script.

  Returns EmailTemplateAdminService

Staticinstance

delete

• delete(
      input: { id: string },
  ): Promise<{ ok: true; value: void } | { error: ServiceError; ok: false }>

  Discard a draft: clear draft_version_id. The version row remains — it is immutable history. live_version_id is untouched, so a variant with a live version keeps sending.

  Parameters

  • input: { id: string }

  Returns Promise<{ ok: true; value: void } | { error: ServiceError; ok: false }>

get

• get(__namedParameters: { id: string }): Promise<EmailTemplate | null>

  Parameters

  • __namedParameters: { id: string }

  Returns Promise<EmailTemplate | null>

search

• search(
      input: {
          ids?: readonly string[];
          keys?: readonly (
              | "IDENTITY"
              | "ORGANIZATION"
              | "LEDGER_ACCOUNT"
              | "PAYMENT_INSTRUMENT"
              | "DEPOSIT"
              | "WITHDRAW"
              | "TRANSFER"
              | "CARD_TRANSACTION"
              | "INVOICE"
              | "RECEIPT"
              | "AUTH"
              | "APPLICATION"
          )[];
          live?: boolean;
          page?: number;
          pageSize?: number;
          statusVariants?: readonly string[];
      },
  ): Promise<
      {
          ok: true;
          value: { hasNext: boolean; items: EmailTemplate[]; total: number };
      },
  >

  Authoring list/read, cached under the admin key-prefix partition. Projects invalidReason from the validator (collect mode), so a broken variant shows its problem in the admin list without a write or render. Write/ render validation stays throwing (update re-validates).

  Parameters

  • input: {
        ids?: readonly string[];
        keys?: readonly (
            | "IDENTITY"
            | "ORGANIZATION"
            | "LEDGER_ACCOUNT"
            | "PAYMENT_INSTRUMENT"
            | "DEPOSIT"
            | "WITHDRAW"
            | "TRANSFER"
            | "CARD_TRANSACTION"
            | "INVOICE"
            | "RECEIPT"
            | "AUTH"
            | "APPLICATION"
        )[];
        live?: boolean;
        page?: number;
        pageSize?: number;
        statusVariants?: readonly string[];
    }

    • Optionalids?: readonly string[]

    • Optionalkeys?: readonly (
          | "IDENTITY"
          | "ORGANIZATION"
          | "LEDGER_ACCOUNT"
          | "PAYMENT_INSTRUMENT"
          | "DEPOSIT"
          | "WITHDRAW"
          | "TRANSFER"
          | "CARD_TRANSACTION"
          | "INVOICE"
          | "RECEIPT"
          | "AUTH"
          | "APPLICATION"
      )[]

    • Optionallive?: boolean

      Only variants with a live version.

    • Optionalpage?: number

    • OptionalpageSize?: number

    • OptionalstatusVariants?: readonly string[]

  Returns Promise<
      {
          ok: true;
          value: { hasNext: boolean; items: EmailTemplate[]; total: number };
      },
  >

searchVersions

• searchVersions(
      input: { id: string; page?: number; pageSize?: number },
  ): Promise<
      | {
          ok: true;
          value: { hasNext: boolean; items: EmailTemplateVersion[]; total: number };
      }
      | { error: ServiceError; ok: false },
  >

  A variant's full authoring history, newest first — what the editor's Versions tab lists and diffs (EMAIL_TEMPLATES.md §4.6: "field-level diff between any two versions to make rollback informed"). versions stays the two-pointer read for the working copy; this is the append-only trail behind it.

  Uncached, like versions: the tab renders straight after a save, and version rows are immutable so there is nothing to invalidate anyway.

  Parameters

  • input: { id: string; page?: number; pageSize?: number }

  Returns Promise<
      | {
          ok: true;
          value: { hasNext: boolean; items: EmailTemplateVersion[]; total: number };
      }
      | { error: ServiceError; ok: false },
  >

sendTest

• sendTest(
      input: {
          notification: EmailNotification;
          recipient: { email: string; name?: string };
          templateKey:
              | "IDENTITY"
              | "ORGANIZATION"
              | "LEDGER_ACCOUNT"
              | "PAYMENT_INSTRUMENT"
              | "DEPOSIT"
              | "WITHDRAW"
              | "TRANSFER"
              | "CARD_TRANSACTION"
              | "INVOICE"
              | "RECEIPT"
              | "AUTH"
              | "APPLICATION";
      },
  ): Promise<{ ok: true; value: EmailSendOutcome }>

  Send a test email via EmailSendCore, exercising the full send pipeline (recipient dedupe → active template resolution → render → SES) in the same way the lambda does for event-driven sends. One implementation, two entrypoints.

  The outcome names the exact copy exercised (version + content hash) on a completed send, and the reason nothing arrived on a skip. Throws on SES failure.

  Parameters

  • input: {
        notification: EmailNotification;
        recipient: { email: string; name?: string };
        templateKey:
            | "IDENTITY"
            | "ORGANIZATION"
            | "LEDGER_ACCOUNT"
            | "PAYMENT_INSTRUMENT"
            | "DEPOSIT"
            | "WITHDRAW"
            | "TRANSFER"
            | "CARD_TRANSACTION"
            | "INVOICE"
            | "RECEIPT"
            | "AUTH"
            | "APPLICATION";
    }

  Returns Promise<{ ok: true; value: EmailSendOutcome }>

update

• update(
      input: { actorId: string; data: EmailTemplateUpdateData; id: string },
  ): Promise<
      | { ok: true; value: EmailTemplate }
      | {
          error:
              | ServiceError<"EMAIL_TEMPLATE_NOT_FOUND">
              | ServiceError<
                  "EMAIL_TEMPLATE_INVALID",
                  {
                      issues: Readonly<
                          {
                              code: EmailTemplateValidationCode;
                              field: EmailTemplateValidationField;
                              message: string;
                              offset?: number;
                              renderCase?: Readonly<(...)>;
                              value?: string;
                          },
                      >[];
                  },
              >
              | ServiceError<"EMAIL_TEMPLATE_SAME_ACTOR_ACTIVATION">
              | ServiceError<"EMAIL_TEMPLATE_VERSION_NOT_FOUND">
              | ServiceError<"EMAIL_TEMPLATE_NOT_DEACTIVATABLE">;
          ok: false;
      },
  >

  Save + lifecycle (PATCH semantics, §4.5). Content fields validate and insert a version row; a status change moves the pointers, running the two-actor guard on ACTIVE. Both happen in one transaction; every write then busts the shared cache. Any refusal rolls the whole transaction back.

  Parameters

  • input: { actorId: string; data: EmailTemplateUpdateData; id: string }

    • actorId: string

      The acting admin, adusr_…; saved content records it as its author.

    • data: EmailTemplateUpdateData

    • id: string

  Returns Promise<
      | { ok: true; value: EmailTemplate }
      | {
          error:
              | ServiceError<"EMAIL_TEMPLATE_NOT_FOUND">
              | ServiceError<
                  "EMAIL_TEMPLATE_INVALID",
                  {
                      issues: Readonly<
                          {
                              code: EmailTemplateValidationCode;
                              field: EmailTemplateValidationField;
                              message: string;
                              offset?: number;
                              renderCase?: Readonly<(...)>;
                              value?: string;
                          },
                      >[];
                  },
              >
              | ServiceError<"EMAIL_TEMPLATE_SAME_ACTOR_ACTIVATION">
              | ServiceError<"EMAIL_TEMPLATE_VERSION_NOT_FOUND">
              | ServiceError<"EMAIL_TEMPLATE_NOT_DEACTIVATABLE">;
          ok: false;
      },
  >

versions

• versions(
      __namedParameters: { id: string },
  ): Promise<
      | {
          draft: StoredEmailTemplate
          | null;
          live: StoredEmailTemplate | null;
      }
      | null,
  >

  The full live-vs-draft content pair for a variant, plus the pointers' copy. The authoring list flattens to the working copy (EmailTemplate) so the versions tab diffs live against draft here instead.

  Parameters

  • __namedParameters: { id: string }

  Returns Promise<
      | {
          draft: StoredEmailTemplate
          | null;
          live: StoredEmailTemplate | null;
      }
      | null,
  >