@openlup/platform 0.28.0 → 0.30.0

package/src/marketing/seo/metadata.ts

@@ -0,0 +1,62 @@
+import { jsonLdGraph, type JsonLdNode } from "./jsonLd.js";
+import { serializeJsonLd } from "./serializeJsonLd.js";
+import { canonicalUrlForRoute, hreflangLinksForRoute, type SiteRoute } from "./urls.js";
+
+export type HeadTag =
+  | { kind: "meta"; name: string; content: string }
+  | { kind: "meta"; property: string; content: string }
+  | { kind: "link"; rel: "canonical" | "alternate"; href: string; hrefLang?: string };
+
+export interface HeadFacts {
+  origin: string;
+  route: SiteRoute;
+  routes: readonly SiteRoute[];
+  xDefaultLocale: string;
+  htmlLang: string;
+  title: string;
+  description: string;
+  siteName: string;
+  ogImage: string;
+  ogImageWidth: number;
+  ogImageHeight: number;
+  ogLocale: string;
+  alternateOgLocale?: string;
+  twitterImage: string;
+  twitterHandle: string;
+  noindex?: boolean;
+  jsonLd?: JsonLdNode | JsonLdNode[];
+}
+
+export function buildHeadDescriptor(facts: HeadFacts): { htmlLang: string; title: string; tags: HeadTag[]; jsonLd: string | null } {
+  const canonicalUrl = canonicalUrlForRoute(facts.origin, facts.route);
+  const nodes = facts.jsonLd ? (Array.isArray(facts.jsonLd) ? facts.jsonLd : [facts.jsonLd]) : [];
+  const tags: HeadTag[] = [
+    { kind: "meta", name: "description", content: facts.description },
+    { kind: "link", rel: "canonical", href: canonicalUrl },
+    ...(facts.noindex ? [{ kind: "meta" as const, name: "robots", content: "noindex, nofollow" }] : []),
+    { kind: "meta", property: "og:title", content: facts.title },
+    { kind: "meta", property: "og:description", content: facts.description },
+    { kind: "meta", property: "og:image", content: facts.ogImage },
+    { kind: "meta", property: "og:image:width", content: String(facts.ogImageWidth) },
+    { kind: "meta", property: "og:image:height", content: String(facts.ogImageHeight) },
+    { kind: "meta", property: "og:type", content: "website" },
+    { kind: "meta", property: "og:site_name", content: facts.siteName },
+    { kind: "meta", property: "og:url", content: canonicalUrl },
+    { kind: "meta", property: "og:locale", content: facts.ogLocale },
+    ...(facts.alternateOgLocale ? [{ kind: "meta" as const, property: "og:locale:alternate", content: facts.alternateOgLocale }] : []),
+    { kind: "meta", name: "twitter:card", content: "summary_large_image" },
+    { kind: "meta", name: "twitter:site", content: facts.twitterHandle },
+    { kind: "meta", name: "twitter:title", content: facts.title },
+    { kind: "meta", name: "twitter:description", content: facts.description },
+    { kind: "meta", name: "twitter:image", content: facts.twitterImage },
+    ...hreflangLinksForRoute(facts.origin, facts.route, facts.routes, facts.xDefaultLocale).map((link) => ({
+      kind: "link" as const, rel: "alternate" as const, hrefLang: link.hrefLang, href: link.href,
+    })),
+  ];
+  return {
+    htmlLang: facts.htmlLang,
+    title: facts.title,
+    tags,
+    jsonLd: nodes.length > 0 ? serializeJsonLd(jsonLdGraph(...nodes)) : null,
+  };
+}

package/src/marketing/seo/serializeJsonLd.ts

@@ -0,0 +1,6 @@
+export function serializeJsonLd(value: object): string {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003c")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}

package/src/marketing/seo/urls.ts

@@ -0,0 +1,34 @@
+export interface SiteRoute {
+  id: string;
+  locale: string;
+  canonicalPath: string;
+  alternateRouteId?: string;
+}
+
+export interface HreflangLink { hrefLang: string; href: string }
+
+export function normalizeSitePath(pathname: string): string {
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return path.length > 1 ? path.replace(/\/$/, "") : path;
+}
+
+export function absoluteSiteUrl(origin: string, pathname: string): string {
+  const site = origin.replace(/\/$/, "");
+  const path = normalizeSitePath(pathname);
+  return path === "/" ? `${site}/` : `${site}${path}`;
+}
+
+export function canonicalUrlForRoute(origin: string, route: SiteRoute): string {
+  return absoluteSiteUrl(origin, route.canonicalPath);
+}
+
+export function hreflangLinksForRoute(origin: string, route: SiteRoute, routes: readonly SiteRoute[], xDefaultLocale: string): HreflangLink[] {
+  const alternate = route.alternateRouteId ? routes.find((candidate) => candidate.id === route.alternateRouteId) : undefined;
+  if (!alternate) return [];
+  const pair = [route, alternate].sort((a, b) => a.locale.localeCompare(b.locale));
+  const preferred = pair.find((candidate) => candidate.locale === xDefaultLocale);
+  return [
+    ...pair.map((candidate) => ({ hrefLang: candidate.locale, href: canonicalUrlForRoute(origin, candidate) })),
+    { hrefLang: "x-default", href: canonicalUrlForRoute(origin, preferred ?? pair[0]) },
+  ];
+}

package/src/marketing/server/acquisitionCaseDirect.ts

@@ -0,0 +1,67 @@
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { BffResponder } from "../../bff/index.js";
+import type { AcquisitionCaseDirectDeps, AcquisitionCaseBindingResolver } from "./directPorts.js";
+import { ACQUISITION_CASE_VIEW, acquisitionCaseActiveCountResponseSchema, acquisitionCaseListRequestSchema, acquisitionCaseListResponseSchema } from "../acquisitionCaseSchemas.js";
+import type { AcquisitionCaseFailureKind } from "../contracts/index.js";
+
+export function createAcquisitionCaseListDirectHandler(options: AcquisitionCaseDirectDeps) {
+  const { respond, authorize, resolveBinding, isDirect } = options;
+  const { sendBffSuccess, sendMethodNotAllowed } = respond;
+  return async (req: HttpRequest, res: HttpResponse): Promise<void> => {
+    if (!isDirect() || first(req.query.view) !== ACQUISITION_CASE_VIEW) return unavailable(res, respond);
+    if (req.method !== "GET") return sendMethodNotAllowed(res, ["GET"]);
+    const actorRef = await authorize(req, res);
+    if (!actorRef) return;
+    const request = acquisitionCaseListRequestSchema.safeParse({
+      view: first(req.query.view), cursor: first(req.query.cursor), limit: integer(first(req.query.limit), 25),
+    });
+    if (!request.success) return badRequest(res, respond, request.error.flatten());
+    const binding = await bindingOrError(res, respond, resolveBinding);
+    if (!binding) return;
+    const result = await operationOrError(res, respond, () => binding.handlers.list(actorRef, request.data));
+    if (!result) return;
+    if (result.ok === false) return failure(res, respond, result.error.kind);
+    const response = acquisitionCaseListResponseSchema.safeParse(result.value);
+    if (!response.success) return invalidResponse(res, respond);
+    sendBffSuccess(res, response.data);
+  };
+}
+
+export function createAcquisitionCaseActiveCountDirectHandler(options: AcquisitionCaseDirectDeps) {
+  const { respond, resolveBinding, isDirect } = options;
+  const { sendBffSuccess, sendMethodNotAllowed } = respond;
+  return async (req: HttpRequest, res: HttpResponse): Promise<void> => {
+    if (!isDirect()) return unavailable(res, respond);
+    if (req.method !== "GET") return sendMethodNotAllowed(res, ["GET"]);
+    const binding = await bindingOrError(res, respond, resolveBinding);
+    if (!binding) return;
+    const result = await operationOrError(res, respond, () => binding.handlers.activeCount());
+    if (!result) return;
+    if (result.ok === false) return failure(res, respond, result.error.kind);
+    const response = acquisitionCaseActiveCountResponseSchema.safeParse(result.value);
+    if (!response.success) return invalidResponse(res, respond);
+    sendBffSuccess(res, response.data);
+  };
+}
+
+async function bindingOrError(res: HttpResponse, respond: BffResponder, resolve: AcquisitionCaseBindingResolver) {
+  try { const binding = await resolve(); if (binding) return binding; } catch { /* fail closed below */ }
+  respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition case service unavailable");
+  return null;
+}
+async function operationOrError<T>(res: HttpResponse, respond: BffResponder, operation: () => Promise<T>): Promise<T | null> {
+  try { return await operation(); } catch { respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition case service unavailable"); return null; }
+}
+function first(value: string | string[] | undefined): string | undefined { return Array.isArray(value) ? value[0] : value; }
+function integer(value: string | undefined, fallback: number): number { return value === undefined ? fallback : Number(value); }
+function badRequest(res: HttpResponse, respond: BffResponder, details?: unknown): void { respond.sendBffError(res, "BAD_REQUEST", "Invalid acquisition case request", { details }); }
+function unavailable(res: HttpResponse, respond: BffResponder): void { respond.sendBffError(res, "NOT_FOUND", "Acquisition case unavailable"); }
+function invalidResponse(res: HttpResponse, respond: BffResponder): void { respond.sendBffError(res, "INVALID_RESPONSE", "Acquisition case returned invalid response"); }
+function failure(res: HttpResponse, respond: BffResponder, kind: AcquisitionCaseFailureKind): void {
+  if (kind === "invalid") return badRequest(res, respond);
+  if (kind === "conflict") return respond.sendBffError(res, "CONFLICT", "Acquisition case request conflicts with prior state");
+  if (kind === "rate_limited") return respond.sendBffError(res, "RATE_LIMITED", "Acquisition submission rate limited");
+  if (kind === "not_found") return unavailable(res, respond);
+  respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition case service unavailable");
+}
+

package/src/marketing/server/acquisitionCaseHandlers.ts

@@ -0,0 +1,57 @@
+import { ACQUISITION_CASE_CONTRACT_VERSION, ACQUISITION_CASE_SOURCE } from "../acquisitionCaseSchemas.js";
+import type { AcquisitionCaseListRequest } from "../contracts/index.js";
+import { type AcquisitionCaseSubmitRequest, type AcquisitionCaseTransitionRequest } from "./acquisitionCasePorts.js";
+import type { AcquisitionCasePort } from "./acquisitionCasePorts.js";
+
+const SCOPE = "public_tester_application" as const;
+
+export interface AcquisitionCaseHandlerOptions {
+  now?: () => string;
+}
+
+export function createAcquisitionCaseHandlers(
+  port: AcquisitionCasePort,
+  options: AcquisitionCaseHandlerOptions = {},
+) {
+  const now = options.now ?? (() => new Date().toISOString());
+  return {
+    submit(request: AcquisitionCaseSubmitRequest, context: {
+      idempotencyKey: string;
+      requesterKey: string;
+    }) {
+      return port.submit({
+        scope: SCOPE,
+        sourceKind: ACQUISITION_CASE_SOURCE,
+        idempotencyKey: context.idempotencyKey,
+        requesterKey: `${SCOPE}:${context.requesterKey}`,
+        acceptedAt: now(),
+        sourcePath: "/tester-application",
+        request,
+      });
+    },
+    list(actorRef: string, request: AcquisitionCaseListRequest) {
+      return port.list({
+        actorRef,
+        scope: SCOPE,
+        ...(request.cursor ? { cursor: request.cursor } : {}),
+        limit: request.limit,
+      });
+    },
+    get(actorRef: string, caseRef: string) {
+      return port.get({ actorRef, scope: SCOPE, caseRef });
+    },
+    transition(actorRef: string, idempotencyKey: string, request: AcquisitionCaseTransitionRequest) {
+      return port.transition({ actorRef, scope: SCOPE, idempotencyKey, request });
+    },
+    async activeCount() {
+      const result = await port.activeCount(SCOPE);
+      return result.ok === false ? result : {
+        ok: true as const,
+        value: { activeTesterCount: result.value },
+      };
+    },
+    contractVersion: ACQUISITION_CASE_CONTRACT_VERSION,
+  };
+}
+
+export type AcquisitionCaseHandlers = ReturnType<typeof createAcquisitionCaseHandlers>;

package/src/marketing/server/acquisitionCasePorts.ts

@@ -0,0 +1,42 @@
+import type { AcquisitionCaseProjection, AcquisitionCaseResult, AcquisitionCasePort as PortableAcquisitionCasePort } from "../contracts/index.js";
+import type { AcquisitionAddressReference, AcquisitionCaseProjection as Projection } from "../contracts/index.js";
+
+/** Historical commands retained by the server adapter; public admission routes remain host-owned. */
+export interface AcquisitionCaseSubmitRequest {
+  contact: { email: string };
+  consent: { accepted: true; consentVersion: string; policyVersion: string; locale: Projection["consent"]["locale"] };
+  addressReference: AcquisitionAddressReference;
+}
+export interface AcquisitionCaseTransitionRequest {
+  view: "acquisition_case_v1";
+  caseRef: string;
+  expectedVersion: number;
+  transition: "approve" | "activate" | "reject" | "withdraw";
+  reason?: string | undefined;
+}
+
+export interface AcquisitionCaseSubmitCommand {
+  scope: "public_tester_application";
+  sourceKind: "tester_application";
+  idempotencyKey: string;
+  requesterKey: string;
+  acceptedAt: string;
+  sourcePath: "/tester-application";
+  request: AcquisitionCaseSubmitRequest;
+}
+
+export interface AcquisitionCaseTransitionCommand {
+  actorRef: string;
+  scope: "public_tester_application";
+  idempotencyKey: string;
+  request: AcquisitionCaseTransitionRequest;
+}
+
+export interface AcquisitionCasePort extends PortableAcquisitionCasePort {
+  submit(command: AcquisitionCaseSubmitCommand): Promise<AcquisitionCaseResult<AcquisitionCaseProjection>>;
+  transition(command: AcquisitionCaseTransitionCommand): Promise<AcquisitionCaseResult<AcquisitionCaseProjection>>;
+}
+
+export type {
+  AcquisitionCaseFailureKind, AcquisitionCaseResult, AcquisitionCaseListQuery, AcquisitionCaseGetQuery,
+} from "../contracts/index.js";

package/src/marketing/server/acquisitionEvidenceDirect.ts

@@ -0,0 +1,76 @@
+import { acquisitionNewsletterConsentEventSchema, acquisitionSurveyListQuerySchema, acquisitionSurveySubmitSchema } from "../acquisitionEvidenceSchemas.js";
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { BffResponder } from "../../bff/index.js";
+import type { AcquisitionEvidenceFailure } from "../contracts/index.js";
+import type { AcquisitionEvidenceDirectDeps, AcquisitionEvidenceBindingResolver } from "./directPorts.js";
+
+export function createAcquisitionSurveySubmitDirectHandler(options: AcquisitionEvidenceDirectDeps) {
+  const { respond, resolveBinding } = options;
+  const { sendBffSuccess, sendMethodNotAllowed } = respond;
+  return async (req: HttpRequest, res: HttpResponse): Promise<void> => {
+    if (req.method !== "POST") return sendMethodNotAllowed(res, ["POST"]);
+    const request = acquisitionSurveySubmitSchema.safeParse(req.body);
+    const idempotencyKey = firstHeader(req.headers["idempotency-key"]);
+    if (!request.success || !idempotencyKey) return badRequest(res, respond, request.success ? undefined : request.error.flatten());
+    const binding = await bindingOrError(res, respond, resolveBinding); if (!binding) return;
+    const result = await safeOperation(() => binding.submitSurvey({ ...request.data, idempotencyKey }));
+    if (!result) return unavailable(res, respond);
+    if (result.ok === false) return failure(res, respond, result.error.kind);
+    sendBffSuccess(res, result.value);
+  };
+}
+
+export function createAcquisitionSurveyListDirectHandler(options: AcquisitionEvidenceDirectDeps) {
+  const { respond, authorize, resolveBinding } = options;
+  const { sendBffSuccess, sendMethodNotAllowed } = respond;
+  return async (req: HttpRequest, res: HttpResponse): Promise<void> => {
+    if (req.method !== "GET") return sendMethodNotAllowed(res, ["GET"]);
+    const actorReference = await authorize(req, res); if (!actorReference) return;
+    const request = acquisitionSurveyListQuerySchema.safeParse({
+      view: first(req.query.view), surveyType: first(req.query.surveyType), limit: first(req.query.limit) ?? "50",
+    });
+    if (!request.success) return badRequest(res, respond, request.error.flatten());
+    const binding = await bindingOrError(res, respond, resolveBinding); if (!binding) return;
+    const result = await safeOperation(() => binding.listSurveys({ ...request.data, actorReference }));
+    if (!result) return unavailable(res, respond);
+    if (result.ok === false) return failure(res, respond, result.error.kind);
+    sendBffSuccess(res, result.value);
+  };
+}
+
+export function createAcquisitionNewsletterConsentDirectHandler(options: AcquisitionEvidenceDirectDeps) {
+  const { respond, resolveBinding } = options;
+  const { sendBffSuccess } = respond;
+  return async (value: unknown, res: HttpResponse): Promise<void> => {
+    const request = acquisitionNewsletterConsentEventSchema.safeParse(value);
+    if (!request.success) return badRequest(res, respond, request.error.flatten());
+    const binding = await bindingOrError(res, respond, resolveBinding); if (!binding) return;
+    const result = await safeOperation(() => binding.applyNewsletterConsent(request.data));
+    if (!result) return unavailable(res, respond);
+    if (result.ok === false) return failure(res, respond, result.error.kind);
+    sendBffSuccess(res, result.value);
+  };
+}
+
+async function bindingOrError(res: HttpResponse, respond: BffResponder, resolve: AcquisitionEvidenceBindingResolver) {
+  try { const binding = await resolve(); if (binding) return binding; }
+  catch { /* fail closed below */ }
+  unavailable(res, respond); return null;
+}
+async function safeOperation<T>(work: () => Promise<T>): Promise<T | null> {
+  try { return await work(); } catch { return null; }
+}
+function failure(res: HttpResponse, respond: BffResponder, kind: AcquisitionEvidenceFailure): void {
+  if (kind === "invalid") return badRequest(res, respond);
+  if (kind === "not_found") return respond.sendBffError(res, "NOT_FOUND", "Acquisition evidence subject not found");
+  if (kind === "conflict") return respond.sendBffError(res, "CONFLICT", "Acquisition evidence request conflicts with prior state");
+  unavailable(res, respond);
+}
+function badRequest(res: HttpResponse, respond: BffResponder, details?: unknown): void {
+  respond.sendBffError(res, "BAD_REQUEST", "Invalid acquisition evidence request", { details });
+}
+function unavailable(res: HttpResponse, respond: BffResponder): void {
+  respond.sendBffError(res, "UPSTREAM_UNAVAILABLE", "Acquisition evidence service unavailable");
+}
+function first(value: string | string[] | undefined): string | undefined { return Array.isArray(value) ? value[0] : value; }
+function firstHeader(value: string | string[] | undefined): string | undefined { return first(value); }

package/src/marketing/server/analyticsContext.ts

@@ -0,0 +1,55 @@
+import { z } from "../validation.js";
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { AnalyticsContextHandlerDeps } from "./analyticsContextPorts.js";
+
+export function createAnalyticsContextHandler(deps: AnalyticsContextHandlerDeps) {
+  const { respond, isEnabled, resolveStore, readAccessToken, resolveTrustedSubject, capabilityCrypto, cookieName, clientIdField } = deps;
+  const { sendBffError, sendBffSuccess, sendMethodNotAllowed } = respond;
+  const requestSchema = z.object({
+    granted: z.boolean(),
+    [clientIdField]: z.string().regex(/^\d+\.\d+$/).max(64).optional(),
+    explicitGrant: z.boolean().default(false),
+  }).strict();
+  return async (req: HttpRequest, res: HttpResponse): Promise<void> => {
+    if (req.method !== "POST") return sendMethodNotAllowed(res, ["POST"]);
+    if (!isEnabled()) return sendBffError(res, "NOT_FOUND", "Analytics context unavailable");
+    // No URL, IP, contact, session, form or account data is accepted or logged.
+    const origin = typeof req.headers.origin === "string" ? req.headers.origin : "";
+    if (!origin || origin !== `https://${req.headers.host}`) return sendBffError(res, "FORBIDDEN", "Same-origin request required");
+    const parsed = requestSchema.safeParse(req.body);
+    const clientId = parsed.success ? parsed.data[clientIdField] as string | undefined : undefined;
+    if (!parsed.success || (parsed.data.granted && !clientId)) return sendBffError(res, "BAD_REQUEST", "Invalid analytics context");
+    const store = resolveStore();
+    if (!store) return sendBffError(res, "UPSTREAM_UNAVAILABLE", "Analytics context unavailable");
+    // The computed shape key widens inference; the strict schema validates these fixed fields.
+    const data = parsed.data as { granted: boolean; explicitGrant: boolean };
+    let hash = contextHash(typeof req.headers.cookie === "string" ? req.headers.cookie : undefined, cookieName, (value) => capabilityCrypto.hashToken(value));
+    // Explicit user re-consent gets a new capability; withdrawn old bindings stay withdrawn.
+    let token: string | null = null;
+    if (data.granted && !hash) {
+      token = capabilityCrypto.mintToken();
+      hash = capabilityCrypto.hashToken(token);
+    }
+    if (!hash) { sendBffSuccess(res, { active: false }); return; }
+    try {
+      const accessToken = readAccessToken(req);
+      const subject = data.granted && accessToken ? await resolveTrustedSubject(accessToken) : null;
+      if (accessToken && data.granted && !subject) return sendBffError(res, "UNAUTHORIZED", "Customer session required");
+      let active = await store.syncContext({ tokenHash: hash, granted: data.granted, clientId: clientId ?? null });
+      if (active !== true && data.granted && data.explicitGrant && !token) {
+        token = capabilityCrypto.mintToken();
+        hash = capabilityCrypto.hashToken(token);
+        active = await store.syncContext({ tokenHash: hash, granted: true, clientId: clientId! });
+      }
+      if (active === true && subject) await store.enrollSubscriptions({ subject, contextHash: hash });
+      if (token && active === true) res.setHeader("Set-Cookie", `${cookieName}=${token}; Path=/; Max-Age=31536000; HttpOnly; Secure; SameSite=Lax`);
+      res.setHeader("Cache-Control", "no-store");
+      sendBffSuccess(res, { active: active === true });
+    } catch { sendBffError(res, "UPSTREAM_UNAVAILABLE", "Analytics context unavailable"); }
+  };
+}
+
+function contextHash(cookie: string | undefined, cookieName: string, hashToken: (token: string) => string): string | null {
+  const token = cookie?.split(";").map((part) => part.trim()).find((part) => part.startsWith(`${cookieName}=`))?.split("=")[1];
+  return token && /^[a-f0-9]{64}$/.test(token) ? hashToken(token) : null;
+}

package/src/marketing/server/analyticsContextPorts.ts

@@ -0,0 +1,28 @@
+import type { HttpRequest } from "../../http/index.js";
+import type { BffResponder } from "../../bff/index.js";
+
+/** Host persistence rejects on failure; only literal true means an active context. */
+export interface AnalyticsContextPersistencePort {
+  syncContext(input: { tokenHash: string; granted: boolean; clientId: string | null }): Promise<unknown>;
+  enrollSubscriptions(input: { subject: string; contextHash: string }): Promise<unknown>;
+}
+
+export type AnalyticsContextStoreResolver = () => AnalyticsContextPersistencePort | null;
+
+/** The host supplies opaque 32-byte hexadecimal tokens and their cryptographic hash. */
+export interface AnalyticsContextCapabilityCrypto {
+  mintToken(): string;
+  hashToken(token: string): string;
+}
+
+export interface AnalyticsContextHandlerDeps {
+  respond: BffResponder;
+  isEnabled: () => boolean;
+  resolveStore: AnalyticsContextStoreResolver;
+  readAccessToken: (req: HttpRequest) => string | null;
+  resolveTrustedSubject: (accessToken: string) => Promise<string | null>;
+  capabilityCrypto: AnalyticsContextCapabilityCrypto;
+  cookieName: string;
+  /** Historical request field name supplied by the host. */
+  clientIdField: string;
+}

package/src/marketing/server/bindings.ts

@@ -0,0 +1,27 @@
+import type { ReadinessIssue } from "@openlup/core/readiness";
+import { createMarketingPrivacyContributor, type MarketingPrivacyContributor, type MarketingPrivacyDependencies } from "./privacyContributor.js";
+
+/** Select one fully bound privacy contributor; absent activation leaves the host registry unchanged. */
+export function createMarketingPrivacyBindings<Context>(input: MarketingPrivacyDependencies<Context> & { enabled?: boolean }): {
+  contributor: MarketingPrivacyContributor<Context> | null;
+  issues: ReadinessIssue[];
+  callables: Readonly<{
+    exportPersonalData: MarketingPrivacyContributor<Context>["export"] | null;
+    assessErasure: MarketingPrivacyContributor<Context>["assessErasure"] | null;
+    eraseOrRetain: MarketingPrivacyContributor<Context>["eraseOrRetain"] | null;
+  }>;
+} {
+  const acquisition = input.acquisition && [input.acquisition.export, input.acquisition.assessErasure, input.acquisition.eraseOrRetain].every(fn => typeof fn === "function") ? input.acquisition : null;
+  const remoteErasure = input.remoteErasure && [input.remoteErasure.read, input.remoteErasure.openAndFence].every(fn => typeof fn === "function") ? input.remoteErasure : null;
+  const issues: ReadinessIssue[] = [];
+  for (const [name, port] of [["acquisition", acquisition], ["remoteErasure", remoteErasure]] as const) {
+    if (!port) issues.push({ code: "OPENLUP_E_PORT_MISSING", package: "@openlup/platform", module: "marketing", subject: name, fix: `Bind the marketing ${name} owner port.` });
+  }
+  const selected = input.enabled === true && issues.length === 0
+    ? createMarketingPrivacyContributor({ ...input, acquisition, remoteErasure }) : null;
+  return { contributor: selected, issues, callables: Object.freeze({
+    exportPersonalData: selected ? selected.export : null,
+    assessErasure: selected ? selected.assessErasure : null,
+    eraseOrRetain: selected ? selected.eraseOrRetain : null,
+  }) };
+}

package/src/marketing/server/directPorts.ts

@@ -0,0 +1,27 @@
+import type { HttpRequest, HttpResponse } from "../../http/index.js";
+import type { BffResponder } from "../../bff/index.js";
+import type { AcquisitionCaseHandlers } from "./acquisitionCaseHandlers.js";
+import type { AcquisitionEvidencePort } from "../contracts/index.js";
+
+export interface AcquisitionCaseReadBinding {
+  handlers: Pick<AcquisitionCaseHandlers, "list" | "get" | "activeCount">;
+}
+export type AcquisitionCaseBindingResolver = () => Promise<AcquisitionCaseReadBinding | null>;
+export type AcquisitionEvidenceBindingResolver = () => Promise<AcquisitionEvidencePort | null>;
+export type AcquisitionAuthorize = (req: HttpRequest, res: HttpResponse) => Promise<string | null>;
+export interface AcquisitionCaseDirectDeps {
+  respond: BffResponder;
+  authorize: AcquisitionAuthorize;
+  resolveBinding: AcquisitionCaseBindingResolver;
+  isDirect: () => boolean;
+}
+export interface PrelaunchAcquisitionDirectDeps {
+  respond: BffResponder;
+  authorize: AcquisitionAuthorize;
+  resolveBinding: AcquisitionCaseBindingResolver;
+}
+export interface AcquisitionEvidenceDirectDeps {
+  respond: BffResponder;
+  authorize: AcquisitionAuthorize;
+  resolveBinding: AcquisitionEvidenceBindingResolver;
+}

package/src/marketing/server/index.ts

@@ -0,0 +1,14 @@
+/** Node-only acquisition and research algorithms. Hosts own routing, authorization and presentation. */
+export * from "./acquisitionCaseHandlers.js";
+export type * from "./acquisitionCasePorts.js";
+export type * from "./directPorts.js";
+export * from "./acquisitionCaseDirect.js";
+export * from "./prelaunchAcquisitionDirect.js";
+export * from "./acquisitionEvidenceDirect.js";
+export * from "./research/surveyResponseSubmitHandler.js";
+export * from "./research/adminSurveyResponsesHandler.js";
+export * from "./research/managedSurveyResponseSubmit.js";
+export { createAnalyticsContextHandler } from "./analyticsContext.js";
+export type * from "./analyticsContextPorts.js";
+export * from "./privacyContributor.js";
+export * from "./bindings.js";