@vertz/db 0.2.0 → 0.2.3

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

@@ -0,0 +1,306 @@
+// 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.replace(/'/g, "''")}'`;
+      } 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) {
+      const DANGEROUS_PATTERN = /;|--|\b(DROP|DELETE|INSERT|UPDATE|ALTER|CREATE|EXEC)\b/i;
+      if (DANGEROUS_PATTERN.test(meta.check)) {
+        throw new Error(`Unsafe CHECK constraint expression: "${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-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());
 }
 

package/dist/sql/index.d.ts

@@ -5,33 +5,69 @@
 * to PostgreSQL column names (snake_case) and vice versa.
 */
 /**
+* Override map for custom casing conversions.
+* Keys are camelCase, values are snake_case.
+* Example: { 'oAuth': 'oauth', 'userID': 'user_id' }
+*/
+type CasingOverrides = Record<string, string>;
+/**
 * Convert a camelCase string to snake_case.
 *
 * Handles acronyms correctly:
 * - "parseJSON" -> "parse_json"
 * - "getHTTPSUrl" -> "get_https_url"
 * - "htmlParser" -> "html_parser"
+*
+* @param str - The camelCase string to convert
+* @param overrides - Optional map of camelCase -> snake_case overrides that take precedence
 */
-declare function camelToSnake(str: string): string;
+declare function camelToSnake(str: string, overrides?: CasingOverrides): string;
 /**
 * Convert a snake_case string to camelCase.
 *
 * - "first_name" -> "firstName"
 * - "created_at_timestamp" -> "createdAtTimestamp"
-*/
-declare function snakeToCamel(str: string): string;
-/**
-* DELETE statement builder.
 *
-* Generates parameterized DELETE queries with support for:
-* - WHERE clause via the where builder
-* - RETURNING clause with column aliasing
-* - camelCase -> snake_case column conversion
-*/
+* @param str - The snake_case string to convert
+* @param overrides - Optional map of camelCase -> snake_case overrides (reverse lookup)
+*/
+declare function snakeToCamel(str: string, overrides?: CasingOverrides): string;
+interface Dialect {
+	/** Dialect name. */
+	readonly name: "postgres" | "sqlite";
+	/**
+	* Parameter placeholder: $1, $2 (postgres) or ? (sqlite).
+	* @param index - 1-based parameter index
+	*/
+	param(index: number): string;
+	/** SQL function for current timestamp. */
+	now(): string;
+	/**
+	* Map a vertz column sqlType to the dialect's SQL type.
+	* @param sqlType - The generic sqlType from column metadata
+	* @param meta - Additional metadata (enum values, length, precision)
+	*/
+	mapColumnType(sqlType: string, meta?: ColumnTypeMeta): string;
+	/** Whether the dialect supports RETURNING clause. */
+	readonly supportsReturning: boolean;
+	/** Whether the dialect supports array operators (@>, <@, &&). */
+	readonly supportsArrayOps: boolean;
+	/** Whether the dialect supports JSONB path operators (->>, ->). */
+	readonly supportsJsonbPath: boolean;
+}
+interface ColumnTypeMeta {
+	readonly enumName?: string;
+	readonly enumValues?: readonly string[];
+	readonly length?: number;
+	readonly precision?: number;
+	readonly scale?: number;
+}
 interface DeleteOptions {
 	readonly table: string;
 	readonly where?: Record<string, unknown>;
 	readonly returning?: "*" | readonly string[];
+	/** SQL dialect to use. Defaults to postgres. */
+	readonly dialect?: Dialect;
 }
 interface DeleteResult {
 	readonly sql: string;
@@ -40,17 +76,7 @@ interface DeleteResult {
 /**
 * Build a DELETE statement from the given options.
 */
-declare function buildDelete(options: DeleteOptions): DeleteResult;
-/**
-* INSERT statement builder.
-*
-* Generates parameterized INSERT queries with support for:
-* - Single row and batch (multi-row VALUES) inserts
-* - RETURNING clause with column aliasing
-* - ON CONFLICT (upsert) — DO NOTHING or DO UPDATE SET
-* - camelCase -> snake_case column conversion
-* - "now" sentinel handling for timestamp defaults
-*/
+declare function buildDelete(options: DeleteOptions, dialect?: Dialect): DeleteResult;
 interface OnConflictOptions {
 	readonly columns: readonly string[];
 	readonly action: "nothing" | "update";
@@ -65,6 +91,8 @@ interface InsertOptions {
 	readonly onConflict?: OnConflictOptions;
 	/** Column names (camelCase) that should use NOW() instead of a parameterized value when the value is "now". */
 	readonly nowColumns?: readonly string[];
+	/** SQL dialect to use. Defaults to postgres. */
+	readonly dialect?: Dialect;
 }
 interface InsertResult {
 	readonly sql: string;
@@ -73,18 +101,7 @@ interface InsertResult {
 /**
 * Build an INSERT statement from the given options.
 */
-declare function buildInsert(options: InsertOptions): InsertResult;
-/**
-* SELECT statement builder.
-*
-* Generates parameterized SELECT queries with support for:
-* - Column selection with camelCase -> snake_case conversion and aliasing
-* - WHERE clause via the where builder
-* - ORDER BY with direction
-* - LIMIT / OFFSET pagination (parameterized)
-* - Cursor-based pagination (cursor + take)
-* - COUNT(*) OVER() for listAndCount
-*/
+declare function buildInsert(options: InsertOptions, dialect?: Dialect): InsertResult;
 interface SelectOptions {
 	readonly table: string;
 	readonly columns?: readonly string[];
@@ -97,6 +114,10 @@ interface SelectOptions {
 	readonly cursor?: Record<string, unknown>;
 	/** Number of rows to take (used with cursor). Aliases `limit` when cursor is present. */
 	readonly take?: number;
+	/** Custom casing overrides for camelCase -> snake_case conversion. */
+	readonly casingOverrides?: CasingOverrides;
+	/** SQL dialect to use. Defaults to postgres. */
+	readonly dialect?: Dialect;
 }
 interface SelectResult {
 	readonly sql: string;
@@ -105,7 +126,7 @@ interface SelectResult {
 /**
 * Build a SELECT statement from the given options.
 */
-declare function buildSelect(options: SelectOptions): SelectResult;
+declare function buildSelect(options: SelectOptions, dialect?: Dialect): SelectResult;
 /**
 * SQL tagged template literal and escape hatch.
 *
@@ -151,16 +172,6 @@ declare const sql: {
 	(strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
 	raw(value: string): SqlFragment;
 };
-/**
-* UPDATE statement builder.
-*
-* Generates parameterized UPDATE queries with support for:
-* - SET clause from a data object
-* - WHERE clause via the where builder
-* - RETURNING clause with column aliasing
-* - camelCase -> snake_case column conversion
-* - "now" sentinel handling for timestamp defaults
-*/
 interface UpdateOptions {
 	readonly table: string;
 	readonly data: Record<string, unknown>;
@@ -168,6 +179,8 @@ interface UpdateOptions {
 	readonly returning?: "*" | readonly string[];
 	/** Column names (camelCase) that should use NOW() instead of a parameterized value when the value is "now". */
 	readonly nowColumns?: readonly string[];
+	/** SQL dialect to use. Defaults to postgres. */
+	readonly dialect?: Dialect;
 }
 interface UpdateResult {
 	readonly sql: string;
@@ -176,22 +189,7 @@ interface UpdateResult {
 /**
 * Build an UPDATE statement from the given options.
 */
-declare function buildUpdate(options: UpdateOptions): UpdateResult;
-/**
-* WHERE clause builder with parameterized queries.
-*
-* Supports all filter operators from the schema layer:
-* - Comparison: eq, ne, gt, gte, lt, lte
-* - String: contains, startsWith, endsWith
-* - Set: in, notIn
-* - Null: isNull (true/false)
-* - Logical: AND, OR, NOT
-* - PostgreSQL array: arrayContains (@>), arrayContainedBy (<@), arrayOverlaps (&&)
-* - JSONB path: metadata->key syntax
-*
-* All values are parameterized ($1, $2, ...) to prevent SQL injection.
-* Column names are converted from camelCase to snake_case.
-*/
+declare function buildUpdate(options: UpdateOptions, dialect?: Dialect): UpdateResult;
 interface WhereResult {
 	readonly sql: string;
 	readonly params: readonly unknown[];
@@ -207,7 +205,9 @@ interface WhereFilter {
 *
 * @param filter - The filter object with column conditions
 * @param paramOffset - Starting parameter offset (0-based, params start at $offset+1)
+* @param overrides - Optional casing overrides for camelCase -> snake_case conversion
+* @param dialect - SQL dialect for parameter placeholders and feature checks
 * @returns WhereResult with the SQL string (without WHERE keyword) and parameter values
 */
-declare function buildWhere(filter: WhereFilter | undefined, paramOffset?: number): WhereResult;
+declare function buildWhere(filter: WhereFilter | undefined, paramOffset?: number, overrides?: CasingOverrides, dialect?: Dialect): WhereResult;
 export { sql, snakeToCamel, camelToSnake, buildWhere, buildUpdate, buildSelect, buildInsert, buildDelete, WhereResult, UpdateResult, UpdateOptions, SqlFragment, SelectResult, SelectOptions, OnConflictOptions, InsertResult, InsertOptions, DeleteResult, DeleteOptions };

package/dist/sql/index.js

@@ -4,11 +4,11 @@ import {
   buildSelect,
   buildUpdate,
   buildWhere
-} from "../shared/chunk-3f2grpak.js";
+} from "../shared/chunk-0e1vy9qd.js";
 import {
   camelToSnake,
   snakeToCamel
-} from "../shared/chunk-hrfdj0rr.js";
+} from "../shared/chunk-v2qm94qp.js";
 // src/sql/tagged.ts
 function isSqlFragment(value) {
   return typeof value === "object" && value !== null && "_tag" in value && value._tag === "SqlFragment";