@hatk/hatk 0.0.1-alpha.40 → 0.0.1-alpha.42

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { mkdirSync, writeFileSync, existsSync, unlinkSync, readdirSync, readFileSync } from 'node:fs';
+import { mkdirSync, writeFileSync, existsSync, unlinkSync, readdirSync, readFileSync, cpSync } from 'node:fs';
 import { resolve, join, dirname } from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { loadLexicons, discoverCollections, buildSchemas } from "./database/schema.js";
@@ -108,148 +108,16 @@ function usage() {
 if (!command)
     usage();
 // --- Templates ---
-const templates = {
-    feed: (name) => `import { defineFeed } from '../hatk.generated.ts'
-
-export default defineFeed({
-  collection: 'your.collection.here',
-  label: '${name.charAt(0).toUpperCase() + name.slice(1)}',
-
-  async generate(ctx) {
-    const { rows, cursor } = await ctx.paginate<{ uri: string }>(
-      \`SELECT uri, cid, indexed_at FROM "your.collection.here"\`,
-    )
-
-    return ctx.ok({ uris: rows.map((r) => r.uri), cursor })
-  },
-})
-`,
-    xrpc: (name) => `import { defineQuery } from '../hatk.generated.ts'
-
-export default defineQuery('${name}', async (ctx) => {
-  const { ok, db, params, packCursor, unpackCursor } = ctx
-  const limit = params.limit ?? 30
-  const cursor = params.cursor
-
-  const conditions: string[] = []
-  const sqlParams: (string | number)[] = []
-  let paramIdx = 1
-
-  if (cursor) {
-    const parsed = unpackCursor(cursor)
-    if (parsed) {
-      conditions.push(\`(s.indexed_at < $\${paramIdx} OR (s.indexed_at = $\${paramIdx + 1} AND s.cid < $\${paramIdx + 2}))\`)
-      sqlParams.push(parsed.primary, parsed.primary, parsed.cid)
-      paramIdx += 3
-    }
-  }
-
-  const where = conditions.length ? 'WHERE ' + conditions.join(' AND ') : ''
-
-  const rows = await db.query(
-    \`SELECT s.* FROM "your.collection.here" s \${where} ORDER BY s.indexed_at DESC, s.cid DESC LIMIT $\${paramIdx}\`,
-    sqlParams.concat([limit + 1]),
-  )
-
-  const hasMore = rows.length > limit
-  if (hasMore) rows.pop()
-  const lastRow = rows[rows.length - 1]
-
-  return ok({
-    items: rows,
-    cursor: hasMore && lastRow ? packCursor(lastRow.indexed_at, lastRow.cid) : undefined,
-  })
-})
-`,
-    label: (name) => `import type { LabelRuleContext } from '@hatk/hatk/labels'
-
-export default {
-  definition: {
-    identifier: '${name}',
-    severity: 'inform',
-    blurs: 'none',
-    defaultSetting: 'warn',
-    locales: [{ lang: 'en', name: '${name.charAt(0).toUpperCase() + name.slice(1)}', description: 'Description here' }],
-  },
-  async evaluate(ctx: LabelRuleContext) {
-    // Return array of label identifiers to apply, or empty array
-    return []
-  },
-}
-`,
-    og: (name) => `import type { OpengraphContext, OpengraphResult } from '@hatk/hatk/opengraph'
-
-export default {
-  path: '/og/${name}/:id',
-  async generate(ctx: OpengraphContext): Promise<OpengraphResult> {
-    const { db, params } = ctx
-    return {
-      element: {
-        type: 'div',
-        props: {
-          style: { display: 'flex', width: '100%', height: '100%', background: '#080b12', color: 'white', alignItems: 'center', justifyContent: 'center' },
-          children: params.id,
-        },
-      },
-    }
-  },
+const templateDir = join(import.meta.dirname, 'templates');
+function loadTemplate(file, name) {
+    const raw = readFileSync(join(templateDir, file), 'utf-8');
+    const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
+    return raw.replaceAll('{{name}}', name).replaceAll('{{Name}}', capitalized);
 }
-`,
-    hook: (name) => `import { defineHook } from '../hatk.generated.ts'
-
-export default defineHook('${name}', async (ctx) => {
-  // Hook logic here
-})
-`,
-    setup: (_name) => `import { defineSetup } from '../hatk.generated.ts'
-
-export default defineSetup(async (ctx) => {
-  // Setup logic here — runs before the server starts
-})
-`,
-};
-const testTemplates = {
-    feed: (name) => `import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-import { createTestContext } from '@hatk/hatk/test'
-
-let ctx: Awaited<ReturnType<typeof createTestContext>>
-
-beforeAll(async () => {
-  ctx = await createTestContext()
-  await ctx.loadFixtures()
-})
-
-afterAll(async () => ctx?.close())
-
-describe('${name} feed', () => {
-  test('returns results', async () => {
-    const feed = ctx.loadFeed('${name}')
-    const result = await feed.generate(ctx.feedContext({ limit: 10 }))
-    expect(result).toBeDefined()
-  })
-})
-`,
-    xrpc: (name) => `import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-import { createTestContext } from '@hatk/hatk/test'
-
-let ctx: Awaited<ReturnType<typeof createTestContext>>
-
-beforeAll(async () => {
-  ctx = await createTestContext()
-  await ctx.loadFixtures()
-})
-
-afterAll(async () => ctx?.close())
-
-describe('${name}', () => {
-  test('returns response', async () => {
-    const handler = ctx.loadXrpc('${name}')
-    const result = await handler.handler({ params: {} })
-    expect(result).toBeDefined()
-  })
-})
-`,
-};
+const templateTypes = ['feed', 'xrpc', 'label', 'og', 'hook', 'setup'];
+const testTemplateTypes = ['feed', 'xrpc'];
+const templates = Object.fromEntries(templateTypes.map((t) => [t, (name) => loadTemplate(`${t}.tpl`, name)]));
+const testTemplates = Object.fromEntries(testTemplateTypes.map((t) => [t, (name) => loadTemplate(`test-${t}.tpl`, name)]));
 const lexiconTemplates = {
     record: (nsid) => ({
         lexicon: 1,
@@ -402,415 +270,10 @@ export default defineConfig({
 <html><head><title>${name}</title></head>
 <body><h1>${name}</h1></body></html>
 `);
-    // Scaffold core framework lexicons under dev.hatk namespace
-    const coreLexDir = join(dir, 'lexicons', 'dev', 'hatk');
-    mkdirSync(coreLexDir, { recursive: true });
-    writeFileSync(join(coreLexDir, 'describeCollections.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.describeCollections',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List indexed collections and their schemas.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            collections: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['collection'],
-                                    properties: {
-                                        collection: { type: 'string' },
-                                        columns: {
-                                            type: 'array',
-                                            items: {
-                                                type: 'object',
-                                                required: ['name', 'originalName', 'type', 'required'],
-                                                properties: {
-                                                    name: { type: 'string' },
-                                                    originalName: { type: 'string' },
-                                                    type: { type: 'string' },
-                                                    required: { type: 'boolean' },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'describeFeeds.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.describeFeeds',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List available feeds.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            feeds: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['name', 'label'],
-                                    properties: {
-                                        name: { type: 'string' },
-                                        label: { type: 'string' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'describeLabels.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.describeLabels',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List available label definitions.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            definitions: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['identifier', 'severity', 'blurs', 'defaultSetting'],
-                                    properties: {
-                                        identifier: { type: 'string' },
-                                        severity: { type: 'string' },
-                                        blurs: { type: 'string' },
-                                        defaultSetting: { type: 'string' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'createRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.createRecord',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Create a record via the user's PDS.",
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['collection', 'repo', 'record'],
-                        properties: {
-                            collection: { type: 'string' },
-                            repo: { type: 'string', format: 'did' },
-                            record: { type: 'unknown' },
-                        },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            uri: { type: 'string', format: 'at-uri' },
-                            cid: { type: 'string', format: 'cid' },
-                            commit: {
-                                type: 'object',
-                                properties: {
-                                    cid: { type: 'string', format: 'cid' },
-                                    rev: { type: 'string' },
-                                },
-                            },
-                            validationStatus: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'deleteRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.deleteRecord',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Delete a record via the user's PDS.",
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['collection', 'rkey'],
-                        properties: {
-                            collection: { type: 'string' },
-                            rkey: { type: 'string' },
-                        },
-                    },
-                },
-                output: { encoding: 'application/json', schema: { type: 'object', properties: {} } },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'putRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.putRecord',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Create or update a record via the user's PDS.",
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['collection', 'rkey', 'record'],
-                        properties: {
-                            collection: { type: 'string' },
-                            rkey: { type: 'string' },
-                            record: { type: 'unknown' },
-                            repo: { type: 'string', format: 'did' },
-                        },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            uri: { type: 'string', format: 'at-uri' },
-                            cid: { type: 'string', format: 'cid' },
-                            commit: {
-                                type: 'object',
-                                properties: {
-                                    cid: { type: 'string', format: 'cid' },
-                                    rev: { type: 'string' },
-                                },
-                            },
-                            validationStatus: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'uploadBlob.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.uploadBlob',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Upload a blob via the user's PDS.",
-                input: {
-                    encoding: '*/*',
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['blob'],
-                        properties: {
-                            blob: { type: 'blob' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'getPreferences.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.getPreferences',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Get all preferences for the authenticated user.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            preferences: { type: 'unknown' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'putPreference.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.putPreference',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: 'Set a single preference by key.',
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['key', 'value'],
-                        properties: {
-                            key: { type: 'string' },
-                            value: { type: 'unknown' },
-                        },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'getFeed.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.getFeed',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Retrieve a named feed of items.',
-                parameters: {
-                    type: 'params',
-                    required: ['feed'],
-                    properties: {
-                        feed: { type: 'string', description: 'Feed name' },
-                        limit: { type: 'integer', minimum: 1, maximum: 100, default: 30 },
-                        cursor: { type: 'string' },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['items'],
-                        properties: {
-                            items: { type: 'array', items: { type: 'unknown' } },
-                            cursor: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'getRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.getRecord',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Fetch a single record by AT URI.',
-                parameters: {
-                    type: 'params',
-                    required: ['uri'],
-                    properties: {
-                        uri: { type: 'string', format: 'at-uri' },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            record: { type: 'unknown' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'getRecords.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.getRecords',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List records from a collection with optional filters.',
-                parameters: {
-                    type: 'params',
-                    required: ['collection'],
-                    properties: {
-                        collection: { type: 'string' },
-                        limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
-                        cursor: { type: 'string' },
-                        sort: { type: 'string' },
-                        order: { type: 'string' },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['items'],
-                        properties: {
-                            items: { type: 'array', items: { type: 'unknown' } },
-                            cursor: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'searchRecords.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.searchRecords',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Full-text search across a collection.',
-                parameters: {
-                    type: 'params',
-                    required: ['collection', 'q'],
-                    properties: {
-                        collection: { type: 'string' },
-                        q: { type: 'string', description: 'Search query' },
-                        limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
-                        cursor: { type: 'string' },
-                        fuzzy: { type: 'boolean', default: true },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['items'],
-                        properties: {
-                            items: { type: 'array', items: { type: 'unknown' } },
-                            cursor: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(dir, 'seeds', 'seed.ts'), `import { seed } from '../hatk.generated.ts'
-
-const { createAccount, createRecord } = seed()
-
-const alice = await createAccount('alice.test')
-
-// await createRecord(alice, 'your.collection.here', {
-//   field: 'value',
-// }, { rkey: 'my-record' })
-
-console.log('\\n[seed] Done!')
-`);
+    // Copy core framework lexicons (dev.hatk.* and dependencies like com.atproto.repo.strongRef)
+    const builtinLexDir = join(import.meta.dirname, 'lexicons');
+    cpSync(builtinLexDir, join(dir, 'lexicons'), { recursive: true });
+    writeFileSync(join(dir, 'seeds', 'seed.ts'), loadTemplate('seed.tpl', ''));
     writeFileSync(join(dir, 'docker-compose.yml'), `services:
   plc:
     build:
@@ -1603,7 +1066,7 @@ else if (command === 'generate') {
         if (procedureNsids.length > 0) {
             clientOut += `  if (_procedures.has(nsid)) {\n`;
             clientOut += `    const res = await _fetch(path, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(arg) })\n`;
-            clientOut += `    if (typeof window !== 'undefined' && res.status === 401) { const _h = getViewer()?.handle; window.location.href = _h ? \`/oauth/login?handle=\${encodeURIComponent(_h)}\` : '/oauth/login'; return new Promise(() => {}) as any }\n`;
+            clientOut += `    if (typeof window !== 'undefined' && res.status === 401) { const _b = await res.json().catch(() => ({})); const _h = _b.handle ?? getViewer()?.handle; window.location.href = _h ? \`/oauth/login?handle=\${encodeURIComponent(_h)}\` : '/oauth/login'; return new Promise(() => {}) as any }\n`;
             clientOut += `    if (!res.ok) throw new Error(\`XRPC \${nsid} failed: \${res.status}\`)\n`;
             clientOut += `    return res.json() as Promise<OutputOf<K>>\n`;
             clientOut += `  }\n`;
@@ -1615,7 +1078,7 @@ else if (command === 'generate') {
         clientOut += `  const qs = params.toString()\n`;
         clientOut += `  if (qs) path += \`?\${qs}\`\n`;
         clientOut += `  const res = await _fetch(path)\n`;
-        clientOut += `  if (typeof window !== 'undefined' && res.status === 401) { window.location.href = '/oauth/login'; return new Promise(() => {}) as any }\n`;
+        clientOut += `  if (typeof window !== 'undefined' && res.status === 401) { const _b = await res.json().catch(() => ({})); const _h = _b.handle ?? getViewer()?.handle; window.location.href = _h ? \`/oauth/login?handle=\${encodeURIComponent(_h)}\` : '/oauth/login'; return new Promise(() => {}) as any }\n`;
         clientOut += `  if (!res.ok) throw new Error(\`XRPC \${nsid} failed: \${res.status}\`)\n`;
         clientOut += `  return res.json() as Promise<OutputOf<K>>\n`;
         clientOut += `}\n`;

package/dist/database/adapters/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../../src/database/adapters/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAoBtE,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,EAAE,OAAO,CAAW;IAE3B,OAAO,CAAC,EAAE,CAAoB;IAExB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvC,KAAK,IAAI,IAAI;IAMP,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAMrF,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3D,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzB,kBAAkB,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAClE,OAAO,CAAC,YAAY,CAAC;CAmCzB"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../../src/database/adapters/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAqBtE,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,EAAE,OAAO,CAAW;IAE3B,OAAO,CAAC,EAAE,CAAoB;IAExB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvC,KAAK,IAAI,IAAI;IAMP,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAMrF,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3D,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzB,kBAAkB,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAClE,OAAO,CAAC,YAAY,CAAC;CAmCzB"}

package/dist/database/adapters/sqlite.js

@@ -10,7 +10,8 @@ function translateParams(sql, params) {
     const expandedParams = [];
     const translated = sql.replace(/\$(\d+)/g, (_match, numStr) => {
         const idx = parseInt(numStr) - 1; // $1 → index 0
-        expandedParams.push(params[idx]);
+        const val = params[idx];
+        expandedParams.push(typeof val === 'boolean' ? (val ? 1 : 0) : val);
         return '?';
     });
     return { sql: translated, params: expandedParams };

package/dist/database/db.d.ts

@@ -155,5 +155,28 @@ export declare function isTakendownDid(did: string): Promise<boolean>;
 export declare function getPreferences(did: string): Promise<Record<string, any>>;
 export declare function putPreference(did: string, key: string, value: any): Promise<void>;
 export declare function filterTakendownDids(dids: string[]): Promise<Set<string>>;
+export declare function insertReport(report: {
+    subjectUri: string;
+    subjectDid: string;
+    label: string;
+    reason?: string;
+    reportedBy: string;
+}): Promise<{
+    id: number;
+}>;
+export declare function queryReports(opts: {
+    status?: string;
+    label?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    reports: any[];
+    total: number;
+}>;
+export declare function resolveReport(id: number, action: 'resolved' | 'dismissed', resolvedBy: string): Promise<{
+    subjectUri: string;
+    label: string;
+} | null>;
+export declare function getOpenReportCount(): Promise<number>;
 export {};
 //# sourceMappingURL=db.d.ts.map