@makerclay/core 1.0.0

package/src/store/sqlite.js

@@ -0,0 +1,540 @@
+import fs from 'node:fs';
+import path from 'upath';
+import { fileURLToPath } from 'node:url';
+
+// `node:sqlite` is only listed in module.builtinModules under its prefixed name,
+// so a plain `import` sends bundlers and test runners hunting for a package
+// called "sqlite" and failing. process.getBuiltinModule reaches the real module
+// without going through any resolver at all.
+const { DatabaseSync } = process.getBuiltinModule('node:sqlite');
+
+const MIGRATIONS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'migrations');
+
+function readMigrations() {
+  return fs.readdirSync(MIGRATIONS_DIR)
+    .filter((name) => name.endsWith('.sql'))
+    .sort()
+    .map((name) => ({ name, sql: fs.readFileSync(path.join(MIGRATIONS_DIR, name), 'utf8') }));
+}
+
+const NODE_COLUMNS = [
+  'id', 'owner', 'path', 'kind',
+  'etag', 'observed_etag', 'bytes', 'mtime_ms', 'dev', 'ino', 'seq',
+  'created_at', 'updated_at', 'deleted_at', 'private', 'isolated', 'signups', 'source_id',
+];
+
+function toNode(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    owner: row.owner ?? '',
+    path: row.path,
+    kind: row.kind,
+    etag: row.etag ?? null,
+    observedEtag: row.observed_etag ?? null,
+    bytes: row.bytes ?? null,
+    mtimeMs: row.mtime_ms ?? null,
+    dev: row.dev ?? null,
+    ino: row.ino ?? null,
+    seq: row.seq,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: row.deleted_at ?? null,
+    private: !!row.private,
+    isolated: row.isolated === null || row.isolated === undefined ? null : !!row.isolated,
+    signups: !!row.signups,
+    sourceId: row.source_id ?? null,
+  };
+}
+
+const CAMEL_TO_COLUMN = {
+  observedEtag: 'observed_etag',
+  mtimeMs: 'mtime_ms',
+  createdAt: 'created_at',
+  updatedAt: 'updated_at',
+  deletedAt: 'deleted_at',
+  sourceId: 'source_id',
+};
+
+function columnFor(key) {
+  const column = CAMEL_TO_COLUMN[key] || key;
+  if (!NODE_COLUMNS.includes(column)) {
+    throw new Error(`updateNode: unknown column "${key}"`);
+  }
+  return column;
+}
+
+function likeEscape(value) {
+  return String(value).replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+
+function toBind(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value === 'boolean') return value ? 1 : 0;
+  return value;
+}
+
+export function createSqliteStore({ file } = {}) {
+  let db = null;
+  let inTx = 0;
+
+  function run(sql, ...params) {
+    return db.prepare(sql).run(...params.map(toBind));
+  }
+  function get(sql, ...params) {
+    return db.prepare(sql).get(...params.map(toBind)) ?? null;
+  }
+  function all(sql, ...params) {
+    return db.prepare(sql).all(...params.map(toBind));
+  }
+
+  const store = {
+    name: 'sqlite',
+
+    // `readOnly` is for inspection (`makerclay doctor`), and the guarantee is
+    // SQLite's rather than this module's: the connection itself refuses every
+    // write, so a reader cannot migrate, checkpoint or repair by accident. That
+    // matters because the normal open MIGRATES, which is a schema change nobody
+    // asked a health check to make.
+    //
+    // No journal_mode pragma on this path: setting WAL is itself a write, and it
+    // is not needed. A read-only connection reads a WAL database fine, including
+    // one another process is holding open, and including one left mid-crash with
+    // a -wal and -shm still on disk, which is exactly when a report is wanted.
+    open({ paths, readOnly = false } = {}) {
+      const target = file || paths?.files?.db;
+      if (!target) throw new Error('sqlite store needs a file path');
+      if (readOnly) {
+        db = new DatabaseSync(target, { readOnly: true });
+        db.exec('PRAGMA busy_timeout = 5000');
+        return store;
+      }
+      db = new DatabaseSync(target);
+      db.exec('PRAGMA journal_mode = WAL');
+      db.exec('PRAGMA synchronous = NORMAL');
+      db.exec('PRAGMA foreign_keys = ON');
+      db.exec('PRAGMA busy_timeout = 5000');
+
+      const current = db.prepare('PRAGMA user_version').get().user_version;
+      const migrations = readMigrations();
+      if (current < migrations.length) {
+        db.exec('BEGIN');
+        try {
+          for (let i = current; i < migrations.length; i++) db.exec(migrations[i].sql);
+          db.exec(`PRAGMA user_version = ${migrations.length}`);
+          db.exec('COMMIT');
+        } catch (error) {
+          db.exec('ROLLBACK');
+          throw error;
+        }
+      }
+      return store;
+    },
+
+    close() {
+      if (db) {
+        db.close();
+        db = null;
+      }
+    },
+
+    integrityCheck() {
+      return all('PRAGMA integrity_check').map((row) => row.integrity_check);
+    },
+
+    // Nested calls join the outer transaction rather than opening a second one:
+    // SQLite has no nested BEGIN, and the kernel calls tx() from inside node ops.
+    tx(fn) {
+      if (inTx > 0) {
+        inTx += 1;
+        try {
+          return fn(store);
+        } finally {
+          inTx -= 1;
+        }
+      }
+      db.exec('BEGIN');
+      inTx = 1;
+      try {
+        const result = fn(store);
+        db.exec('COMMIT');
+        return result;
+      } catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+      } finally {
+        inTx = 0;
+      }
+    },
+
+    nextSeq() {
+      const row = get('SELECT v FROM kv WHERE k = ?', 'seq');
+      const next = (row ? Number(row.v) : 0) + 1;
+      run('INSERT INTO kv (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v', 'seq', String(next));
+      return next;
+    },
+
+    getNode(owner, nodePath) {
+      return toNode(get(
+        'SELECT * FROM nodes WHERE owner = ? AND path = ? AND deleted_at IS NULL',
+        owner ?? '', nodePath,
+      ));
+    },
+
+    getNodeAnyState(owner, nodePath) {
+      return toNode(get('SELECT * FROM nodes WHERE owner = ? AND path = ?', owner ?? '', nodePath));
+    },
+
+    getNodeById(id) {
+      return toNode(get('SELECT * FROM nodes WHERE id = ?', id));
+    },
+
+    listNodes({ owner = '', prefix = null, includeDeleted = false, sinceSeq = null, kind = null } = {}) {
+      const where = ['owner = ?'];
+      const params = [owner];
+      if (!includeDeleted) where.push('deleted_at IS NULL');
+      // `_` is a LIKE wildcard and an extremely common filename character, so an
+      // unescaped prefix makes `my_notes/` match `myXnotes/` and a folder move
+      // rewrite rows belonging to a different folder.
+      if (prefix !== null) { where.push("path LIKE ? ESCAPE '\\'"); params.push(`${likeEscape(prefix)}%`); }
+      if (sinceSeq !== null) { where.push('seq > ?'); params.push(sinceSeq); }
+      if (kind !== null) { where.push('kind = ?'); params.push(kind); }
+      return all(`SELECT * FROM nodes WHERE ${where.join(' AND ')} ORDER BY path`, ...params).map(toNode);
+    },
+
+    listAllNodes({ includeDeleted = false } = {}) {
+      const where = includeDeleted ? '' : 'WHERE deleted_at IS NULL';
+      return all(`SELECT * FROM nodes ${where} ORDER BY owner, path`).map(toNode);
+    },
+
+    listTrash() {
+      return all('SELECT * FROM nodes WHERE deleted_at IS NOT NULL ORDER BY deleted_at DESC').map(toNode);
+    },
+
+    insertNode(node) {
+      const now = node.createdAt ?? Date.now();
+      run(
+        `INSERT INTO nodes (${NODE_COLUMNS.join(', ')})
+         VALUES (${NODE_COLUMNS.map(() => '?').join(', ')})`,
+        node.id,
+        node.owner ?? '',
+        node.path,
+        node.kind,
+        node.etag ?? null,
+        node.observedEtag ?? null,
+        node.bytes ?? null,
+        node.mtimeMs ?? null,
+        node.dev ?? null,
+        node.ino ?? null,
+        node.seq ?? store.nextSeq(),
+        now,
+        node.updatedAt ?? now,
+        node.deletedAt ?? null,
+        node.private ? 1 : 0,
+        node.isolated === null || node.isolated === undefined ? null : (node.isolated ? 1 : 0),
+        node.signups ? 1 : 0,
+        node.sourceId ?? null,
+      );
+      return store.getNodeById(node.id);
+    },
+
+    updateNode(id, patch) {
+      const keys = Object.keys(patch).filter((key) => key !== 'id');
+      if (!keys.length) return store.getNodeById(id);
+      const assignments = keys.map((key) => `${columnFor(key)} = ?`).join(', ');
+      run(`UPDATE nodes SET ${assignments} WHERE id = ?`, ...keys.map((key) => toBind(patch[key])), id);
+      return store.getNodeById(id);
+    },
+
+    tombstone(id, at) {
+      run('UPDATE nodes SET deleted_at = ? WHERE id = ?', at, id);
+      return store.getNodeById(id);
+    },
+
+    deleteNode(id) {
+      return run('DELETE FROM nodes WHERE id = ?', id).changes > 0;
+    },
+
+    getKv(key) {
+      const row = get('SELECT v FROM kv WHERE k = ?', key);
+      return row ? row.v : null;
+    },
+
+    setKv(key, value) {
+      run('INSERT INTO kv (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v', key, value);
+      return value;
+    },
+
+    deleteKv(key) {
+      run('DELETE FROM kv WHERE k = ?', key);
+    },
+
+    // shares
+    insertShare(share) {
+      run(
+        `INSERT INTO shares (token_hash, node_id, grant_kind, label, created_at, expires_at, revoked_at, last_used_at)
+         VALUES (?, ?, ?, ?, ?, ?, NULL, NULL)`,
+        share.tokenHash, share.nodeId, share.grantKind, share.label ?? null,
+        share.createdAt, share.expiresAt ?? null,
+      );
+      return store.getShare(share.tokenHash);
+    },
+    getShare(tokenHash) {
+      const row = get('SELECT * FROM shares WHERE token_hash = ?', tokenHash);
+      if (!row) return null;
+      return {
+        tokenHash: row.token_hash,
+        nodeId: row.node_id,
+        grantKind: row.grant_kind,
+        label: row.label ?? null,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at ?? null,
+        revokedAt: row.revoked_at ?? null,
+        lastUsedAt: row.last_used_at ?? null,
+      };
+    },
+    listShares(nodeId) {
+      return all('SELECT token_hash FROM shares WHERE node_id = ? ORDER BY created_at DESC', nodeId)
+        .map((row) => store.getShare(row.token_hash));
+    },
+    touchShare(tokenHash, at) {
+      run('UPDATE shares SET last_used_at = ? WHERE token_hash = ?', at, tokenHash);
+    },
+    revokeShare(tokenHash, at) {
+      return run('UPDATE shares SET revoked_at = ? WHERE token_hash = ? AND revoked_at IS NULL', at, tokenHash).changes > 0;
+    },
+
+    // sessions
+    insertSession(session) {
+      run(
+        'INSERT INTO sessions (token_hash, principal, created_at, expires_at, last_seen_at) VALUES (?, ?, ?, ?, ?)',
+        session.tokenHash, session.principal, session.createdAt, session.expiresAt, session.createdAt,
+      );
+      return session;
+    },
+    getSession(tokenHash) {
+      const row = get('SELECT * FROM sessions WHERE token_hash = ?', tokenHash);
+      if (!row) return null;
+      return {
+        tokenHash: row.token_hash,
+        principal: row.principal,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at,
+        lastSeenAt: row.last_seen_at ?? null,
+      };
+    },
+    touchSession(tokenHash, at) {
+      run('UPDATE sessions SET last_seen_at = ? WHERE token_hash = ?', at, tokenHash);
+    },
+    deleteSession(tokenHash) {
+      return run('DELETE FROM sessions WHERE token_hash = ?', tokenHash).changes > 0;
+    },
+    deleteSessionsFor(principal) {
+      return run('DELETE FROM sessions WHERE principal = ?', principal).changes;
+    },
+    purgeExpiredSessions(now) {
+      return run('DELETE FROM sessions WHERE expires_at < ?', now).changes;
+    },
+
+    // save tokens
+    insertSaveToken(record) {
+      run(
+        `INSERT INTO save_tokens (token, node_id, principal, share_hash, grant_kind, expires_at)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+        record.token, record.nodeId, record.principal ?? null,
+        record.shareHash ?? null, record.grantKind, record.expiresAt,
+      );
+      return record;
+    },
+    getSaveToken(token) {
+      const row = get('SELECT * FROM save_tokens WHERE token = ?', token);
+      if (!row) return null;
+      return {
+        token: row.token,
+        nodeId: row.node_id,
+        principal: row.principal ?? null,
+        shareHash: row.share_hash ?? null,
+        grantKind: row.grant_kind,
+        expiresAt: row.expires_at,
+      };
+    },
+    findSaveToken({ nodeId, principal, shareHash, now }) {
+      const row = get(
+        `SELECT * FROM save_tokens
+         WHERE node_id = ? AND expires_at > ?
+           AND principal IS ? AND share_hash IS ?
+         ORDER BY expires_at DESC LIMIT 1`,
+        nodeId, now, principal ?? null, shareHash ?? null,
+      );
+      return row ? store.getSaveToken(row.token) : null;
+    },
+    deleteSaveTokensForNode(nodeId) {
+      return run('DELETE FROM save_tokens WHERE node_id = ?', nodeId).changes;
+    },
+    deleteSaveTokensForPrincipal(principal) {
+      return run('DELETE FROM save_tokens WHERE principal = ?', String(principal)).changes;
+    },
+    purgeExpiredSaveTokens(now) {
+      return run('DELETE FROM save_tokens WHERE expires_at < ?', now).changes;
+    },
+
+    // tenants
+    insertTenant(tenant) {
+      run(
+        `INSERT INTO tenants (username, password_hash, recovery_hash, source_id, created_at, approved_at, disabled_at, bytes_used)
+         VALUES (?, ?, ?, ?, ?, ?, NULL, 0)`,
+        tenant.username, tenant.passwordHash, tenant.recoveryHash ?? null,
+        tenant.sourceId ?? null, tenant.createdAt, tenant.approvedAt ?? null,
+      );
+      return store.getTenant(tenant.username);
+    },
+    getTenant(username) {
+      const row = get('SELECT * FROM tenants WHERE username = ?', username);
+      if (!row) return null;
+      return {
+        username: row.username,
+        passwordHash: row.password_hash,
+        recoveryHash: row.recovery_hash ?? null,
+        sourceId: row.source_id ?? null,
+        createdAt: row.created_at,
+        approvedAt: row.approved_at ?? null,
+        disabledAt: row.disabled_at ?? null,
+        bytesUsed: row.bytes_used ?? 0,
+      };
+    },
+    listTenants() {
+      return all('SELECT username FROM tenants ORDER BY created_at').map((row) => store.getTenant(row.username));
+    },
+    updateTenant(username, patch) {
+      const map = {
+        passwordHash: 'password_hash', recoveryHash: 'recovery_hash', sourceId: 'source_id',
+        approvedAt: 'approved_at', disabledAt: 'disabled_at', bytesUsed: 'bytes_used',
+      };
+      const keys = Object.keys(patch).filter((key) => map[key]);
+      if (!keys.length) return store.getTenant(username);
+      run(
+        `UPDATE tenants SET ${keys.map((key) => `${map[key]} = ?`).join(', ')} WHERE username = ?`,
+        ...keys.map((key) => toBind(patch[key])), username,
+      );
+      return store.getTenant(username);
+    },
+    deleteTenant(username) {
+      return run('DELETE FROM tenants WHERE username = ?', username).changes > 0;
+    },
+
+    // collections
+    insertCollection(record) {
+      run(
+        `INSERT INTO collections (node_id, slug, submit_token, accepting, role_map, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+        record.nodeId, record.slug, record.submitToken,
+        record.accepting === false ? 0 : 1,
+        record.roleMap ? JSON.stringify(record.roleMap) : null,
+        record.createdAt,
+      );
+      return store.getCollection(record.nodeId);
+    },
+    getCollection(nodeId) {
+      const row = get('SELECT * FROM collections WHERE node_id = ?', nodeId);
+      return row ? toCollection(row) : null;
+    },
+    getCollectionBySlug(slug) {
+      const row = get('SELECT * FROM collections WHERE slug = ?', slug);
+      return row ? toCollection(row) : null;
+    },
+    listCollections() {
+      return all('SELECT * FROM collections ORDER BY created_at DESC').map(toCollection);
+    },
+    updateCollection(nodeId, patch) {
+      const map = { slug: 'slug', submitToken: 'submit_token', accepting: 'accepting', roleMap: 'role_map' };
+      const keys = Object.keys(patch).filter((key) => map[key]);
+      if (!keys.length) return store.getCollection(nodeId);
+      run(
+        `UPDATE collections SET ${keys.map((key) => `${map[key]} = ?`).join(', ')} WHERE node_id = ?`,
+        ...keys.map((key) => (key === 'roleMap'
+          ? (patch[key] ? JSON.stringify(patch[key]) : null)
+          : toBind(patch[key]))),
+        nodeId,
+      );
+      return store.getCollection(nodeId);
+    },
+    deleteCollection(nodeId) {
+      return run('DELETE FROM collections WHERE node_id = ?', nodeId).changes > 0;
+    },
+
+    // record auth
+    upsertRecordAuth(record) {
+      run(
+        `INSERT INTO record_auth (node_id, code_hash, failures, locked_until, deleted_at)
+         VALUES (?, ?, 0, NULL, NULL)
+         ON CONFLICT(node_id) DO UPDATE SET code_hash = excluded.code_hash, failures = 0, locked_until = NULL, deleted_at = NULL`,
+        record.nodeId, record.codeHash,
+      );
+      return store.getRecordAuth(record.nodeId);
+    },
+    getRecordAuth(nodeId) {
+      const row = get('SELECT * FROM record_auth WHERE node_id = ?', nodeId);
+      if (!row) return null;
+      return {
+        nodeId: row.node_id,
+        codeHash: row.code_hash,
+        failures: row.failures,
+        lockedUntil: row.locked_until ?? null,
+        deletedAt: row.deleted_at ?? null,
+      };
+    },
+    updateRecordAuth(nodeId, patch) {
+      const map = { codeHash: 'code_hash', failures: 'failures', lockedUntil: 'locked_until', deletedAt: 'deleted_at' };
+      const keys = Object.keys(patch).filter((key) => map[key]);
+      if (!keys.length) return store.getRecordAuth(nodeId);
+      run(
+        `UPDATE record_auth SET ${keys.map((key) => `${map[key]} = ?`).join(', ')} WHERE node_id = ?`,
+        ...keys.map((key) => toBind(patch[key])), nodeId,
+      );
+      return store.getRecordAuth(nodeId);
+    },
+    deleteRecordAuth(nodeId) {
+      return run('DELETE FROM record_auth WHERE node_id = ?', nodeId).changes > 0;
+    },
+
+    // operations journal
+    insertOperation(op) {
+      run(
+        'INSERT INTO operations (id, kind, node_id, phase, payload_json, started_at) VALUES (?, ?, ?, ?, ?, ?)',
+        op.id, op.kind, op.nodeId ?? null, op.phase, JSON.stringify(op.payload ?? {}), op.startedAt,
+      );
+      return op;
+    },
+    setOperationPhase(id, phase) {
+      run('UPDATE operations SET phase = ? WHERE id = ?', phase, id);
+    },
+    deleteOperation(id) {
+      return run('DELETE FROM operations WHERE id = ?', id).changes > 0;
+    },
+    listOperations() {
+      return all('SELECT * FROM operations ORDER BY started_at').map((row) => ({
+        id: row.id,
+        kind: row.kind,
+        nodeId: row.node_id ?? null,
+        phase: row.phase,
+        payload: JSON.parse(row.payload_json),
+        startedAt: row.started_at,
+      }));
+    },
+  };
+
+  function toCollection(row) {
+    let roleMap = null;
+    if (row.role_map) { try { roleMap = JSON.parse(row.role_map); } catch { roleMap = null; } }
+    return {
+      nodeId: row.node_id,
+      slug: row.slug,
+      submitToken: row.submit_token,
+      accepting: !!row.accepting,
+      roleMap,
+      createdAt: row.created_at,
+    };
+  }
+
+  return store;
+}

package/src/templates.js

@@ -0,0 +1,50 @@
+import path from 'upath';
+import { fileURLToPath } from 'node:url';
+import { readdirIfExists, readFileTextIfExists, statIfExists } from './util/fsx.js';
+
+// Starter documents. They ship as ordinary files in the package rather than as
+// strings in a module, because they are meant to be read, copied and pillaged:
+// a starter you cannot open in an editor teaches nothing.
+
+const TEMPLATES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'ui', 'templates');
+
+const BLANK = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Untitled</title>
+  <script src="/_/clay.js"></script>
+  <style>
+    body { font: 16px/1.6 system-ui, sans-serif; max-width: 40rem; margin: 4rem auto; padding: 0 1rem; }
+  </style>
+</head>
+<body>
+  <h1 contenteditable>Untitled</h1>
+  <p contenteditable>Click Edit, change anything, then save. The file you are reading is the database.</p>
+</body>
+</html>
+`;
+
+export function createTemplates({ logger = console } = {}) {
+  async function list() {
+    const names = await readdirIfExists(TEMPLATES_DIR);
+    const found = names
+      .filter((name) => name.endsWith('.html'))
+      .map((name) => name.replace(/\.html$/, ''));
+    return found.includes('blank') ? found : ['blank', ...found];
+  }
+
+  async function read(name = 'blank') {
+    const safe = String(name || 'blank').replace(/[^a-z0-9-]/gi, '');
+    if (!safe) return BLANK;
+    const file = path.join(TEMPLATES_DIR, `${safe}.html`);
+    if (!(await statIfExists(file))) {
+      if (safe !== 'blank') logger.warn?.(`[makerclay] unknown template "${name}", using blank`);
+      return BLANK;
+    }
+    return (await readFileTextIfExists(file)) || BLANK;
+  }
+
+  return { list, read, dir: TEMPLATES_DIR };
+}