@takosjp/yurucommu-core 3.4.0 → 3.4.3

package/src/backend/routes/actors.ts

@@ -286,11 +286,11 @@ export async function cancelTombstoneDelete(
   return deleteActivityIds.length;
 }
 
-// Best-effort, opportunistic tombstone reaping on the read path. This Worker
-// has no `scheduled` handler, so (mirroring maybeCleanupExpiredStories) the
-// sweep is triggered probabilistically and guarded so at most one runs per
-// isolate at a time. Tombstones are already excluded from every serving query,
-// so a missed sweep only delays storage/key-material reclamation.
+// Best-effort, opportunistic tombstone reaping on the read path. The public
+// Worker has a scheduled retention handler too; this remains as a fallback for
+// self-hosted runtimes without cron. It is guarded so at most one pass runs per
+// isolate. Tombstones are already excluded from every serving query, so a
+// missed sweep only delays storage/key-material reclamation.
 let tombstoneReapInFlight = false;
 
 export function maybeReapDrainedTombstones(db: Database): void {

package/src/backend/routes/auth.ts

@@ -7,6 +7,7 @@ import {
   fetchUserInfo,
   getAuthConfig,
   getClientCredentials,
+  getMobileOidcAudience,
   getProvider,
 } from "../lib/oauth-providers.ts";
 import { verifyOidcIdToken } from "../lib/oidc-id-token.ts";
@@ -296,7 +297,7 @@ auth.post("/mobile/oidc", async (c) => {
   }
 
   try {
-    const { clientId } = getClientCredentials(c.env, "takos");
+    const clientId = getMobileOidcAudience(c.env);
     const claims = await verifyOidcIdToken(idToken, {
       issuer: provider.issuer,
       clientId,

package/src/backend/routes/posts/post-helpers.ts

@@ -15,7 +15,10 @@ import {
   communities,
   communityMembers,
   inbox as inboxTable,
+  insertMany,
   objects,
+  runBatch,
+  type D1Statement,
 } from "../../../db/index.ts";
 import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
 import type { Database } from "../../../db/index.ts";
@@ -666,33 +669,49 @@ export async function processMentions(
   }
 
   if (activitiesToCreate.length > 0) {
+    // A mention notification is one invariant: its activity and inbox edge
+    // either both exist or neither does. Build D1-safe chunked INSERT
+    // statements, then commit each bounded page as one atomic batch. This
+    // avoids both the 100-bind ceiling and the old activity-without-inbox
+    // partial state when the second independent INSERT failed.
+    const MENTION_NOTIFICATION_PAGE_SIZE = 200;
     try {
-      await db.insert(activities).values(activitiesToCreate);
-    } catch (e) {
-      log.error("Failed to persist mention activities", {
-        event: "posts.mention.activity_persist_failed",
-        error: e,
-      });
-      mentionFailures.push({
-        mention: "__batch__",
-        stage: "persist_activity",
-        reason: "mention_activity_persist_failed",
-      });
-    }
-  }
-  if (inboxEntriesToCreate.length > 0) {
-    try {
-      await db.insert(inboxTable).values(inboxEntriesToCreate);
+      for (
+        let offset = 0;
+        offset < activitiesToCreate.length;
+        offset += MENTION_NOTIFICATION_PAGE_SIZE
+      ) {
+        const activityPage = activitiesToCreate.slice(
+          offset,
+          offset + MENTION_NOTIFICATION_PAGE_SIZE,
+        );
+        const inboxPage = inboxEntriesToCreate.slice(
+          offset,
+          offset + MENTION_NOTIFICATION_PAGE_SIZE,
+        );
+        const statements = [
+          ...insertMany(db, activities, activityPage),
+          ...insertMany(db, inboxTable, inboxPage),
+        ];
+        await runBatch(db, statements as [D1Statement, ...D1Statement[]]);
+      }
     } catch (e) {
-      log.error("Failed to persist mention inbox entries", {
-        event: "posts.mention.inbox_persist_failed",
+      log.error("Failed to atomically persist mention notifications", {
+        event: "posts.mention.notification_persist_failed",
         error: e,
       });
-      mentionFailures.push({
-        mention: "__batch__",
-        stage: "persist_inbox",
-        reason: "mention_inbox_persist_failed",
-      });
+      mentionFailures.push(
+        {
+          mention: "__batch__",
+          stage: "persist_activity",
+          reason: "mention_activity_persist_failed",
+        },
+        {
+          mention: "__batch__",
+          stage: "persist_inbox",
+          reason: "mention_inbox_persist_failed",
+        },
+      );
     }
   }
 

package/src/backend/routes/stories/routes.ts

@@ -62,13 +62,11 @@ const stories = new Hono<{ Bindings: Env; Variables: Variables }>();
 
 // Best-effort, opportunistic retention of expired stories.
 //
-// This is NOT a substitute for a scheduled job: this Worker has no `scheduled`
-// handler / cron trigger, so expiry cleanup is triggered probabilistically on
-// the read path. Expired stories are already excluded from every read query
-// (the feed/single-story handlers filter on `endTime`), so the only impact of
-// a missed sweep is storage growth, not stale data leaking to users. The guard
-// below ensures at most one sweep runs at a time per isolate, so a burst of
-// feed requests cannot kick off several concurrent full-table delete sweeps.
+// The public Worker also exposes a scheduled retention handler. Keep this
+// probabilistic read-path pass as a self-hosting fallback for runtimes that do
+// not configure a cron trigger. Expired stories are already excluded from every
+// read query, so a missed sweep affects storage only. The guard below ensures
+// at most one fallback pass runs at a time per isolate.
 let expiredStoryCleanupInFlight = false;
 
 function maybeCleanupExpiredStories(

package/src/backend/runtime/cloudflare.ts

@@ -8,6 +8,8 @@ import type {
   D1Database,
   Fetcher,
   KVNamespace,
+  MessageBatch,
+  Queue,
   R2Bucket,
   R2Object,
 } from "@cloudflare/workers-types";
@@ -20,6 +22,13 @@ import type {
   ObjectMetadata,
   StorageObject,
 } from "./types.ts";
+import type {
+  IQueueBatch,
+  IQueueMessage,
+  IQueueProducer,
+  QueueBatchItem,
+  QueueSendOptions,
+} from "./queue.ts";
 
 /**
  * Cloudflare R2 Storage Adapter
@@ -170,6 +179,46 @@ class CloudflareAssets implements IStaticAssets {
   }
 }
 
+class CloudflareQueueProducer<T> implements IQueueProducer<T> {
+  constructor(private readonly queue: Queue<T>) {}
+
+  async send(body: T, options?: QueueSendOptions): Promise<void> {
+    await this.queue.send(body, options);
+  }
+
+  async sendBatch(
+    messages: readonly QueueBatchItem<T>[],
+    options?: QueueSendOptions,
+  ): Promise<void> {
+    await this.queue.sendBatch([...messages], options);
+  }
+}
+
+export function wrapCloudflareQueue<T>(queue: Queue<T>): IQueueProducer<T> {
+  return new CloudflareQueueProducer(queue);
+}
+
+export function wrapCloudflareMessageBatch<T>(
+  batch: MessageBatch<T>,
+): IQueueBatch<T> {
+  const messages: readonly IQueueMessage<T>[] = batch.messages.map(
+    (message) => ({
+      id: message.id,
+      timestamp: message.timestamp,
+      body: message.body,
+      attempts: message.attempts,
+      ack: () => message.ack(),
+      retry: (options) => message.retry(options),
+    }),
+  );
+  return {
+    queue: batch.queue,
+    messages,
+    ackAll: () => batch.ackAll(),
+    retryAll: (options) => batch.retryAll(options),
+  };
+}
+
 /**
  * Wrap a native Cloudflare Workers binding env into the app's runtime
  * `Env` shape. The Hono app and all helper functions speak the runtime
@@ -182,21 +231,33 @@ export function wrapCloudflareBindings<
     MEDIA?: R2Bucket;
     KV: KVNamespace;
     ASSETS?: Fetcher;
+    DELIVERY_QUEUE?: Queue<unknown>;
+    DELIVERY_DLQ?: Queue<unknown>;
   },
 >(
   bindings: T,
-): Omit<T, "DB" | "MEDIA" | "KV" | "ASSETS"> & {
+): Omit<
+  T,
+  "DB" | "MEDIA" | "KV" | "ASSETS" | "DELIVERY_QUEUE" | "DELIVERY_DLQ"
+> & {
   DB_INSTANCE: ReturnType<typeof getDb>;
   MEDIA?: IObjectStorage;
   KV: IKeyValueStore;
   ASSETS?: IStaticAssets;
+  DELIVERY_QUEUE?: IQueueProducer<unknown>;
+  DELIVERY_DLQ?: IQueueProducer<unknown>;
 } {
-  const { DB, MEDIA, KV, ASSETS, ...rest } = bindings;
+  const { DB, MEDIA, KV, ASSETS, DELIVERY_QUEUE, DELIVERY_DLQ, ...rest } =
+    bindings;
   return {
     ...rest,
     DB_INSTANCE: getDb(DB),
     MEDIA: MEDIA ? new CloudflareStorage(MEDIA) : undefined,
     KV: new CloudflareKV(KV),
     ASSETS: ASSETS ? new CloudflareAssets(ASSETS) : undefined,
+    DELIVERY_QUEUE: DELIVERY_QUEUE
+      ? wrapCloudflareQueue(DELIVERY_QUEUE)
+      : undefined,
+    DELIVERY_DLQ: DELIVERY_DLQ ? wrapCloudflareQueue(DELIVERY_DLQ) : undefined,
   };
 }

package/src/backend/runtime/managed-relational.ts

@@ -0,0 +1,197 @@
+import {
+  TAKOSUMI_MANAGED_RELATIONAL_RUNTIME_CONTRACT,
+  managedRelationalBatchGatewayRequest,
+  managedRelationalConnection,
+  parseManagedRelationalBatchResponse,
+  type ManagedRelationalMethod,
+  type ManagedRelationalParameter,
+} from "@takosjp/takosumi-contract/managed-relational-runtime";
+import { parseManagedRuntimeConnectionMaterialization } from "@takosjp/takosumi-contract/managed-runtime-connections";
+import {
+  drizzle as drizzleProxy,
+  type AsyncBatchRemoteCallback,
+  type AsyncRemoteCallback,
+} from "drizzle-orm/sqlite-proxy";
+
+import * as schema from "../../db/schema.ts";
+import { ManagedRuntimeGatewayError } from "./managed-runtime.ts";
+import type { ManagedRuntimeGateway } from "./managed-runtime.ts";
+
+const DEFAULT_MAX_RELATIONAL_RESPONSE_BYTES = 8 * 1024 * 1024;
+
+export interface ManagedRelationalDatabaseOptions {
+  readonly materialization: unknown;
+  readonly gateway: ManagedRuntimeGateway;
+  readonly alias: string;
+  readonly idempotencyKey?: () => string;
+  readonly maxResponseBytes?: number;
+}
+
+/**
+ * Provider-neutral Drizzle adapter for a host-issued RelationalDatabase.
+ *
+ * Every callback is one bounded prepared statement. Drizzle `batch()` maps to
+ * one ordered-atomic host call; transaction-control and migration SQL are
+ * deliberately unavailable on this request path.
+ */
+export function createManagedRelationalDatabase(
+  options: ManagedRelationalDatabaseOptions,
+) {
+  const materialization = parseManagedRuntimeConnectionMaterialization(
+    options.materialization,
+  );
+  const connection = managedRelationalConnection(
+    materialization,
+    options.alias,
+  );
+  const idempotencyKey =
+    options.idempotencyKey ??
+    (() => `yurucommu.relational:${crypto.randomUUID()}`);
+  const maxResponseBytes =
+    options.maxResponseBytes ?? DEFAULT_MAX_RELATIONAL_RESPONSE_BYTES;
+  if (
+    !Number.isSafeInteger(maxResponseBytes) ||
+    maxResponseBytes < 1 ||
+    maxResponseBytes > DEFAULT_MAX_RELATIONAL_RESPONSE_BYTES
+  ) {
+    throw new TypeError("managed_relational_response_limit_invalid");
+  }
+
+  const execute = async (
+    statements: readonly {
+      readonly sql: string;
+      readonly params: readonly unknown[];
+      readonly method: ManagedRelationalMethod;
+    }[],
+  ) => {
+    const canonical = statements.map((statement) => ({
+      sql: statement.sql,
+      params: statement.params.map(relationalParameter),
+      method: statement.method,
+    }));
+    const request = managedRelationalBatchGatewayRequest(connection.authority, {
+      statements: canonical,
+      idempotencyKey: idempotencyKey(),
+    });
+    const response = await boundedResponse(
+      await options.gateway.fetch(request),
+      maxResponseBytes,
+    );
+    if (!response.ok) {
+      const value = (await response.json().catch(() => undefined)) as unknown;
+      const code =
+        isRecord(value) && typeof value.error === "string"
+          ? value.error
+          : "managed_relational_request_failed";
+      throw new ManagedRuntimeGatewayError(
+        code,
+        response.status,
+        response.status === 429 || response.status >= 500,
+      );
+    }
+    const value = parseManagedRelationalBatchResponse(
+      await response.json(),
+      canonical.length,
+    );
+    return value.results;
+  };
+
+  const callback: AsyncRemoteCallback = async (sql, params, method) => {
+    const [result] = await execute([{ sql, params, method }]);
+    if (!result) throw new Error("managed_relational_result_missing");
+    return drizzleResult(result, method);
+  };
+  const batchCallback: AsyncBatchRemoteCallback = async (batch) => {
+    const results = await execute(batch);
+    return results.map((result, index) =>
+      drizzleResult(result, batch[index]!.method),
+    );
+  };
+
+  return drizzleProxy(callback, batchCallback, { schema });
+}
+
+function drizzleResult(
+  result: Awaited<
+    ReturnType<typeof parseManagedRelationalBatchResponse>
+  >["results"][number],
+  method: ManagedRelationalMethod,
+) {
+  return {
+    // sqlite-proxy exposes mutable `any[]` at this boundary even though the
+    // public runtime contract is intentionally immutable. Copy here so the
+    // provider-neutral contract never leaks a mutable result reference.
+    rows:
+      method === "get"
+        ? [...(result.rows[0] ?? [])]
+        : result.rows.map((row) => [...row]),
+    meta: result.meta,
+  };
+}
+
+function relationalParameter(value: unknown): ManagedRelationalParameter {
+  if (value === null || typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  throw new TypeError("managed_relational_parameter_unsupported");
+}
+
+async function boundedResponse(
+  response: Response,
+  maxBytes: number,
+): Promise<Response> {
+  const declaredLength = response.headers.get("content-length");
+  if (
+    declaredLength !== null &&
+    (!/^\d+$/u.test(declaredLength) || Number(declaredLength) > maxBytes)
+  ) {
+    throw new ManagedRuntimeGatewayError(
+      "managed_relational_response_too_large",
+      502,
+      false,
+    );
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    return new Response(null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+    });
+  }
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel("managed_relational_response_too_large");
+        throw new ManagedRuntimeGatewayError(
+          "managed_relational_response_too_large",
+          502,
+          false,
+        );
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}