@type32/tauri-sqlite-orm 0.3.0 → 0.4.0

package/dist/builders/select.js

@@ -0,0 +1,427 @@
+import { sql } from 'kysely';
+import { and } from '../operators';
+import { deserializeValue } from '../serialization';
+/** Map DB column names to TypeScript property names for a table */
+function getDbNameToTsName(table) {
+    const map = {};
+    for (const [tsName, col] of Object.entries(table._.columns)) {
+        map[col._.name] = tsName;
+    }
+    return map;
+}
+/** Normalize result key - SQLite may return quoted aliases like "users.id" */
+function normalizeRowKey(key) {
+    if (key.startsWith('"') && key.endsWith('"')) {
+        return key.slice(1, -1);
+    }
+    return key;
+}
+/** Resolve which columns to select for a relation. Always includes primary keys for deduplication. */
+function resolveRelationColumns(table, include) {
+    const allEntries = Object.entries(table._.columns);
+    if (include === true || typeof include !== 'object') {
+        return allEntries.map(([, col]) => col);
+    }
+    const cols = include.columns;
+    if (!cols) {
+        return allEntries.map(([, col]) => col);
+    }
+    const names = Array.isArray(cols)
+        ? cols
+        : Object.entries(cols)
+            .filter(([, v]) => v)
+            .map(([k]) => k);
+    const pkNames = allEntries
+        .filter(([, c]) => c.options.primaryKey)
+        .map(([k]) => k);
+    const combined = new Set([...names, ...pkNames]);
+    return allEntries
+        .filter(([tsName]) => combined.has(tsName))
+        .map(([, col]) => col);
+}
+export class SelectQueryBuilder {
+    kysely;
+    _builder;
+    _table;
+    _columns;
+    _includeRelations = {};
+    _manualJoins = [];
+    _isDistinct = false;
+    _includedColumnAliases = [];
+    constructor(kysely, table, columns) {
+        this.kysely = kysely;
+        this._table = table;
+        this._columns = columns;
+        const selected = columns
+            ? columns.map((c) => table._.columns[c])
+            : Object.values(table._.columns);
+        const colSelections = selected.map((col) => `${table._.name}.${col._.name} as "${table._.name}.${col._.name}"`);
+        this._includedColumnAliases = colSelections;
+        this._builder = kysely.selectFrom(table._.name).select(colSelections);
+    }
+    distinct() {
+        this._isDistinct = true;
+        this._builder = this._builder.distinct();
+        return this;
+    }
+    where(condition) {
+        this._builder = this._builder.where(condition);
+        return this;
+    }
+    orderBy(column, direction = 'asc') {
+        if ('toOperationNode' in column) {
+            this._builder = this._builder.orderBy(column, direction);
+        }
+        else {
+            this._builder = this._builder.orderBy(sql.ref(column._.name), direction);
+        }
+        return this;
+    }
+    limit(count) {
+        this._builder = this._builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this._builder = this._builder.offset(count);
+        return this;
+    }
+    groupBy(...columns) {
+        for (const col of columns) {
+            this._builder = this._builder.groupBy(sql `${sql.ref(this._table._.name)}.${sql.ref(col._.name)}`);
+        }
+        return this;
+    }
+    having(condition) {
+        this._builder = this._builder.having(condition);
+        return this;
+    }
+    leftJoin(table, condition, alias) {
+        this._manualJoins.push({ type: 'LEFT', table, condition, alias });
+        const aliasedCols = Object.values(table._.columns).map((col) => `${alias}.${col._.name} as "${alias}.${col._.name}"`);
+        this._builder = this._builder
+            .leftJoin(`${table._.name} as ${alias}`, (join) => join.on(condition))
+            .select(aliasedCols);
+        return this;
+    }
+    innerJoin(table, condition, alias) {
+        this._manualJoins.push({ type: 'INNER', table, condition, alias });
+        const aliasedCols = Object.values(table._.columns).map((col) => `${alias}.${col._.name} as "${alias}.${col._.name}"`);
+        this._builder = this._builder
+            .innerJoin(`${table._.name} as ${alias}`, (join) => join.on(condition))
+            .select(aliasedCols);
+        return this;
+    }
+    include(relations) {
+        this._includeRelations = { ...this._includeRelations, ...relations };
+        return this;
+    }
+    applyIncludes() {
+        const processRelations = (parentTable, parentAlias, relations, depth = 0) => {
+            if (depth > 10) {
+                console.warn('[Tauri-ORM] Maximum relation depth (10) exceeded.');
+                return;
+            }
+            for (const [relationName, include] of Object.entries(relations)) {
+                if (!include)
+                    continue;
+                const relation = parentTable.relations[relationName];
+                if (!relation) {
+                    console.warn(`[Tauri-ORM] Relation "${relationName}" not found on table "${parentTable._.name}". Skipping.`);
+                    continue;
+                }
+                const foreignTable = relation.foreignTable;
+                const foreignAlias = `${parentAlias}_${relationName}`;
+                const selectedCols = resolveRelationColumns(foreignTable, include);
+                const aliasedCols = selectedCols.map((col) => `${foreignAlias}.${col._.name} as "${foreignAlias}.${col._.name}"`);
+                if (relation.type === 'one' && relation.fields && relation.references) {
+                    const onCondition = sql `${sql.join(relation.fields.map((field, i) => sql `${sql.ref(`${parentAlias}.${field._.name}`)} = ${sql.ref(`${foreignAlias}.${relation.references[i]._.name}`)}`), sql ` AND `)}`;
+                    this._builder = this._builder
+                        .leftJoin(`${foreignTable._.name} as ${foreignAlias}`, (join) => join.on(onCondition))
+                        .select(aliasedCols);
+                }
+                else if (relation.type === 'many') {
+                    // Many-to-many via through(): parent -> junction -> foreign
+                    if (relation.junctionTable && relation.fromJunction && relation.toJunction) {
+                        const junctionTable = relation.junctionTable;
+                        const junctionAlias = `${foreignAlias}_jn`;
+                        const fromJ = relation.fromJunction;
+                        const toJ = relation.toJunction;
+                        const join1 = sql `${sql.ref(`${parentAlias}.${fromJ.column._.name}`)} = ${sql.ref(`${junctionAlias}.${fromJ.junctionColumn._.name}`)}`;
+                        let join2 = sql `${sql.ref(`${junctionAlias}.${toJ.junctionColumn._.name}`)} = ${sql.ref(`${foreignAlias}.${toJ.column._.name}`)}`;
+                        if (relation.where) {
+                            join2 = and(join2, relation.where(foreignAlias));
+                        }
+                        this._builder = this._builder
+                            .leftJoin(`${junctionTable._.name} as ${junctionAlias}`, (join) => join.on(join1))
+                            .leftJoin(`${foreignTable._.name} as ${foreignAlias}`, (join) => join.on(join2))
+                            .select(aliasedCols);
+                    }
+                    else {
+                        // v2: explicit fields/references, or v1: infer from reverse one relation
+                        let fields = relation.fields;
+                        let references = relation.references;
+                        if (!fields || !references) {
+                            const refRelation = Object.entries(foreignTable.relations).find(([, r]) => r.foreignTable === parentTable);
+                            if (refRelation && refRelation[1].fields && refRelation[1].references) {
+                                const [, relationConfig] = refRelation;
+                                fields = relationConfig.fields;
+                                references = relationConfig.references;
+                            }
+                        }
+                        if (fields && references) {
+                            let onCondition = sql `${sql.join(fields.map((field, i) => sql `${sql.ref(`${foreignAlias}.${field._.name}`)} = ${sql.ref(`${parentAlias}.${references[i]._.name}`)}`), sql ` AND `)}`;
+                            if (relation.where) {
+                                onCondition = and(onCondition, relation.where(foreignAlias));
+                            }
+                            this._builder = this._builder
+                                .leftJoin(`${foreignTable._.name} as ${foreignAlias}`, (join) => join.on(onCondition))
+                                .select(aliasedCols);
+                        }
+                    }
+                }
+                if (typeof include === 'object' && include.with) {
+                    processRelations(foreignTable, foreignAlias, include.with, depth + 1);
+                }
+            }
+        };
+        processRelations(this._table, this._table._.name, this._includeRelations, 0);
+    }
+    async execute() {
+        this.applyIncludes();
+        const rawResults = await this._builder.execute();
+        const hasIncludes = Object.values(this._includeRelations).some((i) => i);
+        if (hasIncludes) {
+            return this.processRelationResults(rawResults);
+        }
+        const hasManualJoins = this._manualJoins.length > 0;
+        if (hasManualJoins) {
+            return rawResults;
+        }
+        const prefix = `${this._table._.name}.`;
+        const dbNameToTs = getDbNameToTsName(this._table);
+        return rawResults.map((row) => {
+            const out = {};
+            for (const key in row) {
+                const normKey = normalizeRowKey(key);
+                const dbColName = normKey.startsWith(prefix) ? normKey.slice(prefix.length) : normKey;
+                const tsName = dbNameToTs[dbColName] ?? dbColName;
+                const column = this._table._.columns[tsName];
+                out[tsName] = column ? deserializeValue(row[key], column) : row[key];
+            }
+            return out;
+        });
+    }
+    processRelationResults(rawResults) {
+        if (!rawResults.length)
+            return [];
+        const mainTablePks = Object.values(this._table._.columns)
+            .filter((c) => c.options.primaryKey)
+            .map((c) => c._.name);
+        if (mainTablePks.length === 0)
+            return rawResults;
+        const groupedResults = new Map();
+        const parseRelationPath = (tableAlias, baseAlias) => {
+            if (!tableAlias.startsWith(baseAlias + '_'))
+                return [];
+            return tableAlias.slice(baseAlias.length + 1).split('_');
+        };
+        const setNestedValue = (obj, path, columnName, value) => {
+            let cur = obj;
+            for (let i = 0; i < path.length; i++) {
+                const key = path[i];
+                if (i === path.length - 1) {
+                    if (!cur[key])
+                        cur[key] = {};
+                    cur[key][columnName] = value;
+                }
+                else {
+                    if (!cur[key])
+                        cur[key] = {};
+                    cur = cur[key];
+                }
+            }
+        };
+        const getNestedRelation = (table, path) => {
+            let current = table;
+            let relation = null;
+            for (const name of path) {
+                relation = current.relations[name];
+                if (!relation)
+                    return null;
+                current = relation.foreignTable;
+            }
+            return relation;
+        };
+        for (const row of rawResults) {
+            const getVal = (logicalKey) => {
+                const quoted = `"${logicalKey}"`;
+                return row[quoted] ?? row[logicalKey];
+            };
+            const mainTableKey = mainTablePks
+                .map((pk) => getVal(`${this._table._.name}.${pk}`) ?? getVal(pk))
+                .join('_');
+            if (!groupedResults.has(mainTableKey)) {
+                groupedResults.set(mainTableKey, {});
+            }
+            const result = groupedResults.get(mainTableKey);
+            const relations = {};
+            for (const [key, value] of Object.entries(row)) {
+                const normKey = normalizeRowKey(key);
+                if (!normKey.includes('.')) {
+                    const mainDbToTs = getDbNameToTsName(this._table);
+                    const tsName = mainDbToTs[normKey] ?? normKey;
+                    const column = this._table._.columns[tsName];
+                    result[tsName] = column ? deserializeValue(value, column) : value;
+                    continue;
+                }
+                const dotIndex = normKey.indexOf('.');
+                const tableAlias = normKey.slice(0, dotIndex);
+                const columnName = normKey.slice(dotIndex + 1);
+                if (tableAlias === this._table._.name) {
+                    const mainDbToTs = getDbNameToTsName(this._table);
+                    const tsName = mainDbToTs[columnName] ?? columnName;
+                    const column = this._table._.columns[tsName];
+                    result[tsName] = column ? deserializeValue(value, column) : value;
+                }
+                else {
+                    // Skip junction table alias (used for through() many-to-many)
+                    if (tableAlias.endsWith('_jn'))
+                        continue;
+                    const path = parseRelationPath(tableAlias, this._table._.name);
+                    if (path.length > 0) {
+                        const relationConfig = getNestedRelation(this._table, path);
+                        const foreignTable = relationConfig?.foreignTable;
+                        const foreignDbToTs = foreignTable ? getDbNameToTsName(foreignTable) : {};
+                        const tsName = foreignDbToTs[columnName] ?? columnName;
+                        const col = foreignTable?._.columns?.[tsName];
+                        setNestedValue(relations, path, tsName, col ? deserializeValue(value, col) : value);
+                    }
+                    else {
+                        if (!result[tableAlias])
+                            result[tableAlias] = {};
+                        result[tableAlias][columnName] = value;
+                    }
+                }
+            }
+            const attachRelations = (target, relData, table) => {
+                for (const [relName, data] of Object.entries(relData)) {
+                    const relationConfig = table.relations[relName];
+                    if (!relationConfig)
+                        continue;
+                    const directData = {};
+                    const nestedData = {};
+                    if (typeof data === 'object' && data !== null) {
+                        for (const [k, v] of Object.entries(data)) {
+                            if (typeof v === 'object' && v !== null) {
+                                nestedData[k] = v;
+                            }
+                            else {
+                                directData[k] = v;
+                            }
+                        }
+                    }
+                    const hasData = Object.values(directData).some((v) => v !== null && v !== undefined && v !== '');
+                    if (relationConfig.type === 'many') {
+                        if (!target[relName])
+                            target[relName] = [];
+                        if (hasData) {
+                            const relPks = Object.values(relationConfig.foreignTable._.columns)
+                                .filter((c) => c.options.primaryKey)
+                                .map((c) => c._.name);
+                            const key = relPks.map((pk) => directData[pk]).join('_');
+                            if (relPks.length === 0 ||
+                                !target[relName].some((r) => relPks.map((pk) => r[pk]).join('_') === key)) {
+                                const newItem = { ...directData };
+                                if (Object.keys(nestedData).length > 0) {
+                                    attachRelations(newItem, nestedData, relationConfig.foreignTable);
+                                }
+                                target[relName].push(newItem);
+                            }
+                        }
+                    }
+                    else {
+                        if (hasData || Object.keys(nestedData).length > 0) {
+                            target[relName] = { ...directData };
+                            if (Object.keys(nestedData).length > 0) {
+                                attachRelations(target[relName], nestedData, relationConfig.foreignTable);
+                            }
+                        }
+                    }
+                }
+            };
+            attachRelations(result, relations, this._table);
+        }
+        return Array.from(groupedResults.values());
+    }
+    async all() {
+        return this.execute();
+    }
+    async get() {
+        this.limit(1);
+        const result = await this.execute();
+        return result[0];
+    }
+    async first() {
+        return this.get();
+    }
+    async exists() {
+        this.applyIncludes();
+        const compiledResult = await this._builder
+            .clearSelect()
+            .select(sql.raw('1').as('__exists__'))
+            .limit(1)
+            .execute();
+        return compiledResult.length > 0;
+    }
+    async count() {
+        this.applyIncludes();
+        const result = await this._builder
+            .clearSelect()
+            .select(sql `COUNT(*)`.as('count'))
+            .execute();
+        const row = result[0];
+        const val = row ? (row['"count"'] ?? row.count) : undefined;
+        return Number(val ?? 0);
+    }
+    async pluck(column) {
+        this.applyIncludes();
+        const col = this._table._.columns[column];
+        const alias = col._.name;
+        const results = await this._builder
+            .clearSelect()
+            .select(sql.raw(`${this._table._.name}.${alias}`).as(alias))
+            .execute();
+        return results.map((row) => {
+            const val = row['"' + alias + '"'] ?? row[alias];
+            return col ? deserializeValue(val, col) : val;
+        });
+    }
+    async paginate(page = 1, pageSize = 10) {
+        if (page < 1)
+            page = 1;
+        if (pageSize < 1)
+            pageSize = 10;
+        const total = await this.count();
+        const totalPages = Math.ceil(total / pageSize);
+        const offset = (page - 1) * pageSize;
+        const data = await this.limit(pageSize).offset(offset).all();
+        return {
+            data,
+            total,
+            page,
+            pageSize,
+            totalPages,
+            hasNextPage: page < totalPages,
+            hasPrevPage: page > 1,
+        };
+    }
+    toSQL() {
+        this.applyIncludes();
+        const compiled = this._builder.compile();
+        return { sql: compiled.sql, params: [...compiled.parameters] };
+    }
+    toKyselyExpression() {
+        this.applyIncludes();
+        return this._builder;
+    }
+}

package/dist/builders/update.d.ts

@@ -0,0 +1,30 @@
+import { Kysely } from 'kysely';
+import { InferInsertModel } from '../orm';
+import { AnyTable, InferSelectModel } from '../types';
+import { Condition } from '../operators';
+export declare class UpdateQueryBuilder<T extends AnyTable> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _updateData;
+    private _returningColumns;
+    private _hasWhereClause;
+    private _allowGlobal;
+    private _incrementDecrementOps;
+    constructor(kysely: Kysely<any>, table: T);
+    set(data: Partial<InferInsertModel<T>>): this;
+    where(condition: Condition): this;
+    increment(column: keyof T['_']['columns'], value?: number): this;
+    decrement(column: keyof T['_']['columns'], value?: number): this;
+    allowGlobalOperation(): this;
+    returning(...columns: (keyof T['_']['columns'])[]): this;
+    private mapReturningRows;
+    private buildSetClause;
+    execute(): Promise<T extends AnyTable ? (InferSelectModel<T> & Record<string, any>)[] : never>;
+    returningAll(): Promise<InferSelectModel<T>[]>;
+    returningFirst(): Promise<InferSelectModel<T> | undefined>;
+    toSQL(): {
+        sql: string;
+        params: any[];
+    };
+}

package/dist/builders/update.js

@@ -0,0 +1,124 @@
+import { sql } from 'kysely';
+import { MissingWhereClauseError, UpdateValidationError, ColumnNotFoundError } from '../errors';
+import { serializeValue, deserializeValue } from '../serialization';
+export class UpdateQueryBuilder {
+    kysely;
+    _builder;
+    _table;
+    _updateData = {};
+    _returningColumns = [];
+    _hasWhereClause = false;
+    _allowGlobal = false;
+    _incrementDecrementOps = [];
+    constructor(kysely, table) {
+        this.kysely = kysely;
+        this._table = table;
+        this._builder = kysely.updateTable(table._.name);
+    }
+    set(data) {
+        this._updateData = { ...this._updateData, ...data };
+        return this;
+    }
+    where(condition) {
+        this._hasWhereClause = true;
+        this._builder = this._builder.where(condition);
+        return this;
+    }
+    increment(column, value = 1) {
+        const col = this._table._.columns[column];
+        if (!col)
+            throw new ColumnNotFoundError(String(column), this._table._.name);
+        this._incrementDecrementOps.push({ column: col._.name, op: 'increment', value });
+        return this;
+    }
+    decrement(column, value = 1) {
+        const col = this._table._.columns[column];
+        if (!col)
+            throw new ColumnNotFoundError(String(column), this._table._.name);
+        this._incrementDecrementOps.push({ column: col._.name, op: 'decrement', value });
+        return this;
+    }
+    allowGlobalOperation() {
+        this._allowGlobal = true;
+        return this;
+    }
+    returning(...columns) {
+        this._returningColumns.push(...columns);
+        return this;
+    }
+    mapReturningRows(rows) {
+        const dbNameToTs = {};
+        for (const [tsName, col] of Object.entries(this._table._.columns)) {
+            dbNameToTs[col._.name] = tsName;
+        }
+        const norm = (k) => (k.startsWith('"') && k.endsWith('"') ? k.slice(1, -1) : k);
+        return rows.map((row) => {
+            const out = {};
+            for (const [dbKey, value] of Object.entries(row)) {
+                const logicalKey = norm(dbKey);
+                const tsName = dbNameToTs[logicalKey] ?? logicalKey;
+                const column = this._table._.columns[tsName];
+                out[tsName] = column ? deserializeValue(value, column) : value;
+            }
+            return out;
+        });
+    }
+    buildSetClause() {
+        const finalData = { ...this._updateData };
+        for (const [key, column] of Object.entries(this._table._.columns)) {
+            if (finalData[key] === undefined && column.options.$onUpdateFn) {
+                ;
+                finalData[key] = column.options.$onUpdateFn();
+            }
+        }
+        const entries = Object.entries(finalData);
+        const hasSetData = entries.length > 0;
+        const hasOps = this._incrementDecrementOps.length > 0;
+        if (!hasSetData && !hasOps) {
+            throw new UpdateValidationError('Cannot execute an update query without a .set(), .increment(), or .decrement() call.');
+        }
+        const setMap = {};
+        for (const [key, value] of entries) {
+            const column = this._table._.columns[key];
+            if (!column)
+                throw new ColumnNotFoundError(key, this._table._.name);
+            setMap[column._.name] = serializeValue(value, column);
+        }
+        for (const op of this._incrementDecrementOps) {
+            const sign = op.op === 'increment' ? '+' : '-';
+            setMap[op.column] = sql.raw(`${op.column} ${sign} ${op.value}`);
+        }
+        return setMap;
+    }
+    async execute() {
+        if (!this._hasWhereClause && !this._allowGlobal) {
+            throw new MissingWhereClauseError('UPDATE', this._table._.name);
+        }
+        const setMap = this.buildSetClause();
+        let builder = this._builder.set(setMap);
+        if (this._returningColumns.length > 0) {
+            const cols = this._returningColumns.map((k) => this._table._.columns[k]._.name);
+            const rows = await builder.returning(cols).execute();
+            return this.mapReturningRows(rows);
+        }
+        const result = await builder.executeTakeFirst();
+        return [{ rowsAffected: Number(result?.numUpdatedRows ?? 0) }];
+    }
+    async returningAll() {
+        const allCols = Object.keys(this._table._.columns);
+        return this.returning(...allCols).execute();
+    }
+    async returningFirst() {
+        const results = await this.returningAll();
+        return results[0];
+    }
+    toSQL() {
+        const setMap = this.buildSetClause();
+        let builder = this._builder.set(setMap);
+        if (this._returningColumns.length > 0) {
+            builder = builder.returning(this._returningColumns.map((k) => this._table._.columns[k]._.name));
+        }
+        const compiled = builder.compile();
+        return { sql: compiled.sql, params: [...compiled.parameters] };
+    }
+}

package/dist/builders/with.d.ts

@@ -0,0 +1,17 @@
+import { Kysely } from 'kysely';
+import { SelectQueryBuilder } from './select';
+import { InsertQueryBuilder } from './insert';
+import { UpdateQueryBuilder } from './update';
+import { DeleteQueryBuilder } from './delete';
+import { AnyTable } from '../types';
+export declare class WithQueryBuilder {
+    private readonly kysely;
+    private _ctes;
+    constructor(kysely: Kysely<any>);
+    with(alias: string, query: SelectQueryBuilder<any, any>): this;
+    private applyWith;
+    select<T extends AnyTable, C extends (keyof T['_']['columns'])[] | undefined = undefined>(table: T, columns?: C): SelectQueryBuilder<T, C>;
+    insert<T extends AnyTable>(table: T): InsertQueryBuilder<T>;
+    update<T extends AnyTable>(table: T): UpdateQueryBuilder<T>;
+    delete<T extends AnyTable>(table: T): DeleteQueryBuilder<T>;
+}

package/dist/builders/with.js

@@ -0,0 +1,34 @@
+import { SelectQueryBuilder } from './select';
+import { InsertQueryBuilder } from './insert';
+import { UpdateQueryBuilder } from './update';
+import { DeleteQueryBuilder } from './delete';
+export class WithQueryBuilder {
+    kysely;
+    _ctes = [];
+    constructor(kysely) {
+        this.kysely = kysely;
+    }
+    with(alias, query) {
+        this._ctes.push({ alias, query: query.toKyselyExpression() });
+        return this;
+    }
+    applyWith(builder) {
+        let b = builder;
+        for (const { alias, query } of this._ctes) {
+            b = b.with(alias, () => query);
+        }
+        return b;
+    }
+    select(table, columns) {
+        return new SelectQueryBuilder(this.kysely, table, columns);
+    }
+    insert(table) {
+        return new InsertQueryBuilder(this.kysely, table);
+    }
+    update(table) {
+        return new UpdateQueryBuilder(this.kysely, table);
+    }
+    delete(table) {
+        return new DeleteQueryBuilder(this.kysely, table);
+    }
+}

package/dist/column-helpers.d.ts

@@ -0,0 +1,22 @@
+import { SQLiteColumn } from './orm';
+import { Mode } from './types';
+export declare function text<TName extends string>(name: TName): SQLiteColumn<TName, 'TEXT', 'default', false, false, false, never, never>;
+export declare function text<TName extends string, const TConfig extends {
+    mode?: 'default' | 'json';
+    enum?: readonly string[];
+}>(name: TName, config: TConfig): SQLiteColumn<TName, 'TEXT', TConfig['mode'] extends 'json' ? 'json' : 'default', false, false, false, TConfig['enum'] extends readonly string[] ? TConfig['enum'] : never, never>;
+export declare function integer<TName extends string>(name: TName): SQLiteColumn<TName, 'INTEGER', 'default', false, false, false, never, never>;
+export declare function integer<TName extends string, const TConfig extends {
+    mode: Mode;
+}>(name: TName, config: TConfig): SQLiteColumn<TName, 'INTEGER', TConfig['mode'], false, false, false, never, never>;
+export declare const real: <TName extends string>(name: TName) => SQLiteColumn<TName, "REAL", "default", false, false, false, never, never>;
+export declare function blob<TName extends string>(name: TName): SQLiteColumn<TName, 'BLOB', 'default', false, false, false, never, never>;
+export declare function blob<TName extends string, const TConfig extends {
+    mode: 'json' | 'bigint' | 'default';
+}>(name: TName, config: TConfig): SQLiteColumn<TName, 'BLOB', TConfig['mode'], false, false, false, never, never>;
+export declare const boolean: <TName extends string>(name: TName) => SQLiteColumn<TName, "BOOLEAN", "default", false, false, false, never, never>;
+export declare function numeric<TName extends string>(name: TName): SQLiteColumn<TName, 'NUMERIC', 'default', false, false, false, never, never>;
+export declare function numeric<TName extends string, const TConfig extends {
+    mode: 'bigint' | 'default';
+}>(name: TName, config: TConfig): SQLiteColumn<TName, 'NUMERIC', TConfig['mode'], false, false, false, never, never>;
+export declare const enumType: <TName extends string, TValues extends readonly [string, ...string[]]>(name: TName, values: TValues) => SQLiteColumn<TName, "TEXT", "default", false, false, false, TValues extends readonly string[] ? TValues : never, never>;

package/dist/column-helpers.js

@@ -0,0 +1,17 @@
+// Column helpers
+import { SQLiteColumn } from './orm';
+export function text(name, config) {
+    return new SQLiteColumn(name, 'TEXT', config);
+}
+export function integer(name, config) {
+    return new SQLiteColumn(name, 'INTEGER', config);
+}
+export const real = (name) => new SQLiteColumn(name, 'REAL');
+export function blob(name, config) {
+    return new SQLiteColumn(name, 'BLOB', config);
+}
+export const boolean = (name) => new SQLiteColumn(name, 'BOOLEAN');
+export function numeric(name, config) {
+    return new SQLiteColumn(name, 'NUMERIC', config);
+}
+export const enumType = (name, values) => text(name, { enum: values });