@type32/tauri-sqlite-orm 0.3.0 → 0.4.0

package/dist/dialect.d.ts

@@ -0,0 +1,21 @@
+import { DatabaseIntrospector, Dialect, DialectAdapter, Driver, Kysely, QueryCompiler } from 'kysely';
+/**
+ * Minimal interface that any SQLite-over-Tauri (or compatible mock) database must satisfy.
+ * Using this instead of the concrete `@tauri-apps/plugin-sql` type keeps the dialect
+ * portable and testable outside a Tauri runtime.
+ */
+export interface DatabaseLike {
+    select<T>(query: string, params?: any[]): Promise<T>;
+    execute(query: string, params?: any[]): Promise<{
+        lastInsertId: number;
+        rowsAffected: number;
+    }>;
+}
+export declare class TauriDialect implements Dialect {
+    private readonly db;
+    constructor(db: DatabaseLike);
+    createAdapter(): DialectAdapter;
+    createDriver(): Driver;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+    createQueryCompiler(): QueryCompiler;
+}

package/dist/dialect.js

@@ -0,0 +1,67 @@
+import { CompiledQuery, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from 'kysely';
+class TauriConnection {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const params = parameters;
+        const trimmed = sql.trimStart();
+        const isSelect = /^\s*(SELECT|WITH|PRAGMA)/i.test(trimmed);
+        const hasReturning = /\bRETURNING\b/i.test(sql);
+        // INSERT/UPDATE/DELETE with RETURNING returns rows; use select() not execute()
+        if (isSelect || hasReturning) {
+            const rows = await this.db.select(sql, params);
+            return { rows };
+        }
+        const result = await this.db.execute(sql, params);
+        return {
+            rows: [],
+            insertId: BigInt(Math.round(result.lastInsertId ?? 0)),
+            numAffectedRows: BigInt(result.rowsAffected ?? 0),
+        };
+    }
+    async *streamQuery(_compiledQuery) {
+        throw new Error('Streaming queries are not supported by @tauri-apps/plugin-sql');
+    }
+}
+class TauriDriver {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async init() { }
+    async acquireConnection() {
+        return new TauriConnection(this.db);
+    }
+    async beginTransaction(conn, _settings) {
+        await conn.executeQuery(CompiledQuery.raw('BEGIN'));
+    }
+    async commitTransaction(conn) {
+        await conn.executeQuery(CompiledQuery.raw('COMMIT'));
+    }
+    async rollbackTransaction(conn) {
+        await conn.executeQuery(CompiledQuery.raw('ROLLBACK'));
+    }
+    async releaseConnection(_conn) { }
+    async destroy() { }
+}
+export class TauriDialect {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createAdapter() {
+        return new SqliteAdapter();
+    }
+    createDriver() {
+        return new TauriDriver(this.db);
+    }
+    createIntrospector(db) {
+        return new SqliteIntrospector(db);
+    }
+    createQueryCompiler() {
+        return new SqliteQueryCompiler();
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,30 @@
+export declare class TauriORMError extends Error {
+    constructor(message: string);
+}
+export declare class QueryBuilderError extends TauriORMError {
+    constructor(message: string);
+}
+export declare class MissingWhereClauseError extends QueryBuilderError {
+    constructor(operation: 'UPDATE' | 'DELETE', tableName: string);
+}
+export declare class ValidationError extends TauriORMError {
+    constructor(message: string);
+}
+export declare class InsertValidationError extends ValidationError {
+    constructor(message: string);
+}
+export declare class UpdateValidationError extends ValidationError {
+    constructor(message: string);
+}
+export declare class MigrationError extends TauriORMError {
+    constructor(message: string);
+}
+export declare class RelationError extends TauriORMError {
+    constructor(message: string);
+}
+export declare class ColumnNotFoundError extends TauriORMError {
+    constructor(columnName: string, tableName: string);
+}
+export declare class TableNotFoundError extends TauriORMError {
+    constructor(tableName: string);
+}

package/dist/errors.js

@@ -0,0 +1,66 @@
+// Custom error classes for better error handling
+export class TauriORMError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TauriORMError';
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+export class QueryBuilderError extends TauriORMError {
+    constructor(message) {
+        super(message);
+        this.name = 'QueryBuilderError';
+    }
+}
+export class MissingWhereClauseError extends QueryBuilderError {
+    constructor(operation, tableName) {
+        super(`${operation} operation on table "${tableName}" requires a WHERE clause to prevent accidental data loss. ` +
+            `Use .where() to specify conditions, or use .allowGlobalOperation() to explicitly allow operations without WHERE.`);
+        this.name = 'MissingWhereClauseError';
+    }
+}
+export class ValidationError extends TauriORMError {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+export class InsertValidationError extends ValidationError {
+    constructor(message) {
+        super(message);
+        this.name = 'InsertValidationError';
+    }
+}
+export class UpdateValidationError extends ValidationError {
+    constructor(message) {
+        super(message);
+        this.name = 'UpdateValidationError';
+    }
+}
+export class MigrationError extends TauriORMError {
+    constructor(message) {
+        super(message);
+        this.name = 'MigrationError';
+    }
+}
+export class RelationError extends TauriORMError {
+    constructor(message) {
+        super(message);
+        this.name = 'RelationError';
+    }
+}
+export class ColumnNotFoundError extends TauriORMError {
+    constructor(columnName, tableName) {
+        super(`Column "${columnName}" does not exist on table "${tableName}"`);
+        this.name = 'ColumnNotFoundError';
+    }
+}
+export class TableNotFoundError extends TauriORMError {
+    constructor(tableName) {
+        super(`Table "${tableName}" not found in schema`);
+        this.name = 'TableNotFoundError';
+    }
+}

package/dist/index.d.mts

@@ -584,9 +584,14 @@ interface ManyRelationOptions {
     /** Predefined filter: (alias) => Condition. Applied to the joined relation table. */
     where?: (alias: string) => Condition;
 }
-/** Build the r object passed to defineRelations callback */
-declare function buildR<Tables extends Record<string, AnyTable>>(tables: Tables): {
-    [K in keyof Tables]: Record<string, AnySQLiteColumn>;
+/** Extract table keys from schema (values that extend AnyTable) */
+type ExtractTableKeys<T> = {
+    [K in keyof T]: T[K] extends AnyTable ? K : never;
+}[keyof T];
+type ExtractTables<T extends Record<string, unknown>> = Pick<T, Extract<ExtractTableKeys<T>, keyof T>> extends infer R ? R extends Record<string, AnyTable> ? R : Record<string, AnyTable> : Record<string, AnyTable>;
+/** Build the r object passed to defineRelations callback - all properties required to avoid TS2722 */
+type BuildR<Tables extends Record<string, AnyTable>> = {
+    [K in keyof Tables]: Tables[K]['_']['columns'];
 } & {
     one: {
         [K in keyof Tables]: (opts: OneRelationOptions) => OneRelation<Tables[K]>;
@@ -595,7 +600,7 @@ declare function buildR<Tables extends Record<string, AnyTable>>(tables: Tables)
         [K in keyof Tables]: (opts?: ManyRelationOptions) => ManyRelation<Tables[K]>;
     };
 };
-type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: ReturnType<typeof buildR>) => {
+type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: BuildR<Tables>) => {
     [K in keyof Tables]?: Record<string, OneRelation | ManyRelation>;
 };
 /**
@@ -618,7 +623,7 @@ type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: Retu
  * }))
  * ```
  */
-declare function defineRelations<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<Record<string, AnyTable>>): Record<string, Record<string, OneRelation | ManyRelation>>;
+declare function defineRelations<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<ExtractTables<TSchema>>): Record<string, Record<string, OneRelation | ManyRelation>>;
 /**
  * Define a part of relations - merge multiple parts when passing to TauriORM.
  * Useful for splitting large schema definitions.
@@ -656,4 +661,4 @@ declare class TableNotFoundError extends TauriORMError {
     constructor(tableName: string);
 }
 
-export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, ColumnNotFoundError, type ColumnOptions, type ColumnValueTypes, type Condition, type DatabaseLike, type DefineRelationsCallback, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferRelationalSelectModel, type InferRelationsMap, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, type ManyRelationOptions, MigrationError, MissingWhereClauseError, type Mode, OneRelation, type OneRelationOptions, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, SQLiteColumn, SelectQueryBuilder, Table, TableNotFoundError, TauriDialect, TauriORM, TauriORMError, type ThroughRef, UpdateQueryBuilder, UpdateValidationError, ValidationError, WithQueryBuilder, alias, and, as, asc, avg, between, blob, boolean, contains, count, countDistinct, defineRelations, defineRelationsPart, desc, endsWith, enumType, eq, eqSubquery, exists, getTableColumns, groupConcat, gt, gtSubquery, gte, gteSubquery, ilike, inArray, integer, isNotNull, isNull, like, lt, ltSubquery, lte, lteSubquery, max, min, ne, neSubquery, not, notExists, notIn, numeric, or, real, relations, scalarSubquery, sqliteTable, startsWith, subquery, sum, text, through };
+export { type AnySQLiteColumn, type AnyTable, type BuildR, type ColumnDataType, ColumnNotFoundError, type ColumnOptions, type ColumnValueTypes, type Condition, type DatabaseLike, type DefineRelationsCallback, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferRelationalSelectModel, type InferRelationsMap, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, type ManyRelationOptions, MigrationError, MissingWhereClauseError, type Mode, OneRelation, type OneRelationOptions, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, SQLiteColumn, SelectQueryBuilder, Table, TableNotFoundError, TauriDialect, TauriORM, TauriORMError, type ThroughRef, UpdateQueryBuilder, UpdateValidationError, ValidationError, WithQueryBuilder, alias, and, as, asc, avg, between, blob, boolean, contains, count, countDistinct, defineRelations, defineRelationsPart, desc, endsWith, enumType, eq, eqSubquery, exists, getTableColumns, groupConcat, gt, gtSubquery, gte, gteSubquery, ilike, inArray, integer, isNotNull, isNull, like, lt, ltSubquery, lte, lteSubquery, max, min, ne, neSubquery, not, notExists, notIn, numeric, or, real, relations, scalarSubquery, sqliteTable, startsWith, subquery, sum, text, through };

package/dist/index.d.ts

@@ -584,9 +584,14 @@ interface ManyRelationOptions {
     /** Predefined filter: (alias) => Condition. Applied to the joined relation table. */
     where?: (alias: string) => Condition;
 }
-/** Build the r object passed to defineRelations callback */
-declare function buildR<Tables extends Record<string, AnyTable>>(tables: Tables): {
-    [K in keyof Tables]: Record<string, AnySQLiteColumn>;
+/** Extract table keys from schema (values that extend AnyTable) */
+type ExtractTableKeys<T> = {
+    [K in keyof T]: T[K] extends AnyTable ? K : never;
+}[keyof T];
+type ExtractTables<T extends Record<string, unknown>> = Pick<T, Extract<ExtractTableKeys<T>, keyof T>> extends infer R ? R extends Record<string, AnyTable> ? R : Record<string, AnyTable> : Record<string, AnyTable>;
+/** Build the r object passed to defineRelations callback - all properties required to avoid TS2722 */
+type BuildR<Tables extends Record<string, AnyTable>> = {
+    [K in keyof Tables]: Tables[K]['_']['columns'];
 } & {
     one: {
         [K in keyof Tables]: (opts: OneRelationOptions) => OneRelation<Tables[K]>;
@@ -595,7 +600,7 @@ declare function buildR<Tables extends Record<string, AnyTable>>(tables: Tables)
         [K in keyof Tables]: (opts?: ManyRelationOptions) => ManyRelation<Tables[K]>;
     };
 };
-type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: ReturnType<typeof buildR>) => {
+type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: BuildR<Tables>) => {
     [K in keyof Tables]?: Record<string, OneRelation | ManyRelation>;
 };
 /**
@@ -618,7 +623,7 @@ type DefineRelationsCallback<Tables extends Record<string, AnyTable>> = (r: Retu
  * }))
  * ```
  */
-declare function defineRelations<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<Record<string, AnyTable>>): Record<string, Record<string, OneRelation | ManyRelation>>;
+declare function defineRelations<TSchema extends Record<string, unknown>>(schema: TSchema, callback: DefineRelationsCallback<ExtractTables<TSchema>>): Record<string, Record<string, OneRelation | ManyRelation>>;
 /**
  * Define a part of relations - merge multiple parts when passing to TauriORM.
  * Useful for splitting large schema definitions.
@@ -656,4 +661,4 @@ declare class TableNotFoundError extends TauriORMError {
     constructor(tableName: string);
 }
 
-export { type AnySQLiteColumn, type AnyTable, type ColumnDataType, ColumnNotFoundError, type ColumnOptions, type ColumnValueTypes, type Condition, type DatabaseLike, type DefineRelationsCallback, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferRelationalSelectModel, type InferRelationsMap, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, type ManyRelationOptions, MigrationError, MissingWhereClauseError, type Mode, OneRelation, type OneRelationOptions, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, SQLiteColumn, SelectQueryBuilder, Table, TableNotFoundError, TauriDialect, TauriORM, TauriORMError, type ThroughRef, UpdateQueryBuilder, UpdateValidationError, ValidationError, WithQueryBuilder, alias, and, as, asc, avg, between, blob, boolean, contains, count, countDistinct, defineRelations, defineRelationsPart, desc, endsWith, enumType, eq, eqSubquery, exists, getTableColumns, groupConcat, gt, gtSubquery, gte, gteSubquery, ilike, inArray, integer, isNotNull, isNull, like, lt, ltSubquery, lte, lteSubquery, max, min, ne, neSubquery, not, notExists, notIn, numeric, or, real, relations, scalarSubquery, sqliteTable, startsWith, subquery, sum, text, through };
+export { type AnySQLiteColumn, type AnyTable, type BuildR, type ColumnDataType, ColumnNotFoundError, type ColumnOptions, type ColumnValueTypes, type Condition, type DatabaseLike, type DefineRelationsCallback, DeleteQueryBuilder, type ExtractColumnType, type InferInsertModel, type InferRelationalSelectModel, type InferRelationsMap, type InferSelectModel, InsertQueryBuilder, InsertValidationError, ManyRelation, type ManyRelationOptions, MigrationError, MissingWhereClauseError, type Mode, OneRelation, type OneRelationOptions, QueryBuilderError, Relation, type RelationConfig, RelationError, type RelationType, type RelationsBuilder, type SQLAggregate, type SQLCondition, type SQLSubquery, SQLiteColumn, SelectQueryBuilder, Table, TableNotFoundError, TauriDialect, TauriORM, TauriORMError, type ThroughRef, UpdateQueryBuilder, UpdateValidationError, ValidationError, WithQueryBuilder, alias, and, as, asc, avg, between, blob, boolean, contains, count, countDistinct, defineRelations, defineRelationsPart, desc, endsWith, enumType, eq, eqSubquery, exists, getTableColumns, groupConcat, gt, gtSubquery, gte, gteSubquery, ilike, inArray, integer, isNotNull, isNull, like, lt, ltSubquery, lte, lteSubquery, max, min, ne, neSubquery, not, notExists, notIn, numeric, or, real, relations, scalarSubquery, sqliteTable, startsWith, subquery, sum, text, through };

package/dist/operators.d.ts

@@ -0,0 +1,30 @@
+import { Expression, SqlBool } from 'kysely';
+import { AnySQLiteColumn } from './types';
+export type Condition = Expression<SqlBool>;
+export declare const eq: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => Condition;
+export declare const ne: <T>(column: AnySQLiteColumn, value: T, tableAlias?: string) => Condition;
+export declare const and: (...conditions: Condition[]) => Condition;
+export declare const or: (...conditions: Condition[]) => Condition;
+export declare const not: (condition: Condition) => Condition;
+export declare const gt: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const gte: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const lt: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const lte: <T>(column: AnySQLiteColumn, value: T) => Condition;
+export declare const like: (column: AnySQLiteColumn, pattern: string) => Condition;
+export declare const ilike: (column: AnySQLiteColumn, pattern: string) => Condition;
+export declare const startsWith: (column: AnySQLiteColumn, value: string) => Condition;
+export declare const endsWith: (column: AnySQLiteColumn, value: string) => Condition;
+export declare const contains: (column: AnySQLiteColumn, value: string) => Condition;
+export declare const isNull: (column: AnySQLiteColumn) => Condition;
+export declare const isNotNull: (column: AnySQLiteColumn) => Condition;
+export declare const exists: (subquery: Expression<any>) => Condition;
+export declare const notExists: (subquery: Expression<any>) => Condition;
+export declare const eqSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const neSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const gtSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const gteSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const ltSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const lteSubquery: (column: AnySQLiteColumn, subquery: Expression<any>) => Condition;
+export declare const inArray: <T>(column: AnySQLiteColumn, values: T[] | Expression<any>) => Condition;
+export declare const notIn: <T>(column: AnySQLiteColumn, values: T[] | Expression<any>) => Condition;
+export declare const between: <T>(column: AnySQLiteColumn, min: T, max: T) => Condition;

package/dist/operators.js

@@ -0,0 +1,84 @@
+import { isExpression, sql } from 'kysely';
+import { serializeValue } from './serialization';
+export const eq = (column, value, tableAlias) => {
+    const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(colRef)} = ${sql.val(serialized)}`;
+};
+export const ne = (column, value, tableAlias) => {
+    const colRef = tableAlias ? `${tableAlias}.${column._.name}` : column._.name;
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(colRef)} != ${sql.val(serialized)}`;
+};
+export const and = (...conditions) => {
+    if (conditions.length === 0)
+        return sql `1 = 1`;
+    if (conditions.length === 1)
+        return conditions[0];
+    return sql `(${sql.join(conditions.map(c => sql `(${c})`), sql ` AND `)})`;
+};
+export const or = (...conditions) => {
+    if (conditions.length === 0)
+        return sql `1 = 1`;
+    if (conditions.length === 1)
+        return conditions[0];
+    return sql `(${sql.join(conditions.map(c => sql `(${c})`), sql ` OR `)})`;
+};
+export const not = (condition) => sql `NOT (${condition})`;
+export const gt = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} > ${sql.val(serialized)}`;
+};
+export const gte = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} >= ${sql.val(serialized)}`;
+};
+export const lt = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} < ${sql.val(serialized)}`;
+};
+export const lte = (column, value) => {
+    const serialized = serializeValue(value, column);
+    return sql `${sql.ref(column._.name)} <= ${sql.val(serialized)}`;
+};
+export const like = (column, pattern) => sql `${sql.ref(column._.name)} LIKE ${sql.val(pattern)}`;
+export const ilike = (column, pattern) => sql `${sql.ref(column._.name)} LIKE ${sql.val(pattern)} COLLATE NOCASE`;
+export const startsWith = (column, value) => sql `${sql.ref(column._.name)} LIKE ${sql.val(`${value}%`)}`;
+export const endsWith = (column, value) => sql `${sql.ref(column._.name)} LIKE ${sql.val(`%${value}`)}`;
+export const contains = (column, value) => sql `${sql.ref(column._.name)} LIKE ${sql.val(`%${value}%`)}`;
+export const isNull = (column) => sql `${sql.ref(column._.name)} IS NULL`;
+export const isNotNull = (column) => sql `${sql.ref(column._.name)} IS NOT NULL`;
+// SQLite rejects EXISTS ((subquery)); use single paren level
+export const exists = (subquery) => sql `EXISTS ${subquery}`;
+export const notExists = (subquery) => sql `NOT EXISTS ${subquery}`;
+export const eqSubquery = (column, subquery) => sql `${sql.ref(column._.name)} = (${subquery})`;
+export const neSubquery = (column, subquery) => sql `${sql.ref(column._.name)} != (${subquery})`;
+export const gtSubquery = (column, subquery) => sql `${sql.ref(column._.name)} > (${subquery})`;
+export const gteSubquery = (column, subquery) => sql `${sql.ref(column._.name)} >= (${subquery})`;
+export const ltSubquery = (column, subquery) => sql `${sql.ref(column._.name)} < (${subquery})`;
+export const lteSubquery = (column, subquery) => sql `${sql.ref(column._.name)} <= (${subquery})`;
+export const inArray = (column, values) => {
+    if (isExpression(values)) {
+        return sql `${sql.ref(column._.name)} IN (${values})`;
+    }
+    const arr = values;
+    if (arr.length === 0)
+        return sql `1 = 0`;
+    const serialized = arr.map(v => sql.val(serializeValue(v, column)));
+    return sql `${sql.ref(column._.name)} IN (${sql.join(serialized)})`;
+};
+export const notIn = (column, values) => {
+    if (isExpression(values)) {
+        return sql `${sql.ref(column._.name)} NOT IN (${values})`;
+    }
+    const arr = values;
+    if (arr.length === 0)
+        return sql `1 = 1`;
+    const serialized = arr.map(v => sql.val(serializeValue(v, column)));
+    return sql `${sql.ref(column._.name)} NOT IN (${sql.join(serialized)})`;
+};
+export const between = (column, min, max) => {
+    const serializedMin = serializeValue(min, column);
+    const serializedMax = serializeValue(max, column);
+    return sql `${sql.ref(column._.name)} BETWEEN ${sql.val(serializedMin)} AND ${sql.val(serializedMax)}`;
+};

package/dist/orm.d.ts

@@ -0,0 +1,180 @@
+import { Expression, SqlBool } from 'kysely';
+import { DatabaseLike } from './dialect';
+import { SelectQueryBuilder, InsertQueryBuilder, UpdateQueryBuilder, DeleteQueryBuilder, WithQueryBuilder, RelationsBuilder } from './builders';
+import { AnySQLiteColumn, AnyTable, ColumnDataType, ColumnOptions, ColumnValueTypes, Mode, RelationConfig } from './types';
+export declare class SQLiteColumn<TName extends string = string, TType extends ColumnDataType = ColumnDataType, TMode extends Mode = 'default', TNotNull extends boolean = false, THasDefault extends boolean = false, TAutoincrement extends boolean = false, TEnum extends readonly string[] = never, TCustomType = never> {
+    type: TType;
+    options: ColumnOptions<ColumnValueTypes<TType, TMode>, TEnum>;
+    _: {
+        name: TName;
+        dataType: TType;
+        mode: TMode;
+        notNull: TNotNull;
+        hasDefault: THasDefault;
+        autoincrement: TAutoincrement;
+        enum: TEnum;
+        customType: TCustomType;
+    };
+    constructor(name: TName, type: TType, options?: ColumnOptions<ColumnValueTypes<TType, TMode>, TEnum>);
+    notNull(): SQLiteColumn<TName, TType, TMode, true, THasDefault, TAutoincrement, TEnum, TCustomType>;
+    default(value: ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, true, TAutoincrement, TEnum, TCustomType>;
+    $defaultFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, true, TAutoincrement, TEnum, TCustomType>;
+    primaryKey(): SQLiteColumn<TName, TType, TMode, true, THasDefault, TAutoincrement, TEnum, TCustomType>;
+    autoincrement(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, true, TEnum, TCustomType>;
+    unique(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
+    references<T extends AnyTable, K extends keyof T['_']['columns'] & string>(ref: T, column: K | T['_']['columns'][K], options?: {
+        onDelete?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+        onUpdate?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
+    }): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
+    $onUpdateFn(fn: () => ColumnValueTypes<TType, TMode>): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
+    $type<T>(): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, T>;
+    as(alias: string): SQLiteColumn<TName, TType, TMode, TNotNull, THasDefault, TAutoincrement, TEnum, TCustomType>;
+}
+type IsOptionalOnInsert<C extends AnySQLiteColumn> = C['_']['notNull'] extends false ? true : C['_']['hasDefault'] extends true ? true : C['_']['autoincrement'] extends true ? true : false;
+type OptionalColumns<TColumns extends Record<string, AnySQLiteColumn>> = {
+    [K in keyof TColumns]: IsOptionalOnInsert<TColumns[K]> extends true ? K : never;
+}[keyof TColumns];
+type RequiredColumns<TColumns extends Record<string, AnySQLiteColumn>> = {
+    [K in keyof TColumns]: IsOptionalOnInsert<TColumns[K]> extends true ? never : K;
+}[keyof TColumns];
+type ExtractInsertColumnType<T extends AnySQLiteColumn> = T extends SQLiteColumn<infer _, infer TType, infer TMode, infer TNotNull, infer THasDefault, infer TAutoincrement, infer TEnum, infer TCustomType> ? [
+    TCustomType
+] extends [never] ? [
+    TEnum
+] extends [never] ? TNotNull extends true ? ColumnValueTypes<TType, TMode> : ColumnValueTypes<TType, TMode> | null : TNotNull extends true ? TEnum[number] : TEnum[number] | null : TNotNull extends true ? TCustomType : TCustomType | null : never;
+export type InferInsertModel<T extends AnyTable> = {
+    [K in RequiredColumns<T['_']['columns']>]: ExtractInsertColumnType<T['_']['columns'][K]>;
+} & {
+    [K in OptionalColumns<T['_']['columns']>]?: ExtractInsertColumnType<T['_']['columns'][K]>;
+};
+export declare class Table<TColumns extends Record<string, AnySQLiteColumn>, TTableName extends string> {
+    _: {
+        name: TTableName;
+        columns: TColumns;
+    };
+    relations: Record<string, RelationConfig>;
+    constructor(name: TTableName, columns: TColumns);
+}
+export declare const sqliteTable: <TTableName extends string, TColumns extends Record<string, AnySQLiteColumn>>(tableName: TTableName, columns: TColumns) => Table<TColumns, TTableName>;
+export type SQLCondition = Expression<SqlBool>;
+export type SQLAggregate<T = number> = Expression<T>;
+export type SQLSubquery = Expression<any>;
+export declare const asc: (column: AnySQLiteColumn) => Expression<any>;
+export declare const desc: (column: AnySQLiteColumn) => Expression<any>;
+export declare class TauriORM {
+    private db;
+    private tables;
+    private kysely;
+    constructor(db: DatabaseLike, schema?: Record<string, AnyTable | Record<string, Relation>> | undefined);
+    private buildColumnDefinition;
+    checkMigration(): Promise<{
+        safe: boolean;
+        changes: {
+            tablesToCreate: string[];
+            tablesToRecreate: string[];
+            tablesToDrop: string[];
+            columnsToAdd: Array<{
+                table: string;
+                column: string;
+            }>;
+        };
+    }>;
+    migrate(options?: {
+        performDestructiveActions?: boolean;
+        dryRun?: boolean;
+    }): Promise<void>;
+    private canAddColumnWithAlter;
+    private hasColumnDefinitionChanged;
+    private recreateTable;
+    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>;
+    upsert<T extends AnyTable>(table: T, data: InferInsertModel<T>, conflictTarget: (keyof T['_']['columns'])[]): Promise<T extends AnyTable ? {
+        lastInsertId: number;
+        rowsAffected: number;
+    }[] : never>;
+    $with(alias: string): {
+        as: (query: SelectQueryBuilder<any, any>) => WithQueryBuilder;
+    };
+    transaction<T>(callback: (tx: TauriORM) => Promise<T>): Promise<T>;
+    rollback(): never;
+    private ensureSchemaMeta;
+    private getSchemaMeta;
+    private setSchemaMeta;
+    private normalizeColumn;
+    private computeModelSignature;
+    getSchemaSignature(): string;
+    isSchemaDirty(): Promise<{
+        dirty: boolean;
+        current: string;
+        stored: string | null;
+    }>;
+    migrateIfDirty(): Promise<boolean>;
+    doesTableExist(tableName: string): Promise<boolean>;
+    dropTable(tableName: string): Promise<void>;
+    doesColumnExist(tableName: string, columnName: string): Promise<boolean>;
+    renameTable(from: string, to: string): Promise<void>;
+    dropColumn(tableName: string, columnName: string): Promise<void>;
+    renameColumn(tableName: string, from: string, to: string): Promise<void>;
+}
+export declare class Relation<T extends AnyTable = AnyTable> {
+    foreignTable: T;
+    constructor(foreignTable: T);
+}
+export declare class OneRelation<T extends AnyTable = AnyTable> extends Relation<T> {
+    config?: {
+        fields: AnySQLiteColumn[];
+        references: AnySQLiteColumn[];
+        optional?: boolean;
+        alias?: string;
+    } | undefined;
+    constructor(foreignTable: T, config?: {
+        fields: AnySQLiteColumn[];
+        references: AnySQLiteColumn[];
+        optional?: boolean;
+        alias?: string;
+    } | undefined);
+}
+export declare class ManyRelation<T extends AnyTable = AnyTable> extends Relation<T> {
+    config?: {
+        from?: AnySQLiteColumn[];
+        to?: AnySQLiteColumn[];
+        through?: {
+            junctionTable: AnyTable;
+            fromRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+            toRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+        };
+        optional?: boolean;
+        alias?: string;
+        where?: (alias: string) => unknown;
+    } | undefined;
+    constructor(foreignTable: T, config?: {
+        from?: AnySQLiteColumn[];
+        to?: AnySQLiteColumn[];
+        through?: {
+            junctionTable: AnyTable;
+            fromRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+            toRef: {
+                column: AnySQLiteColumn;
+                junctionColumn: AnySQLiteColumn;
+            };
+        };
+        optional?: boolean;
+        alias?: string;
+        where?: (alias: string) => unknown;
+    } | undefined);
+}
+export declare const relations: <T extends AnyTable, R extends Record<string, Relation>>(table: T, relationsCallback: (helpers: RelationsBuilder) => R) => R;
+export declare const getTableColumns: <T extends AnyTable>(table: T) => Record<string, AnySQLiteColumn>;
+export declare const alias: <T extends AnyTable>(table: T, alias: string) => Table<T["_"]["columns"], T["_"]["name"]>;
+export {};