sqlite-zod-orm 3.9.0 → 3.10.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: ">=",
@@ -4251,7 +4251,7 @@ function compileIQO(tableName, iqo) {
     sql += ` OFFSET ${iqo.offset}`;
   return { sql, params };
 }
-
+// src/builder.ts
 class QueryBuilder {
   iqo;
   tableName;
@@ -4442,7 +4442,7 @@ class QueryBuilder {
     }
   }
 }
-
+// src/proxy.ts
 class ColumnNode {
   table;
   column;
@@ -4550,7 +4550,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 +4605,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,6 +4633,8 @@ 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) => {
@@ -4864,6 +4866,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 [];
@@ -4965,7 +4985,11 @@ 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")
+            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);

package/package.json

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

package/src/builder.ts

@@ -0,0 +1,311 @@
+/**
+ * builder.ts — Fluent QueryBuilder class
+ *
+ * Accumulates query state via chaining and executes when a
+ * terminal method (.all(), .get(), .count()) is called.
+ */
+
+import {
+    type ASTNode, type WhereCallback, type TypedColumnProxy, type FunctionProxy, type Operators,
+    createColumnProxy, createFunctionProxy, op,
+} from './ast';
+import {
+    type IQO, type WhereCondition, type WhereOperator, type OrderDirection,
+    OPERATOR_MAP, compileIQO,
+} from './iqo';
+
+// =============================================================================
+// QueryBuilder Class
+// =============================================================================
+
+/**
+ * A Fluent Query Builder that accumulates query state via chaining
+ * and only executes when a terminal method is called (.all(), .get())
+ * or when it is `await`-ed (thenable).
+ *
+ * Supports two WHERE styles:
+ * - Object-style: `.where({ name: 'Alice', age: { $gt: 18 } })`
+ * - Callback-style (AST): `.where((c, f, op) => op.and(op.eq(c.name, 'Alice'), op.gt(c.age, 18)))`
+ */
+export class QueryBuilder<T extends Record<string, any>> {
+    private iqo: IQO;
+    private tableName: string;
+    private executor: (sql: string, params: any[], raw: boolean) => any[];
+    private singleExecutor: (sql: string, params: any[], raw: boolean) => any | null;
+    private joinResolver: ((fromTable: string, toTable: string) => { fk: string; pk: string } | null) | null;
+    private conditionResolver: ((conditions: Record<string, any>) => Record<string, any>) | null;
+    private eagerLoader: ((parentTable: string, relation: string, parentIds: number[]) => { key: string; groups: Map<number, any[]> } | null) | null;
+
+    constructor(
+        tableName: string,
+        executor: (sql: string, params: any[], raw: boolean) => any[],
+        singleExecutor: (sql: string, params: any[], raw: boolean) => any | null,
+        joinResolver?: ((fromTable: string, toTable: string) => { fk: string; pk: string } | null) | null,
+        conditionResolver?: ((conditions: Record<string, any>) => Record<string, any>) | null,
+        eagerLoader?: ((parentTable: string, relation: string, parentIds: number[]) => { key: string; groups: Map<number, any[]> } | null) | null,
+    ) {
+        this.tableName = tableName;
+        this.executor = executor;
+        this.singleExecutor = singleExecutor;
+        this.joinResolver = joinResolver ?? null;
+        this.conditionResolver = conditionResolver ?? null;
+        this.eagerLoader = eagerLoader ?? null;
+        this.iqo = {
+            selects: [],
+            wheres: [],
+            whereOrs: [],
+            whereAST: null,
+            joins: [],
+            groupBy: [],
+            limit: null,
+            offset: null,
+            orderBy: [],
+            includes: [],
+            raw: false,
+        };
+    }
+
+    /** Specify which columns to select. If called with no arguments, defaults to `*`. */
+    select(...cols: (keyof T & string)[]): this {
+        this.iqo.selects.push(...cols);
+        return this;
+    }
+
+    /**
+     * Add WHERE conditions. Two calling styles:
+     *
+     * **Object-style** (simple equality and operators):
+     * ```ts
+     * .where({ name: 'Alice' })
+     * .where({ age: { $gt: 18 } })
+     * ```
+     *
+     * **Callback-style** (AST-based, full SQL expression power):
+     * ```ts
+     * .where((c, f, op) => op.and(
+     *   op.eq(f.lower(c.name), 'alice'),
+     *   op.gt(c.age, 18)
+     * ))
+     * ```
+     */
+    where(criteriaOrCallback: (Partial<Record<keyof T & string, any>> & { $or?: Partial<Record<keyof T & string, any>>[] }) | WhereCallback<T>): this {
+        if (typeof criteriaOrCallback === 'function') {
+            const ast = (criteriaOrCallback as WhereCallback<T>)(
+                createColumnProxy<T>(),
+                createFunctionProxy(),
+                op,
+            );
+            if (this.iqo.whereAST) {
+                this.iqo.whereAST = { type: 'operator', op: 'AND', left: this.iqo.whereAST, right: ast };
+            } else {
+                this.iqo.whereAST = ast;
+            }
+        } else {
+            const resolved = this.conditionResolver
+                ? this.conditionResolver(criteriaOrCallback as Record<string, any>)
+                : criteriaOrCallback;
+
+            for (const [key, value] of Object.entries(resolved)) {
+                if (key === '$or' && Array.isArray(value)) {
+                    const orConditions: WhereCondition[] = [];
+                    for (const branch of value as Record<string, any>[]) {
+                        const resolvedBranch = this.conditionResolver
+                            ? this.conditionResolver(branch)
+                            : branch;
+                        for (const [bKey, bValue] of Object.entries(resolvedBranch)) {
+                            if (typeof bValue === 'object' && bValue !== null && !Array.isArray(bValue) && !(bValue instanceof Date)) {
+                                for (const [opKey, operand] of Object.entries(bValue)) {
+                                    const sqlOp = OPERATOR_MAP[opKey as WhereOperator];
+                                    if (sqlOp) orConditions.push({ field: bKey, operator: sqlOp as WhereCondition['operator'], value: operand });
+                                }
+                            } else {
+                                orConditions.push({ field: bKey, operator: '=', value: bValue });
+                            }
+                        }
+                    }
+                    if (orConditions.length > 0) this.iqo.whereOrs.push(orConditions);
+                    continue;
+                }
+
+                if (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+                    for (const [opKey, operand] of Object.entries(value)) {
+                        const sqlOp = OPERATOR_MAP[opKey as WhereOperator];
+                        if (!sqlOp) throw new Error(`Unsupported query operator: '${opKey}' on field '${key}'.`);
+                        if (opKey === '$between') {
+                            if (!Array.isArray(operand) || operand.length !== 2) throw new Error(`$between for '${key}' requires [min, max]`);
+                        }
+                        this.iqo.wheres.push({
+                            field: key,
+                            operator: sqlOp as WhereCondition['operator'],
+                            value: operand,
+                        });
+                    }
+                } else {
+                    this.iqo.wheres.push({ field: key, operator: '=', value });
+                }
+            }
+        }
+        return this;
+    }
+
+    /** Set the maximum number of rows to return. */
+    limit(n: number): this {
+        this.iqo.limit = n;
+        return this;
+    }
+
+    /** Set the offset for pagination. */
+    offset(n: number): this {
+        this.iqo.offset = n;
+        return this;
+    }
+
+    /** Add ORDER BY clauses. */
+    orderBy(field: keyof T & string, direction: OrderDirection = 'asc'): this {
+        this.iqo.orderBy.push({ field, direction });
+        return this;
+    }
+
+    /**
+     * Join another table. Two calling styles:
+     *
+     * **Accessor-based** (auto-infers FK from relationships):
+     * ```ts
+     * db.trees.select('name').join(db.forests, ['name']).all()
+     * ```
+     *
+     * **String-based** (manual FK):
+     * ```ts
+     * db.trees.select('name').join('forests', 'forestId', ['name']).all()
+     * ```
+     */
+    join(accessor: { _tableName: string }, columns?: string[]): this;
+    join(table: string, fk: string, columns?: string[], pk?: string): this;
+    join(tableOrAccessor: string | { _tableName: string }, fkOrCols?: string | string[], colsOrPk?: string[] | string, pk?: string): this {
+        let table: string;
+        let fromCol: string;
+        let toCol: string;
+        let columns: string[];
+
+        if (typeof tableOrAccessor === 'object' && '_tableName' in tableOrAccessor) {
+            table = tableOrAccessor._tableName;
+            columns = Array.isArray(fkOrCols) ? fkOrCols : [];
+            if (!this.joinResolver) throw new Error(`Cannot auto-resolve join: no relationship data available`);
+            const resolved = this.joinResolver(this.tableName, table);
+            if (!resolved) throw new Error(`No relationship found between '${this.tableName}' and '${table}'`);
+            fromCol = resolved.fk;
+            toCol = resolved.pk;
+        } else {
+            table = tableOrAccessor;
+            fromCol = fkOrCols as string;
+            columns = Array.isArray(colsOrPk) ? colsOrPk : [];
+            toCol = (typeof colsOrPk === 'string' ? colsOrPk : pk) ?? 'id';
+        }
+
+        this.iqo.joins.push({ table, fromCol, toCol, columns });
+        this.iqo.raw = true;
+        return this;
+    }
+
+    /** Skip Zod parsing and return raw SQLite row objects. */
+    raw(): this {
+        this.iqo.raw = true;
+        return this;
+    }
+
+    /**
+     * Eagerly load a related entity and attach as an array property.
+     *
+     * Runs a single batched query (WHERE fk IN (...)) per relation,
+     * avoiding the N+1 problem of lazy navigation.
+     */
+    with(...relations: string[]): this {
+        this.iqo.includes.push(...relations);
+        return this;
+    }
+
+    /** Internal: apply eager loads to a set of results */
+    private _applyEagerLoads(results: T[]): T[] {
+        if (this.iqo.includes.length === 0 || !this.eagerLoader || results.length === 0) {
+            return results;
+        }
+
+        const parentIds = results.map((r: any) => r.id).filter((id: any) => typeof id === 'number');
+        if (parentIds.length === 0) return results;
+
+        for (const relation of this.iqo.includes) {
+            const loaded = this.eagerLoader(this.tableName, relation, parentIds);
+            if (!loaded) continue;
+
+            for (const row of results as any[]) {
+                row[loaded.key] = loaded.groups.get(row.id) ?? [];
+            }
+        }
+
+        return results;
+    }
+
+    // ---------- Terminal / Execution Methods ----------
+
+    /** Execute the query and return all matching rows. */
+    all(): T[] {
+        const { sql, params } = compileIQO(this.tableName, this.iqo);
+        const results = this.executor(sql, params, this.iqo.raw);
+        return this._applyEagerLoads(results);
+    }
+
+    /** Execute the query and return the first matching row, or null. */
+    get(): T | null {
+        this.iqo.limit = 1;
+        const { sql, params } = compileIQO(this.tableName, this.iqo);
+        const result = this.singleExecutor(sql, params, this.iqo.raw);
+        if (!result) return null;
+        const [loaded] = this._applyEagerLoads([result]);
+        return loaded ?? null;
+    }
+
+    /** Execute the query and return the count of matching rows. */
+    count(): number {
+        // Reuse compileIQO to avoid duplicating WHERE logic
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        // Replace "SELECT ... FROM" with "SELECT COUNT(*) as count FROM"
+        const countSql = selectSql.replace(/^SELECT .+? FROM/, 'SELECT COUNT(*) as count FROM');
+        const results = this.executor(countSql, params, true);
+        return (results[0] as any)?.count ?? 0;
+    }
+
+    /** Alias for get() — returns the first matching row or null. */
+    first(): T | null {
+        return this.get();
+    }
+
+    /** Returns true if at least one row matches the query. */
+    exists(): boolean {
+        const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+        const existsSql = selectSql.replace(/^SELECT .+? FROM/, 'SELECT 1 FROM').replace(/ LIMIT \d+/, '') + ' LIMIT 1';
+        const results = this.executor(existsSql, params, true);
+        return results.length > 0;
+    }
+
+    /** Group results by one or more columns. */
+    groupBy(...fields: string[]): this {
+        this.iqo.groupBy.push(...fields);
+        return this;
+    }
+
+
+
+    // ---------- Thenable (async/await support) ----------
+
+    then<TResult1 = T[], TResult2 = never>(
+        onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null,
+        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+    ): Promise<TResult1 | TResult2> {
+        try {
+            const result = this.all();
+            return Promise.resolve(result).then(onfulfilled, onrejected);
+        } catch (err) {
+            return Promise.reject(err).then(onfulfilled, onrejected);
+        }
+    }
+}

package/src/crud.ts

@@ -4,7 +4,7 @@
  * Each function accepts a `DatabaseContext` so it can access
  * the db handle, schemas, and entity methods without tight coupling.
  */
-import type { AugmentedEntity, UpdateBuilder } from './types';
+import type { AugmentedEntity, UpdateBuilder, DeleteBuilder } from './types';
 import { asZodObject } from './types';
 import { transformForStorage, transformFromStorage } from './schema';
 import type { DatabaseContext } from './context';
@@ -118,6 +118,24 @@ export function deleteEntity(ctx: DatabaseContext, entityName: string, id: numbe
     ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
 }
 
+/** Delete all rows matching the given conditions. Returns the number of rows deleted. */
+export function deleteWhere(ctx: DatabaseContext, entityName: string, conditions: Record<string, any>): number {
+    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 as any).changes ?? 0;
+}
+
+/** Create a fluent delete builder: db.table.delete().where({...}).exec() */
+export function createDeleteBuilder(ctx: DatabaseContext, entityName: string): DeleteBuilder<any> {
+    let _conditions: Record<string, any> = {};
+    const builder: DeleteBuilder<any> = {
+        where: (conditions) => { _conditions = { ..._conditions, ...conditions }; return builder; },
+        exec: () => deleteWhere(ctx, entityName, _conditions),
+    };
+    return builder;
+}
+
 /** Insert multiple rows in a single transaction for better performance. */
 export function insertMany<T extends Record<string, any>>(ctx: DatabaseContext, entityName: string, rows: Omit<T, 'id'>[]): AugmentedEntity<any>[] {
     if (rows.length === 0) return [];

package/src/database.ts

@@ -24,7 +24,7 @@ import type { DatabaseContext } from './context';
 import { buildWhereClause } from './helpers';
 import { attachMethods } from './entity';
 import {
-    insert, insertMany, update, upsert, deleteEntity,
+    insert, insertMany, update, upsert, deleteEntity, createDeleteBuilder,
     getById, getOne, findMany, updateWhere, createUpdateBuilder,
 } from './crud';
 
@@ -95,7 +95,10 @@ class _Database<Schemas extends SchemaMap> {
                     return createUpdateBuilder(this._ctx, entityName, idOrData);
                 },
                 upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
-                delete: (id) => deleteEntity(this._ctx, entityName, id),
+                delete: ((id?: any) => {
+                    if (typeof id === 'number') return deleteEntity(this._ctx, entityName, id);
+                    return createDeleteBuilder(this._ctx, entityName);
+                }) as any,
                 select: (...cols: string[]) => createQueryBuilder(this._ctx, entityName, cols),
                 on: (event: ChangeEvent, callback: (row: any) => void | Promise<void>) => {
                     return this._registerListener(entityName, event, callback);