dbt-js 0.1.1 → 0.1.2

package/src/batches.js

@@ -1,120 +1,129 @@
-// Batch window computation for the microbatch incremental strategy.
-// Date math aligns to a configurable IANA timezone (default 'UTC') — windows
-// snap to that zone's wall-clock boundaries. No DB access, no SQL dialect concerns.
-
-const UNITS = ['hour', 'day', 'month', 'year'];
-
-// Wall-clock components of an instant as seen in `tz`: { year, month(1-12),
-// day, hour, minute, second }. Built on Intl so it tracks DST automatically.
-function partsInZone(date, tz) {
-  const dtf = new Intl.DateTimeFormat('en-US', {
-    timeZone: tz,
-    hourCycle: 'h23',
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-    hour: '2-digit',
-    minute: '2-digit',
-    second: '2-digit',
-  });
-  const p = {};
-  for (const part of dtf.formatToParts(date)) {
-    if (part.type !== 'literal') p[part.type] = Number(part.value);
-  }
-  if (p.hour === 24) p.hour = 0; // some engines emit 24 for midnight under h23
-  return p;
-}
-
-// The UTC instant for a wall-clock time interpreted in `tz`, DST-correct via an
-// offset back-solve (one correction pass resolves spring-forward/fall-back).
-function zonedWallToUtc({ year, month, day, hour, minute, second }, tz) {
-  const offsetAt = (ms) => {
-    const p = partsInZone(new Date(ms), tz);
-    return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - ms;
-  };
-  const naive = Date.UTC(year, month - 1, day, hour, minute, second);
-  let utc = naive - offsetAt(naive);
-  utc = naive - offsetAt(utc);
-  return new Date(utc);
-}
-
-// Parse a date string into a UTC instant. A string carrying an explicit zone
-// (Z or ±HH:MM) is an absolute instant; a naive 'YYYY-MM-DD[ HH:MM[:SS]]' is
-// interpreted as wall-clock in `tz`.
-export function parseInZone(s, tz = 'UTC') {
-  const iso = String(s).trim().replace(' ', 'T');
-  if (/(?:[zZ]|[+-]\d{2}:?\d{2})$/.test(iso)) {
-    const d = new Date(iso);
-    if (Number.isNaN(d.getTime())) throw new Error(`Invalid date '${s}' (use YYYY-MM-DD or ISO 8601)`);
-    return d;
-  }
-  const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2}))?)?$/);
-  if (!m) throw new Error(`Invalid date '${s}' (use YYYY-MM-DD or ISO 8601)`);
-  return zonedWallToUtc(
-    { year: +m[1], month: +m[2], day: +m[3], hour: +(m[4] || 0), minute: +(m[5] || 0), second: +(m[6] || 0) },
-    tz
-  );
-}
-
-// Back-compat alias — parsing in UTC.
-export const parseUtc = (s) => parseInZone(s, 'UTC');
-
-function truncTz(date, size, tz) {
-  const p = partsInZone(date, tz);
-  p.second = 0;
-  p.minute = 0;
-  if (size !== 'hour') p.hour = 0;
-  if (size === 'month' || size === 'year') p.day = 1;
-  if (size === 'year') p.month = 1;
-  return zonedWallToUtc(p, tz);
-}
-
-function addBatchesTz(date, size, n, tz) {
-  const p = partsInZone(date, tz);
-  if (size === 'hour') p.hour += n;
-  else if (size === 'day') p.day += n;
-  else if (size === 'month') p.month += n;
-  else p.year += n;
-  return zonedWallToUtc(p, tz); // Date.UTC normalizes overflow (day 32, month 13, ...)
-}
-
-function fmtTz(date, tz) {
-  const p = partsInZone(date, tz);
-  const pad = (n) => String(n).padStart(2, '0');
-  return `${p.year}-${pad(p.month)}-${pad(p.day)} ${pad(p.hour)}:${pad(p.minute)}:${pad(p.second)}`;
-}
-
-// Returns [{ start, end }] of aligned [start, end) windows as 'YYYY-MM-DD HH:MM:SS'.
-//   first build / --full-refresh : trunc(begin) .. current batch end
-//   normal run                   : trunc(now) - lookback .. current batch end
-//   explicit backfill            : trunc(start) .. ceil(end)  (whole batches)
-// The window never starts before `begin`.
-export function computeBatches({ begin, batchSize, lookback = 1, start, end, firstBuild, timezone = 'UTC', now = new Date() }) {
-  if (!UNITS.includes(batchSize)) throw new Error(`Invalid batch_size '${batchSize}' (use ${UNITS.join('|')})`);
-  const beginAt = truncTz(parseInZone(begin, timezone), batchSize, timezone);
-
-  let endAt;
-  if (end) {
-    const e = parseInZone(end, timezone);
-    const t = truncTz(e, batchSize, timezone);
-    endAt = e.getTime() === t.getTime() ? t : addBatchesTz(t, batchSize, 1, timezone);
-  } else {
-    endAt = addBatchesTz(truncTz(now, batchSize, timezone), batchSize, 1, timezone);
-  }
-
-  let startAt;
-  if (start) startAt = truncTz(parseInZone(start, timezone), batchSize, timezone);
-  else if (firstBuild) startAt = beginAt;
-  else startAt = addBatchesTz(truncTz(now, batchSize, timezone), batchSize, -lookback, timezone);
-  if (startAt < beginAt) startAt = beginAt;
-
-  if (start && startAt >= endAt) {
-    throw new Error(`--event-time-start (${fmtTz(startAt, timezone)}) must be before the end of the window (${fmtTz(endAt, timezone)})`);
-  }
-
-  const batches = [];
-  for (let t = startAt; t < endAt; t = addBatchesTz(t, batchSize, 1, timezone)) {
-    batches.push({ start: fmtTz(t, timezone), end: fmtTz(addBatchesTz(t, batchSize, 1, timezone), timezone) });
-  }
-  return batches;
-}
+// Batch window computation for the microbatch incremental strategy.
+// Date math aligns to a configurable IANA timezone (default 'UTC') — windows
+// snap to that zone's wall-clock boundaries. No DB access, no SQL dialect concerns.
+
+const UNITS = ['hour', 'day', 'month', 'year'];
+
+// Wall-clock components of an instant as seen in `tz`: { year, month(1-12),
+// day, hour, minute, second }. Built on Intl so it tracks DST automatically.
+function partsInZone(date, tz) {
+  const dtf = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    hourCycle: 'h23',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+  const p = {};
+  for (const part of dtf.formatToParts(date)) {
+    if (part.type !== 'literal') p[part.type] = Number(part.value);
+  }
+  if (p.hour === 24) p.hour = 0; // some engines emit 24 for midnight under h23
+  return p;
+}
+
+// The UTC instant for a wall-clock time interpreted in `tz`, DST-correct via an
+// offset back-solve (one correction pass resolves spring-forward/fall-back).
+function zonedWallToUtc({ year, month, day, hour, minute, second }, tz) {
+  const offsetAt = (ms) => {
+    const p = partsInZone(new Date(ms), tz);
+    return Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second) - ms;
+  };
+  const naive = Date.UTC(year, month - 1, day, hour, minute, second);
+  let utc = naive - offsetAt(naive);
+  utc = naive - offsetAt(utc);
+  return new Date(utc);
+}
+
+// Parse a date string into a UTC instant. A string carrying an explicit zone
+// (Z or ±HH:MM) is an absolute instant; a naive 'YYYY-MM-DD[ HH:MM[:SS]]' is
+// interpreted as wall-clock in `tz`.
+export function parseInZone(s, tz = 'UTC') {
+  const iso = String(s).trim().replace(' ', 'T');
+  if (/(?:[zZ]|[+-]\d{2}:?\d{2})$/.test(iso)) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime())) throw new Error(`Invalid date '${s}' (use YYYY-MM-DD or ISO 8601)`);
+    return d;
+  }
+  const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2}))?)?$/);
+  if (!m) throw new Error(`Invalid date '${s}' (use YYYY-MM-DD or ISO 8601)`);
+  return zonedWallToUtc(
+    { year: +m[1], month: +m[2], day: +m[3], hour: +(m[4] || 0), minute: +(m[5] || 0), second: +(m[6] || 0) },
+    tz
+  );
+}
+
+// Back-compat alias — parsing in UTC.
+export const parseUtc = (s) => parseInZone(s, 'UTC');
+
+function truncTz(date, size, tz) {
+  const p = partsInZone(date, tz);
+  p.second = 0;
+  p.minute = 0;
+  if (size !== 'hour') p.hour = 0;
+  if (size === 'month' || size === 'year') p.day = 1;
+  if (size === 'year') p.month = 1;
+  return zonedWallToUtc(p, tz);
+}
+
+function addBatchesTz(date, size, n, tz) {
+  const p = partsInZone(date, tz);
+  if (size === 'hour') p.hour += n;
+  else if (size === 'day') p.day += n;
+  else if (size === 'month') p.month += n;
+  else p.year += n;
+  return zonedWallToUtc(p, tz); // Date.UTC normalizes overflow (day 32, month 13, ...)
+}
+
+function fmtTz(date, tz) {
+  const p = partsInZone(date, tz);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${p.year}-${pad(p.month)}-${pad(p.day)} ${pad(p.hour)}:${pad(p.minute)}:${pad(p.second)}`;
+}
+
+// Returns [{ start, end }] of aligned [start, end) windows as 'YYYY-MM-DD HH:MM:SS'.
+//   first build / --full-refresh : trunc(begin) .. current batch end
+//   normal run                   : trunc(now) - lookback .. current batch end
+//   explicit backfill            : trunc(start) .. ceil(end)  (whole batches)
+// The window never starts before `begin`.
+export function computeBatches({ begin, batchSize, lookback = 1, start, end, firstBuild, timezone = 'UTC', now = new Date() }) {
+  if (!UNITS.includes(batchSize)) throw new Error(`Invalid batch_size '${batchSize}' (use ${UNITS.join('|')})`);
+  const beginAt = truncTz(parseInZone(begin, timezone), batchSize, timezone);
+
+  let endAt;
+  if (end) {
+    const e = parseInZone(end, timezone);
+    const t = truncTz(e, batchSize, timezone);
+    endAt = e.getTime() === t.getTime() ? t : addBatchesTz(t, batchSize, 1, timezone);
+  } else {
+    endAt = addBatchesTz(truncTz(now, batchSize, timezone), batchSize, 1, timezone);
+  }
+
+  let startAt;
+  if (start) startAt = truncTz(parseInZone(start, timezone), batchSize, timezone);
+  else if (firstBuild) startAt = beginAt;
+  else startAt = addBatchesTz(truncTz(now, batchSize, timezone), batchSize, -lookback, timezone);
+  if (startAt < beginAt) startAt = beginAt;
+
+  if (start && startAt >= endAt) {
+    throw new Error(`--event-time-start (${fmtTz(startAt, timezone)}) must be before the end of the window (${fmtTz(endAt, timezone)})`);
+  }
+  // A future (or otherwise out-of-range) `begin` clamps startAt up to or past
+  // endAt, yielding zero batches. Without this guard `compile` crashes on b[0]
+  // and `run` silently reports success while never creating the table.
+  if (startAt >= endAt) {
+    throw new Error(
+      `Microbatch window is empty: start ${fmtTz(startAt, timezone)} is not before end ${fmtTz(endAt, timezone)} — ` +
+        `check that "begin" (${fmtTz(beginAt, timezone)}) is in the past relative to now (${fmtTz(now, timezone)})`
+    );
+  }
+
+  const batches = [];
+  for (let t = startAt; t < endAt; t = addBatchesTz(t, batchSize, 1, timezone)) {
+    batches.push({ start: fmtTz(t, timezone), end: fmtTz(addBatchesTz(t, batchSize, 1, timezone), timezone) });
+  }
+  return batches;
+}

package/src/cli.js

@@ -1,175 +1,178 @@
-// Thin CLI over src/api.js: parse flags, format events as log lines, map
-// result.ok to the exit code. All orchestration lives in the api.
-import { parseArgs } from 'node:util';
-import * as api from './api.js';
-
-const USAGE = `Usage: dbt-js <command> [options]
-
-Commands:
-  run      Build models in dependency order
-  test     Run data tests (not_null, unique, accepted_values)
-  seed     Load seeds/*.csv into the target schema
-  compile  Print compiled SQL without executing (is_incremental() = false)
-  ls       List nodes in execution order
-  debug    Check config and database connectivity
-
-Options:
-  --select SPEC          Comma-separated nodes; +name includes upstream, name+ downstream
-  --full-refresh         Rebuild incremental models from scratch (run only)
-  --vars JSON            Override project vars, e.g. --vars '{"start":"2026-06-01"}'
-  --event-time-start TS  Backfill microbatch models from this time (run only)
-  --event-time-end TS    End of the backfill window (requires --event-time-start)`;
-
-export async function main(argv = process.argv.slice(2)) {
-  let values, command;
-  try {
-    const parsed = parseArgs({
-      args: argv,
-      allowPositionals: true,
-      options: {
-        select: { type: 'string' },
-        'full-refresh': { type: 'boolean', default: false },
-        vars: { type: 'string' },
-        'event-time-start': { type: 'string' },
-        'event-time-end': { type: 'string' },
-        help: { type: 'boolean', default: false },
-      },
-    });
-    values = parsed.values;
-    command = parsed.positionals[0];
-  } catch (e) {
-    console.error(`Error: ${e.message}\n\n${USAGE}`);
-    process.exit(2);
-  }
-
-  if (!command || values.help) {
-    console.log(USAGE);
-    process.exit(command ? 0 : 2);
-  }
-
-  const commands = { run, test, seed, compile, ls, debug };
-  if (!commands[command]) {
-    console.error(`Error: unknown command '${command}'\n\n${USAGE}`);
-    process.exit(2);
-  }
-
-  try {
-    const ok = await commands[command](values);
-    process.exit(ok ? 0 : 1);
-  } catch (e) {
-    console.error(`Error: ${e.message}`);
-    process.exit(1);
-  }
-}
-
-const pad = (s, n) => String(s).padEnd(n);
-
-function baseOpts(values) {
-  const opts = { select: values.select };
-  if (values.vars) {
-    try {
-      opts.vars = JSON.parse(values.vars);
-    } catch {
-      throw new Error(`--vars must be valid JSON, got: ${values.vars}`);
-    }
-  }
-  return opts;
-}
-
-function printModelEvent(e) {
-  if (e.type === 'batch') {
-    const detail = e.ok ? (e.rowCount != null ? `${e.rowCount} rows` : 'ok') : e.message;
-    console.log(`      batch ${e.start} .. ${e.end}  ${e.ok ? 'OK' : 'FAIL'} (${detail})`);
-    return;
-  }
-  const tag = `[${e.index}/${e.total}]`;
-  if (e.status === 'skip') {
-    console.log(`${tag} ${pad('SKIP', 5)} ${pad(e.materialized, 12)} ${e.name} (upstream failed)`);
-  } else if (e.status === 'fail' && e.failedBatches?.length) {
-    const f = e.failedBatches;
-    console.log(
-      `${tag} ${pad('FAIL', 5)} ${pad(e.action, 12)} ${e.name} — ${e.error}; ` +
-      `retry with --select ${e.name} --event-time-start "${f[0].start}" --event-time-end "${f[f.length - 1].end}"`
-    );
-  } else if (e.status === 'fail') {
-    console.log(`${tag} ${pad('FAIL', 5)} ${pad(e.materialized, 12)} ${e.name} — ${e.error}`);
-  } else {
-    const rows = e.rowCount != null ? `, ${e.rowCount} rows` : '';
-    const batches = e.batchCount != null ? `, ${e.batchCount} batches` : '';
-    console.log(`${tag} ${pad('OK', 5)} ${pad(e.action, 12)} ${e.name} (${e.durationMs}ms${rows}${batches})`);
-  }
-}
-
-async function run(values) {
-  if (values['event-time-end'] && !values['event-time-start']) {
-    throw new Error('--event-time-end requires --event-time-start');
-  }
-  const result = await api.run({
-    ...baseOpts(values),
-    fullRefresh: values['full-refresh'],
-    eventTimeStart: values['event-time-start'],
-    eventTimeEnd: values['event-time-end'],
-    onEvent: printModelEvent,
-  });
-  const counts = { ok: 0, fail: 0, skip: 0 };
-  for (const m of result.models) counts[m.status]++;
-  console.log(`\nDone: ${counts.ok} ok, ${counts.fail} failed, ${counts.skip} skipped`);
-  return result.ok;
-}
-
-async function test(values) {
-  const result = await api.test({
-    ...baseOpts(values),
-    onEvent: (e) => {
-      if (e.pass) {
-        console.log(`PASS ${e.id}`);
-      } else {
-        console.log(`FAIL ${e.id} (${e.violations} violating rows)`);
-        for (const row of e.sample) console.log(`     ${JSON.stringify(row)}`);
-      }
-    },
-  });
-  if (!result.tests.length) {
-    console.log('No tests defined.');
-    return true;
-  }
-  const failures = result.tests.filter((t) => !t.pass).length;
-  console.log(`\nDone: ${result.tests.length - failures} passed, ${failures} failed`);
-  return result.ok;
-}
-
-async function seed(values) {
-  const result = await api.seed({
-    select: values.select,
-    onEvent: (e) =>
-      console.log(`[${e.index}/${e.total}] ${pad('OK', 5)} ${pad('seed', 12)} ${e.name} (${e.durationMs}ms, ${e.rowCount} rows)`),
-  });
-  return result.ok;
-}
-
-async function compile(values) {
-  for (const m of await api.compile(baseOpts(values))) {
-    console.log(`-- model: ${m.name} (${m.materialized})`);
-    m.preHookSql.forEach((sql, i) => console.log(`-- pre_hook[${i}]:\n${sql}`));
-    console.log(m.sql);
-    m.postHookSql.forEach((sql, i) => console.log(`-- post_hook[${i}]:\n${sql}`));
-    console.log('');
-  }
-  return true;
-}
-
-async function ls() {
-  for (const n of await api.ls()) {
-    const deps = n.deps.length ? `  <- ${n.deps.join(', ')}` : '';
-    console.log(`${pad(n.kind, 12)} ${n.name}${deps}`);
-  }
-  return true;
-}
-
-async function debug() {
-  const d = await api.debug();
-  console.log(`config:  OK (schema "${d.schema}", ${d.modelCount} models, ${d.seedCount} seeds)`);
-  console.log(`target:  ${d.target}`);
-  console.log(`connect: OK (${d.database}, ${d.version.split(' on ')[0]})`);
-  return true;
-}
+// Thin CLI over src/api.js: parse flags, format events as log lines, map
+// result.ok to the exit code. All orchestration lives in the api.
+import { parseArgs } from 'node:util';
+import * as api from './api.js';
+
+const USAGE = `Usage: dbt-js <command> [options]
+
+Commands:
+  run      Build models in dependency order
+  test     Run data tests (not_null, unique, accepted_values)
+  seed     Load seeds/*.csv into the target schema
+  compile  Print compiled SQL without executing (is_incremental() = false)
+  ls       List nodes in execution order
+  debug    Check config and database connectivity
+
+Options:
+  --select SPEC          Comma-separated nodes; +name includes upstream, name+ downstream
+  --full-refresh         Rebuild incremental models from scratch (run only)
+  --vars JSON            Override project vars, e.g. --vars '{"start":"2026-06-01"}'
+  --event-time-start TS  Backfill microbatch models from this time (run only)
+  --event-time-end TS    End of the backfill window (requires --event-time-start)`;
+
+export async function main(argv = process.argv.slice(2)) {
+  let values, command;
+  try {
+    const parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        select: { type: 'string' },
+        'full-refresh': { type: 'boolean', default: false },
+        vars: { type: 'string' },
+        'event-time-start': { type: 'string' },
+        'event-time-end': { type: 'string' },
+        help: { type: 'boolean', default: false },
+      },
+    });
+    values = parsed.values;
+    command = parsed.positionals[0];
+  } catch (e) {
+    console.error(`Error: ${e.message}\n\n${USAGE}`);
+    process.exit(2);
+  }
+
+  if (!command || values.help) {
+    console.log(USAGE);
+    process.exit(command ? 0 : 2);
+  }
+
+  const commands = { run, test, seed, compile, ls, debug };
+  if (!commands[command]) {
+    console.error(`Error: unknown command '${command}'\n\n${USAGE}`);
+    process.exit(2);
+  }
+
+  try {
+    const ok = await commands[command](values);
+    process.exit(ok ? 0 : 1);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+const pad = (s, n) => String(s).padEnd(n);
+
+function baseOpts(values) {
+  const opts = { select: values.select };
+  if (values.vars) {
+    try {
+      opts.vars = JSON.parse(values.vars);
+    } catch {
+      throw new Error(`--vars must be valid JSON, got: ${values.vars}`);
+    }
+  }
+  return opts;
+}
+
+function printModelEvent(e) {
+  if (e.type === 'batch') {
+    const detail = e.ok ? (e.rowCount != null ? `${e.rowCount} rows` : 'ok') : e.message;
+    console.log(`      batch ${e.start} .. ${e.end}  ${e.ok ? 'OK' : 'FAIL'} (${detail})`);
+    return;
+  }
+  const tag = `[${e.index}/${e.total}]`;
+  if (e.status === 'skip') {
+    console.log(`${tag} ${pad('SKIP', 5)} ${pad(e.materialized, 12)} ${e.name} (upstream failed)`);
+  } else if (e.status === 'fail' && e.failedBatches?.length) {
+    const f = e.failedBatches;
+    console.log(
+      `${tag} ${pad('FAIL', 5)} ${pad(e.action, 12)} ${e.name} — ${e.error}; ` +
+      `retry with --select ${e.name} --event-time-start "${f[0].start}" --event-time-end "${f[f.length - 1].end}"`
+    );
+  } else if (e.status === 'fail') {
+    console.log(`${tag} ${pad('FAIL', 5)} ${pad(e.materialized, 12)} ${e.name} — ${e.error}`);
+  } else {
+    const rows = e.rowCount != null ? `, ${e.rowCount} rows` : '';
+    const batches = e.batchCount != null ? `, ${e.batchCount} batches` : '';
+    console.log(`${tag} ${pad('OK', 5)} ${pad(e.action, 12)} ${e.name} (${e.durationMs}ms${rows}${batches})`);
+  }
+}
+
+async function run(values) {
+  if (values['event-time-end'] && !values['event-time-start']) {
+    throw new Error('--event-time-end requires --event-time-start');
+  }
+  const result = await api.run({
+    ...baseOpts(values),
+    fullRefresh: values['full-refresh'],
+    eventTimeStart: values['event-time-start'],
+    eventTimeEnd: values['event-time-end'],
+    onEvent: printModelEvent,
+  });
+  const counts = { ok: 0, fail: 0, skip: 0 };
+  for (const m of result.models) counts[m.status]++;
+  console.log(`\nDone: ${counts.ok} ok, ${counts.fail} failed, ${counts.skip} skipped`);
+  return result.ok;
+}
+
+async function test(values) {
+  const result = await api.test({
+    ...baseOpts(values),
+    onEvent: (e) => {
+      if (e.pass) {
+        console.log(`PASS ${e.id}`);
+      } else {
+        console.log(`FAIL ${e.id} (${e.violations} violating rows)`);
+        for (const row of e.sample) console.log(`     ${JSON.stringify(row)}`);
+      }
+    },
+  });
+  if (!result.tests.length) {
+    console.log('No tests defined.');
+    return true;
+  }
+  const failures = result.tests.filter((t) => !t.pass).length;
+  console.log(`\nDone: ${result.tests.length - failures} passed, ${failures} failed`);
+  return result.ok;
+}
+
+async function seed(values) {
+  const result = await api.seed({
+    select: values.select,
+    onEvent: (e) =>
+      console.log(`[${e.index}/${e.total}] ${pad('OK', 5)} ${pad('seed', 12)} ${e.name} (${e.durationMs}ms, ${e.rowCount} rows)`),
+  });
+  return result.ok;
+}
+
+async function compile(values) {
+  for (const m of await api.compile(baseOpts(values))) {
+    console.log(`-- model: ${m.name} (${m.materialized})`);
+    m.preHookSql.forEach((sql, i) => console.log(`-- pre_hook[${i}]:\n${sql}`));
+    console.log(m.sql);
+    m.postHookSql.forEach((sql, i) => console.log(`-- post_hook[${i}]:\n${sql}`));
+    console.log('');
+  }
+  return true;
+}
+
+async function ls() {
+  for (const n of await api.ls()) {
+    const deps = n.deps.length ? `  <- ${n.deps.join(', ')}` : '';
+    console.log(`${pad(n.kind, 12)} ${n.name}${deps}`);
+  }
+  return true;
+}
+
+async function debug() {
+  const d = await api.debug();
+  console.log(`config:  OK (schema "${d.schema}", ${d.modelCount} models, ${d.seedCount} seeds)`);
+  console.log(`target:  ${d.target}`);
+  console.log(`connect: OK (${d.database}, ${d.version.split(' on ')[0]})`);
+  for (const a of d.attached ?? []) {
+    console.log(`attach:  OK (${a.alias} -> ${a.path}${a.type ? `, ${a.type}` : ''}${a.readonly ? ', read-only' : ''})`);
+  }
+  return true;
+}