@remit/backend 0.0.144 → 0.0.146

package/dist/src/index.js

@@ -1,9 +1,25 @@
 import { inspect } from "node:util";
 import { logger } from "@remit/logger";
 import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
-import { handleApiEvent } from "./api.js";
+import { assertLocalBypassNotInDeployedEnv, localIdentityFromEnv, } from "./auth.js";
+import { configFromEnv } from "./config/from-env.js";
+import { handlers, publicHandlers } from "./handlers/index.js";
+import { createApiEventHandler } from "./lambda.js";
+import { serveApi } from "./serve.js";
+import { getClient } from "./service/data-client.js";
 installNodeLogger();
-export { api, handleApiEvent, OpenAPISpec } from "./api.js";
+// Boot-time refusal: the local auth-bypass overrides must never be set in a
+// deployed environment, so a leaked env var fails the process at startup
+// rather than silently opening authentication at runtime.
+assertLocalBypassNotInDeployedEnv(process.env);
+export { OpenAPISpec } from "./api.js";
+export { configFromEnv } from "./config/from-env.js";
+export { createApiEventHandler } from "./lambda.js";
+export const handleApiEvent = createApiEventHandler(serveApi({ handlers, publicHandlers }), {
+    config: configFromEnv(process.env),
+    localIdentity: localIdentityFromEnv(process.env),
+    client: getClient,
+});
 /**
  * Last-resort net for a leaked background rejection.
  *

package/dist/src/jwt-auth.d.ts

@@ -1,18 +1,15 @@
 import { type JwtVerifier } from "@remit/auth-service/verifier";
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { HandlerIdentity } from "./types.js";
 /** Test-only override for the memoized verifier. Pass null to reset. */
 export declare const _setVerifierForTest: (v: JwtVerifier | null) => void;
 /**
- * Authenticate a self-host request from a better-auth RS256 JWT.
+ * The caller of a self-host request, from a better-auth RS256 JWT.
  *
- * On a valid token the verified `sub` is injected into the event's authorizer
- * claims, exactly where the Cognito authorizer puts it, so every downstream
- * handler reads identity through the unchanged `auth.ts` path. Returns a 401
- * response (not null) when a token is present but fails verification, or when no
- * token is supplied and no local test bypass is configured. Returns null to let
- * the request proceed.
- *
- * When the edge tier (APISIX) has already verified and injected claims, this is
- * a no-op — the backend trusts pre-populated claims and re-verifies otherwise.
+ * Claims the edge tier (APISIX) already verified and injected are trusted as
+ * they stand. Otherwise a bearer token is verified here; a token that fails
+ * verification is an anonymous caller, so the operation table answers 401. With
+ * no token the local bypass, when one is configured, is the caller. Only an
+ * operation that needs a caller resolves this, so a public route never does.
  */
-export declare const authenticateSelfHostRequest: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult | null>;
+export declare const identityFromSelfHostRequest: (event: APIGatewayProxyEvent, localIdentity: HandlerIdentity) => Promise<HandlerIdentity>;

package/dist/src/jwt-auth.js

@@ -1,8 +1,6 @@
 import { createJwtVerifier, extractBearerToken, resolveVerifierConfig, } from "@remit/auth-service/verifier";
-import { readCalendarFeedToken } from "@remit/calendar-service";
 import { logger } from "@remit/logger";
-import { defaultErrorCode } from "./error.js";
-import { formatResponse } from "./response.js";
+import { getIdentityFromEvent, userFromClaims } from "./auth.js";
 let verifier = null;
 const getVerifier = () => {
     if (!verifier)
@@ -20,78 +18,28 @@ const readHeader = (headers, name) => {
     }
     return undefined;
 };
-const unauthorized = (message) => formatResponse({ code: defaultErrorCode(401), message }, 401);
-const injectClaims = (event, sub, email) => {
-    event.requestContext = {
-        ...event.requestContext,
-        authorizer: {
-            ...event.requestContext?.authorizer,
-            claims: {
-                sub,
-                email: email ?? "",
-            },
-        },
-    };
-};
-const hasLocalBypass = () => Boolean(process.env.LOCAL_ACCOUNT_CONFIG_ID);
-/**
- * The routes that run without a token.
- *
- * Microsoft redirects the browser here after consent, so the request carries no
- * Authorization header and no session to derive one from. The handler takes its
- * identity from the HMAC-signed `state` parameter and validates it there; that
- * signature is the gate, not a JWT.
- *
- * A calendar feed carries its credential in the path for the same reason: a
- * subscribed client polls a URL and has no session to present, so the token is
- * the gate and the handler compares it against a stored hash.
- *
- * Hardcoded, matching the edge exemption in packages/apisix/src/route-table.ts.
- * `@useAuth(NoAuth)` in the spec does not open a path here — a future public
- * route is added by hand.
- */
-const PUBLIC_ROUTES = [
-    {
-        method: "GET",
-        matches: (path) => path === "/accounts/oauth/microsoft/callback",
-    },
-    {
-        method: "GET",
-        matches: (path) => readCalendarFeedToken(path) !== null,
-    },
-];
-const isPublicRoute = (event) => PUBLIC_ROUTES.some((route) => route.method === event.httpMethod && route.matches(event.path));
 /**
- * Authenticate a self-host request from a better-auth RS256 JWT.
+ * The caller of a self-host request, from a better-auth RS256 JWT.
  *
- * On a valid token the verified `sub` is injected into the event's authorizer
- * claims, exactly where the Cognito authorizer puts it, so every downstream
- * handler reads identity through the unchanged `auth.ts` path. Returns a 401
- * response (not null) when a token is present but fails verification, or when no
- * token is supplied and no local test bypass is configured. Returns null to let
- * the request proceed.
- *
- * When the edge tier (APISIX) has already verified and injected claims, this is
- * a no-op — the backend trusts pre-populated claims and re-verifies otherwise.
+ * Claims the edge tier (APISIX) already verified and injected are trusted as
+ * they stand. Otherwise a bearer token is verified here; a token that fails
+ * verification is an anonymous caller, so the operation table answers 401. With
+ * no token the local bypass, when one is configured, is the caller. Only an
+ * operation that needs a caller resolves this, so a public route never does.
  */
-export const authenticateSelfHostRequest = async (event) => {
-    if (isPublicRoute(event))
-        return null;
+export const identityFromSelfHostRequest = async (event, localIdentity) => {
     const existingSub = event.requestContext?.authorizer?.claims?.sub;
-    if (typeof existingSub === "string" && existingSub.length > 0)
-        return null;
-    const token = extractBearerToken(readHeader(event.headers, "authorization"));
-    if (token) {
-        const claims = await getVerifier()(token).catch((err) => {
-            logger.warn({ err: err instanceof Error ? err.message : String(err) }, "better-auth JWT verification failed");
-            return null;
-        });
-        if (!claims)
-            return unauthorized("Invalid or expired token");
-        injectClaims(event, claims.sub, claims.email);
-        return null;
+    if (typeof existingSub === "string" && existingSub.length > 0) {
+        return getIdentityFromEvent(event, localIdentity);
     }
-    if (hasLocalBypass())
+    const token = extractBearerToken(readHeader(event.headers, "authorization"));
+    if (!token)
+        return localIdentity;
+    const claims = await getVerifier()(token).catch((err) => {
+        logger.warn({ err: err instanceof Error ? err.message : String(err) }, "better-auth JWT verification failed");
         return null;
-    return unauthorized("Authentication required");
+    });
+    if (!claims)
+        return { kind: "anonymous" };
+    return userFromClaims(claims.sub, claims.email);
 };

package/dist/src/lambda.d.ts

@@ -0,0 +1,13 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from "aws-lambda";
+import type { ApiConfig } from "./config/api-config.js";
+import type { ServedApi } from "./serve.js";
+import type { RemitClient } from "./service/data-client.js";
+import type { QueueName } from "./service/queues.js";
+import type { HandlerIdentity } from "./types.js";
+export interface ApiEventHandlerOptions<K extends QueueName> {
+    config: ApiConfig;
+    localIdentity: HandlerIdentity;
+    client: () => Promise<RemitClient<K>>;
+}
+export type ApiEventHandler = (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;
+export declare const createApiEventHandler: <K extends QueueName>(served: ServedApi<K>, { config, localIdentity, client }: ApiEventHandlerOptions<NoInfer<K>>) => ApiEventHandler;

package/dist/src/lambda.js

@@ -0,0 +1,33 @@
+import { getIdentityFromEvent } from "./auth.js";
+import { identityFromSelfHostRequest } from "./jwt-auth.js";
+import { normalizeRequest } from "./request.js";
+const queryOf = (event) => {
+    if (event.multiValueQueryStringParameters) {
+        return event.multiValueQueryStringParameters;
+    }
+    return Object.fromEntries(Object.entries(event.queryStringParameters ?? {}).map(([key, value]) => [
+        key,
+        value === undefined ? undefined : [value],
+    ]));
+};
+const headersOf = (event) => ({
+    ...event.headers,
+    ...Object.fromEntries(Object.entries(event.multiValueHeaders ?? {}).map(([name, values]) => [
+        name,
+        values?.join(", "),
+    ])),
+});
+const normalizeApiGatewayEvent = (event) => normalizeRequest({
+    method: event.httpMethod,
+    path: event.path,
+    query: queryOf(event),
+    headers: headersOf(event),
+    body: event.body,
+});
+export const createApiEventHandler = (served, { config, localIdentity, client }) => (event, context) => served.dispatch(normalizeApiGatewayEvent(event), {
+    config,
+    client,
+    identity: async () => config.auth.mode === "BetterAuthJwt"
+        ? identityFromSelfHostRequest(event, localIdentity)
+        : getIdentityFromEvent(event, localIdentity),
+}, context.awsRequestId);

package/dist/src/request.d.ts

@@ -1,3 +1,9 @@
-import type { APIGatewayProxyEvent } from "aws-lambda";
 import type { Request } from "openapi-backend";
-export declare const normalizeRequest: (event: APIGatewayProxyEvent) => Request;
+export interface HostRequest {
+    method: string;
+    path: string;
+    query: Readonly<Record<string, readonly string[] | undefined>> | null;
+    headers: Readonly<Record<string, string | undefined>> | null;
+    body: string | null;
+}
+export declare const normalizeRequest: (request: HostRequest) => Request;

package/dist/src/request.js

@@ -1,7 +1,17 @@
-export const normalizeRequest = (event) => ({
-    method: event.httpMethod,
-    path: event.path,
-    query: (event.queryStringParameters ?? {}),
-    body: event.body,
-    headers: (event.headers ?? {}),
+const definedHeaders = (map) => Object.fromEntries(Object.entries(map ?? {}).filter((entry) => entry[1] !== undefined));
+const collapsedQuery = (map) => {
+    const query = {};
+    for (const [key, values] of Object.entries(map ?? {})) {
+        if (!values || values.length === 0)
+            continue;
+        query[key] = values.length === 1 ? values[0] : [...values];
+    }
+    return query;
+};
+export const normalizeRequest = (request) => ({
+    method: request.method,
+    path: request.path,
+    query: collapsedQuery(request.query),
+    body: request.body === "" ? null : request.body,
+    headers: definedHeaders(request.headers),
 });

package/dist/src/response.d.ts

@@ -1,5 +1,6 @@
 import type { APIGatewayProxyResult } from "aws-lambda";
 import type { Context as OpenAPIContext } from "openapi-backend";
+import type { ApiConfig } from "./config/api-config.js";
 declare const RAW_API_RESPONSE: unique symbol;
 /**
  * A response the caller reads by something other than its JSON body — an
@@ -10,8 +11,8 @@ declare const RAW_API_RESPONSE: unique symbol;
  * stays the default; a handler that has to own its own media type or headers
  * says so with `rawApiResponse` rather than by returning a shape this one has
  * to guess at.
- * The CORS and correlation headers are still added here, so a raw response is
- * not a way around them.
+ * `dispatch` still adds the envelope headers, so a raw response is not a way
+ * around them.
  */
 export interface RawApiResponse {
     statusCode: number;
@@ -22,6 +23,22 @@ type MarkedRawApiResponse = RawApiResponse & {
     readonly [RAW_API_RESPONSE]: true;
 };
 export declare const rawApiResponse: (response: RawApiResponse) => MarkedRawApiResponse;
+/**
+ * The headers every response carries whatever its body is: the CORS grant the
+ * browser needs, and the id the request's log lines are already tagged with.
+ * Returning that id is what makes a bug report's "correlation id" resolve to a
+ * server-side line; the browser can only read a non-safelisted header when it
+ * is exposed.
+ */
+export interface EnvelopeInput {
+    origin: string | undefined;
+    allowedOrigins: readonly string[];
+    correlationId: string;
+}
+export declare const resolveAllowedOrigin: (origin: string | undefined, allowed: readonly string[]) => string;
+export declare const envelopeHeaders: ({ origin, allowedOrigins, correlationId, }: EnvelopeInput) => Record<string, string>;
 export declare const formatResponse: (body: Record<string, unknown>, statusCode?: number) => APIGatewayProxyResult;
-export declare const postResponseHandler: (context: OpenAPIContext) => APIGatewayProxyResult;
+export declare const postResponseHandler: (context: OpenAPIContext, scope: {
+    config: ApiConfig;
+}) => APIGatewayProxyResult;
 export {};

package/dist/src/response.js

@@ -1,17 +1,16 @@
 import { logger } from "@remit/logger";
-import { getRequestCorrelationId, getRequestOrigin, resolveAllowedOrigin, } from "./request-context.js";
 const RAW_API_RESPONSE = Symbol("remit.rawApiResponse");
 export const rawApiResponse = (response) => Object.assign(response, { [RAW_API_RESPONSE]: true });
 const isRawApiResponse = (body) => RAW_API_RESPONSE in body;
-/**
- * The headers every response carries whatever its body is: the CORS grant the
- * browser needs, and the id the request's log lines are already tagged with.
- * Returning that id is what makes a bug report's "correlation id" resolve to a
- * server-side line; the browser can only read a non-safelisted header when it
- * is exposed.
- */
-const envelopeHeaders = () => {
-    const allowOrigin = resolveAllowedOrigin(getRequestOrigin());
+export const resolveAllowedOrigin = (origin, allowed) => {
+    if (allowed.length === 0)
+        return "*";
+    if (origin && allowed.includes(origin))
+        return origin;
+    return allowed[0];
+};
+export const envelopeHeaders = ({ origin, allowedOrigins, correlationId, }) => {
+    const allowOrigin = resolveAllowedOrigin(origin, allowedOrigins);
     const headers = {
         "Access-Control-Allow-Origin": allowOrigin,
         "Access-Control-Allow-Headers": "Authorization,Content-Type",
@@ -21,11 +20,8 @@ const envelopeHeaders = () => {
     if (allowOrigin !== "*") {
         headers["Access-Control-Allow-Credentials"] = "true";
     }
-    const correlationId = getRequestCorrelationId();
-    if (correlationId) {
-        headers["x-correlation-id"] = correlationId;
-        headers["Access-Control-Expose-Headers"] = "x-correlation-id";
-    }
+    headers["x-correlation-id"] = correlationId;
+    headers["Access-Control-Expose-Headers"] = "x-correlation-id";
     return headers;
 };
 export const formatResponse = (body, statusCode = 200) => {
@@ -36,7 +32,7 @@ export const formatResponse = (body, statusCode = 200) => {
         logger.debug({ statusCode: body.statusCode }, "response");
         return {
             statusCode: body.statusCode,
-            headers: { ...envelopeHeaders(), ...body.headers },
+            headers: body.headers,
             body: body.body,
         };
     }
@@ -46,18 +42,15 @@ export const formatResponse = (body, statusCode = 200) => {
     logger.debug({ statusCode }, "response");
     return {
         statusCode: statusCode,
-        headers: {
-            "Content-Type": "application/json",
-            ...envelopeHeaders(),
-        },
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body),
     };
 };
-export const postResponseHandler = (context) => {
+export const postResponseHandler = (context, scope) => {
     const { api, response, operation } = context;
     if (response.statusCode)
         return formatResponse(response, response.statusCode);
-    if (process.env.STAGE_NAME !== "dev")
+    if (scope.config.responseValidation === "Skip")
         return formatResponse(response, 200);
     const { valid, errors } = api.validateResponse(response, operation);
     if (valid)

package/dist/src/serve.d.ts

@@ -0,0 +1,31 @@
+import type { APIGatewayProxyResult } from "aws-lambda";
+import type { Request as OpenAPIRequest } from "openapi-backend";
+import type { ApiConfig } from "./config/api-config.js";
+import type { RemitClient } from "./service/data-client.js";
+import type { QueueName } from "./service/queues.js";
+import type { HandlerIdentity, OperationHandler, OperationIds, PublicOperationHandler, PublicOperationIds } from "./types.js";
+export type { ApiConfig } from "./config/api-config.js";
+export type { HandlerContext, HandlerIdentity, PublicHandlerContext, UserIdentity, } from "./types.js";
+export interface RequestHost<K extends QueueName> {
+    config: ApiConfig;
+    client: () => Promise<RemitClient<K>>;
+    identity: () => Promise<HandlerIdentity>;
+}
+/**
+ * The operations a host serves, each typed by the queues it sends to. An
+ * operation the host leaves out answers 501.
+ */
+export interface ApiRegistry<K extends QueueName> {
+    handlers: Partial<Record<Exclude<OperationIds, PublicOperationIds>, OperationHandler<OperationIds, K>>>;
+    publicHandlers: Partial<Record<PublicOperationIds, PublicOperationHandler<K>>>;
+}
+export interface ServedApi<K extends QueueName> {
+    dispatch: (request: OpenAPIRequest, host: RequestHost<K>, correlationId: string) => Promise<APIGatewayProxyResult>;
+    handleFetch: (request: Request, host: RequestHost<K>, correlationId: string) => Promise<Response>;
+}
+/**
+ * Register a host's operations and return the two ways in: a normalised
+ * request, or a Fetch `Request`. Each request's host supplies the client, and
+ * the client's queues must cover every operation in the registry.
+ */
+export declare const serveApi: <K extends QueueName>(registry: ApiRegistry<NoInfer<K>>) => ServedApi<K>;

package/dist/src/serve.js

@@ -0,0 +1,117 @@
+import { redactCalendarFeedPath } from "@remit/calendar-service";
+import { logger, withLogContext } from "@remit/logger";
+import { api } from "./api.js";
+import { defaultErrorCode, handleError } from "./error.js";
+import { normalizeRequest } from "./request.js";
+import { envelopeHeaders } from "./response.js";
+const unauthenticated = () => ({
+    statusCode: 401,
+    body: { code: defaultErrorCode(401), message: "Unauthorized" },
+});
+const isDefined = (value) => value !== undefined;
+const entriesOf = (record) => Object.entries(record).flatMap(([key, value]) => isDefined(value) ? [[key, value]] : []);
+/**
+ * Register a host's operations and return the two ways in: a normalised
+ * request, or a Fetch `Request`. Each request's host supplies the client, and
+ * the client's queues must cover every operation in the registry.
+ */
+export const serveApi = (registry) => {
+    api.register({
+        ...Object.fromEntries(entriesOf(registry.handlers).map(([operationId, handler]) => [
+            operationId,
+            async (c, host) => {
+                const identity = await host.identity();
+                if (identity.kind === "anonymous")
+                    return unauthenticated();
+                return handler(c, {
+                    client: await host.client(),
+                    identity,
+                    config: host.config,
+                });
+            },
+        ])),
+        ...Object.fromEntries(entriesOf(registry.publicHandlers).map(([operationId, handler]) => [
+            operationId,
+            async (c, host) => handler(c, { client: await host.client(), config: host.config }),
+        ])),
+    });
+    return { dispatch, handleFetch };
+};
+const readHeader = (headers, name) => {
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (key.toLowerCase() === name && typeof value === "string")
+            return value;
+    }
+    return undefined;
+};
+const dispatch = async (request, host, correlationId) => {
+    // A calendar feed carries its credential in the path, so the raw path is a
+    // secret and cannot be a log field (issue #1065). Redacted once, here, where
+    // every line inside the request picks it up from the scope.
+    const path = redactCalendarFeedPath(request.path);
+    const { method } = request;
+    return withLogContext({ path, method }, async () => {
+        logger.debug({ method, path }, "Request received");
+        const startedAt = Date.now();
+        const answered = await api
+            .handleRequest(request, host)
+            .catch(handleError);
+        const result = {
+            ...answered,
+            headers: {
+                ...envelopeHeaders({
+                    origin: readHeader(request.headers, "origin"),
+                    allowedOrigins: host.config.corsAllowedOrigins,
+                    correlationId,
+                }),
+                ...answered.headers,
+            },
+        };
+        // One structured access line per request: method, path, status, and
+        // duration. The correlation id is inlined as a top-level field so a bug
+        // report quoting the id can grep logs by it directly, and emitted at
+        // info so it is on by default in production (the debug "Request
+        // received" above already filters out under normal log levels).
+        // biome-ignore lint/plugin/no-logger-info: one access line per request is an audit-grade signal (issue #1054)
+        logger.info({
+            method,
+            path,
+            statusCode: result.statusCode,
+            durationMs: Date.now() - startedAt,
+            correlationId,
+        }, "Request completed");
+        return result;
+    });
+};
+const queryOf = (params) => {
+    const query = {};
+    for (const [key, value] of params) {
+        query[key] = [...(query[key] ?? []), value];
+    }
+    return query;
+};
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+const toFetchResponse = (result) => {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(result.headers ?? {})) {
+        headers.set(name, String(value));
+    }
+    for (const [name, values] of Object.entries(result.multiValueHeaders ?? {})) {
+        for (const value of values)
+            headers.append(name, String(value));
+    }
+    const body = NULL_BODY_STATUSES.has(result.statusCode) ? null : result.body;
+    return new Response(body, { status: result.statusCode, headers });
+};
+const handleFetch = async (request, host, correlationId) => {
+    const url = new URL(request.url);
+    const body = request.body === null ? null : await request.text();
+    const result = await dispatch(normalizeRequest({
+        method: request.method,
+        path: url.pathname,
+        query: queryOf(url.searchParams),
+        headers: Object.fromEntries(request.headers),
+        body,
+    }), host, correlationId);
+    return toFetchResponse(result);
+};

package/dist/src/service/account-deletion.d.ts

@@ -1,10 +1,8 @@
-import { type SQSClient } from "@aws-sdk/client-sqs";
-import type { AccountItem, IAccountRepository, IConfigImportRepository } from "@remit/data-ports";
+import type { AccountDataPurgeEvent, AccountItem, IAccountRepository, IConfigImportRepository, QueueProducer } from "@remit/data-ports";
 import type { Logger } from "@remit/logger";
 export interface AccountDeletionDeps {
     account: Pick<IAccountRepository, "update">;
-    sqsClient: SQSClient;
-    accountFanoutQueueUrl: string;
+    queue: QueueProducer<AccountDataPurgeEvent>;
     log: Logger;
 }
 export declare const deleteAccount: (deps: AccountDeletionDeps, account: Pick<AccountItem, "accountId" | "accountConfigId">, deletedAt: number) => Promise<void>;

package/dist/src/service/account-deletion.js

@@ -1,16 +1,10 @@
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { readConfigDocument } from "@remit/config-format";
 export const deleteAccount = async (deps, account, deletedAt) => {
     const { accountId, accountConfigId } = account;
     // Purge first: an account whose request never left still reads as not deleted, so it is found and asked for again.
-    await deps.sqsClient.send(new SendMessageCommand({
-        QueueUrl: deps.accountFanoutQueueUrl,
-        MessageBody: JSON.stringify({
-            type: "AccountDataPurge",
-            accountId,
-            accountConfigId,
-        }),
-    }));
+    await deps.queue.send({
+        body: { type: "AccountDataPurge", accountId, accountConfigId },
+    });
     await deps.account.update(accountId, { deletedAt, isActive: false });
     deps.log.info({ accountId, accountConfigId }, "Account data purge initiated");
 };

package/dist/src/service/compose-sqlite.d.ts

@@ -1,2 +1,3 @@
-import { type RemitClient } from "./create-remit-client.js";
+import { type RemitClient, type RemitClientSharedDeps } from "./create-remit-client.js";
+export declare const composeSqliteClient: (shared: RemitClientSharedDeps) => Promise<RemitClient>;
 export declare const buildSqliteClient: () => Promise<RemitClient>;

package/dist/src/service/compose-sqlite.js

@@ -1,11 +1,13 @@
 import { createSqliteRepositories, openSqliteDatabases, sqliteDatabasePathsFromEnv, } from "@remit/drizzle-service";
-import { buildSharedDeps, createRemitClient, } from "./create-remit-client.js";
+import { createRemitClient, } from "./create-remit-client.js";
+import { buildSharedDeps, sqsQueues, sqsQueueUrlsFromEnv, } from "./shared-deps.js";
 // The SQLite adapter composition (RFC 036). Every repo runs on the database
 // that holds its tables: app, tenant mail or tenant search (#1420).
-export const buildSqliteClient = async () => {
+export const composeSqliteClient = async (shared) => {
     const databases = await openSqliteDatabases(sqliteDatabasePathsFromEnv());
     return createRemitClient({
         repositories: createSqliteRepositories(databases),
-        ...buildSharedDeps(),
+        ...shared,
     });
 };
+export const buildSqliteClient = () => composeSqliteClient(buildSharedDeps(sqsQueues(sqsQueueUrlsFromEnv())));

package/dist/src/service/create-remit-client.d.ts

@@ -2,11 +2,12 @@ import type { IAccountConfigRepository, IAccountExportRequestRepository, IAccoun
 import { BodySyncQueueService, BodySyncService, type FilterConfig, FlagQueueService, type IImapConnection, MailboxQueueService, MessageMoveService, OutboxAttachmentService, OutboxQueueService, SpamReportService } from "@remit/mailbox-service";
 import { type SecretsService } from "@remit/secrets-service";
 import type { StorageService } from "@remit/storage-service";
+import type { QueueName, RemitClientQueues } from "./queues.js";
 export interface ConnectionScope {
     getConnection: () => Promise<IImapConnection>;
     disconnect: () => Promise<void>;
 }
-export interface RemitClient {
+export interface RemitClientCore {
     accountConfig: IAccountConfigRepository;
     account: IAccountRepository;
     accountSetting: IAccountSettingRepository;
@@ -36,18 +37,29 @@ export interface RemitClient {
     calendarStore: ICalendarStore;
     storage: StorageService;
     secrets: SecretsService;
-    bodySync: BodySyncService;
-    bodySyncQueue?: BodySyncQueueService;
     placementMove: IMessagePlacementMoveRepository;
     flagPush: IMessageFlagPushRepository;
+    outboxAttachment: OutboxAttachmentService;
+    createConnectionScope: (accountId: string) => Promise<ConnectionScope>;
+}
+export interface SyncQueueServices {
     flagQueue: FlagQueueService;
     mailboxQueue: MailboxQueueService;
     messageMove: MessageMoveService;
-    outboxAttachment: OutboxAttachmentService;
-    outboxQueue: OutboxQueueService;
     spamReport: SpamReportService;
-    createConnectionScope: (accountId: string) => Promise<ConnectionScope>;
 }
+export interface SmtpQueueServices {
+    outboxQueue: OutboxQueueService;
+}
+export interface BodyQueueServices {
+    bodySyncQueue: BodySyncQueueService;
+}
+export interface ReadPathServices {
+    bodySync: BodySyncService;
+}
+export type RemitClient<K extends QueueName = QueueName> = RemitClientCore & {
+    queues: Pick<RemitClientQueues, K>;
+} & ("sync" extends K ? SyncQueueServices : unknown) & ("smtp" extends K ? SmtpQueueServices : unknown) & ("body" extends K ? BodyQueueServices : unknown) & ("sync" | "messageManagement" extends K ? ReadPathServices : unknown);
 export interface RemitClientRepositories {
     accountConfig: IAccountConfigRepository;
     account: IAccountRepository;
@@ -83,13 +95,15 @@ export interface RemitClientRepositories {
 export interface RemitClientSharedDeps {
     storage: StorageService;
     secrets: SecretsService;
-    sqsQueueUrl: string;
-    sqsSmtpQueueUrl: string;
-    bodySyncQueue?: BodySyncQueueService;
+    queues: RemitClientQueues;
 }
 export interface RemitClientDeps extends RemitClientSharedDeps {
     repositories: RemitClientRepositories;
 }
-export declare const buildSharedDeps: () => RemitClientSharedDeps;
-export declare const buildReadPathFilterConfig: (repositories: RemitClientRepositories) => FilterConfig | undefined;
+export declare const buildReadPathFilterConfig: (repositories: Pick<RemitClientRepositories, "filter" | "messageLabel" | "mailbox" | "message" | "threadMessage" | "placementMove" | "address" | "mailboxSpecialUse">, queues: Pick<RemitClientQueues, "messageManagement">) => FilterConfig;
+export declare const createRemitCore: (deps: Omit<RemitClientDeps, "queues">) => RemitClientCore;
+export declare const composeSyncServices: (core: RemitClientCore, queues: Pick<RemitClientQueues, "sync">) => SyncQueueServices;
+export declare const composeSmtpServices: (core: RemitClientCore, queues: Pick<RemitClientQueues, "smtp">) => SmtpQueueServices;
+export declare const composeBodyServices: (queues: Pick<RemitClientQueues, "body">) => BodyQueueServices;
+export declare const composeReadPathServices: (core: RemitClientCore, queues: Pick<RemitClientQueues, "messageManagement">, sync: Pick<SyncQueueServices, "flagQueue">) => ReadPathServices;
 export declare const createRemitClient: (deps: RemitClientDeps) => RemitClient;