Arcrun/kbdb/src/actions/record-crud.ts

// Template + Record CRUD. A "record" = multiple entries composed via a template's slots.
// Base, D1 only. (Ported clean from KBDB; no vectorize/triplet imports.)
import type { Template } from '../types';
import { createEntry } from './entry-crud';

function uid(prefix: string): string {
  return `${prefix}_${crypto.randomUUID()}`;
}

// ---- Templates ----

export interface CreateTemplateInput {
  name: string;
  description?: string | null;
  slots: string[];
  created_by?: string | null;
  id?: string;
}

export async function createTemplate(db: D1Database, input: CreateTemplateInput): Promise<Template> {
  const id = input.id ?? uid('tpl');
  await db
    .prepare(`INSERT INTO templates (id, name, description, slots_json, created_by) VALUES (?, ?, ?, ?, ?)`)
    .bind(id, input.name, input.description ?? null, JSON.stringify(input.slots), input.created_by ?? null)
    .run();
  const row = await getTemplate(db, id);
  if (!row) throw new Error('createTemplate: row not found after insert');
  return row;
}

export async function getTemplate(db: D1Database, idOrName: string): Promise<Template | null> {
  const row = await db
    .prepare('SELECT * FROM templates WHERE id = ? OR name = ? LIMIT 1')
    .bind(idOrName, idOrName)
    .first<Template>();
  return row ?? null;
}

export async function listTemplates(db: D1Database): Promise<Template[]> {
  const res = await db.prepare('SELECT * FROM templates ORDER BY created_at DESC').all<Template>();
  return res.results ?? [];
}

export async function updateTemplate(db: D1Database, id: string, patch: { description?: string | null; slots?: string[] }): Promise<Template | null> {
  const cols: string[] = [];
  const params: unknown[] = [];
  if (patch.description !== undefined) { cols.push('description = ?'); params.push(patch.description); }
  if (patch.slots !== undefined) { cols.push('slots_json = ?'); params.push(JSON.stringify(patch.slots)); }
  if (cols.length === 0) return getTemplate(db, id);
  cols.push('updated_at = unixepoch()');
  await db.prepare(`UPDATE templates SET ${cols.join(', ')} WHERE id = ?`).bind(...params, id).run();
  return getTemplate(db, id);
}

// ---- Records (entry_values composed by template) ----

export interface CreateRecordInput {
  template: string;          // template id or name
  values: Record<string, string>; // slot_name -> content
  owner_id?: string | null;
  record_id?: string;
}

export interface RecordResult {
  record_id: string;
  template_id: string;
  values: Record<string, string>;
}

export async function createRecord(db: D1Database, input: CreateRecordInput): Promise<RecordResult> {
  const tpl = await getTemplate(db, input.template);
  if (!tpl) throw new Error(`template not found: ${input.template}`);
  const slots: string[] = JSON.parse(tpl.slots_json);
  const recordId = input.record_id ?? uid('rec');

  for (const slot of slots) {
    if (!(slot in input.values)) continue;
    const entry = await createEntry(db, {
      content: input.values[slot],
      entry_type: 'value',
      owner_id: input.owner_id ?? null,
    });
    await db
      .prepare(`INSERT INTO entry_values (id, record_id, template_id, slot_name, entry_id) VALUES (?, ?, ?, ?, ?)`)
      .bind(uid('ev'), recordId, tpl.id, slot, entry.id)
      .run();
  }
  return { record_id: recordId, template_id: tpl.id, values: input.values };
}

export async function getRecord(db: D1Database, recordId: string): Promise<RecordResult | null> {
  const res = await db
    .prepare(
      `SELECT ev.slot_name as slot, e.content as content, ev.template_id as template_id
       FROM entry_values ev JOIN entries e ON ev.entry_id = e.id
       WHERE ev.record_id = ?`,
    )
    .bind(recordId)
    .all<{ slot: string; content: string; template_id: string }>();
  const rows = res.results ?? [];
  if (rows.length === 0) return null;
  const values: Record<string, string> = {};
  for (const r of rows) values[r.slot] = r.content;
  return { record_id: recordId, template_id: rows[0].template_id, values };
}

export async function searchByTemplate(db: D1Database, template: string, owner_id?: string, limit = 100): Promise<RecordResult[]> {
  const tpl = await getTemplate(db, template);
  if (!tpl) return [];
  const res = await db
    .prepare(`SELECT DISTINCT record_id FROM entry_values WHERE template_id = ? ORDER BY created_at DESC LIMIT ?`)
    .bind(tpl.id, Math.min(limit, 500))
    .all<{ record_id: string }>();
  const out: RecordResult[] = [];
  for (const { record_id } of res.results ?? []) {
    const rec = await getRecord(db, record_id);
    if (rec && (!owner_id || true)) out.push(rec);
  }
  return out;
}