@hatk/hatk 0.0.1-alpha.0

package/dist/opengraph.js

@@ -0,0 +1,198 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { resolve } from 'node:path';
+import { readFileSync, readdirSync } from 'node:fs';
+import { log } from "./logger.js";
+import satori from 'satori';
+import { Resvg } from '@resvg/resvg-js';
+import { querySQL, runSQL, packCursor, unpackCursor, isTakendownDid, filterTakendownDids, searchRecords, findUriByFields, lookupByFieldBatch, countByFieldBatch, queryLabelsForUris, } from "./db.js";
+import { resolveRecords } from "./hydrate.js";
+import { blobUrl } from "./xrpc.js";
+const handlers = [];
+const pageRoutes = [];
+let defaultFont = null;
+const cache = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+const CACHE_MAX = 200;
+function compilePath(path) {
+    const paramNames = [];
+    const re = path.replace(/:([^/]+)/g, (_, name) => {
+        paramNames.push(name);
+        return '([^/]+)';
+    });
+    return { pattern: new RegExp(`^${re}$`), paramNames };
+}
+export async function initOpengraph(ogDir) {
+    // Load default font
+    try {
+        const fontPath = resolve(import.meta.dirname, '..', 'fonts', 'Inter-Regular.woff');
+        const fontData = readFileSync(fontPath);
+        defaultFont = { name: 'Inter', data: fontData.buffer, weight: 400, style: 'normal' };
+        log('[opengraph] loaded default font: Inter');
+    }
+    catch {
+        console.warn('[opengraph] no default font found at fonts/Inter-Regular.woff — scripts must provide fonts');
+    }
+    let files;
+    try {
+        files = readdirSync(ogDir)
+            .filter((f) => (f.endsWith('.ts') || f.endsWith('.js')) && !f.startsWith('_'))
+            .sort();
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        const name = file.replace(/\.(ts|js)$/, '');
+        const scriptPath = resolve(ogDir, file);
+        const mod = await import(__rewriteRelativeImportExtension(scriptPath));
+        const handler = mod.default;
+        if (!handler.path) {
+            console.warn(`[opengraph] ${file} missing 'path' export, skipping`);
+            continue;
+        }
+        const { pattern, paramNames } = compilePath(handler.path);
+        handlers.push({
+            name,
+            path: handler.path,
+            pattern,
+            paramNames,
+            execute: async (params) => {
+                const ctx = {
+                    db: { query: querySQL, run: runSQL },
+                    params,
+                    input: {},
+                    limit: 1,
+                    viewer: null,
+                    packCursor,
+                    unpackCursor,
+                    isTakendown: isTakendownDid,
+                    filterTakendownDids,
+                    search: searchRecords,
+                    resolve: resolveRecords,
+                    lookup: async (collection, field, values) => {
+                        if (values.length === 0)
+                            return new Map();
+                        const unique = [...new Set(values.filter(Boolean))];
+                        return lookupByFieldBatch(collection, field, unique);
+                    },
+                    count: async (collection, field, values) => {
+                        if (values.length === 0)
+                            return new Map();
+                        const unique = [...new Set(values.filter(Boolean))];
+                        return countByFieldBatch(collection, field, unique);
+                    },
+                    exists: async (collection, filters) => {
+                        const conditions = Object.entries(filters).map(([field, value]) => ({ field, value }));
+                        const uri = await findUriByFields(collection, conditions);
+                        return uri !== null;
+                    },
+                    labels: queryLabelsForUris,
+                    blobUrl,
+                };
+                ctx.fetchImage = async (url) => {
+                    try {
+                        const resp = await fetch(url, { redirect: 'follow' });
+                        if (!resp.ok)
+                            return null;
+                        const buf = Buffer.from(await resp.arrayBuffer());
+                        const contentType = resp.headers.get('content-type') || 'image/jpeg';
+                        return `data:${contentType};base64,${buf.toString('base64')}`;
+                    }
+                    catch {
+                        return null;
+                    }
+                };
+                const result = await handler.generate(ctx);
+                const element = result.element;
+                const options = {
+                    width: 1200,
+                    height: 630,
+                    ...result.options,
+                    fonts: [...(defaultFont ? [defaultFont] : []), ...(result.options?.fonts || [])],
+                };
+                const svg = await satori(element, options);
+                return { svg, meta: result.meta };
+            },
+        });
+        log(`[opengraph] discovered: ${name} → ${handler.path}`);
+        const pagePath = handler.path.replace(/^\/og/, '');
+        if (pagePath !== handler.path) {
+            const compiled = compilePath(pagePath);
+            pageRoutes.push({ ogPath: handler.path, pattern: compiled.pattern, paramNames: compiled.paramNames, name });
+        }
+    }
+}
+export async function handleOpengraphRequest(pathname) {
+    const cached = cache.get(pathname);
+    if (cached && cached.expires > Date.now())
+        return cached.png;
+    for (const handler of handlers) {
+        const match = pathname.match(handler.pattern);
+        if (!match)
+            continue;
+        const params = {};
+        handler.paramNames.forEach((name, i) => {
+            params[name] = decodeURIComponent(match[i + 1]);
+        });
+        try {
+            const { svg, meta } = await handler.execute(params);
+            const png = new Resvg(svg, { fitTo: { mode: 'width', value: 1200 } }).render().asPng();
+            if (cache.size >= CACHE_MAX) {
+                const oldest = cache.keys().next().value;
+                if (oldest)
+                    cache.delete(oldest);
+            }
+            cache.set(pathname, { png, meta, expires: Date.now() + CACHE_TTL });
+            return png;
+        }
+        catch (err) {
+            console.error(`[opengraph] error in ${handler.name}:`, err.message);
+            return null;
+        }
+    }
+    return null;
+}
+export function buildOgMeta(pathname, origin) {
+    for (const route of pageRoutes) {
+        const match = pathname.match(route.pattern);
+        if (!match)
+            continue;
+        let ogImagePath = route.ogPath;
+        for (let i = 0; i < route.paramNames.length; i++) {
+            ogImagePath = ogImagePath.replace(`:${route.paramNames[i]}`, match[i + 1]);
+        }
+        const params = {};
+        route.paramNames.forEach((name, i) => {
+            params[name] = decodeURIComponent(match[i + 1]);
+        });
+        const cached = cache.get(ogImagePath);
+        const cachedMeta = cached && cached.expires > Date.now() ? cached.meta : undefined;
+        const title = cachedMeta?.title || Object.values(params).join(' \u00b7 ');
+        const description = cachedMeta?.description || '';
+        const esc = (s) => s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;');
+        const imageUrl = `${origin}${ogImagePath}`;
+        const pageUrl = `${origin}${pathname}`;
+        const tags = [
+            `<meta property="og:title" content="${esc(title)}">`,
+            ...(description ? [`<meta property="og:description" content="${esc(description)}">`] : []),
+            `<meta property="og:image" content="${esc(imageUrl)}">`,
+            `<meta property="og:image:width" content="1200">`,
+            `<meta property="og:image:height" content="630">`,
+            `<meta property="og:url" content="${esc(pageUrl)}">`,
+            `<meta property="og:type" content="website">`,
+            `<meta name="twitter:card" content="summary_large_image">`,
+            `<meta name="twitter:title" content="${esc(title)}">`,
+            ...(description ? [`<meta name="twitter:description" content="${esc(description)}">`] : []),
+            `<meta name="twitter:image" content="${esc(imageUrl)}">`,
+        ];
+        return tags.join('\n    ');
+    }
+    return null;
+}

package/dist/schema.d.ts

@@ -0,0 +1,51 @@
+export interface ColumnDef {
+    name: string;
+    originalName: string;
+    duckdbType: string;
+    notNull: boolean;
+    isRef: boolean;
+}
+export interface UnionBranchSchema {
+    type: string;
+    branchName: string;
+    tableName: string;
+    columns: ColumnDef[];
+    isArray: boolean;
+    arrayField?: string;
+    wrapperField?: string;
+}
+export interface UnionFieldSchema {
+    fieldName: string;
+    branches: UnionBranchSchema[];
+}
+export interface TableSchema {
+    collection: string;
+    tableName: string;
+    columns: ColumnDef[];
+    refColumns: string[];
+    children: ChildTableSchema[];
+    unions: UnionFieldSchema[];
+}
+export interface ChildTableSchema {
+    parentCollection: string;
+    fieldName: string;
+    tableName: string;
+    columns: ColumnDef[];
+}
+export declare function toSnakeCase(str: string): string;
+export declare function loadLexicons(lexiconsDir: string): Map<string, any>;
+/**
+ * Discover collections by scanning lexicons for record-type definitions.
+ */
+export declare function discoverCollections(lexicons: Map<string, any>): string[];
+export declare function storeLexicons(lexicons: Map<string, any>): void;
+export declare function getLexicon(nsid: string): any | undefined;
+export declare function getAllLexicons(): Array<{
+    nsid: string;
+    lexicon: any;
+}>;
+/** Get all stored lexicons as a flat array (for @bigmoves/lexicon validators) */
+export declare function getLexiconArray(): any[];
+export declare function generateTableSchema(nsid: string, lexicon: any, lexicons?: Map<string, any>): TableSchema;
+export declare function generateCreateTableSQL(schema: TableSchema): string;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,MAAM,EAAE,gBAAgB,EAAE,CAAA;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;CACrB;AAGD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AA8CD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CASlE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,EAAE,CASxE;AAID,wBAAgB,aAAa,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAI9D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAExD;AAED,wBAAgB,cAAc,IAAI,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAEtE;AAED,iFAAiF;AACjF,wBAAgB,eAAe,IAAI,GAAG,EAAE,CAEvC;AAuHD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,WAAW,CA0GxG;AAGD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAoElE"}

package/dist/schema.js

@@ -0,0 +1,358 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+// Convert camelCase to snake_case
+export function toSnakeCase(str) {
+    return str.replace(/([A-Z])/g, '_$1').toLowerCase();
+}
+function mapType(prop) {
+    if (prop.type === 'string') {
+        if (prop.format === 'datetime')
+            return { duckdbType: 'TIMESTAMP', isRef: false };
+        if (prop.format === 'at-uri')
+            return { duckdbType: 'TEXT', isRef: true };
+        return { duckdbType: 'TEXT', isRef: false };
+    }
+    if (prop.type === 'integer')
+        return { duckdbType: 'INTEGER', isRef: false };
+    if (prop.type === 'boolean')
+        return { duckdbType: 'BOOLEAN', isRef: false };
+    if (prop.type === 'bytes')
+        return { duckdbType: 'BLOB', isRef: false };
+    if (prop.type === 'cid-link')
+        return { duckdbType: 'TEXT', isRef: false };
+    if (prop.type === 'array')
+        return { duckdbType: 'JSON', isRef: false };
+    if (prop.type === 'blob')
+        return { duckdbType: 'JSON', isRef: false };
+    if (prop.type === 'union')
+        return { duckdbType: 'JSON', isRef: false };
+    if (prop.type === 'unknown')
+        return { duckdbType: 'JSON', isRef: false };
+    if (prop.type === 'object')
+        return { duckdbType: 'JSON', isRef: false };
+    if (prop.type === 'ref') {
+        // strongRef contains { uri, cid } — handled specially in generateTableSchema
+        if (prop.ref === 'com.atproto.repo.strongRef')
+            return { duckdbType: 'STRONG_REF', isRef: true };
+        return { duckdbType: 'JSON', isRef: false };
+    }
+    return { duckdbType: 'TEXT', isRef: false };
+}
+// Recursively find all .json files in a directory
+function findJsonFiles(dir) {
+    const results = [];
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            results.push(...findJsonFiles(full));
+        }
+        else if (entry.endsWith('.json')) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+// Load all lexicon files and index by NSID
+export function loadLexicons(lexiconsDir) {
+    const lexicons = new Map();
+    for (const file of findJsonFiles(lexiconsDir)) {
+        const content = JSON.parse(readFileSync(file, 'utf-8'));
+        if (content.lexicon === 1 && content.id) {
+            lexicons.set(content.id, content);
+        }
+    }
+    return lexicons;
+}
+/**
+ * Discover collections by scanning lexicons for record-type definitions.
+ */
+export function discoverCollections(lexicons) {
+    const collections = [];
+    for (const [nsid, lexicon] of lexicons) {
+        const mainDef = lexicon.defs?.main;
+        if (mainDef?.type === 'record') {
+            collections.push(nsid);
+        }
+    }
+    return collections.sort();
+}
+const storedLexicons = new Map();
+export function storeLexicons(lexicons) {
+    for (const [nsid, lex] of lexicons) {
+        storedLexicons.set(nsid, lex);
+    }
+}
+export function getLexicon(nsid) {
+    return storedLexicons.get(nsid);
+}
+export function getAllLexicons() {
+    return [...storedLexicons.entries()].map(([nsid, lexicon]) => ({ nsid, lexicon }));
+}
+/** Get all stored lexicons as a flat array (for @bigmoves/lexicon validators) */
+export function getLexiconArray() {
+    return [...storedLexicons.values()];
+}
+function resolveArrayItemProperties(items, defs) {
+    if (!items)
+        return null;
+    // Inline object with properties
+    if (items.type === 'object' && items.properties) {
+        return items.properties;
+    }
+    // Ref to a named def (e.g., "#artist")
+    if (items.type === 'ref' && items.ref?.startsWith('#')) {
+        const defName = items.ref.slice(1);
+        const def = defs?.[defName];
+        if (def?.type === 'object' && def.properties) {
+            return def.properties;
+        }
+    }
+    return null;
+}
+/** Resolve a ref string to its definition object */
+function resolveRefDef(ref, defs, lexicons) {
+    if (ref.startsWith('#')) {
+        return defs?.[ref.slice(1)] || null;
+    }
+    if (ref.includes('#')) {
+        const [nsid, defName] = ref.split('#');
+        return lexicons?.get(nsid)?.defs?.[defName] || null;
+    }
+    return lexicons?.get(ref)?.defs?.main || null;
+}
+/** Resolve a single union ref to a branch schema */
+function resolveUnionBranch(ref, collection, fieldName, defs, lexicons) {
+    let branchDef = null;
+    let branchName;
+    let fullType;
+    let branchDefs = defs; // defs context for resolving inner refs
+    if (ref.startsWith('#')) {
+        const defName = ref.slice(1);
+        branchDef = defs?.[defName];
+        branchName = toSnakeCase(defName);
+        fullType = `${collection}#${defName}`;
+    }
+    else if (ref.includes('#')) {
+        const [nsid, defName] = ref.split('#');
+        const lex = lexicons?.get(nsid);
+        branchDef = lex?.defs?.[defName];
+        branchName = toSnakeCase(defName);
+        fullType = ref;
+        branchDefs = lex?.defs || defs;
+    }
+    else {
+        const lex = lexicons?.get(ref);
+        branchDef = lex?.defs?.main;
+        branchName = ref.split('.').pop();
+        fullType = ref;
+        branchDefs = lex?.defs || defs;
+    }
+    if (!branchDef || branchDef.type !== 'object' || !branchDef.properties)
+        return null;
+    let isArray = false;
+    let arrayField;
+    let wrapperField;
+    let propSource = branchDef.properties;
+    const branchRequired = new Set(branchDef.required || []);
+    // Check for single-property wrapper patterns
+    const propEntries = Object.entries(branchDef.properties);
+    if (propEntries.length === 1) {
+        const [onlyField, onlyProp] = propEntries[0];
+        if (onlyProp.type === 'array' && onlyProp.items) {
+            // Single array property (like embed.images wrapping images[])
+            const items = onlyProp.items;
+            const itemDef = items.type === 'ref' && items.ref ? resolveRefDef(items.ref, branchDefs, lexicons) : items;
+            if (itemDef?.type === 'object' && itemDef.properties) {
+                isArray = true;
+                arrayField = onlyField;
+                propSource = itemDef.properties;
+            }
+        }
+        else if (onlyProp.type === 'ref' && onlyProp.ref) {
+            // Single ref property (like embed.external wrapping external{})
+            const refDef = resolveRefDef(onlyProp.ref, branchDefs, lexicons);
+            if (refDef?.type === 'object' && refDef.properties) {
+                wrapperField = onlyField;
+                propSource = refDef.properties;
+            }
+        }
+    }
+    const snakeField = toSnakeCase(fieldName);
+    const tableName = `"${collection}__${snakeField}_${branchName}"`;
+    const columns = [];
+    for (const [propName, prop] of Object.entries(propSource)) {
+        const { duckdbType, isRef } = mapType(prop);
+        // Skip STRONG_REF expansion in branch tables — treat as JSON
+        const finalType = duckdbType === 'STRONG_REF' ? 'JSON' : duckdbType;
+        columns.push({
+            name: toSnakeCase(propName),
+            originalName: propName,
+            duckdbType: finalType,
+            notNull: branchRequired.has(propName),
+            isRef: finalType !== 'JSON' && isRef,
+        });
+    }
+    return { type: fullType, branchName, tableName, columns, isArray, arrayField, wrapperField };
+}
+// Generate a TableSchema from a lexicon record definition
+export function generateTableSchema(nsid, lexicon, lexicons) {
+    const mainDef = lexicon.defs?.main;
+    if (!mainDef || mainDef.type !== 'record') {
+        throw new Error(`Lexicon ${nsid} does not define a record type`);
+    }
+    const record = mainDef.record;
+    if (!record || record.type !== 'object') {
+        throw new Error(`Lexicon ${nsid} record is not an object type`);
+    }
+    const required = new Set(record.required || []);
+    const columns = [];
+    const children = [];
+    const unions = [];
+    for (const [fieldName, prop] of Object.entries(record.properties || {})) {
+        const p = prop;
+        // Check for union fields — decompose into branch child tables
+        if (p.type === 'union' && p.refs) {
+            const branches = [];
+            for (const ref of p.refs) {
+                const branch = resolveUnionBranch(ref, nsid, fieldName, lexicon.defs, lexicons);
+                if (branch)
+                    branches.push(branch);
+            }
+            if (branches.length > 0) {
+                unions.push({ fieldName, branches });
+            }
+            // Still add the JSON column for the raw union value
+            columns.push({
+                name: toSnakeCase(fieldName),
+                originalName: fieldName,
+                duckdbType: 'JSON',
+                notNull: required.has(fieldName),
+                isRef: false,
+            });
+            continue;
+        }
+        // Check if this is a decomposable array (array of structured objects)
+        if (p.type === 'array') {
+            const itemProps = resolveArrayItemProperties(p.items, lexicon.defs);
+            if (itemProps) {
+                const childColumns = [];
+                const itemRequired = new Set(p.items?.required || lexicon.defs?.[p.items?.ref?.slice(1)]?.required || []);
+                for (const [itemField, itemProp] of Object.entries(itemProps)) {
+                    const { duckdbType, isRef } = mapType(itemProp);
+                    childColumns.push({
+                        name: toSnakeCase(itemField),
+                        originalName: itemField,
+                        duckdbType,
+                        notNull: itemRequired.has(itemField),
+                        isRef,
+                    });
+                }
+                const snakeField = toSnakeCase(fieldName);
+                children.push({
+                    parentCollection: nsid,
+                    fieldName,
+                    tableName: `"${nsid}__${snakeField}"`,
+                    columns: childColumns,
+                });
+                continue;
+            }
+        }
+        const { duckdbType, isRef } = mapType(p);
+        if (duckdbType === 'STRONG_REF') {
+            // Expand strongRef into two columns: {name}_uri and {name}_cid
+            columns.push({
+                name: toSnakeCase(fieldName) + '_uri',
+                originalName: fieldName,
+                duckdbType: 'TEXT',
+                notNull: required.has(fieldName),
+                isRef: true,
+            });
+            columns.push({
+                name: toSnakeCase(fieldName) + '_cid',
+                originalName: fieldName + '__cid',
+                duckdbType: 'TEXT',
+                notNull: required.has(fieldName),
+                isRef: false,
+            });
+        }
+        else {
+            columns.push({
+                name: toSnakeCase(fieldName),
+                originalName: fieldName,
+                duckdbType,
+                notNull: required.has(fieldName),
+                isRef,
+            });
+        }
+    }
+    const refColumns = columns.filter((c) => c.isRef).map((c) => c.name);
+    return {
+        collection: nsid,
+        tableName: `"${nsid}"`,
+        columns,
+        refColumns,
+        children,
+        unions,
+    };
+}
+// Generate CREATE TABLE SQL from a TableSchema
+export function generateCreateTableSQL(schema) {
+    const lines = [
+        '  uri TEXT PRIMARY KEY',
+        '  cid TEXT',
+        '  did TEXT NOT NULL',
+        '  indexed_at TIMESTAMP NOT NULL',
+    ];
+    for (const col of schema.columns) {
+        const nullable = col.notNull ? ' NOT NULL' : '';
+        lines.push(`  ${col.name} ${col.duckdbType}${nullable}`);
+    }
+    const createTable = `CREATE TABLE IF NOT EXISTS ${schema.tableName} (\n${lines.join(',\n')}\n);`;
+    const prefix = schema.collection.replace(/\./g, '_');
+    const indexes = [
+        `CREATE INDEX IF NOT EXISTS idx_${prefix}_indexed ON ${schema.tableName}(indexed_at DESC);`,
+        `CREATE INDEX IF NOT EXISTS idx_${prefix}_author ON ${schema.tableName}(did);`,
+    ];
+    // Index ref columns for hydration lookups
+    for (const refCol of schema.refColumns) {
+        indexes.push(`CREATE INDEX IF NOT EXISTS idx_${prefix}_${refCol} ON ${schema.tableName}(${refCol});`);
+    }
+    // Child table DDL
+    const childDDL = [];
+    for (const child of schema.children) {
+        const childLines = ['  parent_uri TEXT NOT NULL', '  parent_did TEXT NOT NULL'];
+        for (const col of child.columns) {
+            const nullable = col.notNull ? ' NOT NULL' : '';
+            childLines.push(`  ${col.name} ${col.duckdbType}${nullable}`);
+        }
+        childDDL.push(`CREATE TABLE IF NOT EXISTS ${child.tableName} (\n${childLines.join(',\n')}\n);`);
+        const childPrefix = `${prefix}__${toSnakeCase(child.fieldName)}`;
+        childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${childPrefix}_parent ON ${child.tableName}(parent_uri);`);
+        childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${childPrefix}_did ON ${child.tableName}(parent_did);`);
+        for (const col of child.columns) {
+            if (col.duckdbType === 'JSON' || col.duckdbType === 'BLOB')
+                continue;
+            childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${childPrefix}_${col.name} ON ${child.tableName}(${col.name});`);
+        }
+    }
+    // Union branch table DDL
+    for (const union of schema.unions) {
+        for (const branch of union.branches) {
+            const branchLines = ['  parent_uri TEXT NOT NULL', '  parent_did TEXT NOT NULL'];
+            for (const col of branch.columns) {
+                const nullable = col.notNull ? ' NOT NULL' : '';
+                branchLines.push(`  ${col.name} ${col.duckdbType}${nullable}`);
+            }
+            childDDL.push(`CREATE TABLE IF NOT EXISTS ${branch.tableName} (\n${branchLines.join(',\n')}\n);`);
+            const branchPrefix = branch.tableName.replace(/"/g, '').replace(/\./g, '_');
+            childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${branchPrefix}_parent ON ${branch.tableName}(parent_uri);`);
+            childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${branchPrefix}_did ON ${branch.tableName}(parent_did);`);
+            for (const col of branch.columns) {
+                if (col.duckdbType === 'JSON' || col.duckdbType === 'BLOB')
+                    continue;
+                childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${branchPrefix}_${col.name} ON ${branch.tableName}(${col.name});`);
+            }
+        }
+    }
+    return [createTable, ...indexes, ...childDDL].join('\n');
+}

package/dist/seed.d.ts

@@ -0,0 +1,29 @@
+export type Session = {
+    did: string;
+    accessJwt: string;
+    handle: string;
+};
+export type BlobRef = {
+    $type: 'blob';
+    ref: {
+        $link: string;
+    };
+    mimeType: string;
+    size: number;
+};
+export type SeedOpts = {
+    pds?: string;
+    password?: string;
+    lexicons?: string;
+};
+export declare function seed<R extends Record<string, unknown> = Record<string, unknown>>(opts?: SeedOpts): {
+    createAccount: (handle: string) => Promise<Session>;
+    createRecord: <K extends keyof R & string>(session: Session, collection: K, record: R[K] extends Record<string, unknown> ? R[K] : Record<string, unknown>, opts: {
+        rkey: string;
+    }) => Promise<{
+        uri: string;
+        cid: string;
+    }>;
+    uploadBlob: (session: Session, filePath: string) => Promise<BlobRef>;
+};
+//# sourceMappingURL=seed.d.ts.map

package/dist/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AACxE,MAAM,MAAM,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAC/F,MAAM,MAAM,QAAQ,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,QAAQ;4BAM1D,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;mBA4BlC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,WAC3C,OAAO,cACJ,CAAC,UACL,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QACvE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,KACrB,OAAO,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;0BA4BL,OAAO,YAAY,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC;EA4BhF"}