@remit/backend 0.0.142 → 0.0.144

package/src/response.ts

@@ -1,144 +0,0 @@
-import { logger } from "@remit/logger-lambda";
-import type { APIGatewayProxyResult } from "aws-lambda";
-import type { Context as OpenAPIContext } from "openapi-backend";
-import {
-	getRequestCorrelationId,
-	getRequestOrigin,
-	resolveAllowedOrigin,
-} from "./request-context.js";
-
-const RAW_API_RESPONSE: unique symbol = Symbol("remit.rawApiResponse");
-
-/**
- * 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.
- * The CORS and correlation headers are still added here, 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 const rawApiResponse = (
-	response: RawApiResponse,
-): MarkedRawApiResponse =>
-	Object.assign(response, { [RAW_API_RESPONSE]: true as const });
-
-const isRawApiResponse = (
-	body: Record<string, unknown>,
-): body is MarkedRawApiResponse & Record<string, unknown> =>
-	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 = (): Record<string, string> => {
-	const allowOrigin = resolveAllowedOrigin(getRequestOrigin());
-
-	const headers: Record<string, string> = {
-		"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";
-	}
-
-	const correlationId = getRequestCorrelationId();
-	if (correlationId) {
-		headers["x-correlation-id"] = correlationId;
-		headers["Access-Control-Expose-Headers"] = "x-correlation-id";
-	}
-
-	return headers;
-};
-
-export const formatResponse = (
-	body: Record<string, unknown>,
-	statusCode = 200,
-): APIGatewayProxyResult => {
-	if (body.statusCode && typeof body.statusCode === "number") {
-		statusCode = body.statusCode;
-	}
-
-	if (isRawApiResponse(body)) {
-		logger.debug({ statusCode: body.statusCode }, "response");
-		return {
-			statusCode: body.statusCode,
-			headers: { ...envelopeHeaders(), ...body.headers },
-			body: body.body,
-		};
-	}
-
-	if ("body" in body && body.body && typeof body.body === "object") {
-		body = body.body as Record<string, unknown>;
-	}
-
-	logger.debug({ statusCode }, "response");
-
-	return {
-		statusCode: statusCode,
-		headers: {
-			"Content-Type": "application/json",
-			...envelopeHeaders(),
-		},
-		body: JSON.stringify(body),
-	};
-};
-
-export const postResponseHandler = (context: OpenAPIContext) => {
-	const { api, response, operation } = context;
-
-	if (response.statusCode) return formatResponse(response, response.statusCode);
-
-	if (process.env.STAGE_NAME !== "dev") return formatResponse(response, 200);
-
-	const { valid, errors } = api.validateResponse(response, operation);
-
-	if (valid) return formatResponse(response, 200);
-
-	const { operationId } = operation;
-
-	const errorDetails: Record<string, unknown> = {
-		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/src/service/compose-sqlite.ts

@@ -1,98 +0,0 @@
-import {
-	AccountConfigRepo,
-	AccountExportRequestRepo,
-	AccountRepo,
-	AccountSettingRepo,
-	AddressRepo,
-	CalendarCollectionRepo,
-	CalendarEventIndexRepo,
-	CalendarFeedTokenRepo,
-	CalendarObjectRepo,
-	CalendarSuggestionRepo,
-	ConfigImportRepo,
-	createSqliteDatabase,
-	DrizzleCalendarUnitOfWork,
-	DrizzleEnvelopeRepository,
-	DrizzleFilterAnchorTransaction,
-	DrizzleMessageFlagRepository,
-	DrizzleMessageRepository,
-	DrizzleThreadMessageRepository,
-	DrizzleUnitOfWork,
-	FilterAnchorRepo,
-	FilterRepo,
-	LabelRepo,
-	MailboxLockRepo,
-	MailboxRepo,
-	MailboxSpecialUseRepo,
-	MessageFlagPushRepo,
-	MessageLabelRepo,
-	MessagePlacementMoveRepo,
-	messageDataSchema,
-	OrganizeJobRequestRepo,
-	OutboxAttachmentRepo,
-	OutboxMessageRepo,
-	QuarantineRepo,
-	runInTransaction,
-	SenderSignerStandingRepo,
-} from "@remit/drizzle-service";
-import { env } from "expect-env";
-import {
-	buildSharedDeps,
-	createRemitClient,
-	type RemitClient,
-	type RemitClientRepositories,
-} from "./create-remit-client.js";
-
-// The SQLite adapter composition (RFC 036). Every repo runs on the single
-// serialized connection `createSqliteDatabase` opens (D3), so a plain repo
-// write cannot bypass serialization and join an open transaction's savepoint,
-// and `threadMessage` takes that same shared handle, so its writes enlist in
-// the same unit-of-work transaction and the same write queue as everything
-// else.
-export const buildSqliteClient = async (): Promise<RemitClient> => {
-	const sqliteDbPath = env.SQLITE_DB_PATH;
-
-	const { db } = await createSqliteDatabase(messageDataSchema, {
-		filename: sqliteDbPath,
-	});
-	const genericDb = db;
-	const messageDataDb = db;
-
-	const repositories: RemitClientRepositories = {
-		accountConfig: new AccountConfigRepo(genericDb),
-		account: new AccountRepo(genericDb),
-		accountSetting: new AccountSettingRepo(genericDb),
-		address: new AddressRepo(genericDb),
-		mailbox: new MailboxRepo(genericDb),
-		mailboxSpecialUse: new MailboxSpecialUseRepo(genericDb),
-		mailboxLock: new MailboxLockRepo(genericDb),
-		message: new DrizzleMessageRepository(messageDataDb),
-		messageFlag: new DrizzleMessageFlagRepository(messageDataDb),
-		outboxMessage: new OutboxMessageRepo(genericDb),
-		outboxAttachment: new OutboxAttachmentRepo(genericDb),
-		threadMessage: new DrizzleThreadMessageRepository(genericDb),
-		envelope: new DrizzleEnvelopeRepository(messageDataDb),
-		accountExportRequest: new AccountExportRequestRepo(genericDb),
-		configImport: new ConfigImportRepo(genericDb),
-		quarantine: new QuarantineRepo(genericDb),
-		organizeJobRequest: new OrganizeJobRequestRepo(genericDb),
-		placementMove: new MessagePlacementMoveRepo(genericDb),
-		flagPush: new MessageFlagPushRepo(genericDb),
-		filter: new FilterRepo(genericDb),
-		filterAnchor: new FilterAnchorRepo(genericDb),
-		filterAnchorTransaction: new DrizzleFilterAnchorTransaction(genericDb),
-		label: new LabelRepo(genericDb),
-		messageLabel: new MessageLabelRepo(genericDb),
-		senderSignerStanding: new SenderSignerStandingRepo(genericDb),
-		calendarCollection: new CalendarCollectionRepo(genericDb),
-		calendarObject: new CalendarObjectRepo(genericDb),
-		calendarEventIndex: new CalendarEventIndexRepo(genericDb),
-		calendarFeedToken: new CalendarFeedTokenRepo(genericDb),
-		calendarSuggestion: new CalendarSuggestionRepo(genericDb),
-		calendarUnitOfWork: new DrizzleCalendarUnitOfWork(genericDb),
-		unitOfWork: new DrizzleUnitOfWork(messageDataDb),
-		writeSet: (run) => runInTransaction(genericDb, () => run()),
-	};
-
-	return createRemitClient({ repositories, ...buildSharedDeps() });
-};

package/src/service/config-import.ts

@@ -1,39 +0,0 @@
-import type { EmbedAnchor } from "@remit/config-transfer";
-import { logger } from "@remit/logger-lambda";
-import { buildEmbeddingServiceFromEnv } from "@remit/search-service/from-env";
-import { isSemanticCapabilityAbsence } from "./semantic-capability.js";
-
-type Embedder = {
-	embed: (texts: string[]) => Promise<number[][]>;
-	readonly embeddingId: string;
-};
-
-let cached: Embedder | null = null;
-
-/**
- * Re-embed a filter's anchor from the source text its file carries. The vector
- * never travels — it is a function of the model that produced it — so this is
- * the one thing an import computes rather than copies.
- *
- * A deployment that ships no vector pipeline answers `undefined` rather than
- * failing the import: the anchor then lands stamped as un-embedded, and the
- * same lazy repair that handles a model migration builds its vector the first
- * time the filter is matched. A configuration file has to be importable on the
- * instance a person is recovering onto, whatever that instance can run.
- */
-export const embedAnchorText: EmbedAnchor = async (sourceText) => {
-	try {
-		if (!cached) cached = buildEmbeddingServiceFromEnv();
-		const [embedding] = await cached.embed([sourceText]);
-		return embedding
-			? { embedding, embeddingId: cached.embeddingId }
-			: undefined;
-	} catch (error) {
-		if (!isSemanticCapabilityAbsence(error)) throw error;
-		logger.warn(
-			{ error: error instanceof Error ? error.message : String(error) },
-			"No embedding pipeline in this deployment; an imported filter anchor is stored as text and embedded on first use",
-		);
-		return undefined;
-	}
-};