@hogsend/engine 0.66.0 → 0.67.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4,6 +4,7 @@ import {
4
4
  ALL_IDENTITY_KINDS,
5
5
  findContacts,
6
6
  PublishableAnonymousMergeError,
7
+ projectPublicContact,
7
8
  resolveContact,
8
9
  resolveOrCreateContact,
9
10
  serializeContact,
@@ -17,6 +18,7 @@ import {
17
18
  listMembershipError,
18
19
  requireIdentity,
19
20
  } from "../_shared.js";
21
+ import { resolveFeedRecipient } from "../feed/recipient.js";
20
22
 
21
23
  // The public, serialized contact shape (§2.5). `externalId` is nullable (D1 —
22
24
  // email-only / anonymous contacts) and timestamps are ISO strings.
@@ -128,6 +130,58 @@ const findRoute = createRoute({
128
130
  },
129
131
  });
130
132
 
133
+ // ---------------------------------------------------------------------------
134
+ // GET /v1/contacts/me — the BROWSER read of the identified contact's traits
135
+ // (publishable OR secret-ingest tier; guarded as a LITERAL in routes/index.ts).
136
+ // Identity is recipient-scoped SERVER-SIDE via `resolveFeedRecipient`, the same
137
+ // leak boundary as `GET /v1/flags` and the in-app feed: a userToken-verified
138
+ // userId, a secret key's trusted userId/email, or a publishable caller's OWN
139
+ // anon id (a pk_ `anonymousId` colliding with an IDENTIFIED contact's canonical
140
+ // key is rejected 403). A request-supplied contact key is NEVER honored.
141
+ //
142
+ // What comes back is an operator ALLOWLIST projection, not the contact row: only
143
+ // exact `contacts.publicProperties` keys, plus `email` when `exposeEmail`. The
144
+ // default config is empty, so a deploy that configures nothing exposes nothing.
145
+ // No contact / empty allowlist answers 200 `{ identified: false, traits: {} }` —
146
+ // never 404, so the response does not confirm whether a contact exists.
147
+ // ---------------------------------------------------------------------------
148
+ const meQuerySchema = z.object({
149
+ userToken: z.string().optional(),
150
+ anonymousId: z.string().optional(),
151
+ userId: z.string().optional(),
152
+ email: z.string().optional(),
153
+ });
154
+
155
+ const publicContactSchema = z.object({
156
+ identified: z.boolean(),
157
+ traits: z.record(z.string(), z.unknown()),
158
+ email: z.string().nullable().optional(),
159
+ });
160
+
161
+ const meRoute = createRoute({
162
+ method: "get",
163
+ path: "/me",
164
+ tags: ["Contacts"],
165
+ summary: "Read the resolved recipient's public traits",
166
+ description:
167
+ "Recipient-scoped server-side. Returns only the operator-allowlisted contact properties (client option `contacts.publicProperties`), plus the email when `contacts.exposeEmail` is on. Empty allowlist or no contact returns an empty projection, never 404.",
168
+ request: { query: meQuerySchema },
169
+ responses: {
170
+ 200: {
171
+ content: { "application/json": { schema: publicContactSchema } },
172
+ description: "The recipient's allowlisted traits",
173
+ },
174
+ 400: {
175
+ content: { "application/json": { schema: errorSchema } },
176
+ description: "Missing identity",
177
+ },
178
+ 403: {
179
+ content: { "application/json": { schema: errorSchema } },
180
+ description: "Invalid userToken or non-addressable anonymousId",
181
+ },
182
+ },
183
+ });
184
+
131
185
  const deleteRoute = createRoute({
132
186
  method: "delete",
133
187
  path: "/",
@@ -275,6 +329,30 @@ export const contactsRouter = new OpenAPIHono<AppEnv>()
275
329
 
276
330
  return c.json({ contacts: rows.map((row) => serializeContact(row)) }, 200);
277
331
  })
332
+ .openapi(meRoute, async (c) => {
333
+ const { db, contactsConfig } = c.get("container");
334
+ const query = c.req.valid("query");
335
+ const rec = await resolveFeedRecipient(c, query);
336
+ if (!rec.ok) return c.json({ error: rec.error }, rec.status);
337
+ // `resolveFeedRecipient` already did the trust work; the only remaining
338
+ // read is the row it pinned. No `contactId` means no contact exists for
339
+ // this recipient yet, which projects to the same empty answer as a
340
+ // configured-closed allowlist.
341
+ const row = rec.contactId
342
+ ? await resolveContact({ db, id: rec.contactId })
343
+ : null;
344
+ // pk_ is ANON-ONLY; identity is a server-minted userToken. On the token-less
345
+ // publishable arm the resolver pins whatever live row holds this browser's
346
+ // anon id in its `anonymous_id` COLUMN — and that row may be an IDENTIFIED
347
+ // contact (a server-side stitch, or a pre-logout id that leaked), because
348
+ // `collidesWithIdentified` only rejects a value that IS a canonical key.
349
+ // Flags tolerate that (booleans); traits are PII, so an identified row is
350
+ // only readable through a token (or a secret key). Project it as empty.
351
+ const tokenless = c.get("publishable") === true && !query.userToken;
352
+ const identifiedRow = Boolean(row && (row.externalId || row.email));
353
+ const visible = tokenless && identifiedRow ? null : row;
354
+ return c.json(projectPublicContact(visible, contactsConfig), 200);
355
+ })
278
356
  .openapi(deleteRoute, async (c) => {
279
357
  const { db, hatchet, logger } = c.get("container");
280
358
  const { email, userId } = c.req.valid("json");
@@ -17,6 +17,7 @@ import { flagsRouter } from "./flags/index.js";
17
17
  import { groupsRouter } from "./groups/index.js";
18
18
  import { healthRouter } from "./health.js";
19
19
  import { listsRouter } from "./lists/index.js";
20
+ import { createReferralsRouter } from "./referrals/index.js";
20
21
  import { createSnippetRouter } from "./snippet.js";
21
22
  import { trackingRouter } from "./tracking/index.js";
22
23
  import { shortLinkRouter } from "./tracking/short.js";
@@ -138,6 +139,13 @@ export function registerRoutes(
138
139
  v1.use(`${base}/*`, requireApiKey, requireScope("ingest"));
139
140
  }
140
141
  v1.use("/contacts/find", requireApiKey, requireScope("ingest"));
142
+ // `GET /v1/contacts/me` is the BROWSER read of the allowlisted contact
143
+ // projection — publishable OR secret-ingest, exactly like `GET /v1/flags`.
144
+ // Registered as a LITERAL for the reason spelled out above: a
145
+ // `/contacts/*` wildcard would ALSO match the bare `/contacts` upsert and
146
+ // re-run on top of its method-branch guard. Identity is resolved
147
+ // server-side inside the handler, so this guard only sets the key tier.
148
+ v1.use("/contacts/me", requirePublishableOrIngest);
141
149
  // `POST /v1/flags/evaluate` is the SERVER SDK read — secret-only, exactly like
142
150
  // the other secret data-plane routes. The bare `/flags` (browser GET) is
143
151
  // guarded separately above; guard ONLY the `/evaluate` path here so the two
@@ -224,6 +232,37 @@ export function registerRoutes(
224
232
 
225
233
  v1.route("/accounts", createAccountsRouter());
226
234
 
235
+ // ---- Referrals (PRD 05 §7.2) ----
236
+ //
237
+ // TWO TIERS on one prefix, every path enumerated EXPLICITLY. There is
238
+ // deliberately NO `/referrals/*` catch-all: a `/<prefix>/*` `use` in Hono
239
+ // also matches the bare `/<prefix>` path AND every literal sibling, so one
240
+ // would 401 the browser-reachable `/referrals/me`, the same trap documented
241
+ // for `/contacts/*`, `/lists/*` and `/accounts/*` above.
242
+ //
243
+ // Tier 1: the browser-reachable literal, `userToken`-gated INSIDE its
244
+ // handler and non-confirming on every token failure.
245
+ v1.use("/referrals/me", requirePublishableOrIngest);
246
+ // Tier 2: secret-only. `referrals` is an ORTHOGONAL scope exactly like
247
+ // `accounts`: an explicit grant or `full-admin`, and no SCOPE_HIERARCHY edit
248
+ // (`middleware/api-key.ts` `hasScope`). A `pk_` key holds only
249
+ // `["ingest-public"]`, so it 403s here rather than escalating.
250
+ //
251
+ // `/tree/*` is the ONLY parameterised path and it is GET-only, so it needs no
252
+ // method branch: nothing browser-reachable lives under it, unlike the
253
+ // `/accounts/:provider/:providerUserId` shape.
254
+ for (const path of [
255
+ "/referrals",
256
+ "/referrals/report",
257
+ "/referrals/touch",
258
+ "/referrals/import",
259
+ "/referrals/tree/*",
260
+ ]) {
261
+ v1.use(path, requireApiKey, requireScope("referrals"));
262
+ }
263
+
264
+ v1.route("/referrals", createReferralsRouter());
265
+
227
266
  v1.route("/contacts", contactsRouter);
228
267
  v1.route("/events", eventsRouter);
229
268
  v1.route("/feed", feedRouter);
@@ -0,0 +1,41 @@
1
+ import { OpenAPIHono } from "@hono/zod-openapi";
2
+ import type { AppEnv } from "../../app.js";
3
+ import { registerReferralMeRoute } from "./me.js";
4
+ import {
5
+ registerReferralReportRoute,
6
+ registerReferralTreeRoute,
7
+ } from "./report.js";
8
+ import {
9
+ registerReferralImportRoute,
10
+ registerReferralTouchRoute,
11
+ } from "./touch.js";
12
+
13
+ /**
14
+ * The `/v1/referrals/*` router (PRD 05 §7.2). TWO TIERS on one prefix:
15
+ *
16
+ * - `/me` is browser-reachable (publishable OR secret-ingest) and gated INSIDE
17
+ * its handler by a server-minted `userToken`;
18
+ * - `/report`, `/tree/:contactId`, `/touch` and `/import` are secret-key only
19
+ * under the ORTHOGONAL `referrals` scope.
20
+ *
21
+ * The guards live in `routes/index.ts` and BRANCH rather than stack, for the
22
+ * reason `routes/accounts/index.ts` documents at length: Hono runs EVERY
23
+ * matching `use` and `route("/v1", v1)` flattens the middleware, so a blanket
24
+ * `/referrals/*` guard would 401 the browser `/me` route. This router
25
+ * re-applies NO auth of its own.
26
+ *
27
+ * Registration order is LITERALS FIRST. `/me` is a literal and `/tree/{...}`
28
+ * is the only parameterised path, so they cannot collide today - but the order
29
+ * is kept explicit so a future `/referrals/{id}` cannot capture `/me`.
30
+ */
31
+ export function createReferralsRouter(): OpenAPIHono<AppEnv> {
32
+ const router = new OpenAPIHono<AppEnv>();
33
+
34
+ registerReferralMeRoute(router);
35
+ registerReferralReportRoute(router);
36
+ registerReferralTouchRoute(router);
37
+ registerReferralImportRoute(router);
38
+ registerReferralTreeRoute(router);
39
+
40
+ return router;
41
+ }
@@ -0,0 +1,123 @@
1
+ import { referralTouches } from "@hogsend/db";
2
+ import { createRoute, type OpenAPIHono, z } from "@hono/zod-openapi";
3
+ import { and, eq, sql } from "drizzle-orm";
4
+ import type { AppEnv } from "../../app.js";
5
+ import { getReferralLink } from "../../lib/referral-link.js";
6
+ import {
7
+ InvalidUserTokenError,
8
+ verifyUserToken,
9
+ } from "../../lib/user-token.js";
10
+ import { resolveTokenContactId } from "../accounts/resolve.js";
11
+ import { referralIdQuery, resolveReferralId } from "./shared.js";
12
+
13
+ /**
14
+ * `GET /v1/referrals/me` (PRD 05 §7.2) - the CALLER's own share link and
15
+ * counts, `userToken`-gated, and NON-CONFIRMING exactly like
16
+ * `GET /v1/accounts/me` (DECISIONS §6.9).
17
+ *
18
+ * An absent, malformed, expired or forged token takes the SAME code path as
19
+ * "no referral is registered": `200 { link: null, stats: null }`. Anything else
20
+ * would let a caller enumerate which of a customer's users exist.
21
+ *
22
+ * The mint is LAZY and idempotent: a signed-in user who has never shared gets a
23
+ * link on first ask, and `getReferralLink` recovers it on every ask after.
24
+ */
25
+
26
+ const meRoute = createRoute({
27
+ method: "get",
28
+ path: "/me",
29
+ tags: ["Referrals"],
30
+ summary: "The signed-in user's referral link and counts",
31
+ description:
32
+ "Publishable OR secret key, plus a server-minted `userToken` in the query string. Mints the caller's shared link lazily (idempotent). NON-CONFIRMING: an absent, forged, expired or unknown-user token returns `200 { link: null, stats: null }`, byte-identical to a deploy with no referral registered.",
33
+ request: {
34
+ query: z.object({
35
+ userToken: z.string().optional(),
36
+ referral: referralIdQuery,
37
+ }),
38
+ },
39
+ responses: {
40
+ 200: {
41
+ content: {
42
+ "application/json": {
43
+ schema: z.object({
44
+ link: z
45
+ .object({ url: z.string(), slug: z.string().nullable() })
46
+ .nullable(),
47
+ stats: z
48
+ .object({
49
+ touched: z.number(),
50
+ bound: z.number(),
51
+ qualified: z.number(),
52
+ })
53
+ .nullable(),
54
+ }),
55
+ },
56
+ },
57
+ description: "The caller's link + counts, or two nulls",
58
+ },
59
+ },
60
+ });
61
+
62
+ const EMPTY = { link: null, stats: null } as const;
63
+
64
+ export function registerReferralMeRoute(router: OpenAPIHono<AppEnv>) {
65
+ router.openapi(meRoute, async (c) => {
66
+ const container = c.get("container");
67
+ const { db, env, referrals } = container;
68
+ const query = c.req.valid("query");
69
+ const referralId = resolveReferralId(query.referral);
70
+
71
+ if (!query.userToken) return c.json(EMPTY, 200);
72
+ if (!referrals.get(referralId)) return c.json(EMPTY, 200);
73
+
74
+ let contactId: string | null = null;
75
+ try {
76
+ const { userId } = verifyUserToken({
77
+ token: query.userToken,
78
+ secret: env.BETTER_AUTH_SECRET,
79
+ });
80
+ contactId = await resolveTokenContactId(db, userId);
81
+ } catch (err) {
82
+ if (!(err instanceof InvalidUserTokenError)) throw err;
83
+ contactId = null;
84
+ }
85
+ if (!contactId) return c.json(EMPTY, 200);
86
+
87
+ const link = await getReferralLink({
88
+ referral: referralId,
89
+ contactId,
90
+ container: {
91
+ db,
92
+ env: { API_PUBLIC_URL: env.API_PUBLIC_URL },
93
+ referrals,
94
+ },
95
+ });
96
+
97
+ const [counts] = await db
98
+ .select({
99
+ touched: sql<number>`count(*) filter (where ${referralTouches.status} <> 'rejected')::int`,
100
+ bound: sql<number>`count(*) filter (where ${referralTouches.status} in ('bound', 'qualified'))::int`,
101
+ qualified: sql<number>`count(*) filter (where ${referralTouches.status} = 'qualified')::int`,
102
+ })
103
+ .from(referralTouches)
104
+ .where(
105
+ and(
106
+ eq(referralTouches.referralId, referralId),
107
+ eq(referralTouches.referrerContactId, contactId),
108
+ ),
109
+ );
110
+
111
+ return c.json(
112
+ {
113
+ link: { url: link.url, slug: link.slug },
114
+ stats: {
115
+ touched: Number(counts?.touched ?? 0),
116
+ bound: Number(counts?.bound ?? 0),
117
+ qualified: Number(counts?.qualified ?? 0),
118
+ },
119
+ },
120
+ 200,
121
+ );
122
+ });
123
+ }
@@ -0,0 +1,285 @@
1
+ import { createRoute, type OpenAPIHono, z } from "@hono/zod-openapi";
2
+ import type { AppEnv } from "../../app.js";
3
+ import {
4
+ getReferralReport,
5
+ getReferralTree,
6
+ InvalidWindowError,
7
+ parseWindowMs,
8
+ REFERRAL_MODELS,
9
+ REFERRAL_REPORT_MAX_DEPTH,
10
+ resolveLevelWeights,
11
+ } from "../../lib/referral-report.js";
12
+ import { errorSchema } from "../../lib/schemas.js";
13
+ import {
14
+ referralIdQuery,
15
+ resolveNamedContactId,
16
+ resolveReferralId,
17
+ } from "./shared.js";
18
+
19
+ /**
20
+ * `GET /v1/referrals/report` and `GET /v1/referrals/tree/:contactId` (PRD 05
21
+ * §5.3). Model, window, depth and level weights are REQUEST parameters, so
22
+ * these two routes are the entire "reporting feature": nothing is persisted
23
+ * per model and nothing is backfilled when the reader changes their mind.
24
+ */
25
+
26
+ const DEFAULT_WINDOW = "30d";
27
+ const DEFAULT_LIMIT = 50;
28
+ const MAX_LIMIT = 200;
29
+ const DEFAULT_TREE_DEPTH = 3;
30
+ const MAX_TREE_NODES = 1000;
31
+
32
+ const currencyValueSchema = z.object({
33
+ currency: z.string(),
34
+ value: z.number(),
35
+ });
36
+
37
+ const reportRoute = createRoute({
38
+ method: "get",
39
+ path: "/report",
40
+ tags: ["Referrals"],
41
+ summary: "Referral revenue and tree report",
42
+ description:
43
+ "Secret key + the `referrals` scope. Picks each referee's effective edge(s) under `model` within `window` (the touch-to-bind gap), walks the referrer chain to `depth`, and credits `weights[level] * edgeWeight * conversion value`. VALUES ARE NEVER CONVERTED BETWEEN CURRENCIES: every monetary field is a list of `{ currency, value }`.",
44
+ request: {
45
+ query: z.object({
46
+ referral: referralIdQuery,
47
+ model: z.enum(REFERRAL_MODELS).optional(),
48
+ window: z.string().optional(),
49
+ depth: z.coerce
50
+ .number()
51
+ .int()
52
+ .min(1)
53
+ .max(REFERRAL_REPORT_MAX_DEPTH)
54
+ .optional(),
55
+ weights: z.string().optional(),
56
+ from: z.string().optional(),
57
+ to: z.string().optional(),
58
+ limit: z.coerce.number().int().min(1).max(MAX_LIMIT).optional(),
59
+ cursor: z.string().optional(),
60
+ }),
61
+ },
62
+ responses: {
63
+ 200: {
64
+ content: {
65
+ "application/json": {
66
+ schema: z.object({
67
+ referral: z.string(),
68
+ model: z.enum(REFERRAL_MODELS),
69
+ window: z.string(),
70
+ depth: z.number(),
71
+ weights: z.array(z.number()),
72
+ from: z.string().nullable(),
73
+ to: z.string().nullable(),
74
+ beneficiaries: z.array(
75
+ z.object({
76
+ contactId: z.string(),
77
+ direct: z.object({
78
+ touched: z.number(),
79
+ bound: z.number(),
80
+ qualified: z.number(),
81
+ }),
82
+ tree: z.array(
83
+ z.object({
84
+ level: z.number(),
85
+ referees: z.number(),
86
+ conversions: z.number(),
87
+ value: z.array(currencyValueSchema),
88
+ }),
89
+ ),
90
+ value: z.array(currencyValueSchema),
91
+ }),
92
+ ),
93
+ nextCursor: z.string().nullable(),
94
+ }),
95
+ },
96
+ },
97
+ description: "The report",
98
+ },
99
+ 400: {
100
+ content: { "application/json": { schema: errorSchema } },
101
+ description: "Invalid window, weights, cursor or date",
102
+ },
103
+ },
104
+ });
105
+
106
+ const treeRoute = createRoute({
107
+ method: "get",
108
+ path: "/tree/{contactId}",
109
+ tags: ["Referrals"],
110
+ summary: "One referrer's descendants",
111
+ description:
112
+ "Secret key + the `referrals` scope. Walks DOWN from `contactId` to `depth` (default 3, cap 5) over every non-rejected edge. This is a ledger view, not a model: no window, no weights.",
113
+ request: {
114
+ params: z.object({ contactId: z.string().min(1) }),
115
+ query: z.object({
116
+ referral: referralIdQuery,
117
+ depth: z.coerce
118
+ .number()
119
+ .int()
120
+ .min(1)
121
+ .max(REFERRAL_REPORT_MAX_DEPTH)
122
+ .optional(),
123
+ }),
124
+ },
125
+ responses: {
126
+ 200: {
127
+ content: {
128
+ "application/json": {
129
+ schema: z.object({
130
+ referral: z.string(),
131
+ contactId: z.string(),
132
+ depth: z.number(),
133
+ nodes: z.array(
134
+ z.object({
135
+ contactId: z.string(),
136
+ level: z.number(),
137
+ viaContactId: z.string(),
138
+ status: z.string(),
139
+ touchedAt: z.string(),
140
+ boundAt: z.string().nullable(),
141
+ qualifiedAt: z.string().nullable(),
142
+ conversions: z.number(),
143
+ value: z.array(currencyValueSchema),
144
+ }),
145
+ ),
146
+ }),
147
+ },
148
+ },
149
+ description: "The descendant nodes",
150
+ },
151
+ 400: {
152
+ content: { "application/json": { schema: errorSchema } },
153
+ description: "Unresolvable contact key",
154
+ },
155
+ },
156
+ });
157
+
158
+ /** `"1,0.5,0.25"` -> `[1, 0.5, 0.25]`. Throws on anything else. */
159
+ function parseWeights(input: string | undefined, depth: number): number[] {
160
+ if (!input) return [];
161
+ const parts = input.split(",").map((p) => p.trim());
162
+ if (parts.length > depth) {
163
+ throw new RangeError(
164
+ `weights has ${parts.length} entries but depth is ${depth}`,
165
+ );
166
+ }
167
+ return parts.map((part) => {
168
+ const value = Number(part);
169
+ if (!Number.isFinite(value) || value < 0) {
170
+ throw new RangeError(`weight "${part}" is not a non-negative number`);
171
+ }
172
+ return value;
173
+ });
174
+ }
175
+
176
+ /** The cursor is an opaque decimal offset; a non-offset value is a 400. */
177
+ function parseCursor(input: string | undefined): number {
178
+ if (!input) return 0;
179
+ const offset = Number(input);
180
+ if (!Number.isInteger(offset) || offset < 0) {
181
+ throw new RangeError(`invalid cursor "${input}"`);
182
+ }
183
+ return offset;
184
+ }
185
+
186
+ function parseDate(input: string | undefined, label: string): Date | undefined {
187
+ if (!input) return undefined;
188
+ const date = new Date(input);
189
+ if (Number.isNaN(date.getTime())) {
190
+ throw new RangeError(`invalid ${label} date "${input}"`);
191
+ }
192
+ return date;
193
+ }
194
+
195
+ export function registerReferralReportRoute(router: OpenAPIHono<AppEnv>) {
196
+ router.openapi(reportRoute, async (c) => {
197
+ const { db } = c.get("container");
198
+ const query = c.req.valid("query");
199
+
200
+ const referralId = resolveReferralId(query.referral);
201
+ const model = query.model ?? "first_touch";
202
+ const windowInput = query.window ?? DEFAULT_WINDOW;
203
+ const depth = query.depth ?? 1;
204
+ const limit = query.limit ?? DEFAULT_LIMIT;
205
+
206
+ let windowMs: number;
207
+ let weights: number[];
208
+ let offset: number;
209
+ let from: Date | undefined;
210
+ let to: Date | undefined;
211
+ try {
212
+ windowMs = parseWindowMs(windowInput);
213
+ weights = parseWeights(query.weights, depth);
214
+ offset = parseCursor(query.cursor);
215
+ from = parseDate(query.from, "from");
216
+ to = parseDate(query.to, "to");
217
+ } catch (err) {
218
+ if (err instanceof InvalidWindowError || err instanceof RangeError) {
219
+ return c.json({ error: err.message }, 400);
220
+ }
221
+ throw err;
222
+ }
223
+
224
+ const levelWeights = resolveLevelWeights(depth, weights);
225
+ const report = await getReferralReport({
226
+ db,
227
+ referralId,
228
+ model,
229
+ windowMs,
230
+ depth,
231
+ levelWeights,
232
+ ...(from ? { from } : {}),
233
+ ...(to ? { to } : {}),
234
+ limit,
235
+ offset,
236
+ });
237
+
238
+ return c.json(
239
+ {
240
+ referral: referralId,
241
+ model,
242
+ window: windowInput,
243
+ depth,
244
+ weights: levelWeights,
245
+ from: from ? from.toISOString() : null,
246
+ to: to ? to.toISOString() : null,
247
+ beneficiaries: report.beneficiaries,
248
+ nextCursor:
249
+ report.nextOffset === null ? null : String(report.nextOffset),
250
+ },
251
+ 200,
252
+ );
253
+ });
254
+ }
255
+
256
+ export function registerReferralTreeRoute(router: OpenAPIHono<AppEnv>) {
257
+ router.openapi(treeRoute, async (c) => {
258
+ const { db } = c.get("container");
259
+ const { contactId } = c.req.valid("param");
260
+ const query = c.req.valid("query");
261
+ const referralId = resolveReferralId(query.referral);
262
+ const depth = query.depth ?? DEFAULT_TREE_DEPTH;
263
+
264
+ // A tree is addressed by the CONTACT, so an external key resolves the same
265
+ // way every other operator route resolves one. An unknown key is an empty
266
+ // tree, not a 404: "this person referred nobody" is the same answer.
267
+ const resolved = await resolveNamedContactId(db, contactId);
268
+ if (!resolved) {
269
+ return c.json({ referral: referralId, contactId, depth, nodes: [] }, 200);
270
+ }
271
+
272
+ const nodes = await getReferralTree({
273
+ db,
274
+ referralId,
275
+ contactId: resolved,
276
+ depth,
277
+ limit: MAX_TREE_NODES,
278
+ });
279
+
280
+ return c.json(
281
+ { referral: referralId, contactId: resolved, depth, nodes },
282
+ 200,
283
+ );
284
+ });
285
+ }
@@ -0,0 +1,34 @@
1
+ import { DEFAULT_REFERRAL_ID } from "@hogsend/core";
2
+ import type { Database } from "@hogsend/db";
3
+ import { z } from "@hono/zod-openapi";
4
+ import { resolveContact } from "../../lib/contacts.js";
5
+
6
+ /**
7
+ * Helpers shared by the `/v1/referrals` routes. Nothing here creates a
8
+ * contact: an operator naming a key is asking a QUESTION, and minting a row to
9
+ * answer it is the ghost-contact case PRD 02 forbade.
10
+ */
11
+
12
+ /** Every route takes the same optional `referral` selector. */
13
+ export const referralIdQuery = z
14
+ .string()
15
+ .min(1)
16
+ .optional()
17
+ .describe(`The defineReferral id. Default "${DEFAULT_REFERRAL_ID}".`);
18
+
19
+ export function resolveReferralId(input: string | undefined): string {
20
+ return input ?? DEFAULT_REFERRAL_ID;
21
+ }
22
+
23
+ /**
24
+ * Resolve a contact an operator named by uuid or external key. `null` = no
25
+ * such contact; the caller decides whether that is a 404 or a skipped row.
26
+ */
27
+ export async function resolveNamedContactId(
28
+ db: Database,
29
+ key: string | undefined,
30
+ ): Promise<string | null> {
31
+ if (!key) return null;
32
+ const row = await resolveContact({ db, id: key });
33
+ return row?.id ?? null;
34
+ }