sqlite-zod-orm 3.8.0 → 3.9.0

package/src/entity.ts

@@ -0,0 +1,62 @@
+/**
+ * entity.ts — Entity augmentation logic extracted from Database class.
+ *
+ * Handles attaching .update(), .delete(), relationship navigation methods,
+ * and the auto-persist proxy to raw row objects.
+ */
+import type { AugmentedEntity, Relationship } from './types';
+import { getStorableFields, transformForStorage } from './schema';
+import type { DatabaseContext } from './context';
+import { getById, findMany, update, deleteEntity } from './crud';
+
+/**
+ * Augment a raw entity with:
+ * - .update(data) → persist partial update
+ * - .delete() → delete from DB
+ * - Lazy relationship accessors (author(), books(), etc.)
+ * - Auto-persist proxy: `entity.name = 'New'` auto-updates DB
+ */
+export function attachMethods<T extends Record<string, any>>(
+    ctx: DatabaseContext,
+    entityName: string,
+    entity: T,
+): AugmentedEntity<any> {
+    const augmented = entity as any;
+    augmented.update = (data: any) => update(ctx, entityName, entity.id, data);
+    augmented.delete = () => deleteEntity(ctx, entityName, entity.id);
+
+    // Attach lazy relationship navigation
+    for (const rel of ctx.relationships) {
+        if (rel.from === entityName && rel.type === 'belongs-to') {
+            // book.author() → lazy load parent via author_id FK
+            augmented[rel.relationshipField] = () => {
+                const fkValue = entity[rel.foreignKey];
+                return fkValue ? getById(ctx, rel.to, fkValue) : null;
+            };
+        } else if (rel.from === entityName && rel.type === 'one-to-many') {
+            // author.books() → lazy load children
+            const belongsToRel = ctx.relationships.find(
+                r => r.type === 'belongs-to' && r.from === rel.to && r.to === rel.from
+            );
+            if (belongsToRel) {
+                const fk = belongsToRel.foreignKey;
+                augmented[rel.relationshipField] = () => {
+                    return findMany(ctx, rel.to, { [fk]: entity.id });
+                };
+            }
+        }
+    }
+
+    // Auto-persist proxy: setting a field auto-updates the DB row
+    const storableFieldNames = new Set(getStorableFields(ctx.schemas[entityName]!).map(f => f.name));
+    return new Proxy(augmented, {
+        set: (target, prop: string, value) => {
+            if (storableFieldNames.has(prop) && target[prop] !== value) {
+                update(ctx, entityName, target.id, { [prop]: value });
+            }
+            target[prop] = value;
+            return true;
+        },
+        get: (target, prop, receiver) => Reflect.get(target, prop, receiver),
+    });
+}

package/src/helpers.ts

@@ -0,0 +1,87 @@
+/**
+ * sql-helpers.ts — SQL utility functions extracted from Database class.
+ *
+ * Contains WHERE clause building and other SQL-level helpers.
+ */
+import { transformForStorage } from './schema';
+
+/**
+ * Build a parameterized WHERE clause from a conditions object.
+ *
+ * Supports:
+ * - Simple equality: `{ name: 'Alice' }`
+ * - Operators: `{ age: { $gt: 18 } }`
+ * - $in: `{ status: { $in: ['active', 'pending'] } }`
+ * - $or: `{ $or: [{ name: 'Alice' }, { name: 'Bob' }] }`
+ */
+export function buildWhereClause(conditions: Record<string, any>, tablePrefix?: string): { clause: string; values: any[] } {
+    const parts: string[] = [];
+    const values: any[] = [];
+
+    for (const key in conditions) {
+        if (key.startsWith('$')) {
+            if (key === '$or' && Array.isArray(conditions[key])) {
+                const orBranches = conditions[key] as Record<string, any>[];
+                const orParts: string[] = [];
+                for (const branch of orBranches) {
+                    const sub = buildWhereClause(branch, tablePrefix);
+                    if (sub.clause) {
+                        orParts.push(`(${sub.clause.replace(/^WHERE /, '')})`);
+                        values.push(...sub.values);
+                    }
+                }
+                if (orParts.length > 0) parts.push(`(${orParts.join(' OR ')})`);
+            }
+            continue;
+        }
+        const value = conditions[key];
+        const fieldName = tablePrefix ? `"${tablePrefix}"."${key}"` : `"${key}"`;
+
+        if (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+            const operator = Object.keys(value)[0];
+            if (!operator?.startsWith('$')) {
+                throw new Error(`Querying on nested object '${key}' not supported. Use operators like $gt.`);
+            }
+            const operand = value[operator];
+
+            if (operator === '$in') {
+                if (!Array.isArray(operand)) throw new Error(`$in for '${key}' requires an array`);
+                if (operand.length === 0) { parts.push('1 = 0'); continue; }
+                parts.push(`${fieldName} IN (${operand.map(() => '?').join(', ')})`);
+                values.push(...operand.map((v: any) => transformForStorage({ v }).v));
+                continue;
+            }
+
+            if (operator === '$notIn') {
+                if (!Array.isArray(operand)) throw new Error(`$notIn for '${key}' requires an array`);
+                if (operand.length === 0) continue; // no-op: everything is "not in" an empty set
+                parts.push(`${fieldName} NOT IN (${operand.map(() => '?').join(', ')})`);
+                values.push(...operand.map((v: any) => transformForStorage({ v }).v));
+                continue;
+            }
+
+            if (operator === '$like') {
+                parts.push(`${fieldName} LIKE ?`);
+                values.push(operand);
+                continue;
+            }
+
+            if (operator === '$between') {
+                if (!Array.isArray(operand) || operand.length !== 2) throw new Error(`$between for '${key}' requires [min, max]`);
+                parts.push(`${fieldName} BETWEEN ? AND ?`);
+                values.push(transformForStorage({ v: operand[0] }).v, transformForStorage({ v: operand[1] }).v);
+                continue;
+            }
+
+            const sqlOp = ({ $gt: '>', $gte: '>=', $lt: '<', $lte: '<=', $ne: '!=' } as Record<string, string>)[operator];
+            if (!sqlOp) throw new Error(`Unsupported operator '${operator}' on '${key}'`);
+            parts.push(`${fieldName} ${sqlOp} ?`);
+            values.push(transformForStorage({ operand }).operand);
+        } else {
+            parts.push(`${fieldName} = ?`);
+            values.push(transformForStorage({ value }).value);
+        }
+    }
+
+    return { clause: parts.length > 0 ? `WHERE ${parts.join(' AND ')}` : '', values };
+}

package/src/index.ts

@@ -9,14 +9,13 @@ export type { DatabaseType } from './database';
 export type {
     SchemaMap, DatabaseOptions, Relationship,
     EntityAccessor, TypedAccessors, AugmentedEntity, UpdateBuilder,
-    InferSchema, EntityData, IndexDef,
+    InferSchema, EntityData, IndexDef, ChangeEvent,
     ProxyColumns, ColumnRef,
 } from './types';
 
 export { z } from 'zod';
 
-export { QueryBuilder } from './query-builder';
-export { ColumnNode, type ProxyQueryResult } from './proxy-query';
+export { QueryBuilder, ColumnNode, compileIQO, type ProxyQueryResult } from './query';
 export {
     type ASTNode, type WhereCallback, type SetCallback,
     type TypedColumnProxy, type FunctionProxy, type Operators,