@remit/backend 0.0.143 → 0.0.145

package/dist/src/handlers/vip-suggestions.js

@@ -0,0 +1,16 @@
+/**
+ * Map an Address row to the wire-format `VipSuggestionEntry` returned by
+ * `GET /me/vip-suggestions` (issue #234). Absent counters are normalised to
+ * zero so the UI can render `12 received · 4 sent · 2 replies` without a
+ * `?? 0` fallback at every render site.
+ */
+export const toVipSuggestionEntry = (item) => ({
+    addressId: item.addressId,
+    displayName: item.displayName,
+    normalizedEmail: item.normalizedEmail,
+    inboundCount: item.inboundCount ?? 0,
+    outboundCount: item.outboundCount ?? 0,
+    replyCount: item.replyCount ?? 0,
+    lastInboundAt: item.lastInboundAt,
+    lastReplyAt: item.lastReplyAt,
+});

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export { OpenAPISpec } from "./api.js";
+export { configFromEnv } from "./config/from-env.js";
+export { createApiEventHandler } from "./lambda.js";
+export declare const handleApiEvent: import("./lambda.js").ApiEventHandler;
+export declare const handler: (event: import("aws-lambda").APIGatewayProxyEvent, context: import("aws-lambda").Context) => Promise<import("aws-lambda").APIGatewayProxyResult>;

package/dist/src/index.js

@@ -0,0 +1,53 @@
+import { inspect } from "node:util";
+import { logger } from "@remit/logger";
+import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
+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();
+// 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.
+ *
+ * Every fire-and-forget side effect is meant to be contained at its source (see
+ * service/fire-and-forget.ts), so reaching here is a bug — an uncontained
+ * `void promise` somewhere. The API process (dev-server / warm Lambda container)
+ * shares one event loop across requests, so without this handler such a leak
+ * would surface as a spurious 500 on whatever request was in flight. We log it
+ * LOUDLY with a distinct alert so it is observable, and deliberately do NOT exit
+ * — a stray background rejection must never take the API down or fail a request.
+ * (The worker process intentionally has no such net: there each message is its
+ * own invocation and a rejection should crash it.)
+ */
+const unhandledRejectionRegistered = Symbol.for("remit.backend.unhandledRejectionNet");
+const globalProcess = process;
+if (!globalProcess[unhandledRejectionRegistered]) {
+    globalProcess[unhandledRejectionRegistered] = true;
+    process.on("unhandledRejection", (reason) => {
+        logger.error({
+            alert: "unhandled_rejection",
+            errorName: reason?.name,
+            errorCode: reason?.Code ??
+                reason?.code,
+            error: inspect(reason),
+        }, "Unhandled promise rejection leaked into the API event loop (contained, request not failed)");
+    });
+}
+// The Lambda and Node entry point. `withTelemetry` installs the Node logger and
+// its process metrics; a host without Node's process APIs imports
+// `@remit/backend/api` instead and plugs in its own logger with `setLogger`.
+export const handler = withTelemetry(handleApiEvent);

package/{src/json.ts → dist/src/json.d.ts}

@@ -5,7 +5,4 @@
  * absence (e.g. a third-party token, a dev-server response body) — never to
  * soften an internal contract, which must stay a fatal uncaught `JSON.parse`.
  */
-export const safeJsonParse = <T>(raw: string): Promise<T> =>
-	new Promise((resolve) => {
-		resolve(JSON.parse(raw));
-	});
+export declare const safeJsonParse: <T>(raw: string) => Promise<T>;

package/dist/src/json.js

@@ -0,0 +1,10 @@
+/**
+ * Parse JSON in a Promise so a malformed string surfaces as a rejection the
+ * caller can `.catch()`, instead of a synchronous throw that would need a block
+ * try/catch. Use only where an unparseable value is an expected, recoverable
+ * absence (e.g. a third-party token, a dev-server response body) — never to
+ * soften an internal contract, which must stay a fatal uncaught `JSON.parse`.
+ */
+export const safeJsonParse = (raw) => new Promise((resolve) => {
+    resolve(JSON.parse(raw));
+});

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

@@ -0,0 +1,15 @@
+import { type JwtVerifier } from "@remit/auth-service/verifier";
+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;
+/**
+ * The caller of a self-host request, from a better-auth RS256 JWT.
+ *
+ * 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 identityFromSelfHostRequest: (event: APIGatewayProxyEvent, localIdentity: HandlerIdentity) => Promise<HandlerIdentity>;

package/dist/src/jwt-auth.js

@@ -0,0 +1,45 @@
+import { createJwtVerifier, extractBearerToken, resolveVerifierConfig, } from "@remit/auth-service/verifier";
+import { logger } from "@remit/logger";
+import { getIdentityFromEvent, userFromClaims } from "./auth.js";
+let verifier = null;
+const getVerifier = () => {
+    if (!verifier)
+        verifier = createJwtVerifier(resolveVerifierConfig());
+    return verifier;
+};
+/** Test-only override for the memoized verifier. Pass null to reset. */
+export const _setVerifierForTest = (v) => {
+    verifier = v;
+};
+const readHeader = (headers, name) => {
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (key.toLowerCase() === name && typeof value === "string")
+            return value;
+    }
+    return undefined;
+};
+/**
+ * The caller of a self-host request, from a better-auth RS256 JWT.
+ *
+ * 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 identityFromSelfHostRequest = async (event, localIdentity) => {
+    const existingSub = event.requestContext?.authorizer?.claims?.sub;
+    if (typeof existingSub === "string" && existingSub.length > 0) {
+        return getIdentityFromEvent(event, localIdentity);
+    }
+    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;
+    });
+    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

@@ -0,0 +1,9 @@
+import type { Request } from "openapi-backend";
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,44 @@
+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
+ * iCalendar feed, an OAuth redirect's Location, and whatever later joins them.
+ *
+ * Every other handler returns a plain object and lets this module decide the
+ * status, the content type and the serialization. That is the right default and
+ * 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.
+ * `dispatch` still adds the envelope headers, so a raw response is not a way
+ * around them.
+ */
+export interface RawApiResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+}
+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, scope: {
+    config: ApiConfig;
+}) => APIGatewayProxyResult;
+export {};

package/dist/src/response.js

@@ -0,0 +1,80 @@
+import { logger } from "@remit/logger";
+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;
+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",
+        "Access-Control-Allow-Methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+        Vary: "Origin",
+    };
+    if (allowOrigin !== "*") {
+        headers["Access-Control-Allow-Credentials"] = "true";
+    }
+    headers["x-correlation-id"] = correlationId;
+    headers["Access-Control-Expose-Headers"] = "x-correlation-id";
+    return headers;
+};
+export const formatResponse = (body, statusCode = 200) => {
+    if (body.statusCode && typeof body.statusCode === "number") {
+        statusCode = body.statusCode;
+    }
+    if (isRawApiResponse(body)) {
+        logger.debug({ statusCode: body.statusCode }, "response");
+        return {
+            statusCode: body.statusCode,
+            headers: body.headers,
+            body: body.body,
+        };
+    }
+    if ("body" in body && body.body && typeof body.body === "object") {
+        body = body.body;
+    }
+    logger.debug({ statusCode }, "response");
+    return {
+        statusCode: statusCode,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    };
+};
+export const postResponseHandler = (context, scope) => {
+    const { api, response, operation } = context;
+    if (response.statusCode)
+        return formatResponse(response, response.statusCode);
+    if (scope.config.responseValidation === "Skip")
+        return formatResponse(response, 200);
+    const { valid, errors } = api.validateResponse(response, operation);
+    if (valid)
+        return formatResponse(response, 200);
+    const { operationId } = operation;
+    const errorDetails = {
+        errors,
+        operationId,
+        responseKeys: Object.keys(response),
+    };
+    errors?.forEach((error) => {
+        if (error.instancePath) {
+            const pathParts = error.instancePath.split("/").filter(Boolean);
+            let value = response;
+            for (const part of pathParts) {
+                value = value?.[part];
+            }
+            errorDetails[`problematicValue_${error.instancePath}`] = {
+                path: error.instancePath,
+                value: JSON.stringify(value).substring(0, 500),
+                error: error.message,
+            };
+        }
+    });
+    logger.error(errorDetails, "Response validation failed");
+    return formatResponse(response, 200);
+};

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

@@ -0,0 +1,20 @@
+import type { AccountDataPurgeEvent, AccountItem, IAccountRepository, IConfigImportRepository, QueueProducer } from "@remit/data-ports";
+import type { Logger } from "@remit/logger";
+export interface AccountDeletionDeps {
+    account: Pick<IAccountRepository, "update">;
+    queue: QueueProducer<AccountDataPurgeEvent>;
+    log: Logger;
+}
+export declare const deleteAccount: (deps: AccountDeletionDeps, account: Pick<AccountItem, "accountId" | "accountConfigId">, deletedAt: number) => Promise<void>;
+export interface HalfDeletedAccountDeps extends AccountDeletionDeps {
+    account: Pick<IAccountRepository, "update" | "listAll">;
+    configImport: Pick<IConfigImportRepository, "listByAccountConfig">;
+}
+/**
+ * Before #1384 a delete stored `isActive=false` and dropped `deletedAt`. Of the
+ * writers in this repo only that delete and a config import leave an account
+ * inactive, and an import names each account it creates in its stored
+ * document. The public update endpoint accepts `isActive` as sent, so a caller
+ * outside the repo can also leave one inactive.
+ */
+export declare const finishHalfDeletedAccounts: (deps: HalfDeletedAccountDeps) => Promise<void>;

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

@@ -0,0 +1,33 @@
+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.queue.send({
+        body: { type: "AccountDataPurge", accountId, accountConfigId },
+    });
+    await deps.account.update(accountId, { deletedAt, isActive: false });
+    deps.log.info({ accountId, accountConfigId }, "Account data purge initiated");
+};
+/**
+ * Before #1384 a delete stored `isActive=false` and dropped `deletedAt`. Of the
+ * writers in this repo only that delete and a config import leave an account
+ * inactive, and an import names each account it creates in its stored
+ * document. The public update endpoint accepts `isActive` as sent, so a caller
+ * outside the repo can also leave one inactive.
+ */
+export const finishHalfDeletedAccounts = async (deps) => {
+    const imported = new Map();
+    for (const account of await deps.account.listAll()) {
+        if (account.isActive || account.deletedAt !== undefined)
+            continue;
+        let names = imported.get(account.accountConfigId);
+        if (!names) {
+            const imports = await deps.configImport.listByAccountConfig(account.accountConfigId);
+            names = new Set(imports.flatMap((row) => readConfigDocument(row.document).accounts.map((a) => a.accountId)));
+            imported.set(account.accountConfigId, names);
+        }
+        if (names.has(account.accountId))
+            continue;
+        await deleteAccount(deps, account, Date.now());
+    }
+};

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,13 @@
+import { createSqliteRepositories, openSqliteDatabases, sqliteDatabasePathsFromEnv, } from "@remit/drizzle-service";
+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 composeSqliteClient = async (shared) => {
+    const databases = await openSqliteDatabases(sqliteDatabasePathsFromEnv());
+    return createRemitClient({
+        repositories: createSqliteRepositories(databases),
+        ...shared,
+    });
+};
+export const buildSqliteClient = () => composeSqliteClient(buildSharedDeps(sqsQueues(sqsQueueUrlsFromEnv())));