@type32/tauri-sqlite-orm 0.3.0 → 0.4.0

package/dist/aggregates.d.ts

@@ -0,0 +1,12 @@
+import { Expression } from 'kysely';
+import { AnySQLiteColumn } from './types';
+export declare const count: (column?: AnySQLiteColumn) => Expression<number>;
+export declare const countDistinct: (column: AnySQLiteColumn) => Expression<number>;
+export declare const sum: (column: AnySQLiteColumn) => Expression<number>;
+export declare const avg: (column: AnySQLiteColumn) => Expression<number>;
+export declare const max: <T = any>(column: AnySQLiteColumn) => Expression<T>;
+export declare const min: <T = any>(column: AnySQLiteColumn) => Expression<T>;
+export declare const groupConcat: (column: AnySQLiteColumn, separator?: string) => Expression<string>;
+export declare const as: <T>(aggregate: Expression<T>, alias: string) => Expression<T> & {
+    alias: string;
+};

package/dist/aggregates.js

@@ -0,0 +1,9 @@
+import { sql } from 'kysely';
+export const count = (column) => sql `COUNT(${column ? sql.ref(column._.name) : sql.raw('*')})`;
+export const countDistinct = (column) => sql `COUNT(DISTINCT ${sql.ref(column._.name)})`;
+export const sum = (column) => sql `SUM(${sql.ref(column._.name)})`;
+export const avg = (column) => sql `AVG(${sql.ref(column._.name)})`;
+export const max = (column) => sql `MAX(${sql.ref(column._.name)})`;
+export const min = (column) => sql `MIN(${sql.ref(column._.name)})`;
+export const groupConcat = (column, separator = ',') => sql `GROUP_CONCAT(${sql.ref(column._.name)}, ${sql.val(separator)})`;
+export const as = (aggregate, alias) => Object.assign(aggregate, { alias });

package/dist/builders/delete.d.ts

@@ -0,0 +1,23 @@
+import { Kysely } from 'kysely';
+import { AnyTable, InferSelectModel } from '../types';
+import { Condition } from '../operators';
+export declare class DeleteQueryBuilder<T extends AnyTable> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _returningColumns;
+    private _hasWhereClause;
+    private _allowGlobal;
+    constructor(kysely: Kysely<any>, table: T);
+    private mapReturningRows;
+    where(condition: Condition): this;
+    allowGlobalOperation(): this;
+    returning(...columns: (keyof T['_']['columns'])[]): this;
+    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/delete.js

@@ -0,0 +1,73 @@
+import { MissingWhereClauseError } from '../errors';
+import { deserializeValue } from '../serialization';
+export class DeleteQueryBuilder {
+    kysely;
+    _builder;
+    _table;
+    _returningColumns = [];
+    _hasWhereClause = false;
+    _allowGlobal = false;
+    constructor(kysely, table) {
+        this.kysely = kysely;
+        this._table = table;
+        this._builder = kysely.deleteFrom(table._.name);
+    }
+    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;
+        });
+    }
+    where(condition) {
+        this._hasWhereClause = true;
+        this._builder = this._builder.where(condition);
+        return this;
+    }
+    allowGlobalOperation() {
+        this._allowGlobal = true;
+        return this;
+    }
+    returning(...columns) {
+        this._returningColumns.push(...columns);
+        return this;
+    }
+    async execute() {
+        if (!this._hasWhereClause && !this._allowGlobal) {
+            throw new MissingWhereClauseError('DELETE', this._table._.name);
+        }
+        if (this._returningColumns.length > 0) {
+            const cols = this._returningColumns.map((k) => this._table._.columns[k]._.name);
+            const rows = await this._builder.returning(cols).execute();
+            return this.mapReturningRows(rows);
+        }
+        const result = await this._builder.executeTakeFirst();
+        return [{ rowsAffected: Number(result?.numDeletedRows ?? 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() {
+        let builder = this._builder;
+        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/index.d.ts

@@ -0,0 +1,7 @@
+export * from './query-base';
+export * from './select';
+export * from './update';
+export * from './insert';
+export * from './delete';
+export * from './with';
+export * from './relations';

package/dist/builders/index.js

@@ -0,0 +1,7 @@
+export * from './query-base';
+export * from './select';
+export * from './update';
+export * from './insert';
+export * from './delete';
+export * from './with';
+export * from './relations';

package/dist/builders/insert.d.ts

@@ -0,0 +1,31 @@
+import { Kysely } from 'kysely';
+import { InferInsertModel } from '../orm';
+import { AnySQLiteColumn, AnyTable, InferSelectModel } from '../types';
+export declare class InsertQueryBuilder<T extends AnyTable> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _dataSets;
+    private _returningColumns;
+    private _onConflictAction;
+    private _conflictTarget;
+    private _updateSet;
+    constructor(kysely: Kysely<any>, table: T);
+    values(data: InferInsertModel<T> | InferInsertModel<T>[]): this;
+    returning(...columns: (keyof T['_']['columns'])[]): this;
+    onConflictDoNothing(target?: AnySQLiteColumn | AnySQLiteColumn[]): this;
+    onConflictDoUpdate(config: {
+        target: AnySQLiteColumn | AnySQLiteColumn[];
+        set: Partial<InferInsertModel<T>>;
+    }): this;
+    private processDefaults;
+    private mapReturningRows;
+    private serializeDataSet;
+    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/insert.js

@@ -0,0 +1,141 @@
+import { InsertValidationError } from '../errors';
+import { serializeValue, deserializeValue } from '../serialization';
+export class InsertQueryBuilder {
+    kysely;
+    _builder;
+    _table;
+    _dataSets = [];
+    _returningColumns = [];
+    _onConflictAction = null;
+    _conflictTarget = [];
+    _updateSet = {};
+    constructor(kysely, table) {
+        this.kysely = kysely;
+        this._table = table;
+        this._builder = kysely.insertInto(table._.name);
+    }
+    values(data) {
+        const arr = Array.isArray(data) ? data : [data];
+        this._dataSets.push(...arr);
+        return this;
+    }
+    returning(...columns) {
+        this._returningColumns.push(...columns);
+        return this;
+    }
+    onConflictDoNothing(target) {
+        this._onConflictAction = 'nothing';
+        if (target) {
+            this._conflictTarget = Array.isArray(target) ? target : [target];
+        }
+        return this;
+    }
+    onConflictDoUpdate(config) {
+        this._onConflictAction = 'update';
+        this._conflictTarget = Array.isArray(config.target) ? config.target : [config.target];
+        this._updateSet = config.set;
+        return this;
+    }
+    processDefaults(data) {
+        const out = { ...data };
+        for (const [key, column] of Object.entries(this._table._.columns)) {
+            if (out[key] === undefined && column.options.$defaultFn) {
+                ;
+                out[key] = column.options.$defaultFn();
+            }
+        }
+        return out;
+    }
+    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;
+        });
+    }
+    serializeDataSet(data) {
+        const out = {};
+        for (const [key, value] of Object.entries(data)) {
+            const column = this._table._.columns[key];
+            out[column ? column._.name : key] = column ? serializeValue(value, column) : value;
+        }
+        return out;
+    }
+    async execute() {
+        if (this._dataSets.length === 0) {
+            throw new InsertValidationError('No data provided for insert. Use .values() to provide data.');
+        }
+        const processed = this._dataSets.map((d) => this.serializeDataSet(this.processDefaults(d)));
+        let builder = this._builder.values(processed.length === 1 ? processed[0] : processed);
+        if (this._onConflictAction === 'nothing') {
+            if (this._conflictTarget.length > 0) {
+                const targetCols = this._conflictTarget.map((c) => c._.name);
+                builder = builder.onConflict((oc) => oc.columns(targetCols).doNothing());
+            }
+            else {
+                builder = builder.onConflict((oc) => oc.doNothing());
+            }
+        }
+        else if (this._onConflictAction === 'update') {
+            const targetCols = this._conflictTarget.map((c) => c._.name);
+            const updateData = this.serializeDataSet(this._updateSet);
+            builder = builder.onConflict((oc) => oc.columns(targetCols).doUpdateSet(updateData));
+        }
+        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 [
+            {
+                lastInsertId: Number(result?.insertId ?? 0),
+                rowsAffected: Number(result?.numInsertedOrUpdatedRows ?? 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() {
+        if (this._dataSets.length === 0) {
+            throw new InsertValidationError('No data provided for insert. Use .values() to provide data.');
+        }
+        const processed = this._dataSets.map((d) => this.serializeDataSet(this.processDefaults(d)));
+        let builder = this._builder.values(processed.length === 1 ? processed[0] : processed);
+        if (this._onConflictAction === 'nothing') {
+            if (this._conflictTarget.length > 0) {
+                builder = builder.onConflict((oc) => oc.columns(this._conflictTarget.map((c) => c._.name)).doNothing());
+            }
+            else {
+                builder = builder.onConflict((oc) => oc.doNothing());
+            }
+        }
+        else if (this._onConflictAction === 'update') {
+            const updateData = this.serializeDataSet(this._updateSet);
+            builder = builder.onConflict((oc) => oc
+                .columns(this._conflictTarget.map((c) => c._.name))
+                .doUpdateSet(updateData));
+        }
+        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/query-base.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/builders/query-base.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/relations.d.ts

@@ -0,0 +1,11 @@
+import { ManyRelation, OneRelation } from '../orm';
+import { AnySQLiteColumn, AnyTable } from '../types';
+export type RelationsBuilder = {
+    one: <U extends AnyTable>(table: U, config?: {
+        fields: AnySQLiteColumn[];
+        references: AnySQLiteColumn[];
+        optional?: boolean;
+        alias?: string;
+    }) => OneRelation<U>;
+    many: <U extends AnyTable>(table: U) => ManyRelation<U>;
+};

package/dist/builders/relations.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/select.d.ts

@@ -0,0 +1,54 @@
+import { Expression, Kysely, SqlBool } from 'kysely';
+import { Condition } from '../operators';
+import { AnySQLiteColumn, AnyTable, InferSelectModel } from '../types';
+type NestedInclude = boolean | {
+    columns?: string[] | Record<string, boolean>;
+    with?: Record<string, NestedInclude>;
+};
+type ExtractRelationNames<T extends AnyTable> = T['relations'] extends Record<string, any> ? keyof T['relations'] & string : never;
+type IncludeRelations<T extends AnyTable> = T['relations'] extends Record<string, any> ? Partial<Record<ExtractRelationNames<T>, NestedInclude>> : Record<string, never>;
+export declare class SelectQueryBuilder<TTable extends AnyTable, TSelectedColumns extends (keyof TTable['_']['columns'])[] | undefined = undefined> {
+    private readonly kysely;
+    private _builder;
+    private _table;
+    private _columns?;
+    private _includeRelations;
+    private _manualJoins;
+    private _isDistinct;
+    private _includedColumnAliases;
+    constructor(kysely: Kysely<any>, table: TTable, columns?: TSelectedColumns);
+    distinct(): this;
+    where(condition: Condition): this;
+    orderBy(column: AnySQLiteColumn | Expression<any>, direction?: 'asc' | 'desc'): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    groupBy(...columns: AnySQLiteColumn[]): this;
+    having(condition: Condition): this;
+    leftJoin<T extends AnyTable>(table: T, condition: Expression<SqlBool>, alias: string): this;
+    innerJoin<T extends AnyTable>(table: T, condition: Expression<SqlBool>, alias: string): this;
+    include(relations: IncludeRelations<TTable>): this;
+    private applyIncludes;
+    execute(): Promise<InferSelectModel<TTable>[]>;
+    private processRelationResults;
+    all(): Promise<InferSelectModel<TTable>[]>;
+    get(): Promise<InferSelectModel<TTable> | undefined>;
+    first(): Promise<InferSelectModel<TTable> | undefined>;
+    exists(): Promise<boolean>;
+    count(): Promise<number>;
+    pluck<K extends keyof TTable['_']['columns']>(column: K): Promise<InferSelectModel<TTable>[K][]>;
+    paginate(page?: number, pageSize?: number): Promise<{
+        data: InferSelectModel<TTable>[];
+        total: number;
+        page: number;
+        pageSize: number;
+        totalPages: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+    }>;
+    toSQL(): {
+        sql: string;
+        params: any[];
+    };
+    toKyselyExpression(): Expression<any>;
+}
+export {};