sqlite-zod-orm 3.0.0 → 3.2.0

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.0.0",
-  "description": "A fast, type-safe SQLite ORM for Bun powered by Zod schemas",
+  "version": "3.2.0",
+  "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
   "type": "module",
-  "main": "./dist/satidb.js",
-  "module": "./dist/satidb.js",
-  "types": "./src/satidb.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./src/index.ts",
   "exports": {
     ".": {
-      "import": "./dist/satidb.js",
-      "types": "./src/satidb.ts"
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
     }
   },
-  "bin": {
-    "sqlite-zod-orm": "./dist/satidb.js"
-  },
   "scripts": {
     "build": "bun run ./src/build.ts",
     "test": "bun test",
@@ -32,13 +29,16 @@
     "typescript",
     "type-safe",
     "orm",
-    "sql"
+    "zod",
+    "sql",
+    "query-builder",
+    "relationships"
   ],
   "author": "7flash",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git@github.com:7flash/satidb.git"
+    "url": "git@github.com:7flash/sqlite-zod-orm.git"
   },
   "devDependencies": {
     "bun-types": "latest"
@@ -52,4 +52,4 @@
   "engines": {
     "bun": ">=1.0.0"
   }
-}
+}

package/src/build.ts

@@ -1,23 +1,21 @@
 import { EOL } from 'os';
 
-console.log("Starting build process for satidb...");
+console.log("Building sqlite-zod-orm...");
 
 const result = await Bun.build({
-  entrypoints: ['./src/satidb.ts'],
+  entrypoints: ['./src/index.ts'],
   outdir: './dist',
-  target: 'bun', // Optimize for the Bun runtime
+  target: 'bun',
   format: 'esm',
-  minify: true, // Minify for smaller file size
+  minify: false,
 });
 
 if (!result.success) {
-  console.error("Build failed");
-  for (const message of result.logs) {
-    console.error(message);
+  console.error("Build failed:");
+  for (const msg of result.logs) {
+    console.error(msg);
   }
   process.exit(1);
 }
 
-const outFile = result.outputs[0].path;
-
-console.log(`Build successful! Executable created at: ${outFile}`);
+console.log(`Build complete → dist/ (${result.outputs.length} file${result.outputs.length > 1 ? 's' : ''})${EOL}`);

package/src/database.ts

@@ -0,0 +1,491 @@
+/**
+ * database.ts — Main Database class for sqlite-zod-orm
+ *
+ * Orchestrates schema-driven table creation, CRUD, relationships,
+ * query builders, and event handling.
+ */
+import { Database as SqliteDatabase } from 'bun:sqlite';
+import { EventEmitter } from 'events';
+import { z } from 'zod';
+import { QueryBuilder } from './query-builder';
+import { executeProxyQuery, type ProxyQueryResult } from './proxy-query';
+import type {
+    SchemaMap, DatabaseOptions, Relationship, RelationsConfig,
+    EntityAccessor, TypedAccessors, TypedNavAccessors, AugmentedEntity, UpdateBuilder,
+    ProxyColumns, InferSchema,
+} from './types';
+import { asZodObject } from './types';
+import {
+    parseRelationsConfig,
+    getStorableFields,
+    zodTypeToSqlType, transformForStorage, transformFromStorage,
+} from './schema';
+
+// =============================================================================
+// Database Class
+// =============================================================================
+
+class _Database<Schemas extends SchemaMap> extends EventEmitter {
+    private db: SqliteDatabase;
+    private schemas: Schemas;
+    private relationships: Relationship[];
+    private subscriptions: Record<'insert' | 'update' | 'delete', Record<string, ((data: any) => void)[]>>;
+    private options: DatabaseOptions;
+
+    constructor(dbFile: string, schemas: Schemas, options: DatabaseOptions = {}) {
+        super();
+        this.db = new SqliteDatabase(dbFile);
+        this.db.run('PRAGMA foreign_keys = ON');
+        this.schemas = schemas;
+        this.options = options;
+        this.subscriptions = { insert: {}, update: {}, delete: {} };
+        this.relationships = options.relations ? parseRelationsConfig(options.relations, schemas) : [];
+        this.initializeTables();
+        this.runMigrations();
+        if (options.indexes) this.createIndexes(options.indexes);
+        if (options.changeTracking) this.setupChangeTracking();
+
+        // Create typed entity accessors (db.users, db.posts, etc.)
+        for (const entityName of Object.keys(schemas)) {
+            const key = entityName as keyof Schemas;
+            const accessor: EntityAccessor<Schemas[typeof key]> = {
+                insert: (data) => this.insert(entityName, data),
+                update: (idOrData: any, data?: any) => {
+                    if (typeof idOrData === 'number') return this.update(entityName, idOrData, data);
+                    return this._createUpdateBuilder(entityName, idOrData);
+                },
+                upsert: (conditions, data) => this.upsert(entityName, data, conditions),
+                delete: (id) => this.delete(entityName, id),
+                subscribe: (event, callback) => this.subscribe(event, entityName, callback),
+                unsubscribe: (event, callback) => this.unsubscribe(event, entityName, callback),
+                select: (...cols: string[]) => this._createQueryBuilder(entityName, cols),
+                _tableName: entityName,
+            };
+            (this as any)[key] = accessor;
+        }
+    }
+
+    // ===========================================================================
+    // Table Initialization & Migrations
+    // ===========================================================================
+
+    private initializeTables(): void {
+        for (const [entityName, schema] of Object.entries(this.schemas)) {
+            const storableFields = getStorableFields(schema);
+            const columnDefs = storableFields.map(f => `${f.name} ${zodTypeToSqlType(f.type)}`);
+            const constraints: string[] = [];
+
+            // Add FOREIGN KEY constraints for FK columns declared in the schema
+            const belongsToRels = this.relationships.filter(
+                rel => rel.type === 'belongs-to' && rel.from === entityName
+            );
+            for (const rel of belongsToRels) {
+                constraints.push(`FOREIGN KEY (${rel.foreignKey}) REFERENCES ${rel.to}(id) ON DELETE SET NULL`);
+            }
+
+            const allCols = columnDefs.join(', ');
+            const allConstraints = constraints.length > 0 ? ', ' + constraints.join(', ') : '';
+            this.db.run(`CREATE TABLE IF NOT EXISTS ${entityName} (id INTEGER PRIMARY KEY AUTOINCREMENT, ${allCols}${allConstraints})`);
+        }
+    }
+
+    private runMigrations(): void {
+        this.db.run(`CREATE TABLE IF NOT EXISTS _schema_meta (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      table_name TEXT NOT NULL,
+      column_name TEXT NOT NULL,
+      added_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(table_name, column_name)
+    )`);
+
+        for (const [entityName, schema] of Object.entries(this.schemas)) {
+            const existingCols = new Set(
+                (this.db.query(`PRAGMA table_info(${entityName})`).all() as any[]).map(c => c.name)
+            );
+            const storableFields = getStorableFields(schema);
+
+            for (const field of storableFields) {
+                if (!existingCols.has(field.name)) {
+                    this.db.run(`ALTER TABLE ${entityName} ADD COLUMN ${field.name} ${zodTypeToSqlType(field.type)}`);
+                    this.db.query(`INSERT OR IGNORE INTO _schema_meta (table_name, column_name) VALUES (?, ?)`).run(entityName, field.name);
+                }
+            }
+        }
+    }
+
+    // ===========================================================================
+    // Indexes
+    // ===========================================================================
+
+    private createIndexes(indexDefs: Record<string, string | (string | string[])[]>): void {
+        for (const [tableName, indexes] of Object.entries(indexDefs)) {
+            if (!this.schemas[tableName]) throw new Error(`Cannot create index on unknown table '${tableName}'`);
+            const indexList = Array.isArray(indexes) ? indexes : [indexes];
+            for (const indexDef of indexList) {
+                const columns = Array.isArray(indexDef) ? indexDef : [indexDef];
+                const indexName = `idx_${tableName}_${columns.join('_')}`;
+                this.db.run(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName} (${columns.join(', ')})`);
+            }
+        }
+    }
+
+    // ===========================================================================
+    // Change Tracking
+    // ===========================================================================
+
+    private setupChangeTracking(): void {
+        this.db.run(`CREATE TABLE IF NOT EXISTS _changes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      table_name TEXT NOT NULL,
+      row_id INTEGER NOT NULL,
+      action TEXT NOT NULL CHECK(action IN ('INSERT', 'UPDATE', 'DELETE')),
+      changed_at TEXT DEFAULT (datetime('now'))
+    )`);
+        this.db.run(`CREATE INDEX IF NOT EXISTS idx_changes_table ON _changes (table_name, id)`);
+
+        for (const entityName of Object.keys(this.schemas)) {
+            for (const action of ['insert', 'update', 'delete'] as const) {
+                const ref = action === 'delete' ? 'OLD' : 'NEW';
+                this.db.run(`CREATE TRIGGER IF NOT EXISTS _trg_${entityName}_${action}
+          AFTER ${action.toUpperCase()} ON ${entityName}
+          BEGIN
+            INSERT INTO _changes (table_name, row_id, action) VALUES ('${entityName}', ${ref}.id, '${action.toUpperCase()}');
+          END`);
+            }
+        }
+    }
+
+    public getChangeSeq(tableName?: string): number {
+        if (!this.options.changeTracking) return -1;
+        const sql = tableName
+            ? `SELECT MAX(id) as seq FROM _changes WHERE table_name = ?`
+            : `SELECT MAX(id) as seq FROM _changes`;
+        const row = this.db.query(sql).get(...(tableName ? [tableName] : [])) as any;
+        return row?.seq ?? 0;
+    }
+
+    public getChangesSince(sinceSeq: number, tableName?: string) {
+        const sql = tableName
+            ? `SELECT * FROM _changes WHERE id > ? AND table_name = ? ORDER BY id ASC`
+            : `SELECT * FROM _changes WHERE id > ? ORDER BY id ASC`;
+        return this.db.query(sql).all(...(tableName ? [sinceSeq, tableName] : [sinceSeq])) as any[];
+    }
+
+    // ===========================================================================
+    // CRUD
+    // ===========================================================================
+
+    private insert<T extends Record<string, any>>(entityName: string, data: Omit<T, 'id'>): AugmentedEntity<any> {
+        const schema = this.schemas[entityName]!;
+        const validatedData = asZodObject(schema).passthrough().parse(data);
+        const transformed = transformForStorage(validatedData);
+        const columns = Object.keys(transformed);
+
+        const sql = columns.length === 0
+            ? `INSERT INTO ${entityName} DEFAULT VALUES`
+            : `INSERT INTO ${entityName} (${columns.join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`;
+
+        const result = this.db.query(sql).run(...Object.values(transformed));
+        const newEntity = this._getById(entityName, result.lastInsertRowid as number);
+        if (!newEntity) throw new Error('Failed to retrieve entity after insertion');
+
+        this.emit('insert', entityName, newEntity);
+        this.subscriptions.insert[entityName]?.forEach(cb => cb(newEntity));
+        return newEntity;
+    }
+
+    /** Internal: get a single entity by ID */
+    private _getById(entityName: string, id: number): AugmentedEntity<any> | null {
+        const row = this.db.query(`SELECT * FROM ${entityName} WHERE id = ?`).get(id) as any;
+        if (!row) return null;
+        return this._attachMethods(entityName, transformFromStorage(row, this.schemas[entityName]!));
+    }
+
+    /** Internal: get a single entity by conditions */
+    private _getOne(entityName: string, conditions: Record<string, any>): AugmentedEntity<any> | null {
+        const { clause, values } = this.buildWhereClause(conditions);
+        const row = this.db.query(`SELECT * FROM ${entityName} ${clause} LIMIT 1`).get(...values) as any;
+        if (!row) return null;
+        return this._attachMethods(entityName, transformFromStorage(row, this.schemas[entityName]!));
+    }
+
+    /** Internal: find multiple entities by conditions */
+    private _findMany(entityName: string, conditions: Record<string, any> = {}): AugmentedEntity<any>[] {
+        const { clause, values } = this.buildWhereClause(conditions);
+        const rows = this.db.query(`SELECT * FROM ${entityName} ${clause}`).all(...values);
+        return rows.map((row: any) =>
+            this._attachMethods(entityName, transformFromStorage(row, this.schemas[entityName]!))
+        );
+    }
+
+    private update<T extends Record<string, any>>(entityName: string, id: number, data: Partial<Omit<T, 'id'>>): AugmentedEntity<any> | null {
+        const schema = this.schemas[entityName]!;
+        const validatedData = asZodObject(schema).partial().parse(data);
+        const transformed = transformForStorage(validatedData);
+        if (Object.keys(transformed).length === 0) return this._getById(entityName, id);
+
+        const setClause = Object.keys(transformed).map(key => `${key} = ?`).join(', ');
+        this.db.query(`UPDATE ${entityName} SET ${setClause} WHERE id = ?`).run(...Object.values(transformed), id);
+
+        const updatedEntity = this._getById(entityName, id);
+        if (updatedEntity) {
+            this.emit('update', entityName, updatedEntity);
+            this.subscriptions.update[entityName]?.forEach(cb => cb(updatedEntity));
+        }
+        return updatedEntity;
+    }
+
+    private _updateWhere(entityName: string, data: Record<string, any>, conditions: Record<string, any>): number {
+        const schema = this.schemas[entityName]!;
+        const validatedData = asZodObject(schema).partial().parse(data);
+        const transformed = transformForStorage(validatedData);
+        if (Object.keys(transformed).length === 0) return 0;
+
+        const { clause, values: whereValues } = this.buildWhereClause(conditions);
+        if (!clause) throw new Error('update().where() requires at least one condition');
+
+        const setCols = Object.keys(transformed);
+        const setClause = setCols.map(key => `${key} = ?`).join(', ');
+        const result = this.db.query(`UPDATE ${entityName} SET ${setClause} ${clause}`).run(
+            ...setCols.map(key => transformed[key]),
+            ...whereValues
+        );
+
+        const affected = (result as any).changes ?? 0;
+        if (affected > 0 && (this.subscriptions.update[entityName]?.length || this.options.changeTracking)) {
+            for (const entity of this._findMany(entityName, conditions)) {
+                this.emit('update', entityName, entity);
+                this.subscriptions.update[entityName]?.forEach(cb => cb(entity));
+            }
+        }
+        return affected;
+    }
+
+    private _createUpdateBuilder(entityName: string, data: Record<string, any>): UpdateBuilder<any> {
+        let _conditions: Record<string, any> = {};
+        const builder: UpdateBuilder<any> = {
+            where: (conditions) => { _conditions = { ..._conditions, ...conditions }; return builder; },
+            exec: () => this._updateWhere(entityName, data, _conditions),
+        };
+        return builder;
+    }
+
+    private upsert<T extends Record<string, any>>(entityName: string, data: any, conditions: any = {}): AugmentedEntity<any> {
+        const hasId = data?.id && typeof data.id === 'number';
+        const existing = hasId
+            ? this._getById(entityName, data.id)
+            : Object.keys(conditions ?? {}).length > 0
+                ? this._getOne(entityName, conditions)
+                : null;
+
+        if (existing) {
+            const updateData = { ...data };
+            delete updateData.id;
+            return this.update(entityName, existing.id, updateData) as AugmentedEntity<any>;
+        }
+        const insertData = { ...(conditions ?? {}), ...(data ?? {}) };
+        delete insertData.id;
+        return this.insert(entityName, insertData);
+    }
+
+    private delete(entityName: string, id: number): void {
+        const entity = this._getById(entityName, id);
+        if (entity) {
+            this.db.query(`DELETE FROM ${entityName} WHERE id = ?`).run(id);
+            this.emit('delete', entityName, entity);
+            this.subscriptions.delete[entityName]?.forEach(cb => cb(entity));
+        }
+    }
+
+    // ===========================================================================
+    // Entity Methods
+    // ===========================================================================
+
+    private _attachMethods<T extends Record<string, any>>(
+        entityName: string, entity: T
+    ): AugmentedEntity<any> {
+        const augmented = entity as any;
+        augmented.update = (data: any) => this.update(entityName, entity.id, data);
+        augmented.delete = () => this.delete(entityName, entity.id);
+
+        // Attach lazy relationship navigation
+        for (const rel of this.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 ? this._getById(rel.to, fkValue) : null;
+                };
+            } else if (rel.from === entityName && rel.type === 'one-to-many') {
+                // author.books() → lazy load children
+                const belongsToRel = this.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 this._findMany(rel.to, { [fk]: entity.id });
+                    };
+                }
+            }
+        }
+
+        // Auto-persist proxy: setting a field auto-updates the DB row
+        const storableFieldNames = new Set(getStorableFields(this.schemas[entityName]!).map(f => f.name));
+        return new Proxy(augmented, {
+            set: (target, prop: string, value) => {
+                if (storableFieldNames.has(prop) && target[prop] !== value) {
+                    this.update(entityName, target.id, { [prop]: value });
+                }
+                target[prop] = value;
+                return true;
+            },
+            get: (target, prop, receiver) => Reflect.get(target, prop, receiver),
+        });
+    }
+
+    // ===========================================================================
+    // SQL Helpers
+    // ===========================================================================
+
+    private 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 = this.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;
+                }
+
+                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 };
+    }
+
+    // ===========================================================================
+    // Transactions
+    // ===========================================================================
+
+    public transaction<T>(callback: () => T): T {
+        try {
+            this.db.run('BEGIN TRANSACTION');
+            const result = callback();
+            this.db.run('COMMIT');
+            return result;
+        } catch (error) {
+            this.db.run('ROLLBACK');
+            throw new Error(`Transaction failed: ${(error as Error).message}`);
+        }
+    }
+
+    // ===========================================================================
+    // Events
+    // ===========================================================================
+
+    private subscribe(event: 'insert' | 'update' | 'delete', entityName: string, callback: (data: any) => void): void {
+        this.subscriptions[event][entityName] = this.subscriptions[event][entityName] || [];
+        this.subscriptions[event][entityName].push(callback);
+    }
+
+    private unsubscribe(event: 'insert' | 'update' | 'delete', entityName: string, callback: (data: any) => void): void {
+        if (this.subscriptions[event][entityName]) {
+            this.subscriptions[event][entityName] = this.subscriptions[event][entityName].filter(cb => cb !== callback);
+        }
+    }
+
+    // ===========================================================================
+    // Query Builders
+    // ===========================================================================
+
+    private _createQueryBuilder(entityName: string, initialCols: string[]): QueryBuilder<any> {
+        const schema = this.schemas[entityName]!;
+
+        const executor = (sql: string, params: any[], raw: boolean): any[] => {
+            const rows = this.db.query(sql).all(...params);
+            if (raw) return rows;
+            return rows.map((row: any) => this._attachMethods(entityName, transformFromStorage(row, schema)));
+        };
+
+        const singleExecutor = (sql: string, params: any[], raw: boolean): any | null => {
+            const results = executor(sql, params, raw);
+            return results.length > 0 ? results[0] : null;
+        };
+
+        const joinResolver = (fromTable: string, toTable: string): { fk: string; pk: string } | null => {
+            const belongsTo = this.relationships.find(
+                r => r.type === 'belongs-to' && r.from === fromTable && r.to === toTable
+            );
+            if (belongsTo) return { fk: belongsTo.foreignKey, pk: 'id' };
+            const reverse = this.relationships.find(
+                r => r.type === 'belongs-to' && r.from === toTable && r.to === fromTable
+            );
+            if (reverse) return { fk: 'id', pk: reverse.foreignKey };
+            return null;
+        };
+
+        const builder = new QueryBuilder(entityName, executor, singleExecutor, joinResolver);
+        if (initialCols.length > 0) builder.select(...initialCols);
+        return builder;
+    }
+
+    /** Proxy callback query for complex SQL-like JOINs */
+    public query<T extends Record<string, any> = Record<string, any>>(
+        callback: (ctx: { [K in keyof Schemas]: ProxyColumns<InferSchema<Schemas[K]>> }) => ProxyQueryResult
+    ): T[] {
+        return executeProxyQuery(
+            this.schemas,
+            callback as any,
+            (sql: string, params: any[]) => this.db.query(sql).all(...params) as T[],
+        );
+    }
+}
+
+// =============================================================================
+// Public Export
+// =============================================================================
+
+const Database = _Database as unknown as new <S extends SchemaMap, const R extends RelationsConfig = {}>(
+    dbFile: string, schemas: S, options?: DatabaseOptions<R>
+) => _Database<S> & TypedNavAccessors<S, R>;
+
+type Database<S extends SchemaMap, R extends RelationsConfig = {}> = _Database<S> & TypedNavAccessors<S, R>;
+
+export { Database };
+export type { Database as DatabaseType };

package/src/index.ts

@@ -0,0 +1,24 @@
+/**
+ * sqlite-zod-orm — Type-safe SQLite ORM for Bun with Zod schemas.
+ *
+ * @module sqlite-zod-orm
+ */
+export { Database } from './database';
+export type { DatabaseType } from './database';
+
+export type {
+    SchemaMap, DatabaseOptions, Relationship,
+    EntityAccessor, TypedAccessors, AugmentedEntity, UpdateBuilder,
+    InferSchema, EntityData, IndexDef,
+    ProxyColumns, ColumnRef,
+} from './types';
+
+export { z } from 'zod';
+
+export { QueryBuilder } from './query-builder';
+export { ColumnNode, type ProxyQueryResult } from './proxy-query';
+export {
+    type ASTNode, type WhereCallback, type SetCallback,
+    type TypedColumnProxy, type FunctionProxy, type Operators,
+    compileAST, wrapNode, createColumnProxy, createFunctionProxy, op,
+} from './ast';