@vertz/db 0.2.0

package/dist/shared/chunk-3f2grpak.js

@@ -0,0 +1,428 @@
+import {
+  camelToSnake
+} from "./chunk-hrfdj0rr.js";
+
+// src/sql/where.ts
+var OPERATOR_KEYS = new Set([
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "notIn",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "isNull",
+  "arrayContains",
+  "arrayContainedBy",
+  "arrayOverlaps"
+]);
+function isOperatorObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((k) => OPERATOR_KEYS.has(k));
+}
+function escapeSingleQuotes(str) {
+  return str.replace(/'/g, "''");
+}
+function escapeLikeValue(str) {
+  return str.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function resolveColumnRef(key) {
+  if (key.includes("->")) {
+    const parts = key.split("->");
+    const baseCol = parts[0] ?? key;
+    const column = `"${camelToSnake(baseCol)}"`;
+    const jsonPath = parts.slice(1);
+    if (jsonPath.length === 1) {
+      return `${column}->>'${escapeSingleQuotes(jsonPath[0] ?? "")}'`;
+    }
+    const intermediate = jsonPath.slice(0, -1).map((p) => `->'${escapeSingleQuotes(p)}'`).join("");
+    const lastKey = jsonPath[jsonPath.length - 1] ?? "";
+    const final = `->>'${escapeSingleQuotes(lastKey)}'`;
+    return `${column}${intermediate}${final}`;
+  }
+  return `"${camelToSnake(key)}"`;
+}
+function buildOperatorCondition(columnRef, operators, paramIndex) {
+  const clauses = [];
+  const params = [];
+  let idx = paramIndex;
+  if (operators.eq !== undefined) {
+    clauses.push(`${columnRef} = $${idx + 1}`);
+    params.push(operators.eq);
+    idx++;
+  }
+  if (operators.ne !== undefined) {
+    clauses.push(`${columnRef} != $${idx + 1}`);
+    params.push(operators.ne);
+    idx++;
+  }
+  if (operators.gt !== undefined) {
+    clauses.push(`${columnRef} > $${idx + 1}`);
+    params.push(operators.gt);
+    idx++;
+  }
+  if (operators.gte !== undefined) {
+    clauses.push(`${columnRef} >= $${idx + 1}`);
+    params.push(operators.gte);
+    idx++;
+  }
+  if (operators.lt !== undefined) {
+    clauses.push(`${columnRef} < $${idx + 1}`);
+    params.push(operators.lt);
+    idx++;
+  }
+  if (operators.lte !== undefined) {
+    clauses.push(`${columnRef} <= $${idx + 1}`);
+    params.push(operators.lte);
+    idx++;
+  }
+  if (operators.contains !== undefined) {
+    clauses.push(`${columnRef} LIKE $${idx + 1}`);
+    params.push(`%${escapeLikeValue(operators.contains)}%`);
+    idx++;
+  }
+  if (operators.startsWith !== undefined) {
+    clauses.push(`${columnRef} LIKE $${idx + 1}`);
+    params.push(`${escapeLikeValue(operators.startsWith)}%`);
+    idx++;
+  }
+  if (operators.endsWith !== undefined) {
+    clauses.push(`${columnRef} LIKE $${idx + 1}`);
+    params.push(`%${escapeLikeValue(operators.endsWith)}`);
+    idx++;
+  }
+  if (operators.in !== undefined) {
+    if (operators.in.length === 0) {
+      clauses.push("FALSE");
+    } else {
+      const placeholders = operators.in.map((_, i) => `$${idx + 1 + i}`).join(", ");
+      clauses.push(`${columnRef} IN (${placeholders})`);
+      params.push(...operators.in);
+      idx += operators.in.length;
+    }
+  }
+  if (operators.notIn !== undefined) {
+    if (operators.notIn.length === 0) {
+      clauses.push("TRUE");
+    } else {
+      const placeholders = operators.notIn.map((_, i) => `$${idx + 1 + i}`).join(", ");
+      clauses.push(`${columnRef} NOT IN (${placeholders})`);
+      params.push(...operators.notIn);
+      idx += operators.notIn.length;
+    }
+  }
+  if (operators.isNull !== undefined) {
+    clauses.push(`${columnRef} ${operators.isNull ? "IS NULL" : "IS NOT NULL"}`);
+  }
+  if (operators.arrayContains !== undefined) {
+    clauses.push(`${columnRef} @> $${idx + 1}`);
+    params.push(operators.arrayContains);
+    idx++;
+  }
+  if (operators.arrayContainedBy !== undefined) {
+    clauses.push(`${columnRef} <@ $${idx + 1}`);
+    params.push(operators.arrayContainedBy);
+    idx++;
+  }
+  if (operators.arrayOverlaps !== undefined) {
+    clauses.push(`${columnRef} && $${idx + 1}`);
+    params.push(operators.arrayOverlaps);
+    idx++;
+  }
+  return { clauses, params, nextIndex: idx };
+}
+function buildFilterClauses(filter, paramOffset) {
+  const clauses = [];
+  const allParams = [];
+  let idx = paramOffset;
+  for (const [key, value] of Object.entries(filter)) {
+    if (key === "OR" || key === "AND" || key === "NOT") {
+      continue;
+    }
+    const columnRef = resolveColumnRef(key);
+    if (isOperatorObject(value)) {
+      const result = buildOperatorCondition(columnRef, value, idx);
+      clauses.push(...result.clauses);
+      allParams.push(...result.params);
+      idx = result.nextIndex;
+    } else {
+      clauses.push(`${columnRef} = $${idx + 1}`);
+      allParams.push(value);
+      idx++;
+    }
+  }
+  if (filter.OR !== undefined) {
+    if (filter.OR.length === 0) {
+      clauses.push("FALSE");
+    } else {
+      const orClauses = [];
+      for (const subFilter of filter.OR) {
+        const sub = buildFilterClauses(subFilter, idx);
+        const joined = sub.clauses.join(" AND ");
+        orClauses.push(sub.clauses.length > 1 ? `(${joined})` : joined);
+        allParams.push(...sub.params);
+        idx = sub.nextIndex;
+      }
+      clauses.push(`(${orClauses.join(" OR ")})`);
+    }
+  }
+  if (filter.AND !== undefined) {
+    if (filter.AND.length === 0) {
+      clauses.push("TRUE");
+    } else {
+      const andClauses = [];
+      for (const subFilter of filter.AND) {
+        const sub = buildFilterClauses(subFilter, idx);
+        const joined = sub.clauses.join(" AND ");
+        andClauses.push(sub.clauses.length > 1 ? `(${joined})` : joined);
+        allParams.push(...sub.params);
+        idx = sub.nextIndex;
+      }
+      clauses.push(`(${andClauses.join(" AND ")})`);
+    }
+  }
+  if (filter.NOT !== undefined) {
+    const sub = buildFilterClauses(filter.NOT, idx);
+    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) {
+  if (!filter || Object.keys(filter).length === 0) {
+    return { sql: "", params: [] };
+  }
+  const { clauses, params } = buildFilterClauses(filter, paramOffset);
+  return {
+    sql: clauses.join(" AND "),
+    params
+  };
+}
+
+// src/sql/delete.ts
+function buildReturningColumnRef(name) {
+  const snakeName = camelToSnake(name);
+  if (snakeName === name) {
+    return `"${name}"`;
+  }
+  return `"${snakeName}" AS "${name}"`;
+}
+function buildDelete(options) {
+  const allParams = [];
+  let sql = `DELETE FROM "${options.table}"`;
+  if (options.where) {
+    const whereResult = buildWhere(options.where);
+    if (whereResult.sql.length > 0) {
+      sql += ` WHERE ${whereResult.sql}`;
+      allParams.push(...whereResult.params);
+    }
+  }
+  if (options.returning) {
+    if (options.returning === "*") {
+      sql += " RETURNING *";
+    } else {
+      const returnCols = options.returning.map(buildReturningColumnRef).join(", ");
+      sql += ` RETURNING ${returnCols}`;
+    }
+  }
+  return { sql, params: allParams };
+}
+
+// src/sql/insert.ts
+function buildReturningColumnRef2(name) {
+  const snakeName = camelToSnake(name);
+  if (snakeName === name) {
+    return `"${name}"`;
+  }
+  return `"${snakeName}" AS "${name}"`;
+}
+function buildInsert(options) {
+  const rows = Array.isArray(options.data) ? options.data : [options.data];
+  const firstRow = rows[0];
+  if (!firstRow) {
+    return { sql: `INSERT INTO "${options.table}" DEFAULT VALUES`, params: [] };
+  }
+  const keys = Object.keys(firstRow);
+  const nowSet = new Set(options.nowColumns ?? []);
+  const columns = keys.map((k) => `"${camelToSnake(k)}"`).join(", ");
+  const allParams = [];
+  const valuesClauses = [];
+  for (const row of rows) {
+    const placeholders = [];
+    for (const key of keys) {
+      const value = row[key];
+      if (nowSet.has(key) && value === "now") {
+        placeholders.push("NOW()");
+      } else {
+        allParams.push(value);
+        placeholders.push(`$${allParams.length}`);
+      }
+    }
+    valuesClauses.push(`(${placeholders.join(", ")})`);
+  }
+  let sql = `INSERT INTO "${options.table}" (${columns}) VALUES ${valuesClauses.join(", ")}`;
+  if (options.onConflict) {
+    const conflictCols = options.onConflict.columns.map((c) => `"${camelToSnake(c)}"`).join(", ");
+    if (options.onConflict.action === "nothing") {
+      sql += ` ON CONFLICT (${conflictCols}) DO NOTHING`;
+    } else if (options.onConflict.action === "update" && options.onConflict.updateColumns) {
+      if (options.onConflict.updateValues) {
+        const updateVals = options.onConflict.updateValues;
+        const setClauses = options.onConflict.updateColumns.map((c) => {
+          const snakeCol = camelToSnake(c);
+          allParams.push(updateVals[c]);
+          return `"${snakeCol}" = $${allParams.length}`;
+        }).join(", ");
+        sql += ` ON CONFLICT (${conflictCols}) DO UPDATE SET ${setClauses}`;
+      } else {
+        const setClauses = options.onConflict.updateColumns.map((c) => {
+          const snakeCol = camelToSnake(c);
+          return `"${snakeCol}" = EXCLUDED."${snakeCol}"`;
+        }).join(", ");
+        sql += ` ON CONFLICT (${conflictCols}) DO UPDATE SET ${setClauses}`;
+      }
+    }
+  }
+  if (options.returning) {
+    if (options.returning === "*") {
+      sql += " RETURNING *";
+    } else {
+      const returnCols = options.returning.map(buildReturningColumnRef2).join(", ");
+      sql += ` RETURNING ${returnCols}`;
+    }
+  }
+  return { sql, params: allParams };
+}
+
+// src/sql/select.ts
+function buildColumnRef(name) {
+  const snakeName = camelToSnake(name);
+  if (snakeName === name) {
+    return `"${name}"`;
+  }
+  return `"${snakeName}" AS "${name}"`;
+}
+function buildSelect(options) {
+  const parts = [];
+  const allParams = [];
+  let columnList;
+  if (options.columns && options.columns.length > 0) {
+    columnList = options.columns.map(buildColumnRef).join(", ");
+  } else {
+    columnList = "*";
+  }
+  if (options.withCount) {
+    columnList += ', COUNT(*) OVER() AS "totalCount"';
+  }
+  parts.push(`SELECT ${columnList} FROM "${options.table}"`);
+  const whereClauses = [];
+  if (options.where) {
+    const whereResult = buildWhere(options.where);
+    if (whereResult.sql.length > 0) {
+      whereClauses.push(whereResult.sql);
+      allParams.push(...whereResult.params);
+    }
+  }
+  if (options.cursor) {
+    const cursorEntries = Object.entries(options.cursor);
+    if (cursorEntries.length === 1) {
+      const [col, value] = cursorEntries[0];
+      const snakeCol = camelToSnake(col);
+      const dir = options.orderBy?.[col] ?? "asc";
+      const op = dir === "desc" ? "<" : ">";
+      allParams.push(value);
+      whereClauses.push(`"${snakeCol}" ${op} $${allParams.length}`);
+    } else if (cursorEntries.length > 1) {
+      const cols = [];
+      const placeholders = [];
+      const firstCol = cursorEntries[0]?.[0] ?? "";
+      const dir = options.orderBy?.[firstCol] ?? "asc";
+      const op = dir === "desc" ? "<" : ">";
+      for (const [col, value] of cursorEntries) {
+        cols.push(`"${camelToSnake(col)}"`);
+        allParams.push(value);
+        placeholders.push(`$${allParams.length}`);
+      }
+      whereClauses.push(`(${cols.join(", ")}) ${op} (${placeholders.join(", ")})`);
+    }
+  }
+  if (whereClauses.length > 0) {
+    parts.push(`WHERE ${whereClauses.join(" AND ")}`);
+  }
+  if (options.orderBy) {
+    const orderClauses = Object.entries(options.orderBy).map(([col, dir]) => `"${camelToSnake(col)}" ${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`);
+    if (orderClauses.length > 0) {
+      parts.push(`ORDER BY ${orderClauses.join(", ")}`);
+    }
+  }
+  const effectiveLimit = options.take ?? options.limit;
+  if (effectiveLimit !== undefined) {
+    allParams.push(effectiveLimit);
+    parts.push(`LIMIT $${allParams.length}`);
+  }
+  if (options.offset !== undefined) {
+    allParams.push(options.offset);
+    parts.push(`OFFSET $${allParams.length}`);
+  }
+  return {
+    sql: parts.join(" "),
+    params: allParams
+  };
+}
+
+// src/sql/update.ts
+function buildReturningColumnRef3(name) {
+  const snakeName = camelToSnake(name);
+  if (snakeName === name) {
+    return `"${name}"`;
+  }
+  return `"${snakeName}" AS "${name}"`;
+}
+function buildUpdate(options) {
+  const keys = Object.keys(options.data);
+  const nowSet = new Set(options.nowColumns ?? []);
+  const allParams = [];
+  const setClauses = [];
+  for (const key of keys) {
+    const snakeCol = camelToSnake(key);
+    const value = options.data[key];
+    if (nowSet.has(key) && value === "now") {
+      setClauses.push(`"${snakeCol}" = NOW()`);
+    } else {
+      allParams.push(value);
+      setClauses.push(`"${snakeCol}" = $${allParams.length}`);
+    }
+  }
+  let sql = `UPDATE "${options.table}" SET ${setClauses.join(", ")}`;
+  if (options.where) {
+    const whereResult = buildWhere(options.where, allParams.length);
+    if (whereResult.sql.length > 0) {
+      sql += ` WHERE ${whereResult.sql}`;
+      allParams.push(...whereResult.params);
+    }
+  }
+  if (options.returning) {
+    if (options.returning === "*") {
+      sql += " RETURNING *";
+    } else {
+      const returnCols = options.returning.map(buildReturningColumnRef3).join(", ");
+      sql += ` RETURNING ${returnCols}`;
+    }
+  }
+  return { sql, params: allParams };
+}
+
+export { buildWhere, buildDelete, buildInsert, buildSelect, buildUpdate };

package/dist/shared/chunk-hrfdj0rr.js

@@ -0,0 +1,13 @@
+// src/sql/casing.ts
+function camelToSnake(str) {
+  if (str.length === 0)
+    return 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) {
+  if (str.length === 0)
+    return str;
+  return str.replace(/([a-zA-Z\d])_([a-zA-Z])/g, (_, prev, char) => prev + char.toUpperCase());
+}
+
+export { camelToSnake, snakeToCamel };

package/dist/shared/chunk-wj026daz.js

@@ -0,0 +1,86 @@
+// src/diagnostic/index.ts
+var ERROR_PATTERNS = [
+  {
+    pattern: /Column '([^']+)' does not exist on table '([^']+)'/,
+    code: "INVALID_COLUMN",
+    explanation: "The column name used in a select, where, or orderBy clause does not exist on the specified table.",
+    suggestion: "Check the table schema definition for available column names. Column names are camelCase in TypeScript."
+  },
+  {
+    pattern: /Relation '([^']+)' does not exist/,
+    code: "INVALID_RELATION",
+    explanation: "The relation name used in an include clause does not match any declared relation on the table entry.",
+    suggestion: "Check the relations record passed to the table entry in your database registry."
+  },
+  {
+    pattern: /Filter on '([^']+)' expects type '([^']+)', got '([^']+)'/,
+    code: "INVALID_FILTER_TYPE",
+    explanation: "The value passed to a where filter does not match the column type.",
+    suggestion: "Ensure the filter value matches the column type. For example, use a number for integer columns."
+  },
+  {
+    pattern: /Cannot combine 'not' with explicit field selection/,
+    code: "MIXED_SELECT",
+    explanation: 'The select option uses both `not: "sensitive"` and explicit field selection like `{ id: true }`, which are mutually exclusive.',
+    suggestion: 'Use either `{ not: "sensitive" }` OR `{ id: true, name: true }`, not both.'
+  },
+  {
+    pattern: /Unique constraint violated on ([^.]+)\.([^\s(]+)/,
+    code: "UNIQUE_VIOLATION",
+    explanation: "An INSERT or UPDATE tried to set a value that already exists in a unique column.",
+    suggestion: "Check the violating value and either use a different value or use upsert() to handle conflicts."
+  },
+  {
+    pattern: /Foreign key constraint "([^"]+)" violated on table ([^\s]+)/,
+    code: "FK_VIOLATION",
+    explanation: "An INSERT or UPDATE references a row in another table that does not exist.",
+    suggestion: "Ensure the referenced row exists before creating the dependent row."
+  },
+  {
+    pattern: /Not-null constraint violated on ([^.]+)\.([^\s]+)/,
+    code: "NOT_NULL_VIOLATION",
+    explanation: "An INSERT or UPDATE tried to set a NOT NULL column to null.",
+    suggestion: "Provide a non-null value for the column, or make the column nullable in the schema with `.nullable()`."
+  },
+  {
+    pattern: /Record not found in table ([^\s]+)/,
+    code: "NOT_FOUND",
+    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."
+  },
+  {
+    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()`."
+  }
+];
+function diagnoseError(message) {
+  for (const entry of ERROR_PATTERNS) {
+    if (entry.pattern.test(message)) {
+      return {
+        code: entry.code,
+        explanation: entry.explanation,
+        suggestion: entry.suggestion
+      };
+    }
+  }
+  return null;
+}
+function formatDiagnostic(diag) {
+  return [
+    `[${diag.code}]`,
+    `  Explanation: ${diag.explanation}`,
+    `  Suggestion: ${diag.suggestion}`
+  ].join(`
+`);
+}
+function explainError(message) {
+  const diag = diagnoseError(message);
+  if (!diag) {
+    return `[UNKNOWN] No diagnostic available for: ${message}`;
+  }
+  return formatDiagnostic(diag);
+}
+
+export { diagnoseError, formatDiagnostic, explainError };