@alteran/astro 0.3.9 → 0.5.2

package/src/lib/labeler.ts

@@ -6,38 +6,54 @@ export interface LabelerViewOptions {
   detailed?: boolean;
 }
 
+interface LabelerView {
+  uri: string;
+  cid: string;
+  creator: ReturnType<typeof buildProfileView>;
+  indexedAt: string;
+  likeCount: number;
+  viewer: Record<string, unknown>;
+  labels?: unknown;
+  policies?: { labelValues: unknown[]; labelValueDefinitions?: unknown[] };
+  reasonTypes?: unknown[];
+  subjectTypes?: unknown[];
+  subjectCollections?: unknown[];
+}
+
 const LABELER_COLLECTION = 'app.bsky.labeler.service';
 const LABELER_RKEY = 'self';
 
 export async function getLabelerServiceViews(
   env: Env,
   dids: string[],
-  options: LabelerViewOptions = {}
-) {
+  options: LabelerViewOptions = {},
+): Promise<LabelerView[]> {
   const detailed = options.detailed ?? false;
   const primaryActor = await getPrimaryActor(env);
 
   const unique = Array.from(new Set(dids.map((did) => did.trim()).filter(Boolean)));
-  const views: any[] = [];
+  const views: LabelerView[] = [];
 
   for (const did of unique) {
-    if (did !== primaryActor.did) continue; // Single-user PDS only has local labeler data
+    // Single-user PDS only has local labeler data.
+    if (did !== primaryActor.did) continue;
 
     const uri = `at://${did}/${LABELER_COLLECTION}/${LABELER_RKEY}`;
     const row = await getRecord(env, uri);
     if (!row || !row.json) continue;
 
-    let record: any;
+    let parsedRecord: Record<string, unknown>;
     try {
-      record = JSON.parse(row.json);
+      const parsed = JSON.parse(row.json);
+      if (typeof parsed !== 'object' || parsed === null) continue;
+      parsedRecord = parsed as Record<string, unknown>;
     } catch {
       continue;
     }
 
-    if (typeof record !== 'object' || record === null) continue;
-
-    const indexedAt = typeof record.createdAt === 'string' ? record.createdAt : new Date().toISOString();
-    const baseView: any = {
+    const indexedAt =
+      typeof parsedRecord.createdAt === 'string' ? parsedRecord.createdAt : new Date().toISOString();
+    const baseView: LabelerView = {
       uri,
       cid: row.cid,
       creator: buildProfileView(primaryActor),
@@ -47,17 +63,18 @@ export async function getLabelerServiceViews(
     };
 
     if (detailed) {
-      const policies = normalizePolicies(record.policies);
       views.push({
         ...baseView,
-        policies,
-        reasonTypes: Array.isArray(record.reasonTypes) ? record.reasonTypes : undefined,
-        subjectTypes: Array.isArray(record.subjectTypes) ? record.subjectTypes : undefined,
-        subjectCollections: Array.isArray(record.subjectCollections) ? record.subjectCollections : undefined,
-        labels: extractLabels(record.labels),
+        policies: normalizePolicies(parsedRecord.policies),
+        reasonTypes: Array.isArray(parsedRecord.reasonTypes) ? parsedRecord.reasonTypes : undefined,
+        subjectTypes: Array.isArray(parsedRecord.subjectTypes) ? parsedRecord.subjectTypes : undefined,
+        subjectCollections: Array.isArray(parsedRecord.subjectCollections)
+          ? parsedRecord.subjectCollections
+          : undefined,
+        labels: extractLabels(parsedRecord.labels),
       });
     } else {
-      const labels = extractLabels(record.labels);
+      const labels = extractLabels(parsedRecord.labels);
       if (labels) baseView.labels = labels;
       views.push(baseView);
     }
@@ -66,24 +83,20 @@ export async function getLabelerServiceViews(
   return views;
 }
 
-function normalizePolicies(input: any) {
-  if (input && typeof input === 'object') {
-    const labelValues = Array.isArray(input.labelValues) ? input.labelValues : [];
-    const labelValueDefinitions = Array.isArray(input.labelValueDefinitions)
-      ? input.labelValueDefinitions
-      : undefined;
+function normalizePolicies(input: unknown): LabelerView['policies'] {
+  if (input && typeof input === 'object' && !Array.isArray(input)) {
+    const policies = input as { labelValues?: unknown; labelValueDefinitions?: unknown };
     return {
-      labelValues,
-      labelValueDefinitions,
+      labelValues: Array.isArray(policies.labelValues) ? policies.labelValues : [],
+      labelValueDefinitions: Array.isArray(policies.labelValueDefinitions)
+        ? policies.labelValueDefinitions
+        : undefined,
     };
   }
-
-  return {
-    labelValues: [],
-  };
+  return { labelValues: [] };
 }
 
-function extractLabels(input: any) {
+function extractLabels(input: unknown): unknown {
   if (!input) return undefined;
   if (Array.isArray(input)) return input.length ? input : undefined;
   if (typeof input === 'object') return input;

package/src/lib/logger.ts

@@ -16,6 +16,10 @@ export interface LogContext {
   [key: string]: unknown;
 }
 
+// Logger is a class because the inherited-context + child(context) pattern
+// maps cleanly onto an immutable object whose state is exactly the
+// accumulated context. Each child() returns a new Logger so request-scoped
+// loggers don't leak fields back into the global instance.
 export class Logger {
   constructor(private context: LogContext = {}) {}
 

package/src/lib/mst/block-map.ts

@@ -0,0 +1,172 @@
+import { CID } from 'multiformats/cid';
+import * as uint8arrays from 'uint8arrays';
+import * as dagCbor from '@ipld/dag-cbor';
+import { cidForCbor } from './util';
+
+/**
+ * BlockMap - Efficient storage for IPLD blocks
+ * Maps CIDs to their encoded bytes
+ */
+export class BlockMap implements Iterable<[cid: CID, bytes: Uint8Array]> {
+  private map: Map<string, Uint8Array> = new Map();
+
+  constructor(entries?: Iterable<readonly [cid: CID, bytes: Uint8Array]>) {
+    if (entries) {
+      for (const [cid, bytes] of entries) {
+        this.set(cid, bytes);
+      }
+    }
+  }
+
+  /**
+   * Add a value to the map (encodes to CBOR and generates CID)
+   */
+  async add(value: unknown): Promise<CID> {
+    const bytes = dagCbor.encode(value);
+    const cid = await cidForCbor(value);
+    this.set(cid, bytes);
+    return cid;
+  }
+
+  /**
+   * Set a CID->bytes mapping
+   */
+  set(cid: CID, bytes: Uint8Array): BlockMap {
+    this.map.set(cid.toString(), bytes);
+    return this;
+  }
+
+  /**
+   * Get bytes for a CID
+   */
+  get(cid: CID): Uint8Array | undefined {
+    return this.map.get(cid.toString());
+  }
+
+  /**
+   * Delete a CID from the map
+   */
+  delete(cid: CID): BlockMap {
+    this.map.delete(cid.toString());
+    return this;
+  }
+
+  /**
+   * Get multiple CIDs, returning both found blocks and missing CIDs
+   */
+  getMany(cids: CID[]): { blocks: BlockMap; missing: CID[] } {
+    const missing: CID[] = [];
+    const blocks = new BlockMap();
+    for (const cid of cids) {
+      const got = this.map.get(cid.toString());
+      if (got) {
+        blocks.set(cid, got);
+      } else {
+        missing.push(cid);
+      }
+    }
+    return { blocks, missing };
+  }
+
+  /**
+   * Check if a CID exists in the map
+   */
+  has(cid: CID): boolean {
+    return this.map.has(cid.toString());
+  }
+
+  /**
+   * Clear all blocks
+   */
+  clear(): void {
+    this.map.clear();
+  }
+
+  /**
+   * Iterate over all blocks
+   */
+  forEach(cb: (bytes: Uint8Array, cid: CID) => void): void {
+    for (const [cid, bytes] of this) {
+      cb(bytes, cid);
+    }
+  }
+
+  /**
+   * Get all CIDs
+   */
+  cids(): CID[] {
+    return Array.from(this.keys());
+  }
+
+  /**
+   * Add all blocks from another BlockMap
+   */
+  addMap(toAdd: BlockMap): BlockMap {
+    for (const [cid, bytes] of toAdd) {
+      this.set(cid, bytes);
+    }
+    return this;
+  }
+
+  /**
+   * Number of blocks in the map
+   */
+  get size(): number {
+    return this.map.size;
+  }
+
+  /**
+   * Total byte size of all blocks
+   */
+  get byteSize(): number {
+    let size = 0;
+    for (const bytes of this.values()) {
+      size += bytes.length;
+    }
+    return size;
+  }
+
+  /**
+   * Check if two BlockMaps are equal
+   */
+  equals(other: BlockMap): boolean {
+    if (this.size !== other.size) {
+      return false;
+    }
+    for (const [cid, bytes] of this) {
+      const otherBytes = other.get(cid);
+      if (!otherBytes) return false;
+      if (!uint8arrays.equals(bytes, otherBytes)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Iterator for CIDs
+   */
+  *keys(): Generator<CID, void, unknown> {
+    for (const cidStr of this.map.keys()) {
+      yield CID.parse(cidStr);
+    }
+  }
+
+  /**
+   * Iterator for bytes
+   */
+  *values(): Generator<Uint8Array, void, unknown> {
+    for (const bytes of this.map.values()) {
+      yield bytes;
+    }
+  }
+
+  /**
+   * Iterator for [CID, bytes] entries
+   */
+  *[Symbol.iterator](): Generator<[CID, Uint8Array], void, unknown> {
+    for (const [cidStr, bytes] of this.map.entries()) {
+      yield [CID.parse(cidStr), bytes];
+    }
+  }
+}

package/src/lib/mst/blockstore.ts

@@ -1,4 +1,5 @@
 import { CID } from 'multiformats/cid';
+import { errorMessage } from '../errors';
 import * as dagCbor from '@ipld/dag-cbor';
 import type { Env } from '../../env';
 import { drizzle } from 'drizzle-orm/d1';
@@ -30,40 +31,54 @@ export class D1Blockstore implements WritableBlockstore {
   constructor(private env: Env) {}
 
   async get(cid: CID): Promise<Uint8Array | null> {
-    const db = drizzle(this.env.DB);
-    const result = await db
-      .select()
-      .from(blockstore)
-      .where(eq(blockstore.cid, cid.toString()))
-      .get();
-
-    if (!result || !result.bytes) return null;
-
-    // Decode base64 string to Uint8Array
-    return Uint8Array.from(atob(result.bytes), c => c.charCodeAt(0));
+    const row = await this.env.DB.prepare(
+      `SELECT bytes FROM blockstore WHERE cid = ? LIMIT 1`
+    ).bind(cid.toString()).first();
+
+    if (!row) return null;
+    const base64 = (row as any).bytes as string | null | undefined;
+    if (!base64 || base64.length === 0) return null;
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
   }
 
   async has(cid: CID): Promise<boolean> {
-    const db = drizzle(this.env.DB);
-    const result = await db
-      .select({ cid: blockstore.cid })
-      .from(blockstore)
-      .where(eq(blockstore.cid, cid.toString()))
-      .get();
-
-    return result !== null;
+    // Treat rows with NULL or empty bytes as missing
+    const row = await this.env.DB.prepare(
+      `SELECT bytes FROM blockstore WHERE cid = ? LIMIT 1`
+    ).bind(cid.toString()).first();
+
+    if (!row) return false;
+    const bytes = (row as any).bytes as string | null | undefined;
+    return typeof bytes === 'string' && bytes.length > 0;
   }
 
   async getMany(cids: CID[]): Promise<{ blocks: Map<string, Uint8Array>; missing: CID[] }> {
     const blocks = new Map<string, Uint8Array>();
     const missing: CID[] = [];
 
-    for (const cid of cids) {
-      const bytes = await this.get(cid);
-      if (bytes) {
-        blocks.set(cid.toString(), bytes);
-      } else {
-        missing.push(cid);
+    if (cids.length === 0) return { blocks, missing };
+
+    // Fetch in chunks using a single IN-clause per chunk.
+    // Cloudflare D1 can error with "too many SQL variables" on large IN lists,
+    // so keep this conservatively small.
+    const BATCH = 50;
+    for (let i = 0; i < cids.length; i += BATCH) {
+      const chunk = cids.slice(i, i + BATCH);
+      const placeholders = new Array(chunk.length).fill('?').join(',');
+      const stmt = this.env.DB.prepare(`SELECT cid, bytes FROM blockstore WHERE cid IN (${placeholders})`);
+      const binds = chunk.map((c) => c.toString());
+      const response = await stmt.bind(...binds).all();
+      const rows = (response.results ?? []) as Array<{ cid: string; bytes: string }>;
+      const got = new Set<string>();
+      for (const row of rows) {
+        got.add(row.cid);
+        if (row.bytes && row.bytes.length > 0) {
+          const u8 = Uint8Array.from(atob(row.bytes), (c) => c.charCodeAt(0));
+          blocks.set(row.cid, u8);
+        }
+      }
+      for (const c of chunk) {
+        if (!got.has(c.toString())) missing.push(c);
       }
     }
 
@@ -71,21 +86,7 @@ export class D1Blockstore implements WritableBlockstore {
   }
 
   async put(cid: CID, bytes: Uint8Array): Promise<void> {
-    const db = drizzle(this.env.DB);
     const cidStr = cid.toString();
-
-    // Check if block already exists - D1 has issues with ON CONFLICT DO NOTHING
-    const existing = await db
-      .select({ cid: blockstore.cid })
-      .from(blockstore)
-      .where(eq(blockstore.cid, cidStr))
-      .get();
-
-    if (existing) {
-      // Block already exists, skip insert
-      return;
-    }
-
     // Encode Uint8Array to base64 string for storage. Chunk to avoid call-stack limits.
     let binary = '';
     const CHUNK_SIZE = 0x8000;
@@ -94,84 +95,44 @@ export class D1Blockstore implements WritableBlockstore {
     }
     const base64 = btoa(binary);
 
+    // Always upsert: replace rows with NULL/empty bytes
     try {
-      await db
-        .insert(blockstore)
-        .values({
-          cid: cidStr,
-          bytes: base64,
-        })
-        .run();
-    } catch (error: any) {
-      // If we get a unique constraint error, another request inserted it - that's ok
-      if (error?.message?.includes('UNIQUE constraint failed') ||
-          error?.message?.includes('constraint failed')) {
-        return;
-      }
+      await this.env.DB.prepare(
+        `INSERT OR REPLACE INTO blockstore (cid, bytes) VALUES (?, ?)`
+      ).bind(cidStr, base64).run();
+    } catch (error) {
       console.error(JSON.stringify({
         level: 'error',
         type: 'blockstore_put',
         cid: cidStr,
         size: bytes.byteLength,
-        message: error?.message,
+        message: errorMessage(error),
       }));
       throw error;
     }
   }
 
   async putMany(blocks: Map<CID, Uint8Array>): Promise<void> {
-    const db = drizzle(this.env.DB);
-    const BATCH_SIZE = 100; // Insert 100 blocks at a time
+    const BATCH_SIZE = 100;
     const entries = Array.from(blocks.entries());
-
     for (let i = 0; i < entries.length; i += BATCH_SIZE) {
       const batch = entries.slice(i, i + BATCH_SIZE);
-      const values = [];
-
+      const stmts = [] as Array<ReturnType<typeof this.env.DB['prepare']>>;
       for (const [cid, bytes] of batch) {
         const cidStr = cid.toString();
-
-        // Check if block already exists
-        const existing = await db
-          .select({ cid: blockstore.cid })
-          .from(blockstore)
-          .where(eq(blockstore.cid, cidStr))
-          .get();
-
-        if (existing) continue;
-
-        // Encode to base64
         let binary = '';
         const CHUNK_SIZE = 0x8000;
         for (let j = 0; j < bytes.length; j += CHUNK_SIZE) {
           binary += String.fromCharCode(...bytes.subarray(j, j + CHUNK_SIZE));
         }
         const base64 = btoa(binary);
-
-        values.push({ cid: cidStr, bytes: base64 });
+        stmts.push(
+          this.env.DB.prepare(`INSERT OR REPLACE INTO blockstore (cid, bytes) VALUES (?, ?)`)
+            .bind(cidStr, base64)
+        );
       }
-
-      if (values.length > 0) {
-        try {
-          await db.insert(blockstore).values(values).run();
-        } catch (error: any) {
-          // If batch insert fails, fall back to individual inserts
-          for (const value of values) {
-            try {
-              await db.insert(blockstore).values(value).run();
-            } catch (e: any) {
-              if (!e?.message?.includes('UNIQUE constraint failed') &&
-                  !e?.message?.includes('constraint failed')) {
-                console.error(JSON.stringify({
-                  level: 'error',
-                  type: 'blockstore_put_many',
-                  cid: value.cid,
-                  message: e?.message,
-                }));
-              }
-            }
-          }
-        }
+      if (stmts.length > 0) {
+        await this.env.DB.batch(stmts);
       }
     }
   }
@@ -182,6 +143,8 @@ export class D1Blockstore implements WritableBlockstore {
   async readObj<T>(cid: CID): Promise<T> {
     const bytes = await this.get(cid);
     if (!bytes) {
+      console.error('[Blockstore] Block not found:', cid.toString());
+      console.error('[Blockstore] Stack trace:', new Error().stack);
       throw new Error(`Block not found: ${cid.toString()}`);
     }
     return dagCbor.decode(bytes) as T;

package/src/lib/mst/index.ts

@@ -1,3 +1,4 @@
 export { MST, Leaf, type NodeData, type TreeEntry, type NodeEntry, type MstOpts } from './mst';
 export { D1Blockstore, type ReadableBlockstore, type WritableBlockstore } from './blockstore';
+export { BlockMap } from './block-map';
 export * as util from './util';

package/src/lib/mst/leaf.ts

@@ -0,0 +1,25 @@
+import type { CID } from 'multiformats/cid';
+import type { MST } from './mst';
+import type { NodeEntry } from './types';
+
+export class Leaf {
+  constructor(
+    public key: string,
+    public value: CID,
+  ) {}
+
+  isTree(): this is MST {
+    return false;
+  }
+
+  isLeaf(): this is Leaf {
+    return true;
+  }
+
+  equals(entry: NodeEntry): boolean {
+    if (entry.isLeaf()) {
+      return this.key === entry.key && this.value.equals(entry.value);
+    }
+    return false;
+  }
+}