@rocapine/community 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocapine/community",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI to install, upgrade and adopt the Rocapine Community SDK's Supabase backend (migrations, Edge Functions) into a project.",
   "license": "MIT",
   "repository": {

package/templates/functions/_shared/client.ts

@@ -11,6 +11,31 @@ export function adminClient() {
   return createClient(SUPABASE_URL, Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!);
 }
 
+// Reads every row of a query page by page: PostgREST caps one response at the
+// project's max_rows (Supabase default 1000), so a single select silently
+// truncates. `page` must apply a deterministic order and `.range(from, to)`.
+// Stops on the first short page. A failed page logs and returns what was read
+// so far — for a broadcast, a partial send beats none (re-running would
+// double-send to the pages already pushed).
+export async function fetchAllRows<T>(
+  page: (
+    from: number,
+    to: number,
+  ) => PromiseLike<{ data: T[] | null; error: { message: string } | null }>,
+  pageSize = 1000,
+): Promise<T[]> {
+  const rows: T[] = [];
+  for (let from = 0; ; from += pageSize) {
+    const { data, error } = await page(from, from + pageSize - 1);
+    if (error) {
+      console.error(`fetchAllRows: page failed, keeping ${rows.length} rows`, error.message);
+      return rows;
+    }
+    rows.push(...(data ?? []));
+    if ((data?.length ?? 0) < pageSize) return rows;
+  }
+}
+
 // The gateway (verify_jwt) has already validated the bearer's signature, so
 // only the role claim needs checking here. An exact string match against the
 // injected SUPABASE_SERVICE_ROLE_KEY broke when a project migrated to the new

package/templates/functions/_shared/push.ts

@@ -1,6 +1,8 @@
 // Shared Expo push sender. Used by notify-comment, notify-like,
 // notify-reaction and broadcast-post (push module).
 
+import { runPool } from "./translation.ts";
+
 export interface ExpoPushMessage {
   to: string;
   title: string;
@@ -11,21 +13,29 @@ export interface ExpoPushMessage {
   badge?: number;
 }
 
-// Sends in chunks of 100 (Expo API limit). Best-effort: push failures must
-// never fail the calling webhook. Projects with Enhanced Security for push
-// must set the EXPO_ACCESS_TOKEN function secret.
-export async function sendExpoPushBatch(messages: ExpoPushMessage[]): Promise<void> {
+// Sends in chunks of 100 (Expo API limit), 4 requests in flight at a time, each
+// aborted after 10 s so one hung request can't stall a large broadcast past the
+// function's wall-clock limit. Best-effort: push failures must never fail the
+// calling webhook. Projects with Enhanced Security for push must set the
+// EXPO_ACCESS_TOKEN function secret. `fetchImpl`/`concurrency` are for tests.
+export async function sendExpoPushBatch(
+  messages: ExpoPushMessage[],
+  opts: { fetchImpl?: typeof fetch; concurrency?: number } = {},
+): Promise<void> {
+  const fetchImpl = opts.fetchImpl ?? fetch;
   const headers: Record<string, string> = { "Content-Type": "application/json" };
   const accessToken = Deno.env.get("EXPO_ACCESS_TOKEN");
   if (accessToken) headers["Authorization"] = `Bearer ${accessToken}`;
-  for (let i = 0; i < messages.length; i += 100) {
-    const chunk = messages.slice(i, i + 100);
-    await fetch("https://exp.host/--/api/v2/push/send", {
+  const chunks: ExpoPushMessage[][] = [];
+  for (let i = 0; i < messages.length; i += 100) chunks.push(messages.slice(i, i + 100));
+  await runPool(chunks, opts.concurrency ?? 4, (chunk) =>
+    fetchImpl("https://exp.host/--/api/v2/push/send", {
       method: "POST",
       headers,
       body: JSON.stringify(chunk.length === 1 ? chunk[0] : chunk),
-    }).catch(() => {});
-  }
+      signal: AbortSignal.timeout(10_000),
+    }).catch(() => {}),
+  );
 }
 
 export async function sendExpoPush(message: ExpoPushMessage): Promise<void> {

package/templates/functions/_shared/translation.ts

@@ -32,7 +32,15 @@ export type TranslationRow = {
  * with nothing to translate, "attempt" claims an in-flight/failed attempt. */
 const MARKERS = ["source", "attempt"];
 const isMarker = (r: TranslationRow) => MARKERS.includes(r.locale);
+/** Real translation rows only, without created_at — what callers receive. */
+const realRows = (rows: TranslationRow[]): TranslationRow[] =>
+  rows
+    .filter((h) => !isMarker(h))
+    .map(({ locale, source_locale, content }) => ({ locale, source_locale, content }));
 const ATTEMPT_MAX_AGE_MS = 6 * 60 * 60 * 1000;
+/** An attempt younger than this may still be running (20 s OpenAI timeout plus
+ * claim/upsert time); an older one within the 6 h window has failed. */
+export const IN_FLIGHT_MS = 45_000;
 export type ParsedTranslation = {
   sourceLocale: string;
   translations: Record<string, { content: string; options: string[] }>;
@@ -207,9 +215,9 @@ export async function runPool<T, R>(
  * carries one (the attempt marker's is ""). */
 export function missingLocales(have: TranslationRow[], targets: string[]): string[] {
   const knownSource = have.find((h) => h.source_locale !== "")?.source_locale;
-  const realRows = have.filter((h) => !isMarker(h));
+  const real = have.filter((h) => !isMarker(h));
   return targets.filter(
-    (l) => !realRows.some((h) => h.locale === l) && (!knownSource || languageOf(l) !== knownSource),
+    (l) => !real.some((h) => h.locale === l) && (!knownSource || languageOf(l) !== knownSource),
   );
 }
 
@@ -220,16 +228,123 @@ export function hasFreshAttempt(have: TranslationRow[], nowMs: number, maxAgeMs:
   );
 }
 
+/** An attempt row not yet marked failed (its owner may still be translating). A
+ * failed attempt keeps its claim (and created_at) for the 6 h retry window,
+ * but nobody should wait on it. */
+const isPendingAttempt = (h: TranslationRow) => h.locale === "attempt" && h.content !== "failed";
+
+/** True when `have` holds an attempt young enough to still be in flight
+ * (a failed attempt never is). */
+export function isInFlight(have: TranslationRow[], nowMs: number, inFlightMs: number): boolean {
+  return hasFreshAttempt(have.filter(isPendingAttempt), nowMs, inFlightMs);
+}
+
+/**
+ * Calls `read` until it reports `done` or `timeoutMs` has elapsed, sleeping
+ * `intervalMs` between reads (the last sleep is cut to the deadline), and
+ * returns the last value read. `sleep`/`now` are injectable for tests.
+ */
+export async function waitFor<T>(
+  read: () => Promise<{ done: boolean; value: T }>,
+  opts: {
+    timeoutMs: number;
+    intervalMs: number;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+  },
+): Promise<T> {
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? ((ms: number) => new Promise<void>((r) => setTimeout(r, ms)));
+  const deadline = now() + opts.timeoutMs;
+  let r = await read();
+  while (!r.done) {
+    const left = deadline - now();
+    if (left <= 0) break;
+    await sleep(Math.min(opts.intervalMs, left));
+    r = await read();
+  }
+  return r.value;
+}
+
+/**
+ * Another caller holds the attempt claim. Without `waitMs`, return what exists
+ * now (`have`); with it, wait for that caller — but only while its attempt can
+ * still be in flight (a failed attempt keeps its claim for 6 h; waiting on it
+ * would only delay the push). `claimRows` carries the attempt row's
+ * created_at; absent (23505: the claim was just taken by someone else), it is
+ * re-read. Internal export for tests; `targets`/`sleep`/`now` are injectable.
+ */
+export async function otherCallerResult(args: {
+  supabase: SupabaseClient;
+  tTable: string;
+  fk: string;
+  id: string;
+  have: TranslationRow[];
+  waitMs?: number;
+  claimRows?: TranslationRow[];
+  targets?: string[];
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+}): Promise<TranslationRow[]> {
+  const { supabase, tTable, fk, id, have } = args;
+  const waitMs = args.waitMs ?? 0;
+  const now = args.now ?? Date.now;
+  if (waitMs <= 0) return have;
+  let claimRows = args.claimRows;
+  if (!claimRows) {
+    const { data, error } = await supabase
+      .from(tTable)
+      .select("locale, source_locale, content, created_at")
+      .eq(fk, id)
+      .eq("locale", "attempt");
+    if (error) {
+      console.error("translation claim lookup failed", error.message);
+      return have;
+    }
+    claimRows = (data ?? []) as TranslationRow[];
+  }
+  // No attempt left means the other caller just finished: the first read
+  // below picks up its rows at once.
+  const stale =
+    claimRows.some((h) => h.locale === "attempt") && !isInFlight(claimRows, now(), IN_FLIGHT_MS);
+  if (stale) return have;
+  return await waitFor(
+    async () => {
+      const { data, error } = await supabase
+        .from(tTable)
+        .select("locale, source_locale, content")
+        .eq(fk, id);
+      if (error) {
+        console.error("translation wait lookup failed", error.message);
+        return { done: true, value: have };
+      }
+      const rows = (data ?? []) as TranslationRow[];
+      return {
+        done:
+          !rows.some(isPendingAttempt) ||
+          missingLocales(rows, args.targets ?? TARGET_LOCALES).length === 0,
+        value: realRows(rows),
+      };
+    },
+    { timeoutMs: waitMs, intervalMs: 1500, sleep: args.sleep, now: args.now },
+  );
+}
+
 /**
  * Translate `kind`/`id` into every missing target locale and upsert the rows.
  * Returns the rows now present for the item (possibly empty when the item is
  * in a target language), or null when translation failed (nothing written).
  * Idempotent: complete items make no API call.
+ *
+ * `waitMs` (pushes): when another caller holds the attempt claim, poll for up
+ * to `waitMs` until its claim is released or the rows cover every missing
+ * locale, instead of returning the (usually empty) rows at once.
  */
 export async function ensureTranslations(
   supabase: SupabaseClient,
   kind: "post" | "comment",
   id: string,
+  opts?: { waitMs?: number },
 ): Promise<TranslationRow[] | null> {
   if (TARGET_LOCALES.length === 0) {
     console.log("community-sdk: COMMUNITY_TRANSLATION_LOCALES not set, skipping translation");
@@ -260,9 +375,7 @@ export async function ensureTranslations(
     return null;
   }
   const all = (existing ?? []) as TranslationRow[];
-  const have = all
-    .filter((h) => !isMarker(h))
-    .map(({ locale, source_locale, content }) => ({ locale, source_locale, content }));
+  const have = realRows(all);
   const missing = missingLocales(all, TARGET_LOCALES);
   if (missing.length === 0) return have;
 
@@ -272,9 +385,12 @@ export async function ensureTranslations(
   // (translate-one + notify-comment, or a sweep) exactly one wins and the other
   // gets 23505 and returns what exists. A stale claim is deleted first (only if
   // still stale, so a claim another caller just took survives). Deleted on
-  // success, left on failure: the item is retried after 6 h.
+  // success, left (marked "failed") on failure: the item is retried after 6 h.
   const now = Date.now();
-  if (hasFreshAttempt(all, now, ATTEMPT_MAX_AGE_MS)) return have;
+  const waitArgs = { supabase, tTable, fk, id, have, waitMs: opts?.waitMs };
+  if (hasFreshAttempt(all, now, ATTEMPT_MAX_AGE_MS)) {
+    return await otherCallerResult({ ...waitArgs, claimRows: all });
+  }
   if (all.some((h) => h.locale === "attempt")) {
     await supabase
       .from(tTable)
@@ -287,10 +403,18 @@ export async function ensureTranslations(
     .from(tTable)
     .insert({ [fk]: id, locale: "attempt", source_locale: "", content: "", engine: ENGINE });
   if (claimError) {
-    if (claimError.code === "23505") return have; // another caller holds the claim
+    // Another caller holds the claim.
+    if (claimError.code === "23505") return await otherCallerResult(waitArgs);
     console.error("translation attempt claim failed", claimError.message);
     return null;
   }
+  // From here on this caller holds the claim. Every failure marks it "failed"
+  // (keeping created_at, so the 6 h retry window is unchanged) so pushes
+  // waiting on it stop at once; an error marking it is ignored.
+  const fail = async (): Promise<null> => {
+    await supabase.from(tTable).update({ content: "failed" }).eq(fk, id).eq("locale", "attempt");
+    return null;
+  };
 
   let options: { id: string; idx: number; label: string }[] = [];
   if (kind === "post") {
@@ -302,7 +426,7 @@ export async function ensureTranslations(
     // A backend without the polls module has no poll_options relation: no options.
     if (error && error.code !== "PGRST205" && error.code !== "42P01") {
       console.error("poll options lookup failed", error.message);
-      return null;
+      return await fail();
     }
     if (!error && data) options = data as typeof options;
   }
@@ -312,14 +436,14 @@ export async function ensureTranslations(
     options: options.map((o) => o.label),
     targets: missing,
   });
-  if (!parsed) return null;
+  if (!parsed) return await fail();
 
   const incomplete = missing.filter(
     (l) => languageOf(l) !== parsed.sourceLocale && !(l in parsed.translations),
   );
   if (incomplete.length > 0) {
     console.error("translation response missing locales", incomplete.join(", "));
-    return null;
+    return await fail();
   }
 
   // Poll option rows are written first: if they fail, nothing lands, so the item
@@ -334,7 +458,7 @@ export async function ensureTranslations(
         .upsert(optionRows, { onConflict: "option_id,locale" });
       if (error) {
         console.error("poll option translation upsert failed", error.message);
-        return null;
+        return await fail();
       }
     }
   }
@@ -350,7 +474,7 @@ export async function ensureTranslations(
     const { error } = await supabase.from(tTable).upsert(rows, { onConflict: `${fk},locale` });
     if (error) {
       console.error("translation upsert failed", error.message);
-      return null;
+      return await fail();
     }
   } else {
     // ponytail: every missing target shares the source language, so there was
@@ -376,7 +500,7 @@ export async function ensureTranslations(
     );
     if (error) {
       console.error("translation marker upsert failed", error.message);
-      return null;
+      return await fail();
     }
   }
   // Release the claim; an error is ignored (a leftover claim only keeps the

package/templates/functions/broadcast-post/index.ts

@@ -4,7 +4,7 @@
 // Guarded by a service-role check — the public anon key passes the platform's
 // verify_jwt but must NOT be able to trigger a broadcast.
 
-import { adminClient, isServiceCaller } from "../_shared/client.ts";
+import { adminClient, fetchAllRows, isServiceCaller } from "../_shared/client.ts";
 import { sendExpoPushBatch } from "../_shared/push.ts";
 import { BROADCAST_FALLBACK_TITLE } from "../_shared/config.ts";
 import { ensureTranslations, resolveTargetLocale, TARGET_LOCALES } from "../_shared/translation.ts";
@@ -34,21 +34,34 @@ Deno.serve(async (req) => {
   const title = author?.username?.trim() || BROADCAST_FALLBACK_TITLE;
 
   const original = post.content.length > 140 ? `${post.content.slice(0, 137)}...` : post.content;
+  // waitMs: when translate-one holds the claim (it fires on the same insert),
+  // wait for its rows instead of pushing the source language.
   const translations =
     TARGET_LOCALES.length === 0
       ? []
-      : ((await ensureTranslations(supabase, "post", post.id)) ?? []);
+      : ((await ensureTranslations(supabase, "post", post.id, { waitMs: 20_000 })) ?? []);
   const excerptFor = (locale: string | null): string => {
     if (!locale) return original;
     const t = translations.find((r) => r.locale === locale);
     return t ? (t.content.length > 140 ? `${t.content.slice(0, 137)}...` : t.content) : original;
   };
 
-  const { data: rows } = await supabase
-    .from("push_tokens")
-    .select("expo_push_token, profiles(locale)")
-    .not("expo_push_token", "is", null);
-  const messages = (rows ?? [])
+  // Paged (PostgREST max_rows caps a single select, default 1000) with a total
+  // order so pages don't overlap. Newest registration first: a reinstall
+  // creates a new anonymous user while the old row keeps the same token, and
+  // the dedupe below keeps the first (newest) row's locale. Offset paging can
+  // skip a row if one is deleted mid-broadcast — acceptable.
+  const rows = await fetchAllRows((from, to) =>
+    supabase
+      .from("push_tokens")
+      .select("user_id, expo_push_token, profiles(locale)")
+      .not("expo_push_token", "is", null)
+      .order("updated_at", { ascending: false })
+      .order("user_id")
+      .range(from, to),
+  );
+  const seen = new Set<string>();
+  const messages = rows
     .map((r) => {
       const profile = Array.isArray(r.profiles) ? r.profiles[0] : r.profiles;
       return {
@@ -56,7 +69,12 @@ Deno.serve(async (req) => {
         locale: resolveTargetLocale(profile?.locale ?? null),
       };
     })
-    .filter((m) => Boolean(m.to))
+    .filter((m) => {
+      // A stale duplicate token must not double-push.
+      if (!m.to || seen.has(m.to)) return false;
+      seen.add(m.to);
+      return true;
+    })
     .map(({ to, locale }) => ({
       to,
       title,

package/templates/functions/notify-comment/index.ts

@@ -62,11 +62,13 @@ Deno.serve(async (req) => {
   const name = actor?.username?.trim() || copy.fallbackName;
   // Recipient-language excerpt when the translation module is on: translate
   // now (a few seconds) rather than push the source language; on failure the
-  // original goes out and the sweep fills the rows later.
+  // original goes out and the sweep fills the rows later. translate-one fires
+  // on the same insert, so when it holds the claim wait up to 20 s (the OpenAI
+  // request timeout) for its rows.
   let excerptSource = comment.content;
   const targetLocale = resolveTargetLocale(recipient?.locale);
   if (targetLocale) {
-    const rows = await ensureTranslations(supabase, "comment", comment.id);
+    const rows = await ensureTranslations(supabase, "comment", comment.id, { waitMs: 20_000 });
     const match = rows?.find(
       (r) => r.locale === targetLocale && languageOf(r.locale) !== r.source_locale,
     );