@vertz/db 0.2.0 → 0.2.3

package/dist/shared/{chunk-3f2grpak.js → chunk-0e1vy9qd.js}

@@ -1,7 +1,89 @@
 import {
   camelToSnake
-} from "./chunk-hrfdj0rr.js";
+} from "./chunk-v2qm94qp.js";
 
+// src/dialect/postgres.ts
+class PostgresDialect {
+  name = "postgres";
+  supportsReturning = true;
+  supportsArrayOps = true;
+  supportsJsonbPath = true;
+  param(index) {
+    return `$${index}`;
+  }
+  now() {
+    return "NOW()";
+  }
+  mapColumnType(sqlType, meta) {
+    switch (sqlType) {
+      case "uuid":
+        return "UUID";
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "serial":
+        return "SERIAL";
+      case "boolean":
+        return "BOOLEAN";
+      case "timestamp":
+        return "TIMESTAMPTZ";
+      case "float":
+        return "DOUBLE PRECISION";
+      case "json":
+        return "JSONB";
+      case "decimal":
+        return meta?.precision ? `NUMERIC(${meta.precision},${meta.scale ?? 0})` : "NUMERIC";
+      case "varchar":
+        return meta?.length ? `VARCHAR(${meta.length})` : "VARCHAR";
+      case "enum":
+        return meta?.enumName ?? "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+}
+var defaultPostgresDialect = new PostgresDialect;
+
+// src/dialect/sqlite.ts
+class SqliteDialect {
+  name = "sqlite";
+  supportsReturning = true;
+  supportsArrayOps = false;
+  supportsJsonbPath = false;
+  param(_index) {
+    return "?";
+  }
+  now() {
+    return "datetime('now')";
+  }
+  mapColumnType(sqlType, _meta) {
+    switch (sqlType) {
+      case "uuid":
+        return "TEXT";
+      case "boolean":
+        return "INTEGER";
+      case "timestamp":
+        return "TEXT";
+      case "json":
+      case "jsonb":
+        return "TEXT";
+      case "decimal":
+        return "REAL";
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "bigint":
+        return "INTEGER";
+      case "serial":
+        return "INTEGER";
+      default:
+        return "TEXT";
+    }
+  }
+}
+var defaultSqliteDialect = new SqliteDialect;
 // src/sql/where.ts
 var OPERATOR_KEYS = new Set([
   "eq",
@@ -33,11 +115,14 @@ function escapeSingleQuotes(str) {
 function escapeLikeValue(str) {
   return str.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
-function resolveColumnRef(key) {
+function resolveColumnRef(key, overrides, dialect) {
   if (key.includes("->")) {
+    if (dialect && !dialect.supportsJsonbPath) {
+      throw new Error("JSONB path operators (->>, ->) are not supported on SQLite. " + "Use json_extract() via raw SQL or switch to Postgres.");
+    }
     const parts = key.split("->");
     const baseCol = parts[0] ?? key;
-    const column = `"${camelToSnake(baseCol)}"`;
+    const column = `"${camelToSnake(baseCol, overrides)}"`;
     const jsonPath = parts.slice(1);
     if (jsonPath.length === 1) {
       return `${column}->>'${escapeSingleQuotes(jsonPath[0] ?? "")}'`;
@@ -47,54 +132,54 @@ function resolveColumnRef(key) {
     const final = `->>'${escapeSingleQuotes(lastKey)}'`;
     return `${column}${intermediate}${final}`;
   }
-  return `"${camelToSnake(key)}"`;
+  return `"${camelToSnake(key, overrides)}"`;
 }
-function buildOperatorCondition(columnRef, operators, paramIndex) {
+function buildOperatorCondition(columnRef, operators, paramIndex, dialect) {
   const clauses = [];
   const params = [];
   let idx = paramIndex;
   if (operators.eq !== undefined) {
-    clauses.push(`${columnRef} = $${idx + 1}`);
+    clauses.push(`${columnRef} = ${dialect.param(idx + 1)}`);
     params.push(operators.eq);
     idx++;
   }
   if (operators.ne !== undefined) {
-    clauses.push(`${columnRef} != $${idx + 1}`);
+    clauses.push(`${columnRef} != ${dialect.param(idx + 1)}`);
     params.push(operators.ne);
     idx++;
   }
   if (operators.gt !== undefined) {
-    clauses.push(`${columnRef} > $${idx + 1}`);
+    clauses.push(`${columnRef} > ${dialect.param(idx + 1)}`);
     params.push(operators.gt);
     idx++;
   }
   if (operators.gte !== undefined) {
-    clauses.push(`${columnRef} >= $${idx + 1}`);
+    clauses.push(`${columnRef} >= ${dialect.param(idx + 1)}`);
     params.push(operators.gte);
     idx++;
   }
   if (operators.lt !== undefined) {
-    clauses.push(`${columnRef} < $${idx + 1}`);
+    clauses.push(`${columnRef} < ${dialect.param(idx + 1)}`);
     params.push(operators.lt);
     idx++;
   }
   if (operators.lte !== undefined) {
-    clauses.push(`${columnRef} <= $${idx + 1}`);
+    clauses.push(`${columnRef} <= ${dialect.param(idx + 1)}`);
     params.push(operators.lte);
     idx++;
   }
   if (operators.contains !== undefined) {
-    clauses.push(`${columnRef} LIKE $${idx + 1}`);
+    clauses.push(`${columnRef} LIKE ${dialect.param(idx + 1)}`);
     params.push(`%${escapeLikeValue(operators.contains)}%`);
     idx++;
   }
   if (operators.startsWith !== undefined) {
-    clauses.push(`${columnRef} LIKE $${idx + 1}`);
+    clauses.push(`${columnRef} LIKE ${dialect.param(idx + 1)}`);
     params.push(`${escapeLikeValue(operators.startsWith)}%`);
     idx++;
   }
   if (operators.endsWith !== undefined) {
-    clauses.push(`${columnRef} LIKE $${idx + 1}`);
+    clauses.push(`${columnRef} LIKE ${dialect.param(idx + 1)}`);
     params.push(`%${escapeLikeValue(operators.endsWith)}`);
     idx++;
   }
@@ -102,7 +187,7 @@ function buildOperatorCondition(columnRef, operators, paramIndex) {
     if (operators.in.length === 0) {
       clauses.push("FALSE");
     } else {
-      const placeholders = operators.in.map((_, i) => `$${idx + 1 + i}`).join(", ");
+      const placeholders = operators.in.map((_, i) => dialect.param(idx + 1 + i)).join(", ");
       clauses.push(`${columnRef} IN (${placeholders})`);
       params.push(...operators.in);
       idx += operators.in.length;
@@ -112,7 +197,7 @@ function buildOperatorCondition(columnRef, operators, paramIndex) {
     if (operators.notIn.length === 0) {
       clauses.push("TRUE");
     } else {
-      const placeholders = operators.notIn.map((_, i) => `$${idx + 1 + i}`).join(", ");
+      const placeholders = operators.notIn.map((_, i) => dialect.param(idx + 1 + i)).join(", ");
       clauses.push(`${columnRef} NOT IN (${placeholders})`);
       params.push(...operators.notIn);
       idx += operators.notIn.length;
@@ -122,23 +207,32 @@ function buildOperatorCondition(columnRef, operators, paramIndex) {
     clauses.push(`${columnRef} ${operators.isNull ? "IS NULL" : "IS NOT NULL"}`);
   }
   if (operators.arrayContains !== undefined) {
-    clauses.push(`${columnRef} @> $${idx + 1}`);
+    if (!dialect.supportsArrayOps) {
+      throw new Error("Array operators (arrayContains, arrayContainedBy, arrayOverlaps) are not supported on SQLite. " + "Use a different filter strategy or switch to Postgres.");
+    }
+    clauses.push(`${columnRef} @> ${dialect.param(idx + 1)}`);
     params.push(operators.arrayContains);
     idx++;
   }
   if (operators.arrayContainedBy !== undefined) {
-    clauses.push(`${columnRef} <@ $${idx + 1}`);
+    if (!dialect.supportsArrayOps) {
+      throw new Error("Array operators (arrayContains, arrayContainedBy, arrayOverlaps) are not supported on SQLite. " + "Use a different filter strategy or switch to Postgres.");
+    }
+    clauses.push(`${columnRef} <@ ${dialect.param(idx + 1)}`);
     params.push(operators.arrayContainedBy);
     idx++;
   }
   if (operators.arrayOverlaps !== undefined) {
-    clauses.push(`${columnRef} && $${idx + 1}`);
+    if (!dialect.supportsArrayOps) {
+      throw new Error("Array operators (arrayContains, arrayContainedBy, arrayOverlaps) are not supported on SQLite. " + "Use a different filter strategy or switch to Postgres.");
+    }
+    clauses.push(`${columnRef} && ${dialect.param(idx + 1)}`);
     params.push(operators.arrayOverlaps);
     idx++;
   }
   return { clauses, params, nextIndex: idx };
 }
-function buildFilterClauses(filter, paramOffset) {
+function buildFilterClauses(filter, paramOffset, overrides, dialect) {
   const clauses = [];
   const allParams = [];
   let idx = paramOffset;
@@ -146,14 +240,14 @@ function buildFilterClauses(filter, paramOffset) {
     if (key === "OR" || key === "AND" || key === "NOT") {
       continue;
     }
-    const columnRef = resolveColumnRef(key);
+    const columnRef = resolveColumnRef(key, overrides, dialect);
     if (isOperatorObject(value)) {
-      const result = buildOperatorCondition(columnRef, value, idx);
+      const result = buildOperatorCondition(columnRef, value, idx, dialect);
       clauses.push(...result.clauses);
       allParams.push(...result.params);
       idx = result.nextIndex;
     } else {
-      clauses.push(`${columnRef} = $${idx + 1}`);
+      clauses.push(`${columnRef} = ${dialect.param(idx + 1)}`);
       allParams.push(value);
       idx++;
     }
@@ -164,7 +258,7 @@ function buildFilterClauses(filter, paramOffset) {
     } else {
       const orClauses = [];
       for (const subFilter of filter.OR) {
-        const sub = buildFilterClauses(subFilter, idx);
+        const sub = buildFilterClauses(subFilter, idx, overrides, dialect);
         const joined = sub.clauses.join(" AND ");
         orClauses.push(sub.clauses.length > 1 ? `(${joined})` : joined);
         allParams.push(...sub.params);
@@ -179,7 +273,7 @@ function buildFilterClauses(filter, paramOffset) {
     } else {
       const andClauses = [];
       for (const subFilter of filter.AND) {
-        const sub = buildFilterClauses(subFilter, idx);
+        const sub = buildFilterClauses(subFilter, idx, overrides, dialect);
         const joined = sub.clauses.join(" AND ");
         andClauses.push(sub.clauses.length > 1 ? `(${joined})` : joined);
         allParams.push(...sub.params);
@@ -189,18 +283,18 @@ function buildFilterClauses(filter, paramOffset) {
     }
   }
   if (filter.NOT !== undefined) {
-    const sub = buildFilterClauses(filter.NOT, idx);
+    const sub = buildFilterClauses(filter.NOT, idx, overrides, dialect);
     clauses.push(`NOT (${sub.clauses.join(" AND ")})`);
     allParams.push(...sub.params);
     idx = sub.nextIndex;
   }
   return { clauses, params: allParams, nextIndex: idx };
 }
-function buildWhere(filter, paramOffset = 0) {
+function buildWhere(filter, paramOffset = 0, overrides, dialect = defaultPostgresDialect) {
   if (!filter || Object.keys(filter).length === 0) {
     return { sql: "", params: [] };
   }
-  const { clauses, params } = buildFilterClauses(filter, paramOffset);
+  const { clauses, params } = buildFilterClauses(filter, paramOffset, overrides, dialect);
   return {
     sql: clauses.join(" AND "),
     params
@@ -215,11 +309,11 @@ function buildReturningColumnRef(name) {
   }
   return `"${snakeName}" AS "${name}"`;
 }
-function buildDelete(options) {
+function buildDelete(options, dialect = options.dialect ?? defaultPostgresDialect) {
   const allParams = [];
   let sql = `DELETE FROM "${options.table}"`;
   if (options.where) {
-    const whereResult = buildWhere(options.where);
+    const whereResult = buildWhere(options.where, 0, undefined, dialect);
     if (whereResult.sql.length > 0) {
       sql += ` WHERE ${whereResult.sql}`;
       allParams.push(...whereResult.params);
@@ -244,7 +338,7 @@ function buildReturningColumnRef2(name) {
   }
   return `"${snakeName}" AS "${name}"`;
 }
-function buildInsert(options) {
+function buildInsert(options, dialect = options.dialect ?? defaultPostgresDialect) {
   const rows = Array.isArray(options.data) ? options.data : [options.data];
   const firstRow = rows[0];
   if (!firstRow) {
@@ -260,10 +354,10 @@ function buildInsert(options) {
     for (const key of keys) {
       const value = row[key];
       if (nowSet.has(key) && value === "now") {
-        placeholders.push("NOW()");
+        placeholders.push(dialect.now());
       } else {
         allParams.push(value);
-        placeholders.push(`$${allParams.length}`);
+        placeholders.push(dialect.param(allParams.length));
       }
     }
     valuesClauses.push(`(${placeholders.join(", ")})`);
@@ -279,7 +373,7 @@ function buildInsert(options) {
         const setClauses = options.onConflict.updateColumns.map((c) => {
           const snakeCol = camelToSnake(c);
           allParams.push(updateVals[c]);
-          return `"${snakeCol}" = $${allParams.length}`;
+          return `"${snakeCol}" = ${dialect.param(allParams.length)}`;
         }).join(", ");
         sql += ` ON CONFLICT (${conflictCols}) DO UPDATE SET ${setClauses}`;
       } else {
@@ -303,19 +397,20 @@ function buildInsert(options) {
 }
 
 // src/sql/select.ts
-function buildColumnRef(name) {
-  const snakeName = camelToSnake(name);
+function buildColumnRef(name, casingOverrides) {
+  const snakeName = camelToSnake(name, casingOverrides);
   if (snakeName === name) {
     return `"${name}"`;
   }
   return `"${snakeName}" AS "${name}"`;
 }
-function buildSelect(options) {
+function buildSelect(options, dialect = options.dialect ?? defaultPostgresDialect) {
   const parts = [];
   const allParams = [];
+  const { casingOverrides } = options;
   let columnList;
   if (options.columns && options.columns.length > 0) {
-    columnList = options.columns.map(buildColumnRef).join(", ");
+    columnList = options.columns.map((col) => buildColumnRef(col, casingOverrides)).join(", ");
   } else {
     columnList = "*";
   }
@@ -325,7 +420,7 @@ function buildSelect(options) {
   parts.push(`SELECT ${columnList} FROM "${options.table}"`);
   const whereClauses = [];
   if (options.where) {
-    const whereResult = buildWhere(options.where);
+    const whereResult = buildWhere(options.where, 0, casingOverrides, dialect);
     if (whereResult.sql.length > 0) {
       whereClauses.push(whereResult.sql);
       allParams.push(...whereResult.params);
@@ -335,11 +430,11 @@ function buildSelect(options) {
     const cursorEntries = Object.entries(options.cursor);
     if (cursorEntries.length === 1) {
       const [col, value] = cursorEntries[0];
-      const snakeCol = camelToSnake(col);
+      const snakeCol = camelToSnake(col, casingOverrides);
       const dir = options.orderBy?.[col] ?? "asc";
       const op = dir === "desc" ? "<" : ">";
       allParams.push(value);
-      whereClauses.push(`"${snakeCol}" ${op} $${allParams.length}`);
+      whereClauses.push(`"${snakeCol}" ${op} ${dialect.param(allParams.length)}`);
     } else if (cursorEntries.length > 1) {
       const cols = [];
       const placeholders = [];
@@ -347,9 +442,9 @@ function buildSelect(options) {
       const dir = options.orderBy?.[firstCol] ?? "asc";
       const op = dir === "desc" ? "<" : ">";
       for (const [col, value] of cursorEntries) {
-        cols.push(`"${camelToSnake(col)}"`);
+        cols.push(`"${camelToSnake(col, casingOverrides)}"`);
         allParams.push(value);
-        placeholders.push(`$${allParams.length}`);
+        placeholders.push(dialect.param(allParams.length));
       }
       whereClauses.push(`(${cols.join(", ")}) ${op} (${placeholders.join(", ")})`);
     }
@@ -358,12 +453,12 @@ function buildSelect(options) {
     parts.push(`WHERE ${whereClauses.join(" AND ")}`);
   }
   if (options.orderBy) {
-    const orderClauses = Object.entries(options.orderBy).map(([col, dir]) => `"${camelToSnake(col)}" ${dir.toUpperCase()}`);
+    const orderClauses = Object.entries(options.orderBy).map(([col, dir]) => `"${camelToSnake(col, casingOverrides)}" ${dir.toUpperCase()}`);
     if (orderClauses.length > 0) {
       parts.push(`ORDER BY ${orderClauses.join(", ")}`);
     }
   } else if (options.cursor) {
-    const orderClauses = Object.keys(options.cursor).map((col) => `"${camelToSnake(col)}" ASC`);
+    const orderClauses = Object.keys(options.cursor).map((col) => `"${camelToSnake(col, casingOverrides)}" ASC`);
     if (orderClauses.length > 0) {
       parts.push(`ORDER BY ${orderClauses.join(", ")}`);
     }
@@ -371,11 +466,11 @@ function buildSelect(options) {
   const effectiveLimit = options.take ?? options.limit;
   if (effectiveLimit !== undefined) {
     allParams.push(effectiveLimit);
-    parts.push(`LIMIT $${allParams.length}`);
+    parts.push(`LIMIT ${dialect.param(allParams.length)}`);
   }
   if (options.offset !== undefined) {
     allParams.push(options.offset);
-    parts.push(`OFFSET $${allParams.length}`);
+    parts.push(`OFFSET ${dialect.param(allParams.length)}`);
   }
   return {
     sql: parts.join(" "),
@@ -391,7 +486,7 @@ function buildReturningColumnRef3(name) {
   }
   return `"${snakeName}" AS "${name}"`;
 }
-function buildUpdate(options) {
+function buildUpdate(options, dialect = options.dialect ?? defaultPostgresDialect) {
   const keys = Object.keys(options.data);
   const nowSet = new Set(options.nowColumns ?? []);
   const allParams = [];
@@ -400,15 +495,15 @@ function buildUpdate(options) {
     const snakeCol = camelToSnake(key);
     const value = options.data[key];
     if (nowSet.has(key) && value === "now") {
-      setClauses.push(`"${snakeCol}" = NOW()`);
+      setClauses.push(`"${snakeCol}" = ${dialect.now()}`);
     } else {
       allParams.push(value);
-      setClauses.push(`"${snakeCol}" = $${allParams.length}`);
+      setClauses.push(`"${snakeCol}" = ${dialect.param(allParams.length)}`);
     }
   }
   let sql = `UPDATE "${options.table}" SET ${setClauses.join(", ")}`;
   if (options.where) {
-    const whereResult = buildWhere(options.where, allParams.length);
+    const whereResult = buildWhere(options.where, allParams.length, undefined, dialect);
     if (whereResult.sql.length > 0) {
       sql += ` WHERE ${whereResult.sql}`;
       allParams.push(...whereResult.params);
@@ -425,4 +520,4 @@ function buildUpdate(options) {
   return { sql, params: allParams };
 }
 
-export { buildWhere, buildDelete, buildInsert, buildSelect, buildUpdate };
+export { PostgresDialect, defaultPostgresDialect, SqliteDialect, defaultSqliteDialect, buildWhere, buildDelete, buildInsert, buildSelect, buildUpdate };

package/dist/shared/chunk-2gd1fqcw.js

@@ -0,0 +1,7 @@
+import {
+  createPostgresDriver
+} from "./chunk-rqe0prft.js";
+import"./chunk-j4kwq1gh.js";
+export {
+  createPostgresDriver
+};

package/dist/shared/{chunk-xp022dyp.js → chunk-agyds4jw.js}

@@ -1,6 +1,6 @@
 import {
   snakeToCamel
-} from "./chunk-hrfdj0rr.js";
+} from "./chunk-v2qm94qp.js";
 
 // src/errors/db-error.ts
 class DbError extends Error {
@@ -111,7 +111,7 @@ class CheckConstraintError extends DbError {
 }
 
 class NotFoundError extends DbError {
-  code = "NOT_FOUND";
+  code = "NotFound";
   table;
   query;
   constructor(table, query) {
@@ -239,21 +239,16 @@ function getColumnNames(table) {
   return Object.keys(table._columns);
 }
 function getDefaultColumns(table) {
-  return Object.keys(table._columns).filter((key) => {
-    const col = table._columns[key];
-    return col ? !col._meta.hidden : true;
-  });
-}
-function getNotSensitiveColumns(table) {
-  return Object.keys(table._columns).filter((key) => {
-    const col = table._columns[key];
-    return col ? !col._meta.sensitive && !col._meta.hidden : true;
-  });
+  return getColumnsWithoutAnnotations(table, []);
 }
-function getNotHiddenColumns(table) {
+function getColumnsWithoutAnnotations(table, annotations) {
+  const allAnnotations = annotations.includes("hidden") ? annotations : [...annotations, "hidden"];
   return Object.keys(table._columns).filter((key) => {
     const col = table._columns[key];
-    return col ? !col._meta.hidden : true;
+    if (!col)
+      return true;
+    const colAnnotations = col._meta._annotations;
+    return !allAnnotations.some((f) => colAnnotations[f]);
   });
 }
 function resolveSelectColumns(table, select) {
@@ -261,10 +256,9 @@ function resolveSelectColumns(table, select) {
     return getDefaultColumns(table);
   }
   if ("not" in select && select.not !== undefined) {
-    if (select.not === "sensitive") {
-      return getNotSensitiveColumns(table);
-    }
-    return getNotHiddenColumns(table);
+    const notValue = select.not;
+    const flags = Array.isArray(notValue) ? notValue : [notValue];
+    return getColumnsWithoutAnnotations(table, flags);
   }
   return Object.keys(select).filter((k) => select[k] === true);
 }
@@ -280,6 +274,18 @@ function getPrimaryKeyColumns(table) {
     return col ? col._meta.primary : false;
   });
 }
+function getReadOnlyColumns(table) {
+  return Object.keys(table._columns).filter((key) => {
+    const col = table._columns[key];
+    return col ? col._meta.isReadOnly : false;
+  });
+}
+function getAutoUpdateColumns(table) {
+  return Object.keys(table._columns).filter((key) => {
+    const col = table._columns[key];
+    return col ? col._meta.isAutoUpdate : false;
+  });
+}
 
 // src/query/row-mapper.ts
 function mapRow(row) {
@@ -293,4 +299,4 @@ function mapRows(rows) {
   return rows.map((row) => mapRow(row));
 }
 
-export { DbError, UniqueConstraintError, ForeignKeyError, NotNullError, CheckConstraintError, NotFoundError, ConnectionError, ConnectionPoolExhaustedError, parsePgError, executeQuery, getColumnNames, getDefaultColumns, getNotSensitiveColumns, getNotHiddenColumns, resolveSelectColumns, getTimestampColumns, getPrimaryKeyColumns, mapRow, mapRows };
+export { DbError, UniqueConstraintError, ForeignKeyError, NotNullError, CheckConstraintError, NotFoundError, ConnectionError, ConnectionPoolExhaustedError, parsePgError, executeQuery, getColumnNames, getDefaultColumns, getColumnsWithoutAnnotations, resolveSelectColumns, getTimestampColumns, getPrimaryKeyColumns, getReadOnlyColumns, getAutoUpdateColumns, mapRow, mapRows };

package/dist/shared/chunk-dvwe5jsq.js

@@ -0,0 +1,7 @@
+import {
+  NodeSnapshotStorage
+} from "./chunk-kb4tnn2k.js";
+import"./chunk-j4kwq1gh.js";
+export {
+  NodeSnapshotStorage
+};

package/dist/shared/chunk-j4kwq1gh.js

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __commonJS, __require };

package/dist/shared/{chunk-wj026daz.js → chunk-k04v1jjx.js}

@@ -44,7 +44,7 @@ var ERROR_PATTERNS = [
   },
   {
     pattern: /Record not found in table ([^\s]+)/,
-    code: "NOT_FOUND",
+    code: "NotFound",
     explanation: "A getOrThrow, update, or delete query did not match any rows.",
     suggestion: "Verify the where clause matches existing rows. Use get() if the record may not exist."
   },
@@ -52,7 +52,7 @@ var ERROR_PATTERNS = [
     pattern: /Table "([^"]+)" is not registered in the database/,
     code: "UNREGISTERED_TABLE",
     explanation: "The table name passed to a query method is not in the database registry.",
-    suggestion: "Register the table in the `tables` record passed to `createDb()`."
+    suggestion: "Register the table in the `models` record passed to `createDb()`."
   }
 ];
 function diagnoseError(message) {

package/dist/shared/chunk-kb4tnn2k.js

@@ -0,0 +1,26 @@
+// src/migration/snapshot-storage.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+class NodeSnapshotStorage {
+  async load(path) {
+    try {
+      const content = await readFile(path, "utf-8");
+      return JSON.parse(content);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async save(path, snapshot) {
+    const dir = dirname(path);
+    await mkdir(dir, { recursive: true });
+    const content = JSON.stringify(snapshot, null, 2);
+    await writeFile(path, `${content}
+`, "utf-8");
+  }
+}
+
+export { NodeSnapshotStorage };

package/dist/shared/chunk-pnk6yzjv.js

@@ -0,0 +1,48 @@
+import {
+  BaseSqlAdapter,
+  generateCreateTableSql,
+  generateIndexSql
+} from "./chunk-sfmyxz6r.js";
+
+// src/adapters/d1-adapter.ts
+function createD1Driver(d1) {
+  const query = async (sql, params) => {
+    const prepared = d1.prepare(sql);
+    const bound = params ? prepared.bind(...params) : prepared;
+    const result = await bound.all();
+    return result.results;
+  };
+  const execute = async (sql, params) => {
+    const prepared = d1.prepare(sql);
+    const bound = params ? prepared.bind(...params) : prepared;
+    const result = await bound.run();
+    return { rowsAffected: result.meta.changes };
+  };
+  return {
+    query,
+    execute,
+    close: async () => {}
+  };
+}
+
+class D1Adapter extends BaseSqlAdapter {
+  constructor(driver, schema) {
+    super(driver, schema);
+  }
+}
+function createD1Adapter(options) {
+  const { schema, d1, migrations } = options;
+  const driver = createD1Driver(d1);
+  if (migrations?.autoApply) {
+    const createTableSql = generateCreateTableSql(schema);
+    driver.execute(createTableSql);
+    const indexSqls = generateIndexSql(schema);
+    for (const sql of indexSqls) {
+      driver.execute(sql);
+    }
+    console.log(`\uD83D\uDCE6 D1 database adapter initialized for table: ${schema._name}`);
+  }
+  return new D1Adapter(driver, schema);
+}
+
+export { createD1Driver, createD1Adapter };