@type32/tauri-sqlite-orm 0.2.15 → 0.4.0

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 {};