@alteran/astro 0.3.9 → 0.5.2

package/src/services/repo-manager.ts

@@ -1,248 +1,295 @@
 import { CID } from 'multiformats/cid';
 import type { Env } from '../env';
-import { MST, D1Blockstore, Leaf } from '../lib/mst';
+import { MST, D1Blockstore, type BlockMap } from '../lib/mst';
 import { drizzle } from 'drizzle-orm/d1';
 import { repo_root } from '../db/schema';
 import { eq, sql } from 'drizzle-orm';
 import type { RepoOp } from '../lib/firehose/frames';
-import * as dagCbor from '@ipld/dag-cbor';
-import { cidForCbor } from '../lib/mst/util';
 import { putRecord as dalPutRecord, deleteRecord as dalDeleteRecord } from '../db/dal';
 import { bumpRoot } from '../db/repo';
 import { generateTid } from '../lib/commit';
 import { resolveSecret } from '../lib/secrets';
+import { storeRecord, storeMstBlocks } from './repo/blockstore-ops';
+import { extractOps as extractOpsImpl } from './repo/operations';
+import { ServerMisconfigured } from '../lib/errors';
+
+interface RecordMutation {
+  mst: MST;
+  recordCid: CID;
+  prevMstRoot: CID | null;
+  newMstBlocks: BlockMap;
+}
+
+interface CommitResult {
+  uri: string;
+  cid: string;
+  commitCid: string;
+  rev: string;
+  ops: RepoOp[];
+  commitData: string;
+  sig: string;
+  blocks: string;
+}
 
-/**
- * Repository Manager
- * Manages MST-based repository operations
- */
 export class RepoManager {
   private blockstore: D1Blockstore;
-  private did: string;
 
   constructor(private env: Env) {
     this.blockstore = new D1Blockstore(env);
-    // Note: this.did will be set asynchronously, but it's only used in async methods
-    this.did = 'did:example:single-user'; // Default, will be resolved in async methods
   }
 
   private async getDid(): Promise<string> {
-    return (await resolveSecret(this.env.PDS_DID)) ?? 'did:example:single-user';
+    const did = await resolveSecret(this.env.PDS_DID);
+    if (!did) throw new ServerMisconfigured('PDS_DID is required');
+    return did;
   }
 
-  /**
-   * Get the current MST root
-   */
   async getRoot(): Promise<MST | null> {
-    const db = drizzle(this.env.DB);
-    const row = await db
-      .select()
-      .from(repo_root)
-      .where(eq(repo_root.did, this.did))
-      .get();
+    try {
+      const db = drizzle(this.env.DB);
+      const did = await this.getDid();
+
+      const rows = await db
+        .select()
+        .from(repo_root)
+        .where(eq(repo_root.did, did))
+        .limit(1);
+
+      const row = rows[0];
+      if (!row) return null;
+
+      const commit = await this.env.DB.prepare(
+        `SELECT data FROM commit_log WHERE cid = ? LIMIT 1`,
+      )
+        .bind(row.commitCid)
+        .first();
+
+      if (!commit) {
+        console.error(`[RepoManager] No commit found for CID: ${row.commitCid}`);
+        return null;
+      }
 
-    if (!row || !row.commitCid) return null;
+      const parsed = JSON.parse(String(commit.data));
+      const mstRoot = CID.parse(String(parsed.data));
 
-    try {
-      const rootCid = CID.parse(row.commitCid);
-      return MST.load(this.blockstore, rootCid);
-    } catch {
+      console.log(
+        `[RepoManager] Loading MST root: ${mstRoot.toString()} from commit: ${row.commitCid}`,
+      );
+
+      return MST.load(this.blockstore, mstRoot);
+    } catch (error) {
+      console.error('[RepoManager] Error in getRoot:', error);
       return null;
     }
   }
 
-  /**
-   * Get or create the MST root
-   */
   async getOrCreateRoot(): Promise<MST> {
     const existing = await this.getRoot();
-    if (existing) return existing;
+    if (existing) {
+      const pointer = await existing.getPointer();
+      console.log(`[RepoManager] Loaded existing MST root: ${pointer.toString()}`);
+      return existing;
+    }
 
-    // Create new empty MST
+    console.log('[RepoManager] Creating new empty MST');
     const mst = await MST.create(this.blockstore, []);
+    await storeMstBlocks(this.blockstore, mst);
+    const pointer = await mst.getPointer();
+    console.log(`[RepoManager] Created new MST root: ${pointer.toString()}`);
     return mst;
   }
 
-  /**
-   * Add a record to the repository
-   */
-  async addRecord(collection: string, rkey: string, record: unknown): Promise<{
-    mst: MST;
-    recordCid: CID;
-    prevMstRoot: CID | null;
-  }> {
+  async addRecord(
+    collection: string,
+    rkey: string,
+    record: unknown,
+  ): Promise<RecordMutation> {
     const key = `${collection}/${rkey}`;
-
-    // Get previous MST root for op extraction
     const currentMst = await this.getOrCreateRoot();
     const prevMstRoot = await currentMst.getPointer();
-
-    // Encode record and store in blockstore
-    const recordCid = await this.storeRecord(record);
-
-    // Add the new record
+    const recordCid = await storeRecord(this.blockstore, record);
     const newMst = await currentMst.add(key, recordCid);
-
-    // Store all new MST blocks
-    await this.storeMstBlocks(newMst);
-
-    return { mst: newMst, recordCid, prevMstRoot };
+    const newMstBlocks = await storeMstBlocks(this.blockstore, newMst);
+    return { mst: newMst, recordCid, prevMstRoot, newMstBlocks };
   }
 
-  /**
-   * High-level helper: create record, persist JSON, bump root, return commit info
-   */
-  async createRecord(collection: string, record: unknown, rkey?: string): Promise<{
-    uri: string;
-    cid: string;
-    commitCid: string;
-    rev: string;
-    ops: RepoOp[];
-    commitData: string;
-    sig: string;
-    blocks: string;
-  }> {
+  async createRecord(
+    collection: string,
+    record: unknown,
+    rkey?: string,
+  ): Promise<CommitResult> {
     const key = rkey ?? generateTid();
-    const { mst, recordCid, prevMstRoot } = await this.addRecord(collection, key, record);
-
-    // Persist JSON to table for easy reads
-    const uri = `at://${this.did}/${collection}/${key}`;
-    await dalPutRecord(this.env, { uri, did: this.did, cid: recordCid.toString(), json: JSON.stringify(record) } as any);
+    const { mst, recordCid, prevMstRoot, newMstBlocks } = await this.addRecord(
+      collection,
+      key,
+      record,
+    );
 
-    // Update repo root with signed commit and extract ops
-    const { commitCid, rev, ops, commitData, sig, blocks } = await bumpRoot(this.env, prevMstRoot ?? undefined);
+    const did = await this.getDid();
+    const uri = `at://${did}/${collection}/${key}`;
+    await dalPutRecord(this.env, {
+      uri,
+      did,
+      cid: recordCid.toString(),
+      json: JSON.stringify(record),
+    });
+
+    const currentRoot = await mst.getPointer();
+    const { commitCid, rev, ops, commitData, sig, blocks } = await bumpRoot(
+      this.env,
+      prevMstRoot ?? undefined,
+      currentRoot,
+      { newMstBlocks: Array.from(newMstBlocks) },
+    );
 
     return { uri, cid: recordCid.toString(), commitCid, rev, ops, commitData, sig, blocks };
   }
 
-  /**
-   * Update a record in the repository
-   */
-  async updateRecord(collection: string, rkey: string, record: unknown): Promise<{
-    mst: MST;
-    recordCid: CID;
-    prevMstRoot: CID | null;
-  }> {
+  async updateRecord(
+    collection: string,
+    rkey: string,
+    record: unknown,
+  ): Promise<RecordMutation> {
     const key = `${collection}/${rkey}`;
-
-    // Get previous MST root for op extraction
     const currentMst = await this.getOrCreateRoot();
     const prevMstRoot = await currentMst.getPointer();
-
-    // Encode record and store in blockstore
-    const recordCid = await this.storeRecord(record);
-
-    // Update the record
+    const recordCid = await storeRecord(this.blockstore, record);
     const newMst = await currentMst.update(key, recordCid);
-
-    // Store all new MST blocks
-    await this.storeMstBlocks(newMst);
-
-    return { mst: newMst, recordCid, prevMstRoot };
+    const newMstBlocks = await storeMstBlocks(this.blockstore, newMst);
+    return { mst: newMst, recordCid, prevMstRoot, newMstBlocks };
   }
 
-  /**
-   * High-level helper: put record (update), persist JSON, bump root
-   */
-  async putRecord(collection: string, rkey: string, record: unknown): Promise<{
-    uri: string;
-    cid: string;
-    commitCid: string;
-    rev: string;
-    ops: RepoOp[];
-    commitData: string;
-    sig: string;
-    blocks: string;
-  }> {
-    const { mst, recordCid, prevMstRoot } = await this.updateRecord(collection, rkey, record);
-    const uri = `at://${this.did}/${collection}/${rkey}`;
-    await dalPutRecord(this.env, { uri, did: this.did, cid: recordCid.toString(), json: JSON.stringify(record) } as any);
-    const { commitCid, rev, ops, commitData, sig, blocks } = await bumpRoot(this.env, prevMstRoot ?? undefined);
+  async putRecord(collection: string, rkey: string, record: unknown): Promise<CommitResult> {
+    const { mst, recordCid, prevMstRoot, newMstBlocks } = await this.updateRecord(
+      collection,
+      rkey,
+      record,
+    );
+    const did = await this.getDid();
+    const uri = `at://${did}/${collection}/${rkey}`;
+    await dalPutRecord(this.env, {
+      uri,
+      did,
+      cid: recordCid.toString(),
+      json: JSON.stringify(record),
+    });
+    const currentRoot = await mst.getPointer();
+    const { commitCid, rev, ops, commitData, sig, blocks } = await bumpRoot(
+      this.env,
+      prevMstRoot ?? undefined,
+      currentRoot,
+      { newMstBlocks: Array.from(newMstBlocks) },
+    );
     return { uri, cid: recordCid.toString(), commitCid, rev, ops, commitData, sig, blocks };
   }
 
-  /**
-   * Delete a record from the repository
-   */
-  async deleteRecord(collection: string, rkey: string): Promise<{
-    uri: string;
-    commitCid: string;
-    rev: string;
-    ops: RepoOp[];
-    commitData: string;
-    sig: string;
-    blocks: string;
-  }> {
+  async deleteRecord(
+    collection: string,
+    rkey: string,
+  ): Promise<{ mst: MST; prevMstRoot: CID | null; uri: string; newMstBlocks: BlockMap }> {
     const key = `${collection}/${rkey}`;
-
-    // Get previous MST root for op extraction
     const currentMst = await this.getOrCreateRoot();
     const prevMstRoot = await currentMst.getPointer();
-
-    // Delete the record
     const newMst = await currentMst.delete(key);
+    const newMstBlocks = await storeMstBlocks(this.blockstore, newMst);
 
-    // Store all new MST blocks
-    await this.storeMstBlocks(newMst);
-
-    // Delete from records table
-    const uri = `at://${this.did}/${collection}/${rkey}`;
+    const did = await this.getDid();
+    const uri = `at://${did}/${collection}/${rkey}`;
     await dalDeleteRecord(this.env, uri);
 
-    const { commitCid, rev, ops, commitData, sig, blocks } = await bumpRoot(this.env, prevMstRoot ?? undefined);
-    return { uri, commitCid, rev, ops, commitData, sig, blocks };
+    return { mst: newMst, prevMstRoot, uri, newMstBlocks };
   }
 
-  /**
-   * Get a record from the repository
-   */
   async getRecord(collection: string, rkey: string): Promise<unknown | null> {
     const key = `${collection}/${rkey}`;
-
     const currentMst = await this.getRoot();
-    if (!currentMst) return null;
+    if (!currentMst) return this.getRecordFromTable(collection, rkey);
 
     const recordCid = await currentMst.get(key);
-    if (!recordCid) return null;
+    if (!recordCid) return this.getRecordFromTable(collection, rkey);
 
     return this.blockstore.readObj(recordCid);
   }
 
-  /**
-   * List records in a collection
-   */
-  async listRecords(collection: string, limit = 50, cursor?: string): Promise<{ key: string; cid: CID }[]> {
+  private async getRecordFromTable(collection: string, rkey: string): Promise<unknown | null> {
+    const did = await this.getDid();
+    const uri = `at://${did}/${collection}/${rkey}`;
+
+    const result = await this.env.DB.prepare(`SELECT json FROM record WHERE uri = ?`)
+      .bind(uri)
+      .first();
+
+    if (!result) return null;
+    try {
+      return JSON.parse(result.json as string);
+    } catch (parseError) {
+      console.warn('[RepoManager] Failed to parse record JSON:', parseError);
+      return null;
+    }
+  }
+
+  async listRecords(
+    collection: string,
+    limit = 50,
+    cursor?: string,
+  ): Promise<{ key: string; cid: CID }[]> {
     const currentMst = await this.getRoot();
-    if (!currentMst) return [];
+    if (!currentMst) return this.listRecordsFromTable(collection, limit, cursor);
 
     const prefix = `${collection}/`;
     const leaves = await currentMst.listWithPrefix(prefix, limit);
 
-    return leaves
-      .filter(leaf => !cursor || leaf.key > `${collection}/${cursor}`)
-      .map(leaf => ({
+    const results = leaves
+      .filter((leaf) => !cursor || leaf.key > `${collection}/${cursor}`)
+      .map((leaf) => ({
         key: leaf.key.replace(prefix, ''),
         cid: leaf.value,
       }));
+
+    if (results.length === 0) return this.listRecordsFromTable(collection, limit, cursor);
+    return results;
+  }
+
+  private async listRecordsFromTable(
+    collection: string,
+    limit = 50,
+    cursor?: string,
+  ): Promise<{ key: string; cid: CID }[]> {
+    const did = await this.getDid();
+    const prefix = `at://${did}/${collection}/`;
+
+    // D1's LIKE planner is flaky on long prefixes; use a >= / < range instead.
+    // URIs sort lexicographically so this scans only the collection's slice.
+    const rangeEnd =
+      prefix.slice(0, -1) +
+      String.fromCharCode(prefix.charCodeAt(prefix.length - 1) + 1);
+
+    const stmt = cursor
+      ? this.env.DB.prepare(
+          `SELECT uri, cid FROM record WHERE uri >= ? AND uri < ? AND uri > ? ORDER BY uri LIMIT ?`,
+        ).bind(prefix, rangeEnd, prefix + cursor, limit)
+      : this.env.DB.prepare(
+          `SELECT uri, cid FROM record WHERE uri >= ? AND uri < ? ORDER BY uri LIMIT ?`,
+        ).bind(prefix, rangeEnd, limit);
+
+    const result = await stmt.all();
+    const rows = result.results as Array<{ uri: string; cid: string }>;
+
+    return rows.map((row) => ({
+      key: row.uri.replace(prefix, ''),
+      cid: CID.parse(row.cid),
+    }));
   }
 
-  /**
-   * Update the repo root to point to the new MST
-   */
   async updateRoot(mst: MST, rev: number): Promise<void> {
     const db = drizzle(this.env.DB);
     const rootCid = await mst.getPointer();
     const did = await this.getDid();
     const revStr = String(rev);
 
-    // Use sql.raw with excluded to properly reference INSERT values
     await db
       .insert(repo_root)
-      .values({
-        did,
-        commitCid: rootCid.toString(),
-        rev: revStr,
-      })
+      .values({ did, commitCid: rootCid.toString(), rev: revStr })
       .onConflictDoUpdate({
         target: repo_root.did,
         set: {
@@ -253,105 +300,7 @@ export class RepoManager {
       .run();
   }
 
-  /**
-   * Extract operations from MST diff between two commits
-   * Compares old MST root with new MST root to identify create/update/delete operations
-   */
-  async extractOps(prevRoot: CID | null, newRoot: CID): Promise<RepoOp[]> {
-    const ops: RepoOp[] = [];
-
-    // Load both trees
-    const newMst = await MST.load(this.blockstore, newRoot).getEntries();
-    const prevMst = prevRoot ? await MST.load(this.blockstore, prevRoot).getEntries() : [];
-
-    // Build maps for efficient lookup
-    const prevMap = new Map<string, CID>();
-    const newMap = new Map<string, CID>();
-
-    // Collect all leaves from previous tree
-    await this.collectLeaves(prevMst, prevMap);
-
-    // Collect all leaves from new tree
-    await this.collectLeaves(newMst, newMap);
-
-    // Find creates and updates
-    for (const [path, cid] of Array.from(newMap.entries())) {
-      const prevCid = prevMap.get(path);
-      if (!prevCid) {
-        // New key - create operation
-        ops.push({
-          action: 'create',
-          path,
-          cid,
-        });
-      } else if (!prevCid.equals(cid)) {
-        // Key exists but CID changed - update operation
-        ops.push({
-          action: 'update',
-          path,
-          cid,
-          prev: prevCid,
-        });
-      }
-    }
-
-    // Find deletes
-    for (const [path, prevCid] of Array.from(prevMap.entries())) {
-      if (!newMap.has(path)) {
-        // Key no longer exists - delete operation
-        ops.push({
-          action: 'delete',
-          path,
-          cid: null,
-          prev: prevCid,
-        });
-      }
-    }
-
-    // Sort ops by path for deterministic ordering
-    ops.sort((a, b) => a.path.localeCompare(b.path));
-
-    return ops;
-  }
-
-  /**
-   * Recursively collect all leaves from MST entries into a map
-   */
-  private async collectLeaves(entries: (MST | Leaf)[], map: Map<string, CID>): Promise<void> {
-    for (const entry of entries) {
-      if (entry.isLeaf()) {
-        map.set(entry.key, entry.value);
-      } else {
-        // Recursively collect from subtree
-        const subEntries = await entry.getEntries();
-        await this.collectLeaves(subEntries, map);
-      }
-    }
-  }
-
-  /**
-   * Store a record in the blockstore and return its CID
-   */
-  private async storeRecord(record: unknown): Promise<CID> {
-    const bytes = dagCbor.encode(record);
-    const cid = await cidForCbor(record);
-    await this.blockstore.put(cid, bytes);
-    return cid;
-  }
-
-  /**
-   * Store all blocks from an MST to the blockstore
-   */
-  private async storeMstBlocks(mst: MST): Promise<void> {
-    const { cid, bytes } = await mst.serialize();
-    await this.blockstore.put(cid, bytes);
-
-    // Recursively store child blocks
-    const entries = await mst.getEntries();
-    for (const entry of entries) {
-      if (entry.isTree()) {
-        await this.storeMstBlocks(entry);
-      }
-    }
+  extractOps(prevRoot: CID | null, newRoot: CID): Promise<RepoOp[]> {
+    return extractOpsImpl(this.blockstore, prevRoot, newRoot);
   }
 }

package/src/worker/runtime.ts

@@ -75,7 +75,7 @@ export function createPdsFetchHandler(options?: CreatePdsFetchHandlerOptions): P
       return new Response(null, { status: 204, headers }) as unknown as WorkersResponse;
     }
 
-    await seed(resolvedEnv.DB, (resolvedEnv.PDS_DID as string | undefined) ?? 'did:example:single-user');
+    await seed(resolvedEnv.DB, resolvedEnv.PDS_DID as string);
 
     // Fire-and-forget: let relays know this PDS exists and is reachable.
     // Throttled per isolate and safe to call frequently.
@@ -89,15 +89,46 @@ export function createPdsFetchHandler(options?: CreatePdsFetchHandlerOptions): P
       if (!isRelayPath) {
         ctx.waitUntil(notifyRelaysIfNeeded(resolvedEnv as any, request.url));
       }
-    } catch (err) {
+    } catch (error) {
       // Never block on relay notification
     }
 
     const url = new URL(request.url);
+
+    // Lightweight debug endpoint for Sequencer metrics
+    if (url.pathname === '/debug/sequencer' && request.method === 'GET') {
+      try {
+        if (!('SEQUENCER' in resolvedEnv) || !resolvedEnv.SEQUENCER) {
+          return new Response('Sequencer not configured', { status: 503 }) as unknown as WorkersResponse;
+        }
+        const id = (resolvedEnv as any).SEQUENCER.idFromName('default');
+        const stub = (resolvedEnv as any).SEQUENCER.get(id);
+        const proxyRequest = new Request(new URL('/metrics', request.url).toString(), { method: 'GET' });
+        const response = await stub.fetch(proxyRequest as any);
+        // Pass through JSON
+        const headers = new Headers(response.headers);
+        headers.set('Content-Type', 'application/json');
+        return new Response(await response.text(), { status: response.status, headers }) as unknown as WorkersResponse;
+      } catch (error) {
+        return new Response(JSON.stringify({ error: 'InternalError', message: 'Failed to fetch sequencer metrics' }), { status: 500, headers: { 'Content-Type': 'application/json' } }) as unknown as WorkersResponse;
+      }
+    }
     if (url.pathname === '/xrpc/com.atproto.sync.subscribeRepos') {
       const upgrade = request.headers.get('upgrade');
       if (upgrade !== 'websocket') {
-        return new Response('Expected websocket', { status: 426 }) as unknown as WorkersResponse;
+        try {
+          console.log(JSON.stringify({
+            level: 'warn',
+            type: 'ws_expected',
+            path: url.pathname,
+            method: request.method,
+            message: 'subscribeRepos requires WebSocket upgrade',
+            timestamp: new Date().toISOString(),
+          }));
+        } catch {
+          // Logging-only path; never block the response on log serialization.
+        }
+        return new Response('This endpoint requires a WebSocket (wss://) upgrade', { status: 426 }) as unknown as WorkersResponse;
       }
       if (!resolvedEnv.SEQUENCER) {
         return new Response('Sequencer not configured', { status: 503 }) as unknown as WorkersResponse;
@@ -123,9 +154,21 @@ type AstroFetchHandler = (
 let cachedFetchPromise: Promise<AstroFetchHandler> | undefined;
 
 async function loadAstroFetchFromManifest(manifest: SSRManifest): Promise<AstroFetchHandler> {
-  const { createExports } = await import('@astrojs/cloudflare/entrypoints/server.js');
-  const exports = createExports(manifest);
-  return exports.default.fetch as unknown as AstroFetchHandler;
+  const { App } = await import('astro/app');
+  const { handle } = await import('@astrojs/cloudflare/handler');
+  const app = new App(manifest);
+  return async (
+    request: WorkersRequest,
+    env: Env,
+    ctx: ExecutionContext,
+  ) =>
+    (await handle(
+      manifest,
+      app,
+      request as any,
+      env as any,
+      ctx as any,
+    )) as unknown as WorkersResponse;
 }
 
 async function getAstroFetch(options?: CreatePdsFetchHandlerOptions): Promise<AstroFetchHandler> {
@@ -135,8 +178,10 @@ async function getAstroFetch(options?: CreatePdsFetchHandlerOptions): Promise<As
 
   if (!cachedFetchPromise) {
     cachedFetchPromise = (async () => {
-      const { manifest } = await import('@astrojs-manifest');
-      return loadAstroFetchFromManifest(manifest as SSRManifest);
+      const moduleSpecifier = '@astrojs-manifest';
+      const mod = await import(/* @vite-ignore */ moduleSpecifier);
+      const manifest = (mod as any).manifest as SSRManifest;
+      return loadAstroFetchFromManifest(manifest);
     })();
   }