sqlite-zod-orm 3.9.0 → 3.11.0

package/dist/index.js

@@ -13,65 +13,6 @@ var __export = (target, all) => {
 // src/database.ts
 import { Database as SqliteDatabase } from "bun:sqlite";
 
-// src/ast.ts
-var wrapNode = (val) => val !== null && typeof val === "object" && ("type" in val) ? val : { type: "literal", value: val };
-function compileAST(node) {
-  if (node.type === "column")
-    return { sql: `"${node.name}"`, params: [] };
-  if (node.type === "literal") {
-    if (node.value instanceof Date)
-      return { sql: "?", params: [node.value.toISOString()] };
-    if (typeof node.value === "boolean")
-      return { sql: "?", params: [node.value ? 1 : 0] };
-    return { sql: "?", params: [node.value] };
-  }
-  if (node.type === "function") {
-    const compiledArgs = node.args.map(compileAST);
-    return {
-      sql: `${node.name}(${compiledArgs.map((c) => c.sql).join(", ")})`,
-      params: compiledArgs.flatMap((c) => c.params)
-    };
-  }
-  if (node.type === "operator") {
-    const left = compileAST(node.left);
-    const right = compileAST(node.right);
-    return {
-      sql: `(${left.sql} ${node.op} ${right.sql})`,
-      params: [...left.params, ...right.params]
-    };
-  }
-  throw new Error("Unknown AST node type");
-}
-var createColumnProxy = () => new Proxy({}, {
-  get: (_, prop) => ({ type: "column", name: prop })
-});
-var createFunctionProxy = () => new Proxy({}, {
-  get: (_, funcName) => (...args) => ({
-    type: "function",
-    name: funcName.toUpperCase(),
-    args: args.map(wrapNode)
-  })
-});
-var op = {
-  eq: (left, right) => ({ type: "operator", op: "=", left: wrapNode(left), right: wrapNode(right) }),
-  ne: (left, right) => ({ type: "operator", op: "!=", left: wrapNode(left), right: wrapNode(right) }),
-  gt: (left, right) => ({ type: "operator", op: ">", left: wrapNode(left), right: wrapNode(right) }),
-  gte: (left, right) => ({ type: "operator", op: ">=", left: wrapNode(left), right: wrapNode(right) }),
-  lt: (left, right) => ({ type: "operator", op: "<", left: wrapNode(left), right: wrapNode(right) }),
-  lte: (left, right) => ({ type: "operator", op: "<=", left: wrapNode(left), right: wrapNode(right) }),
-  and: (left, right) => ({ type: "operator", op: "AND", left: wrapNode(left), right: wrapNode(right) }),
-  or: (left, right) => ({ type: "operator", op: "OR", left: wrapNode(left), right: wrapNode(right) }),
-  like: (left, right) => ({ type: "operator", op: "LIKE", left: wrapNode(left), right: wrapNode(right) }),
-  isNull: (node) => ({ type: "operator", op: "IS", left: wrapNode(node), right: { type: "literal", value: null } }),
-  isNotNull: (node) => ({ type: "operator", op: "IS NOT", left: wrapNode(node), right: { type: "literal", value: null } }),
-  in: (left, values) => ({
-    type: "function",
-    name: `${compileAST(wrapNode(left)).sql} IN`,
-    args: values.map((v) => wrapNode(v))
-  }),
-  not: (node) => ({ type: "operator", op: "NOT", left: { type: "literal", value: "" }, right: wrapNode(node) })
-};
-
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -4139,7 +4080,66 @@ function transformFromStorage(row, schema) {
   return transformed;
 }
 
-// src/query.ts
+// src/ast.ts
+var wrapNode = (val) => val !== null && typeof val === "object" && ("type" in val) ? val : { type: "literal", value: val };
+function compileAST(node) {
+  if (node.type === "column")
+    return { sql: `"${node.name}"`, params: [] };
+  if (node.type === "literal") {
+    if (node.value instanceof Date)
+      return { sql: "?", params: [node.value.toISOString()] };
+    if (typeof node.value === "boolean")
+      return { sql: "?", params: [node.value ? 1 : 0] };
+    return { sql: "?", params: [node.value] };
+  }
+  if (node.type === "function") {
+    const compiledArgs = node.args.map(compileAST);
+    return {
+      sql: `${node.name}(${compiledArgs.map((c) => c.sql).join(", ")})`,
+      params: compiledArgs.flatMap((c) => c.params)
+    };
+  }
+  if (node.type === "operator") {
+    const left = compileAST(node.left);
+    const right = compileAST(node.right);
+    return {
+      sql: `(${left.sql} ${node.op} ${right.sql})`,
+      params: [...left.params, ...right.params]
+    };
+  }
+  throw new Error("Unknown AST node type");
+}
+var createColumnProxy = () => new Proxy({}, {
+  get: (_, prop) => ({ type: "column", name: prop })
+});
+var createFunctionProxy = () => new Proxy({}, {
+  get: (_, funcName) => (...args) => ({
+    type: "function",
+    name: funcName.toUpperCase(),
+    args: args.map(wrapNode)
+  })
+});
+var op = {
+  eq: (left, right) => ({ type: "operator", op: "=", left: wrapNode(left), right: wrapNode(right) }),
+  ne: (left, right) => ({ type: "operator", op: "!=", left: wrapNode(left), right: wrapNode(right) }),
+  gt: (left, right) => ({ type: "operator", op: ">", left: wrapNode(left), right: wrapNode(right) }),
+  gte: (left, right) => ({ type: "operator", op: ">=", left: wrapNode(left), right: wrapNode(right) }),
+  lt: (left, right) => ({ type: "operator", op: "<", left: wrapNode(left), right: wrapNode(right) }),
+  lte: (left, right) => ({ type: "operator", op: "<=", left: wrapNode(left), right: wrapNode(right) }),
+  and: (left, right) => ({ type: "operator", op: "AND", left: wrapNode(left), right: wrapNode(right) }),
+  or: (left, right) => ({ type: "operator", op: "OR", left: wrapNode(left), right: wrapNode(right) }),
+  like: (left, right) => ({ type: "operator", op: "LIKE", left: wrapNode(left), right: wrapNode(right) }),
+  isNull: (node) => ({ type: "operator", op: "IS", left: wrapNode(node), right: { type: "literal", value: null } }),
+  isNotNull: (node) => ({ type: "operator", op: "IS NOT", left: wrapNode(node), right: { type: "literal", value: null } }),
+  in: (left, values) => ({
+    type: "function",
+    name: `${compileAST(wrapNode(left)).sql} IN`,
+    args: values.map((v) => wrapNode(v))
+  }),
+  not: (node) => ({ type: "operator", op: "NOT", left: { type: "literal", value: "" }, right: wrapNode(node) })
+};
+
+// src/iqo.ts
 var OPERATOR_MAP = {
   $gt: ">",
   $gte: ">=",
@@ -4149,7 +4149,9 @@ var OPERATOR_MAP = {
   $in: "IN",
   $like: "LIKE",
   $notIn: "NOT IN",
-  $between: "BETWEEN"
+  $between: "BETWEEN",
+  $isNull: "IS NULL",
+  $isNotNull: "IS NOT NULL"
 };
 function transformValueForStorage(value) {
   if (value instanceof Date)
@@ -4173,7 +4175,7 @@ function compileIQO(tableName, iqo) {
       selectParts.push(`${j.table}.*`);
     }
   }
-  let sql = `SELECT ${selectParts.join(", ")} FROM ${tableName}`;
+  let sql = `SELECT ${iqo.distinct ? "DISTINCT " : ""}${selectParts.join(", ")} FROM ${tableName}`;
   for (const j of iqo.joins) {
     sql += ` JOIN ${j.table} ON ${tableName}.${j.fromCol} = ${j.table}.${j.toCol}`;
   }
@@ -4206,6 +4208,10 @@ function compileIQO(tableName, iqo) {
         const [min, max] = w.value;
         whereParts.push(`${qualify(w.field)} BETWEEN ? AND ?`);
         params.push(transformValueForStorage(min), transformValueForStorage(max));
+      } else if (w.operator === "IS NULL") {
+        whereParts.push(`${qualify(w.field)} IS NULL`);
+      } else if (w.operator === "IS NOT NULL") {
+        whereParts.push(`${qualify(w.field)} IS NOT NULL`);
       } else {
         whereParts.push(`${qualify(w.field)} ${w.operator} ?`);
         params.push(transformValueForStorage(w.value));
@@ -4241,6 +4247,22 @@ function compileIQO(tableName, iqo) {
   if (iqo.groupBy.length > 0) {
     sql += ` GROUP BY ${iqo.groupBy.join(", ")}`;
   }
+  if (iqo.having && iqo.having.length > 0) {
+    const havingParts = [];
+    for (const h of iqo.having) {
+      if (h.operator === "IS NULL") {
+        havingParts.push(`${h.field} IS NULL`);
+      } else if (h.operator === "IS NOT NULL") {
+        havingParts.push(`${h.field} IS NOT NULL`);
+      } else {
+        havingParts.push(`${h.field} ${h.operator} ?`);
+        params.push(transformValueForStorage(h.value));
+      }
+    }
+    if (havingParts.length > 0) {
+      sql += ` HAVING ${havingParts.join(" AND ")}`;
+    }
+  }
   if (iqo.orderBy.length > 0) {
     const parts = iqo.orderBy.map((o) => `${o.field} ${o.direction.toUpperCase()}`);
     sql += ` ORDER BY ${parts.join(", ")}`;
@@ -4251,7 +4273,7 @@ function compileIQO(tableName, iqo) {
     sql += ` OFFSET ${iqo.offset}`;
   return { sql, params };
 }
-
+// src/builder.ts
 class QueryBuilder {
   iqo;
   tableName;
@@ -4274,11 +4296,13 @@ class QueryBuilder {
       whereAST: null,
       joins: [],
       groupBy: [],
+      having: [],
       limit: null,
       offset: null,
       orderBy: [],
       includes: [],
-      raw: false
+      raw: false,
+      distinct: false
     };
   }
   select(...cols) {
@@ -4433,6 +4457,61 @@ class QueryBuilder {
     this.iqo.groupBy.push(...fields);
     return this;
   }
+  distinct() {
+    this.iqo.distinct = true;
+    return this;
+  }
+  withTrashed() {
+    this.iqo.wheres = this.iqo.wheres.filter((w) => !(w.field === "deletedAt" && w.operator === "IS NULL"));
+    return this;
+  }
+  having(conditions) {
+    for (const [field, value] of Object.entries(conditions)) {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        for (const [opKey, operand] of Object.entries(value)) {
+          const sqlOp = OPERATOR_MAP[opKey];
+          if (!sqlOp)
+            throw new Error(`Unsupported having operator: '${opKey}'`);
+          this.iqo.having.push({ field, operator: sqlOp, value: operand });
+        }
+      } else {
+        this.iqo.having.push({ field, operator: "=", value });
+      }
+    }
+    return this;
+  }
+  sum(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT COALESCE(SUM("${field}"), 0) as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? 0;
+  }
+  avg(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT AVG("${field}") as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? 0;
+  }
+  min(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT MIN("${field}") as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? null;
+  }
+  max(field) {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const aggSql = selectSql.replace(/^SELECT .+? FROM/, `SELECT MAX("${field}") as val FROM`);
+    const results = this.executor(aggSql, params, true);
+    return results[0]?.val ?? null;
+  }
+  paginate(page = 1, perPage = 20) {
+    const total = this.count();
+    const pages = Math.ceil(total / perPage);
+    this.iqo.limit = perPage;
+    this.iqo.offset = (page - 1) * perPage;
+    const data = this.all();
+    return { data, total, page, perPage, pages };
+  }
   then(onfulfilled, onrejected) {
     try {
       const result = this.all();
@@ -4442,7 +4521,7 @@ class QueryBuilder {
     }
   }
 }
-
+// src/proxy.ts
 class ColumnNode {
   table;
   column;
@@ -4550,7 +4629,7 @@ function compileProxyQuery(queryResult, aliasMap) {
     const whereParts = [];
     for (const [key, value] of Object.entries(queryResult.where)) {
       let fieldRef;
-      const quotedMatch = key.match(/^"([^"]+)"\.\"([^"]+)"$/);
+      const quotedMatch = key.match(/^"([^"]+)"\."([^"]+)"$/);
       if (quotedMatch && tablesUsed.has(quotedMatch[1])) {
         fieldRef = key;
       } else {
@@ -4605,7 +4684,7 @@ function compileProxyQuery(queryResult, aliasMap) {
     const parts = [];
     for (const [key, dir] of Object.entries(queryResult.orderBy)) {
       let fieldRef;
-      const quotedMatch = key.match(/^"([^"]+)"\.\"([^"]+)"$/);
+      const quotedMatch = key.match(/^"([^"]+)"\."([^"]+)"$/);
       if (quotedMatch && tablesUsed.has(quotedMatch[1])) {
         fieldRef = key;
       } else {
@@ -4633,9 +4712,13 @@ function executeProxyQuery(schemas, callback, executor) {
   const { sql, params } = compileProxyQuery(queryResult, aliasMap);
   return executor(sql, params);
 }
+
+// src/query.ts
 function createQueryBuilder(ctx, entityName, initialCols) {
   const schema = ctx.schemas[entityName];
   const executor = (sql, params, raw) => {
+    if (ctx.debug)
+      console.log("[satidb]", sql, params);
     const rows = ctx.db.query(sql).all(...params);
     if (raw)
       return rows;
@@ -4705,6 +4788,9 @@ function createQueryBuilder(ctx, entityName, initialCols) {
   const builder = new QueryBuilder(entityName, executor, singleExecutor, joinResolver, conditionResolver, eagerLoader);
   if (initialCols.length > 0)
     builder.select(...initialCols);
+  if (ctx.softDeletes) {
+    builder.where({ deletedAt: { $isNull: true } });
+  }
   return builder;
 }
 
@@ -4769,6 +4855,14 @@ function buildWhereClause(conditions, tablePrefix) {
         values.push(transformForStorage({ v: operand[0] }).v, transformForStorage({ v: operand[1] }).v);
         continue;
       }
+      if (operator === "$isNull") {
+        parts.push(`${fieldName} IS NULL`);
+        continue;
+      }
+      if (operator === "$isNotNull") {
+        parts.push(`${fieldName} IS NOT NULL`);
+        continue;
+      }
       const sqlOp = { $gt: ">", $gte: ">=", $lt: "<", $lte: "<=", $ne: "!=" }[operator];
       if (!sqlOp)
         throw new Error(`Unsupported operator '${operator}' on '${key}'`);
@@ -4805,9 +4899,16 @@ function insert(ctx, entityName, data) {
   const schema = ctx.schemas[entityName];
   const validatedData = asZodObject(schema).passthrough().parse(data);
   const transformed = transformForStorage(validatedData);
+  if (ctx.timestamps) {
+    const now = new Date().toISOString();
+    transformed.createdAt = now;
+    transformed.updatedAt = now;
+  }
   const columns = Object.keys(transformed);
   const quotedCols = columns.map((c) => `"${c}"`);
   const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
+  if (ctx.debug)
+    console.log("[satidb]", sql, Object.values(transformed));
   const result = ctx.db.query(sql).run(...Object.values(transformed));
   const newEntity = getById(ctx, entityName, result.lastInsertRowid);
   if (!newEntity)
@@ -4818,10 +4919,16 @@ function update(ctx, entityName, id, data) {
   const schema = ctx.schemas[entityName];
   const validatedData = asZodObject(schema).partial().parse(data);
   const transformed = transformForStorage(validatedData);
-  if (Object.keys(transformed).length === 0)
+  if (Object.keys(transformed).length === 0 && !ctx.timestamps)
     return getById(ctx, entityName, id);
+  if (ctx.timestamps) {
+    transformed.updatedAt = new Date().toISOString();
+  }
   const setClause = Object.keys(transformed).map((key) => `"${key}" = ?`).join(", ");
-  ctx.db.query(`UPDATE "${entityName}" SET ${setClause} WHERE id = ?`).run(...Object.values(transformed), id);
+  const sql = `UPDATE "${entityName}" SET ${setClause} WHERE id = ?`;
+  if (ctx.debug)
+    console.log("[satidb]", sql, [...Object.values(transformed), id]);
+  ctx.db.query(sql).run(...Object.values(transformed), id);
   return getById(ctx, entityName, id);
 }
 function updateWhere(ctx, entityName, data, conditions) {
@@ -4864,6 +4971,24 @@ function upsert(ctx, entityName, data, conditions = {}) {
 function deleteEntity(ctx, entityName, id) {
   ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
 }
+function deleteWhere(ctx, entityName, conditions) {
+  const { clause, values } = ctx.buildWhereClause(conditions);
+  if (!clause)
+    throw new Error("delete().where() requires at least one condition");
+  const result = ctx.db.query(`DELETE FROM "${entityName}" ${clause}`).run(...values);
+  return result.changes ?? 0;
+}
+function createDeleteBuilder(ctx, entityName) {
+  let _conditions = {};
+  const builder = {
+    where: (conditions) => {
+      _conditions = { ..._conditions, ...conditions };
+      return builder;
+    },
+    exec: () => deleteWhere(ctx, entityName, _conditions)
+  };
+  return builder;
+}
 function insertMany(ctx, entityName, rows) {
   if (rows.length === 0)
     return [];
@@ -4874,6 +4999,11 @@ function insertMany(ctx, entityName, rows) {
     for (const data of rows) {
       const validatedData = zodSchema.parse(data);
       const transformed = transformForStorage(validatedData);
+      if (ctx.timestamps) {
+        const now = new Date().toISOString();
+        transformed.createdAt = now;
+        transformed.updatedAt = now;
+      }
       const columns = Object.keys(transformed);
       const quotedCols = columns.map((c) => `"${c}"`);
       const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
@@ -4924,6 +5054,9 @@ function attachMethods(ctx, entityName, entity) {
 class _Database {
   db;
   _reactive;
+  _timestamps;
+  _softDeletes;
+  _debug;
   schemas;
   relationships;
   options;
@@ -4939,6 +5072,9 @@ class _Database {
     this.schemas = schemas;
     this.options = options;
     this._reactive = options.reactive !== false;
+    this._timestamps = options.timestamps === true;
+    this._softDeletes = options.softDeletes === true;
+    this._debug = options.debug === true;
     this._pollInterval = options.pollInterval ?? 100;
     this.relationships = options.relations ? parseRelationsConfig(options.relations, schemas) : [];
     this._ctx = {
@@ -4946,7 +5082,10 @@ class _Database {
       schemas: this.schemas,
       relationships: this.relationships,
       attachMethods: (name, entity) => attachMethods(this._ctx, name, entity),
-      buildWhereClause: (conds, prefix) => buildWhereClause(conds, prefix)
+      buildWhereClause: (conds, prefix) => buildWhereClause(conds, prefix),
+      debug: this._debug,
+      timestamps: this._timestamps,
+      softDeletes: this._softDeletes
     };
     this.initializeTables();
     if (this._reactive)
@@ -4965,7 +5104,17 @@ class _Database {
           return createUpdateBuilder(this._ctx, entityName, idOrData);
         },
         upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
-        delete: (id) => deleteEntity(this._ctx, entityName, id),
+        delete: (id) => {
+          if (typeof id === "number") {
+            if (this._softDeletes) {
+              const now = new Date().toISOString();
+              this.db.run(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`, now, id);
+              return;
+            }
+            return deleteEntity(this._ctx, entityName, id);
+          }
+          return createDeleteBuilder(this._ctx, entityName);
+        },
         select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),
         on: (event, callback) => {
           return this._registerListener(entityName, event, callback);
@@ -4979,6 +5128,13 @@ class _Database {
     for (const [entityName, schema] of Object.entries(this.schemas)) {
       const storableFields = getStorableFields(schema);
       const columnDefs = storableFields.map((f) => `"${f.name}" ${zodTypeToSqlType(f.type)}`);
+      if (this._timestamps) {
+        columnDefs.push('"createdAt" TEXT');
+        columnDefs.push('"updatedAt" TEXT');
+      }
+      if (this._softDeletes) {
+        columnDefs.push('"deletedAt" TEXT');
+      }
       const constraints = [];
       const belongsToRels = this.relationships.filter((rel) => rel.type === "belongs-to" && rel.from === entityName);
       for (const rel of belongsToRels) {
@@ -5103,7 +5259,21 @@ class _Database {
     this.db.close();
   }
   query(callback) {
-    return executeProxyQuery(this.schemas, callback, (sql, params) => this.db.query(sql).all(...params));
+    return executeProxyQuery(this.schemas, callback, (sql, params) => {
+      if (this._debug)
+        console.log("[satidb]", sql, params);
+      return this.db.query(sql).all(...params);
+    });
+  }
+  raw(sql, ...params) {
+    if (this._debug)
+      console.log("[satidb]", sql, params);
+    return this.db.query(sql).all(...params);
+  }
+  exec(sql, ...params) {
+    if (this._debug)
+      console.log("[satidb]", sql, params);
+    this.db.run(sql, ...params);
   }
 }
 var Database = _Database;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
   "type": "module",
   "main": "./dist/index.js",