@remit/backend 0.0.144 → 0.0.146

package/dist/src/service/create-remit-client.js

@@ -1,9 +1,7 @@
 import { logger } from "@remit/logger";
-import { BodySyncQueueService, BodySyncService, createConnection, FlagPushService, FlagQueueService, MailboxQueueService, MessageMoveService, OutboxAttachmentService, OutboxQueueService, PlacementMoveService, SpamReportService, SyncWarningService, } from "@remit/mailbox-service";
+import { BodySyncQueueService, BodySyncService, createConnection, FlagPushService, FlagQueueService, fifoMailboxManagement, MailboxQueueService, MessageMoveService, OutboxAttachmentService, OutboxQueueService, PlacementMoveService, SpamReportService, SyncWarningService, } from "@remit/mailbox-service";
 import { buildFilterConfig } from "@remit/mailbox-service/filter-config";
-import { createCachedDataKeyProvider, createKmsDataKeyProvider, createSecretsService, deserializeEncryptedPayload, FAKE_KMS_KEY_ID, } from "@remit/secrets-service";
-import { createStorageService } from "@remit/storage-service/s3";
-import { env } from "expect-env";
+import { deserializeEncryptedPayload, } from "@remit/secrets-service";
 const buildConnectionScope = (accountService, secretsService) => async (accountId) => {
     const account = await accountService.get(accountId);
     if (!account.passwordHash) {
@@ -36,34 +34,6 @@ const buildConnectionScope = (accountService, secretsService) => async (accountI
     };
     return { getConnection, disconnect };
 };
-// The body queue lives on the worker infra; the API only knows it locally
-// (dev / e2e set SQS_QUEUE_URL_BODY). When unset the read path still returns a
-// retryable 202 — it just cannot re-arm the cue itself.
-const buildBodySyncQueue = () => {
-    const bodyQueueUrl = process.env.SQS_QUEUE_URL_BODY;
-    if (!bodyQueueUrl)
-        return undefined;
-    return new BodySyncQueueService({ sqsQueueUrl: bodyQueueUrl, logger });
-};
-// Everything a RemitClient needs that is chosen from the environment and does
-// not vary by data backend: storage, secrets, the SQS queue URLs, and
-// the optional body-sync queue. Each composition root builds its backend's
-// repositories and merges them with this.
-export const buildSharedDeps = () => {
-    const storage = createStorageService();
-    const kmsKeyId = process.env.KMS_KEY_ID ?? FAKE_KMS_KEY_ID;
-    const dataKeyProvider = createCachedDataKeyProvider(createKmsDataKeyProvider(kmsKeyId));
-    const secrets = createSecretsService(dataKeyProvider);
-    const sqsQueueUrl = env.SQS_QUEUE_URL;
-    const sqsSmtpQueueUrl = process.env.SQS_QUEUE_URL_SMTP ?? sqsQueueUrl;
-    return {
-        storage,
-        secrets,
-        sqsQueueUrl,
-        sqsSmtpQueueUrl,
-        bodySyncQueue: buildBodySyncQueue(),
-    };
-};
 // The read-path body backfill (describeMessage / getRawMessage →
 // fetchAndGetBody) materializes a body that was never sync-synced, and must run
 // the account's standing filters the same way the imap-worker's sync path does.
@@ -73,77 +43,26 @@ export const buildSharedDeps = () => {
 // #223). Only the explicit user-rule half is wired here; heuristic classifier
 // placement stays on the sync path. It shares `buildFilterConfig` with
 // `sync-message-body.ts`, so a filter fires on either (issue #298). Over the
-// message-management queue's
-// local-first PlacementMoveService; filters stay off when that queue is unset.
-export const buildReadPathFilterConfig = (repositories) => {
-    const placementMoveQueueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
+// message-management queue's local-first PlacementMoveService.
+export const buildReadPathFilterConfig = (repositories, queues) => {
+    const { messageManagement } = queues;
     return buildFilterConfig({
         filterService: repositories.filter,
         messageLabelService: repositories.messageLabel,
         mailboxService: repositories.mailbox,
-        placementMoveService: placementMoveQueueUrl
-            ? new PlacementMoveService({
-                messageService: repositories.message,
-                threadMessageService: repositories.threadMessage,
-                markerService: repositories.placementMove,
-                addressService: repositories.address,
-                mailboxSpecialUseService: repositories.mailboxSpecialUse,
-                mailboxService: repositories.mailbox,
-                sqsQueueUrl: placementMoveQueueUrl,
-            })
-            : undefined,
+        placementMoveService: new PlacementMoveService({
+            messageService: repositories.message,
+            threadMessageService: repositories.threadMessage,
+            markerService: repositories.placementMove,
+            addressService: repositories.address,
+            mailboxSpecialUseService: repositories.mailboxSpecialUse,
+            mailboxService: repositories.mailbox,
+            queue: messageManagement,
+        }),
     });
 };
-// Backend-neutral composition root: given repositories (from any data-ports
-// implementation) and the shared services, wire the domain and queue services
-// and assemble a RemitClient. Imports neither ElectroDB nor Drizzle — the
-// caller chooses the backend.
-export const createRemitClient = (deps) => {
-    const { repositories, storage, secrets, sqsQueueUrl, sqsSmtpQueueUrl, bodySyncQueue, } = deps;
-    const filterConfig = buildReadPathFilterConfig(repositories);
-    const flagPushService = new FlagPushService({
-        markerService: repositories.flagPush,
-        sqsQueueUrl,
-        logger,
-    });
-    // Shared with the returned `flagQueue` below (issue #302): body sync
-    // auto-marks-read a message from an unsubscribed sender through the exact
-    // same `FlagQueueService.markAsRead` a manual mark-as-read goes through, not
-    // a second instance or a second primitive.
-    const flagQueueService = new FlagQueueService({
-        messageFlagService: repositories.messageFlag,
-        messageService: repositories.message,
-        threadMessageService: repositories.threadMessage,
-        flagPushService,
-        logger,
-    });
-    const messageMoveService = new MessageMoveService({
-        messageService: repositories.message,
-        mailboxService: repositories.mailbox,
-        mailboxSpecialUseService: repositories.mailboxSpecialUse,
-        threadMessageService: repositories.threadMessage,
-        addressService: repositories.address,
-        sqsQueueUrl,
-        logger,
-    });
-    // One instance, shared with the queue service below: the per-draft chain that
-    // makes the attachment cap safe under concurrency lives on it, and a discard
-    // racing an upload has to take the same lock the upload does.
-    const outboxAttachmentService = new OutboxAttachmentService({
-        outboxMessageService: repositories.outboxMessage,
-        outboxAttachmentService: repositories.outboxAttachment,
-        storage,
-    });
-    const bodySync = new BodySyncService(repositories.message, storage, repositories.threadMessage, repositories.address, repositories.envelope, new SyncWarningService(repositories.syncWarning), logger, undefined, filterConfig, undefined, { flagQueueService }, 
-    // The read-path backfill materializes a body the sync path never got to,
-    // so it is a message's first sight as much as the sync pass is — and an
-    // invitation the user opens before background sync must still get its
-    // card (issue #1033, the same argument as the filter wiring above).
-    {
-        calendarSuggestionService: repositories.calendarSuggestion,
-        calendarStore: repositories.calendarStore,
-        filterService: repositories.filter,
-    });
+export const createRemitCore = (deps) => {
+    const { repositories, storage, secrets } = deps;
     return {
         accountConfig: repositories.accountConfig,
         account: repositories.account,
@@ -174,34 +93,96 @@ export const createRemitClient = (deps) => {
         calendarStore: repositories.calendarStore,
         storage,
         secrets,
-        bodySync,
-        bodySyncQueue,
         placementMove: repositories.placementMove,
         flagPush: repositories.flagPush,
-        flagQueue: flagQueueService,
-        mailboxQueue: new MailboxQueueService({
-            mailboxService: repositories.mailbox,
-            sqsQueueUrl,
+        // One instance, shared with the outbox queue service: the per-draft chain
+        // that makes the attachment cap safe under concurrency lives on it, and a
+        // discard racing an upload has to take the same lock the upload does.
+        outboxAttachment: new OutboxAttachmentService({
+            outboxMessageService: repositories.outboxMessage,
+            outboxAttachmentService: repositories.outboxAttachment,
+            storage,
+        }),
+        createConnectionScope: buildConnectionScope(repositories.account, secrets),
+    };
+};
+export const composeSyncServices = (core, queues) => {
+    const flagPushService = new FlagPushService({
+        markerService: core.flagPush,
+        queue: queues.sync,
+        logger,
+    });
+    const messageMove = new MessageMoveService({
+        messageService: core.message,
+        mailboxService: core.mailbox,
+        mailboxSpecialUseService: core.mailboxSpecialUse,
+        threadMessageService: core.threadMessage,
+        addressService: core.address,
+        queue: queues.sync,
+        logger,
+    });
+    return {
+        flagQueue: new FlagQueueService({
+            messageFlagService: core.messageFlag,
+            messageService: core.message,
+            threadMessageService: core.threadMessage,
+            flagPushService,
             logger,
         }),
-        messageMove: messageMoveService,
-        outboxAttachment: outboxAttachmentService,
-        outboxQueue: new OutboxQueueService({
-            outboxMessageService: repositories.outboxMessage,
-            outboxAttachmentService,
-            accountService: repositories.account,
-            sqsSmtpQueueUrl,
+        mailboxQueue: new MailboxQueueService({
+            mailboxService: core.mailbox,
+            enqueue: fifoMailboxManagement(queues.sync),
             logger,
         }),
+        messageMove,
         spamReport: new SpamReportService({
-            messageService: repositories.message,
-            addressService: repositories.address,
-            accountService: repositories.account,
-            mailboxSpecialUseService: repositories.mailboxSpecialUse,
-            messageMoveService,
+            messageService: core.message,
+            addressService: core.address,
+            accountService: core.account,
+            mailboxSpecialUseService: core.mailboxSpecialUse,
+            messageMoveService: messageMove,
             flagPushService,
             logger,
         }),
-        createConnectionScope: buildConnectionScope(repositories.account, secrets),
+    };
+};
+export const composeSmtpServices = (core, queues) => ({
+    outboxQueue: new OutboxQueueService({
+        outboxMessageService: core.outboxMessage,
+        outboxAttachmentService: core.outboxAttachment,
+        accountService: core.account,
+        queue: queues.smtp,
+        logger,
+    }),
+});
+export const composeBodyServices = (queues) => ({
+    bodySyncQueue: new BodySyncQueueService({ queue: queues.body, logger }),
+});
+export const composeReadPathServices = (core, queues, sync) => ({
+    // The flag service is the one `flagQueue` is (issue #302): body sync
+    // auto-marks-read a message from an unsubscribed sender through the exact
+    // same `FlagQueueService.markAsRead` a manual mark-as-read goes through.
+    bodySync: new BodySyncService(core.message, core.storage, core.threadMessage, core.address, core.envelope, new SyncWarningService(core.syncWarning), logger, undefined, buildReadPathFilterConfig(core, queues), undefined, { flagQueueService: sync.flagQueue }, 
+    // The read-path backfill materializes a body the sync path never got to,
+    // so it is a message's first sight as much as the sync pass is — and an
+    // invitation the user opens before background sync must still get its
+    // card (issue #1033, the same argument as the filter wiring above).
+    {
+        calendarSuggestionService: core.calendarSuggestion,
+        calendarStore: core.calendarStore,
+        filterService: core.filter,
+    }),
+});
+export const createRemitClient = (deps) => {
+    const { queues } = deps;
+    const core = createRemitCore(deps);
+    const sync = composeSyncServices(core, queues);
+    return {
+        ...core,
+        queues,
+        ...sync,
+        ...composeSmtpServices(core, queues),
+        ...composeBodyServices(queues),
+        ...composeReadPathServices(core, queues, sync),
     };
 };

package/dist/src/service/data-client.js

@@ -30,11 +30,9 @@ const buildRelationalClient = async () => {
     return composition.buildSqliteClient();
 };
 export const getClient = () => {
-    if (!clientPromise) {
-        clientPromise = injected
-            ? Promise.resolve(injected)
-            : buildRelationalClient();
-    }
+    clientPromise ??= injected
+        ? Promise.resolve(injected)
+        : buildRelationalClient();
     return clientPromise;
 };
 /** Reset the singleton and any injected client — test use only. */

package/dist/src/service/export-identity.d.ts

@@ -1,3 +1,4 @@
 import type { ConfigExportIdentity } from "@remit/config-transfer";
+import type { ApiConfig } from "../config/api-config.js";
 /** Who wrote a configuration file, and from where. Provenance only. */
-export declare const exportIdentity: (now?: Date) => ConfigExportIdentity;
+export declare const exportIdentity: (config: Pick<ApiConfig, "updateControlDir" | "publicOrigin">, now?: Date) => ConfigExportIdentity;

package/dist/src/service/export-identity.js

@@ -1,6 +1,5 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-const DEFAULT_CONTROL_DIR = "/data/control";
 /**
  * The version a file says it was written by. The updater owns this fact: it
  * reads the tag from `.env` and writes it into `state.json`, which is the only
@@ -9,8 +8,7 @@ const DEFAULT_CONTROL_DIR = "/data/control";
  * stamp, and an export says so rather than inventing a version an importing
  * reader would then trust.
  */
-const runningVersion = () => {
-    const dir = process.env.REMIT_UPDATE_CONTROL_DIR ?? DEFAULT_CONTROL_DIR;
+const runningVersion = (dir) => {
     let raw;
     try {
         raw = readFileSync(join(dir, "state.json"), "utf8");
@@ -27,9 +25,9 @@ const runningVersion = () => {
         : "unknown";
 };
 /** Who wrote a configuration file, and from where. Provenance only. */
-export const exportIdentity = (now = new Date()) => ({
+export const exportIdentity = (config, now = new Date()) => ({
     app: "reader",
-    version: runningVersion(),
+    version: runningVersion(config.updateControlDir),
     exportedAt: now.toISOString(),
-    instance: process.env.PUBLIC_ORIGIN ?? "",
+    instance: config.publicOrigin,
 });

package/dist/src/service/fire-and-forget.js

@@ -1,4 +1,3 @@
-import { inspect } from "node:util";
 import { logger } from "@remit/logger";
 /**
  * Run unawaited background work that MUST NOT be able to fail the request that
@@ -32,7 +31,7 @@ export const fireAndForget = async (work, context) => {
             errorName: error?.name,
             errorCode: error?.Code ??
                 error?.code,
-            error: inspect(error),
+            error,
         }, context.message);
     });
 };

package/dist/src/service/organize.d.ts

@@ -117,22 +117,19 @@ export declare const organizePredicateRejection: (predicate: OrganizePredicate)
  */
 export declare const matchOrganize: (deps: OrganizeMatchDeps, accountConfigId: string, predicate: OrganizePredicate, limit?: number, scope?: OrganizeMatchScope) => Promise<OrganizeMatchResult>;
 /** The matcher deps for the running backend/worker. */
-export declare const buildOrganizeMatchDeps: (client: RemitClient) => OrganizeMatchDeps;
+export declare const buildOrganizeMatchDeps: (client: RemitClient<never>) => OrganizeMatchDeps;
 /**
  * The exclusive-move arm of a back-apply, wired exactly like the body-sync
  * placement mover (`sync-message-body.ts`): the local-first
  * {@link PlacementMoveService} over the shared message-management queue. A move
  * commits locally (marker + ThreadMessage + Message row) and enqueues a
  * `PLACEMENT_MOVE_PUSH` for the reconciler; its marker state engine makes a
- * redelivered job idempotent (mirrors #1297). Returns `undefined` when no
- * message-management queue is wired — the same gate body sync uses to keep the
- * move path off — so a move requested in that environment is counted as failed
- * rather than silently dropped (see {@link applyOrganize}).
+ * redelivered job idempotent (mirrors #1297).
  */
-export declare const buildOrganizeMoveService: (client: RemitClient) => PlacementMoveService | undefined;
+export declare const buildOrganizeMoveService: (client: RemitClient<"messageManagement">) => PlacementMoveService;
 export interface ApplyOrganizeDeps {
-    client: RemitClient;
-    moveService?: PlacementMoveService;
+    client: RemitClient<never>;
+    moveService: PlacementMoveService;
 }
 export interface ApplyOrganizeResult {
     applied: number;
@@ -165,9 +162,9 @@ export interface FilterBackApplyResult {
     failures: string[];
 }
 export interface FilterBackApplyDeps {
-    client: RemitClient;
+    client: RemitClient<never>;
     matchDeps: OrganizeMatchDeps;
-    moveService?: PlacementMoveService;
+    moveService: PlacementMoveService;
 }
 /**
  * Run one standing filter over the inbox as if each matching message had just

package/dist/src/service/organize.js

@@ -154,25 +154,17 @@ export const buildOrganizeMatchDeps = (client) => ({
  * {@link PlacementMoveService} over the shared message-management queue. A move
  * commits locally (marker + ThreadMessage + Message row) and enqueues a
  * `PLACEMENT_MOVE_PUSH` for the reconciler; its marker state engine makes a
- * redelivered job idempotent (mirrors #1297). Returns `undefined` when no
- * message-management queue is wired — the same gate body sync uses to keep the
- * move path off — so a move requested in that environment is counted as failed
- * rather than silently dropped (see {@link applyOrganize}).
+ * redelivered job idempotent (mirrors #1297).
  */
-export const buildOrganizeMoveService = (client) => {
-    const queueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
-    if (!queueUrl)
-        return undefined;
-    return new PlacementMoveService({
-        messageService: client.message,
-        threadMessageService: client.threadMessage,
-        markerService: client.placementMove,
-        addressService: client.address,
-        mailboxSpecialUseService: client.mailboxSpecialUse,
-        mailboxService: client.mailbox,
-        sqsQueueUrl: queueUrl,
-    });
-};
+export const buildOrganizeMoveService = (client) => new PlacementMoveService({
+    messageService: client.message,
+    threadMessageService: client.threadMessage,
+    markerService: client.placementMove,
+    addressService: client.address,
+    mailboxSpecialUseService: client.mailboxSpecialUse,
+    mailboxService: client.mailbox,
+    queue: client.queues.messageManagement,
+});
 /**
  * Apply the back-apply action to every matched message, reusing the index-time
  * apply plumbing: an idempotent MessageLabel upsert (additive) with
@@ -195,12 +187,6 @@ export const applyOrganize = async (deps, accountConfigId, messageIds, predicate
     const applyMove = predicate.actionMailboxId !== NO_ACTION && predicate.actionMailboxId !== "";
     const applyToMessage = async (messageId) => {
         if (applyMove) {
-            if (!moveService) {
-                // An exclusive move was requested but this caller wired no move
-                // service. Never silently pretend it applied — surface it as a
-                // failed message so the job's failedCount reflects reality.
-                throw new Error("Organize move action requested but no move service is wired");
-            }
             const message = await client.message.get(messageId);
             const accountId = await client.mailbox.resolveAccountId(message.mailboxId);
             if (!accountId) {
@@ -324,9 +310,6 @@ export const backApplyFilter = async (deps, accountConfigId, filterId) => {
         mailboxService: client.mailbox,
         placementMoveService: moveService,
     });
-    if (!config) {
-        throw new Error("Filter back-apply needs the message-management queue to move mail");
-    }
     const pipeline = new FilterPipeline(config, logger);
     const mailboxIds = await inboxMailboxIds(client, accountConfigId);
     const nothing = {

package/dist/src/service/queues.d.ts

@@ -0,0 +1,12 @@
+import type { AccountFanoutEvent, FifoQueueProducer, QueueProducer } from "@remit/data-ports";
+import type { FlagPushEvent, MailboxManagementEvent, MessageMoveQueueEvent, PlacementMovePushEvent, SendMessageEvent, SyncMessageBodyEvent } from "@remit/mailbox-service";
+import type { SyncMailboxesEvent } from "./trigger-sync.js";
+export type SyncQueueEvent = SyncMailboxesEvent | FlagPushEvent | MailboxManagementEvent | MessageMoveQueueEvent;
+export interface RemitClientQueues {
+    sync: FifoQueueProducer<SyncQueueEvent>;
+    accountFanout: QueueProducer<AccountFanoutEvent>;
+    smtp: QueueProducer<SendMessageEvent>;
+    messageManagement: QueueProducer<PlacementMovePushEvent>;
+    body: QueueProducer<SyncMessageBodyEvent>;
+}
+export type QueueName = keyof RemitClientQueues;

package/dist/src/service/queues.js

@@ -0,0 +1 @@
+export {};

package/dist/src/service/shared-deps.d.ts

@@ -0,0 +1,6 @@
+import type { RemitClientSharedDeps } from "./create-remit-client.js";
+import type { QueueName, RemitClientQueues } from "./queues.js";
+export type SqsQueueUrls = Record<QueueName, string>;
+export declare const sqsQueueUrlsFromEnv: () => SqsQueueUrls;
+export declare const sqsQueues: (urls: SqsQueueUrls) => RemitClientQueues;
+export declare const buildSharedDeps: (queues: RemitClientQueues) => RemitClientSharedDeps;

package/dist/src/service/shared-deps.js

@@ -0,0 +1,26 @@
+import { createCachedDataKeyProvider, createSecretsService, } from "@remit/secrets-service";
+import { createKmsDataKeyProvider, FAKE_KMS_KEY_ID, } from "@remit/secrets-service/kms";
+import { createFifoQueueProducer, createStandardQueueProducer, } from "@remit/sqs-client/producer";
+import { createStorageService } from "@remit/storage-service/s3";
+import { env } from "expect-env";
+export const sqsQueueUrlsFromEnv = () => ({
+    sync: env.SQS_QUEUE_URL,
+    accountFanout: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
+    smtp: env.SQS_QUEUE_URL_SMTP,
+    messageManagement: env.SQS_QUEUE_URL_MESSAGE_MGMT,
+    body: env.SQS_QUEUE_URL_BODY,
+});
+export const sqsQueues = (urls) => ({
+    sync: createFifoQueueProducer({ queueUrl: urls.sync }),
+    accountFanout: createStandardQueueProducer({ queueUrl: urls.accountFanout }),
+    smtp: createStandardQueueProducer({ queueUrl: urls.smtp }),
+    messageManagement: createStandardQueueProducer({
+        queueUrl: urls.messageManagement,
+    }),
+    body: createStandardQueueProducer({ queueUrl: urls.body }),
+});
+export const buildSharedDeps = (queues) => ({
+    storage: createStorageService(),
+    secrets: createSecretsService(createCachedDataKeyProvider(createKmsDataKeyProvider(process.env.KMS_KEY_ID ?? FAKE_KMS_KEY_ID))),
+    queues,
+});

package/dist/src/service/trigger-sync.d.ts

@@ -1,7 +1,13 @@
-import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
+import type { FifoQueueMessage, FifoQueueProducer } from "@remit/data-ports";
+export interface SyncMailboxesEvent {
+    type: "SYNC_MAILBOXES";
+    eventId: string;
+    timestamp: number;
+    accountId: string;
+    explicitRequest?: boolean;
+}
 interface TriggerAccountSyncInput {
-    sqsClient: SQSClient;
-    queueUrl: string;
+    queue: FifoQueueProducer<SyncMailboxesEvent>;
     accountId: string;
     /**
      * Set by POST /sync, whose callers ask for a sync of one named account: the
@@ -21,7 +27,7 @@ interface TriggerAccountSyncInput {
      */
     explicitRequest?: boolean;
     /**
-     * Override the FIFO `MessageDeduplicationId`. Defaults to the event's own
+     * Override the queue deduplication id. Defaults to the event's own
      * id, so the queue suppresses a re-send of one event and nothing else —
      * every manual call site (POST /sync, OAuth connect, config load,
      * pull-to-refresh, the client's online-poll) always enqueues. A shared,
@@ -44,7 +50,7 @@ interface TriggerAccountSyncInput {
  * retried Lambda) — see `dedupId` above.
  */
 export declare const buildScheduledSyncDedupId: (accountId: string, now: number, bucketMs: number) => string;
-export declare const buildSyncMailboxesCommand: (input: Omit<TriggerAccountSyncInput, "sqsClient">) => SendMessageCommand;
+export declare const buildSyncMailboxesMessage: (input: Omit<TriggerAccountSyncInput, "queue">) => FifoQueueMessage<SyncMailboxesEvent>;
 export declare const triggerAccountSync: (input: TriggerAccountSyncInput) => Promise<{
     eventId: string;
 }>;

package/dist/src/service/trigger-sync.js

@@ -1,6 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
-const isFifoQueue = (queueUrl) => queueUrl.endsWith(".fifo");
 /**
  * Build the scheduler's own dedup namespace, bucketed by tick interval so
  * consecutive ticks each get a fresh id (never colliding with each other)
@@ -11,8 +9,8 @@ export const buildScheduledSyncDedupId = (accountId, now, bucketMs) => {
     const bucket = Math.floor(now / bucketMs);
     return `SYNC_MAILBOXES:scheduled:${accountId}:${bucket}`;
 };
-export const buildSyncMailboxesCommand = (input) => {
-    const { queueUrl, accountId, dedupId, explicitRequest } = input;
+export const buildSyncMailboxesMessage = (input) => {
+    const { accountId, dedupId, explicitRequest } = input;
     const event = {
         type: "SYNC_MAILBOXES",
         eventId: randomUUID(),
@@ -20,20 +18,14 @@ export const buildSyncMailboxesCommand = (input) => {
         accountId,
         ...(explicitRequest && { explicitRequest }),
     };
-    const useFifo = isFifoQueue(queueUrl);
-    return new SendMessageCommand({
-        QueueUrl: queueUrl,
-        MessageBody: JSON.stringify(event),
-        ...(useFifo && {
-            MessageGroupId: accountId,
-            MessageDeduplicationId: dedupId ?? event.eventId,
-        }),
-    });
+    return {
+        body: event,
+        groupId: accountId,
+        deduplicationId: dedupId ?? event.eventId,
+    };
 };
 export const triggerAccountSync = async (input) => {
-    const command = buildSyncMailboxesCommand(input);
-    await input.sqsClient.send(command);
-    const body = command.input.MessageBody ?? "{}";
-    const parsed = JSON.parse(body);
-    return { eventId: parsed.eventId };
+    const message = buildSyncMailboxesMessage(input);
+    await input.queue.send(message);
+    return { eventId: message.body.eventId };
 };

package/dist/src/types.d.ts

@@ -1,4 +1,7 @@
 import type { Context } from "openapi-backend";
+import type { ApiConfig } from "./config/api-config.js";
+import type { RemitClient } from "./service/create-remit-client.js";
+import type { QueueName } from "./service/queues.js";
 type MatchPrefix<Prefix extends string, S extends string> = S extends `${Prefix}${infer _}` ? S : never;
 export type OperationIds = "MeOperations_deleteMe" | "MeOperations_listVipSuggestions" | "MeOperations_createExport" | "MeOperations_getExport" | "MeOperations_listQuarantine" | "ConfigOperations_getConfig" | "ConfigOperations_exportConfig" | "ConfigOperations_importConfig" | "SystemOperations_getSystemUpdate" | "SystemOperations_applySystemUpdate" | "AccountOperations_createAccount" | "AccountOperations_testConnection" | "AccountDetailOperations_updateAccount" | "AccountDetailOperations_deleteAccount" | "MicrosoftOAuthOperations_microsoftOAuthStart" | "MicrosoftOAuthOperations_microsoftOAuthCallback" | "MailboxOperations_listMailboxes" | "MailboxOperations_createMailbox" | "MailboxDetailOperations_getMailbox" | "MailboxDetailOperations_renameMailbox" | "MailboxDetailOperations_deleteMailbox" | "FolderRoleOperations_appointFolderRole" | "FilterOperations_listFilters" | "FilterOperations_createFilter" | "FilterDetailOperations_getFilter" | "FilterDetailOperations_updateFilter" | "FilterDetailOperations_deleteFilter" | "LabelOperations_listLabels" | "LabelOperations_createLabel" | "LabelDetailOperations_getLabel" | "LabelDetailOperations_updateLabel" | "LabelDetailOperations_deleteLabel" | "OrganizeOperations_createOrganizeJob" | "OrganizeOperations_previewOrganize" | "OrganizeJobDetailOperations_getOrganizeJob" | "SyncOperations_triggerSync" | "SyncOperations_getSyncStatus" | "ThreadDetailOperations_listThreadMessages" | "UnifiedThreadOperations_listAllThreads" | "ThreadOperations_listThreads" | "ThreadOperations_searchThreads" | "MessageOperations_describeMessage" | "MessageOperations_getRawMessage" | "MessageOperations_updateMessageFlags" | "MessageBulkOperations_deleteMessages" | "MessageBulkOperations_moveMessages" | "MessageBulkOperations_updateFlags" | "MessageBulkOperations_copyMessages" | "MessageBulkOperations_updateMessageLabels" | "MessageBulkOperations_reportSpam" | "MessageBulkOperations_notSpam" | "CalendarOperations_listCalendars" | "CalendarOperations_createCalendar" | "CalendarDetailOperations_getCalendar" | "CalendarDetailOperations_updateCalendar" | "CalendarDetailOperations_deleteCalendar" | "CalendarDetailOperations_getCalendarFeed" | "CalendarDetailOperations_putCalendarFeed" | "CalendarDetailOperations_revokeCalendarFeed" | "CalendarFeedOperations_getCalendarFeedIcal" | "CalendarEventOperations_listCalendarEvents" | "CalendarEventOperations_createCalendarEvent" | "CalendarEventDetailOperations_getCalendarEvent" | "CalendarEventDetailOperations_updateCalendarEvent" | "CalendarEventDetailOperations_deleteCalendarEvent" | "CalendarFreeBusyOperations_listCalendarFreeBusy" | "TrashOperations_emptyTrash" | "OutboxOperations_createOutboxMessage" | "OutboxOperations_listOutboxMessages" | "OutboxDetailOperations_getOutboxMessage" | "OutboxDetailOperations_updateOutboxMessage" | "OutboxDetailOperations_deleteOutboxMessage" | "OutboxDetailOperations_sendOutboxMessage" | "OutboxDetailOperations_mintOutboxAttachment" | "OutboxAttachmentOperations_completeOutboxAttachment" | "AddressOperations_searchAddresses" | "AddressDetailOperations_updateAddress" | "CalendarSuggestionOperations_listCalendarSuggestions" | "MessageCalendarSuggestionOperations_listMessageCalendarSuggestions" | "CalendarSuggestionActionOperations_acceptCalendarSuggestion" | "CalendarSuggestionActionOperations_declineCalendarSuggestion" | "CalendarSuggestionActionOperations_dismissCalendarSuggestion" | "CalendarSuggestionActionOperations_reopenCalendarSuggestion";
 export type MeOperationIds = MatchPrefix<"MeOperations_", OperationIds>;
@@ -45,5 +48,25 @@ export type CalendarSuggestionOperationIds = MatchPrefix<"CalendarSuggestionOper
 export type MessageCalendarSuggestionOperationIds = MatchPrefix<"MessageCalendarSuggestionOperations_", OperationIds>;
 export type CalendarSuggestionActionOperationIds = MatchPrefix<"CalendarSuggestionActionOperations_", OperationIds>;
 type HandlerResponse = Record<string, any>;
-export type OperationHandler<_T extends OperationIds = OperationIds> = (context: Context) => Promise<HandlerResponse>;
+export interface UserIdentity {
+    kind: "user";
+    accountConfigId: string;
+    sub: string;
+    email: string;
+}
+export type HandlerIdentity = {
+    kind: "anonymous";
+} | UserIdentity;
+export interface HandlerContext<K extends QueueName = never> {
+    client: RemitClient<K>;
+    identity: UserIdentity;
+    config: ApiConfig;
+}
+export interface PublicHandlerContext<K extends QueueName = never> {
+    client: RemitClient<K>;
+    config: ApiConfig;
+}
+export type PublicOperationIds = "MicrosoftOAuthOperations_microsoftOAuthCallback" | "CalendarFeedOperations_getCalendarFeedIcal";
+export type OperationHandler<_T extends OperationIds = OperationIds, K extends QueueName = never> = (context: Context, ctx: HandlerContext<K>) => Promise<HandlerResponse>;
+export type PublicOperationHandler<K extends QueueName = never> = (context: Context, ctx: PublicHandlerContext<K>) => Promise<HandlerResponse>;
 export {};