@vertz/db 0.2.0 → 0.2.1

package/dist/shared/chunk-fwk49jvg.js

@@ -0,0 +1,302 @@
+// src/id/generators.ts
+import { createId } from "@paralleldrive/cuid2";
+import { v7 as uuidv7 } from "uuid";
+import { nanoid } from "nanoid";
+function generateId(strategy) {
+  switch (strategy) {
+    case "cuid":
+      return createId();
+    case "uuid":
+      return uuidv7();
+    case "nanoid":
+      return nanoid();
+    default:
+      throw new Error(`Unknown ID generation strategy: ${strategy}`);
+  }
+}
+
+// src/adapters/sql-utils.ts
+function getSqlType(meta) {
+  switch (meta.sqlType) {
+    case "serial":
+      return "INTEGER";
+    case "varchar":
+      return meta.length ? `VARCHAR(${meta.length})` : "TEXT";
+    case "text":
+      return "TEXT";
+    case "integer":
+      return "INTEGER";
+    case "bigint":
+      return "BIGINT";
+    case "decimal":
+      return meta.precision && meta.scale ? `DECIMAL(${meta.precision},${meta.scale})` : "REAL";
+    case "boolean":
+      return "INTEGER";
+    case "timestamp":
+    case "timestamptz":
+      return "TEXT";
+    case "date":
+      return "TEXT";
+    case "json":
+    case "jsonb":
+      return "TEXT";
+    case "uuid":
+      return "TEXT";
+    case "enum":
+      return "TEXT";
+    default:
+      return "TEXT";
+  }
+}
+function generateCreateTableSql(schema) {
+  const columns = [];
+  const tableName = schema._name;
+  for (const [colName, colBuilder] of Object.entries(schema._columns)) {
+    const meta = colBuilder._meta;
+    let colDef = `${colName} ${getSqlType(meta)}`;
+    if (meta.primary) {
+      colDef += " PRIMARY KEY";
+      if (meta.generate === "uuid") {
+        colDef += " DEFAULT (uuid())";
+      } else if (meta.generate === "cuid") {
+        colDef += " DEFAULT (cuid())";
+      }
+    }
+    if (meta.unique && !meta.primary) {
+      colDef += " UNIQUE";
+    }
+    if (!meta.nullable && !meta.primary) {
+      colDef += " NOT NULL";
+    }
+    if (meta.hasDefault && meta.defaultValue !== undefined) {
+      if (meta.defaultValue === "now") {
+        colDef += " DEFAULT (datetime('now'))";
+      } else if (typeof meta.defaultValue === "string") {
+        colDef += ` DEFAULT '${meta.defaultValue}'`;
+      } else if (typeof meta.defaultValue === "number") {
+        colDef += ` DEFAULT ${meta.defaultValue}`;
+      } else if (typeof meta.defaultValue === "boolean") {
+        colDef += ` DEFAULT ${meta.defaultValue ? 1 : 0}`;
+      }
+    }
+    if (meta.check) {
+      colDef += ` CHECK (${meta.check})`;
+    }
+    columns.push(colDef);
+  }
+  return `CREATE TABLE IF NOT EXISTS ${tableName} (
+  ${columns.join(`,
+  `)}
+)`;
+}
+function generateIndexSql(schema) {
+  const sqls = [];
+  const tableName = schema._name;
+  for (const index of schema._indexes) {
+    const indexName = index.name || `idx_${tableName}_${index.columns.join("_")}`;
+    const unique = index.unique ? "UNIQUE " : "";
+    sqls.push(`CREATE ${unique}INDEX IF NOT EXISTS ${indexName} ON ${tableName} (${index.columns.join(", ")})`);
+  }
+  for (const [colName, colBuilder] of Object.entries(schema._columns)) {
+    const meta = colBuilder._meta;
+    if (meta.primary || meta.unique)
+      continue;
+    if (meta.sqlType === "boolean") {
+      sqls.push(`CREATE INDEX IF NOT EXISTS idx_${tableName}_${colName} ON ${tableName}(${colName})`);
+    }
+  }
+  return sqls;
+}
+function convertValueForSql(value, sqlType) {
+  if (sqlType === "boolean") {
+    return value ? 1 : 0;
+  }
+  return value;
+}
+function buildWhereClause(where, columns) {
+  const clauses = [];
+  const params = [];
+  for (const [key, value] of Object.entries(where)) {
+    clauses.push(`${key} = ?`);
+    const colMeta = columns[key]?._meta;
+    const convertedValue = convertValueForSql(value, colMeta?.sqlType);
+    params.push(convertedValue);
+  }
+  return { clauses, params };
+}
+
+class BaseSqlAdapter {
+  driver;
+  schema;
+  tableName;
+  constructor(driver, schema) {
+    this.driver = driver;
+    this.schema = schema;
+    this.tableName = schema._name;
+  }
+  getAllowedWhereColumns() {
+    const columns = new Set;
+    for (const colName of Object.keys(this.schema._columns)) {
+      columns.add(colName);
+    }
+    return columns;
+  }
+  convertRow(row) {
+    const converted = { ...row };
+    for (const [colName, colBuilder] of Object.entries(this.schema._columns)) {
+      const meta = colBuilder._meta;
+      if (meta.sqlType === "boolean" && row[colName] !== undefined) {
+        converted[colName] = Boolean(row[colName]);
+      }
+    }
+    return converted;
+  }
+  convertValueForColumn(value, colName) {
+    const colBuilder = this.schema._columns[colName];
+    if (!colBuilder)
+      return value;
+    const meta = colBuilder._meta;
+    return convertValueForSql(value, meta?.sqlType);
+  }
+  async get(id) {
+    try {
+      const rows = await this.driver.query(`SELECT * FROM ${this.tableName} WHERE id = ?`, [id]);
+      if (!rows[0])
+        return null;
+      return this.convertRow(rows[0]);
+    } catch {
+      throw new Error(`Failed to retrieve record: resource may be unavailable`);
+    }
+  }
+  async list(options) {
+    const allowedColumns = this.getAllowedWhereColumns();
+    try {
+      if (options?.where) {
+        for (const key of Object.keys(options.where)) {
+          if (!allowedColumns.has(key)) {
+            throw new Error(`Invalid filter column: ${key}`);
+          }
+        }
+      }
+      let countSql = `SELECT COUNT(*) as count FROM ${this.tableName}`;
+      const countParams = [];
+      if (options?.where && Object.keys(options.where).length > 0) {
+        const { clauses, params: params2 } = buildWhereClause(options.where, this.schema._columns);
+        countSql += ` WHERE ${clauses.join(" AND ")}`;
+        countParams.push(...params2);
+      }
+      const countResult = await this.driver.query(countSql, countParams);
+      const total = Number(countResult[0]?.count ?? 0);
+      let sql = `SELECT * FROM ${this.tableName}`;
+      const params = [];
+      if (options?.where && Object.keys(options.where).length > 0) {
+        const { clauses, params: whereParams } = buildWhereClause(options.where, this.schema._columns);
+        sql += ` WHERE ${clauses.join(" AND ")}`;
+        params.push(...whereParams);
+      }
+      if (options?.after) {
+        sql += params.length > 0 ? " AND" : " WHERE";
+        sql += " id > ?";
+        params.push(options.after);
+      }
+      sql += " ORDER BY id ASC";
+      const limit = options?.limit ?? 20;
+      sql += " LIMIT ?";
+      params.push(limit);
+      const data = await this.driver.query(sql, params);
+      const convertedData = data.map((row) => this.convertRow(row));
+      return { data: convertedData, total };
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("Invalid filter column:")) {
+        throw error;
+      }
+      throw new Error(`Failed to list records: please try again later`);
+    }
+  }
+  async create(data) {
+    try {
+      const columns = [];
+      const placeholders = [];
+      const params = [];
+      for (const [colName, colBuilder] of Object.entries(this.schema._columns)) {
+        const meta = colBuilder._meta;
+        if (meta.isReadOnly && !meta.isAutoUpdate)
+          continue;
+        if (meta.primary && !data[colName] && meta.generate) {
+          data[colName] = generateId(meta.generate);
+        }
+        if (meta.isAutoUpdate) {
+          data[colName] = new Date().toISOString();
+        }
+        if (data[colName] !== undefined || meta.hasDefault) {
+          columns.push(colName);
+          placeholders.push("?");
+          let value = data[colName];
+          if (value === undefined && meta.hasDefault) {
+            if (meta.defaultValue === "now") {
+              value = new Date().toISOString();
+            } else {
+              value = meta.defaultValue;
+            }
+          }
+          value = this.convertValueForColumn(value, colName);
+          params.push(value);
+        }
+      }
+      await this.driver.execute(`INSERT INTO ${this.tableName} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`, params);
+      const id = data.id;
+      return this.get(id);
+    } catch {
+      throw new Error(`Failed to create record: please check your input`);
+    }
+  }
+  async update(id, data) {
+    try {
+      const updates = [];
+      const params = [];
+      for (const [colName, colBuilder] of Object.entries(this.schema._columns)) {
+        const meta = colBuilder._meta;
+        if (meta.isReadOnly && !meta.isAutoUpdate || meta.primary)
+          continue;
+        if (meta.isAutoUpdate) {
+          updates.push(`${colName} = ?`);
+          params.push(new Date().toISOString());
+        }
+        if (data[colName] !== undefined) {
+          updates.push(`${colName} = ?`);
+          const value = this.convertValueForColumn(data[colName], colName);
+          params.push(value);
+        }
+      }
+      if (updates.length === 0) {
+        return this.get(id);
+      }
+      params.push(id);
+      await this.driver.execute(`UPDATE ${this.tableName} SET ${updates.join(", ")} WHERE id = ?`, params);
+      const result = await this.get(id);
+      if (!result) {
+        throw new Error("Record not found");
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof Error && error.message === "Record not found") {
+        throw error;
+      }
+      throw new Error(`Failed to update record: please try again later`);
+    }
+  }
+  async delete(id) {
+    try {
+      const existing = await this.get(id);
+      if (!existing) {
+        return null;
+      }
+      await this.driver.execute(`DELETE FROM ${this.tableName} WHERE id = ?`, [id]);
+      return existing;
+    } catch {
+      throw new Error(`Failed to delete record: please try again later`);
+    }
+  }
+}
+
+export { generateId, generateCreateTableSql, generateIndexSql, BaseSqlAdapter };

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-ktbebkz5.js

@@ -0,0 +1,48 @@
+import {
+  BaseSqlAdapter,
+  generateCreateTableSql,
+  generateIndexSql
+} from "./chunk-fwk49jvg.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 };

package/dist/shared/chunk-rqe0prft.js

@@ -0,0 +1,100 @@
+import {
+  __require
+} from "./chunk-j4kwq1gh.js";
+
+// src/client/postgres-driver.ts
+function loadPostgres() {
+  try {
+    const mod = __require("postgres");
+    return typeof mod === "function" ? mod : mod.default;
+  } catch {
+    throw new Error('The "postgres" package is required for PostgreSQL. Install: bun add postgres');
+  }
+}
+function isPostgresError(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
+}
+function adaptPostgresError(error) {
+  if (isPostgresError(error)) {
+    const adapted = Object.assign(new Error(error.message), {
+      code: error.code,
+      message: error.message,
+      table: error.table_name,
+      column: error.column_name,
+      constraint: error.constraint_name,
+      detail: error.detail
+    });
+    throw adapted;
+  }
+  throw error;
+}
+function createPostgresDriver(url, pool) {
+  const sql = loadPostgres()(url, {
+    max: pool?.max ?? 10,
+    idle_timeout: pool?.idleTimeout !== undefined ? pool.idleTimeout / 1000 : 30,
+    connect_timeout: pool?.connectionTimeout !== undefined ? pool.connectionTimeout / 1000 : 10,
+    fetch_types: false
+  });
+  const queryFn = async (sqlStr, params) => {
+    try {
+      const result = await sql.unsafe(sqlStr, params);
+      const rows = result.map((row) => {
+        const mapped = {};
+        for (const [key, value] of Object.entries(row)) {
+          mapped[key] = coerceValue(value);
+        }
+        return mapped;
+      });
+      return {
+        rows,
+        rowCount: result.count ?? rows.length
+      };
+    } catch (error) {
+      adaptPostgresError(error);
+    }
+  };
+  return {
+    queryFn,
+    query: async (sql2, params) => {
+      const result = await queryFn(sql2, params ?? []);
+      return result.rows;
+    },
+    execute: async (sql2, params) => {
+      const result = await queryFn(sql2, params ?? []);
+      return { rowsAffected: result.rowCount };
+    },
+    async close() {
+      await sql.end();
+    },
+    async isHealthy() {
+      let timer;
+      try {
+        const healthCheckTimeout = pool?.healthCheckTimeout ?? 5000;
+        const timeout = new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Health check timed out")), healthCheckTimeout);
+        });
+        await Promise.race([sql`SELECT 1`, timeout]);
+        return true;
+      } catch {
+        return false;
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    }
+  };
+}
+function coerceValue(value) {
+  if (typeof value === "string" && isTimestampString(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+}
+function isTimestampString(value) {
+  return /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(value);
+}
+
+export { createPostgresDriver };

package/dist/shared/chunk-ssga2xea.js

@@ -0,0 +1,9 @@
+// src/util/hash.ts
+async function sha256Hex(input) {
+  const data = new TextEncoder().encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export { sha256Hex };

package/dist/shared/{chunk-hrfdj0rr.js → chunk-v2qm94qp.js}

@@ -1,12 +1,22 @@
 // src/sql/casing.ts
-function camelToSnake(str) {
+function camelToSnake(str, overrides) {
   if (str.length === 0)
     return str;
+  if (overrides && str in overrides) {
+    return overrides[str];
+  }
   return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase();
 }
-function snakeToCamel(str) {
+function snakeToCamel(str, overrides) {
   if (str.length === 0)
     return str;
+  if (overrides) {
+    for (const [camelKey, snakeVal] of Object.entries(overrides)) {
+      if (snakeVal === str) {
+        return camelKey;
+      }
+    }
+  }
   return str.replace(/([a-zA-Z\d])_([a-zA-Z])/g, (_, prev, char) => prev + char.toUpperCase());
 }