@type32/tauri-sqlite-orm 0.1.4 → 0.1.6

package/README.md

@@ -56,6 +56,20 @@ const res = await db.query.users.findMany({
 });
 ```
 
+### Documentation
+
+- See full docs in `docs/`:
+  - Getting Started: `docs/getting-started.md`
+  - Schema & Types: `docs/schema-and-types.md`
+  - Relations: `docs/relations.md`
+  - Queries (select): `docs/queries-select.md`
+  - CRUD (insert): `docs/crud-insert.md`
+  - CRUD (update): `docs/crud-update.md`
+  - CRUD (delete): `docs/crud-delete.md`
+  - SQL Helpers: `docs/sql-helpers.md`
+  - Indexes & Constraints: `docs/indexes-constraints.md`
+  - Migrations: `docs/migrations.md`
+
 ### Schema builder
 
 Chainable, Drizzle-style:
@@ -236,12 +250,6 @@ export default defineNuxtPlugin(async () => {
 });
 ```
 
-### Roadmap
-
-- Aliasing helpers and typed orderBy (asc(users.id)) for findMany
-- Unique(), check(), composite primary/unique constraints
-- Insert returning / batch returning (where feasible)
-
 ### License
 
 MIT

package/dist/index.d.mts

@@ -79,11 +79,62 @@ declare function timestamp(name: string): ColumnBuilder<Date>;
 declare function timestamp(): ColumnBuilder<Date>;
 declare function increments(name: string): ColumnBuilder<number>;
 declare function increments(): ColumnBuilder<number>;
+type UniqueSpec = {
+    name?: string;
+    columns: string[];
+};
+type PrimaryKeySpec = {
+    name?: string;
+    columns: string[];
+};
+type CheckSpec = {
+    name: string;
+    expr: SQLExpression | {
+        raw: string;
+    };
+};
+type ForeignKeySpec = {
+    name?: string;
+    columns: string[];
+    foreignTable: string;
+    foreignColumns: string[];
+    onDelete?: UpdateDeleteAction;
+    onUpdate?: UpdateDeleteAction;
+};
+type IndexSpec = {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+    where?: SQLExpression;
+};
+declare function unique(name?: string): {
+    on: (...cols: Column<any>[]) => UniqueSpec;
+};
+declare function primaryKey(opts: {
+    name?: string;
+    columns: Column<any>[];
+}): PrimaryKeySpec;
+declare function check(name: string, expr: SQLExpression): CheckSpec;
+declare function foreignKey(opts: {
+    name?: string;
+    columns: Column<any>[];
+    foreignColumns: Column<any>[];
+    onDelete?: UpdateDeleteAction;
+    onUpdate?: UpdateDeleteAction;
+}): ForeignKeySpec;
+declare function index(name: string): {
+    on: (...cols: Column<any>[]) => IndexSpec;
+    where: (expr: SQLExpression) => IndexSpec;
+};
+declare function uniqueIndex(name: string): {
+    on: (...cols: Column<any>[]) => IndexSpec;
+    where: (expr: SQLExpression) => IndexSpec;
+};
 type SchemaDefinition = Record<string, Column<any>>;
 type InferModel<T extends SchemaDefinition> = {
     [K in keyof T]: T[K]["_dataType"];
 };
-declare function defineTable<T extends SchemaDefinition>(tableName: string, schema: T): any & InferModel<T>;
+declare function defineTable<T extends SchemaDefinition>(tableName: string, schema: T, extras?: (t: any) => Array<UniqueSpec | PrimaryKeySpec | CheckSpec | ForeignKeySpec | IndexSpec>): any & InferModel<T>;
 type Table<T extends SchemaDefinition> = ReturnType<typeof defineTable<T>>;
 
 interface SQL {
@@ -92,6 +143,11 @@ interface SQL {
         bindings: any[];
     };
 }
+declare function raw(strings: TemplateStringsArray, ...values: any[]): SQL;
+declare function getQualifiedName(column: Column): string;
+declare const and: (...conditions: SQL[]) => SQL;
+declare const or: (...conditions: SQL[]) => SQL;
+declare const not: (condition: SQL) => SQL;
 declare const eq: (column: Column, value: any) => SQL;
 declare const ne: (column: Column, value: any) => SQL;
 declare const gt: (column: Column, value: number | Date) => SQL;
@@ -99,6 +155,36 @@ declare const gte: (column: Column, value: number | Date) => SQL;
 declare const lt: (column: Column, value: number | Date) => SQL;
 declare const lte: (column: Column, value: number | Date) => SQL;
 declare const like: (column: Column<string>, value: string) => SQL;
+declare const ilike: (column: Column<string>, value: string | Column) => SQL;
+declare const notIlike: (column: Column<string>, value: string | Column) => SQL;
+declare const isNull: (column: Column) => SQL;
+declare const isNotNull: (column: Column) => SQL;
+declare const between: (column: Column, from: number | string | Date | Column, to: number | string | Date | Column) => SQL;
+declare const notBetween: (column: Column, from: number | string | Date | Column, to: number | string | Date | Column) => SQL;
+declare const inArray: (column: Column, valuesOrQuery: any[] | SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
+declare const notInArray: (column: Column, valuesOrQuery: any[] | SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
+declare const exists: (subquery: SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
+declare const notExists: (subquery: SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
 declare const asc: (column: Column) => string;
 declare const desc: (column: Column) => string;
 
@@ -110,16 +196,23 @@ declare class SelectQueryBuilder<T> {
     private _orderBy;
     private _limit;
     private _offset;
-    private _eager;
+    private _groupBy;
+    private _having;
+    private _distinct;
     private _dbProvider;
     constructor(dbProvider: () => Promise<Database>, fields?: Record<string, Column<any>>);
+    distinct(): this;
+    select(fields: Record<string, Column<any> | SQL>): this;
     from(table: Table<any>): this;
-    where(...conditions: SQL[]): this;
+    where(...conditions: (SQL | undefined)[]): this;
     leftJoin(otherTable: Table<any>, on: SQL): this;
-    orderBy(...clauses: string[]): this;
+    groupBy(...exprs: (Column | string)[]): this;
+    having(...conditions: SQL[]): this;
+    orderBy(...clauses: (string | Column<any> | SQL)[]): this;
     limit(value: number): this;
     offset(value: number): this;
     execute(): Promise<T[]>;
+    iterator(): Promise<AsyncIterableIterator<T>>;
 }
 declare class TauriORM {
     query: Record<string, any>;
@@ -130,25 +223,76 @@ declare class TauriORM {
     private getDb;
     configureQuery(tables: Record<string, Table<any>>, relations: Record<string, Record<string, RelationConfig>>): void;
     select<T>(fields?: Record<string, Column<any>>): SelectQueryBuilder<T>;
+    selectDistinct<T>(fields?: Record<string, Column<any>>): SelectQueryBuilder<T>;
     insert(table: Table<any>): {
         _table: any;
         _rows: Record<string, any>[];
+        _selectSql: {
+            clause: string;
+            bindings: any[];
+        } | null;
+        _conflict: null | {
+            kind: "doNothing";
+            target?: string | string[];
+            where?: SQL;
+        } | {
+            kind: "doUpdate";
+            target: string | string[];
+            targetWhere?: SQL;
+            set: Record<string, any>;
+            setWhere?: SQL;
+        };
+        _returning: null | "__RETURNING_ID__" | Record<string, Column<any>>;
         values(rowOrRows: Record<string, any> | Record<string, any>[]): /*elided*/ any;
-        execute(): Promise<void>;
+        select(qb: {
+            toSQL?: () => {
+                clause: string;
+                bindings: any[];
+            };
+        } | SQL): /*elided*/ any;
+        returning(fields?: Record<string, Column<any>>): any;
+        $returningId(): any;
+        onConflictDoNothing(opts?: {
+            target?: Column<any> | Column<any>[];
+            where?: SQL;
+        }): /*elided*/ any;
+        onConflictDoUpdate(opts: {
+            target: Column<any> | Column<any>[];
+            targetWhere?: SQL;
+            set: Record<string, any>;
+            setWhere?: SQL;
+        }): /*elided*/ any;
+        execute(): Promise<any>;
+        _buildConflictClause(): string;
+        _executeWithReturning(db: any, query: string, bindings: any[]): Promise<any>;
     };
     update(table: Table<any>): {
         _table: any;
         _data: Record<string, any> | null;
         _where: Record<string, any> | SQL | null;
+        _orderBy: Array<string | SQL>;
+        _limit: number | null;
+        _from: Table<any> | null;
+        _returning: null | Record<string, Column<any>>;
         set(data: Record<string, any>): /*elided*/ any;
         where(cond: Record<string, any> | SQL): /*elided*/ any;
-        execute(): Promise<void>;
+        orderBy(...clauses: (string | Column<any> | SQL)[]): /*elided*/ any;
+        limit(n: number): /*elided*/ any;
+        from(tbl: Table<any>): /*elided*/ any;
+        returning(fields?: Record<string, Column<any>>): any;
+        execute(): Promise<unknown>;
     };
     delete(table: Table<any>): {
         _table: any;
         _where: Record<string, any> | SQL | null;
+        _orderBy: Array<string | SQL>;
+        _limit: number | null;
+        _returning: null | Record<string, Column<any>>;
         where(cond: Record<string, any> | SQL): /*elided*/ any;
-        execute(): Promise<void>;
+        orderBy(...clauses: (string | Column<any> | SQL)[]): /*elided*/ any;
+        limit(n: number): /*elided*/ any;
+        returning(fields?: Record<string, Column<any>>): any;
+        execute(): Promise<unknown>;
     };
     run(query: string, bindings?: any[]): Promise<void>;
     private generateCreateTableSql;
@@ -262,4 +406,4 @@ declare function makeQueryAPI(tables: Record<string, Table<any>>, relDefs: Recor
     }) => Promise<any | null>;
 }; };
 
-export { type BlobMode, type Column, type ColumnBuilder, type IntegerMode, type ManyRelation, type NumericMode, type OneRelation, type SQL, type SQLExpression, type Table, TauriORM, type UpdateDeleteAction, asc, blob, boolean, defineTable, desc, eq, gt, gte, increments, integer, like, lt, lte, makeQueryAPI, ne, numeric, real, relations, sql, text, timestamp };
+export { type BlobMode, type CheckSpec, type Column, type ColumnBuilder, type ForeignKeySpec, type IndexSpec, type IntegerMode, type ManyRelation, type NumericMode, type OneRelation, type PrimaryKeySpec, type SQL, type SQLExpression, type Table, TauriORM, type UniqueSpec, type UpdateDeleteAction, and, asc, between, blob, boolean, check, defineTable, desc, eq, exists, foreignKey, getQualifiedName, gt, gte, ilike, inArray, increments, index, integer, isNotNull, isNull, like, lt, lte, makeQueryAPI, ne, not, notBetween, notExists, notIlike, notInArray, numeric, or, primaryKey, raw, real, relations, sql, text, timestamp, unique, uniqueIndex };

package/dist/index.d.ts

@@ -79,11 +79,62 @@ declare function timestamp(name: string): ColumnBuilder<Date>;
 declare function timestamp(): ColumnBuilder<Date>;
 declare function increments(name: string): ColumnBuilder<number>;
 declare function increments(): ColumnBuilder<number>;
+type UniqueSpec = {
+    name?: string;
+    columns: string[];
+};
+type PrimaryKeySpec = {
+    name?: string;
+    columns: string[];
+};
+type CheckSpec = {
+    name: string;
+    expr: SQLExpression | {
+        raw: string;
+    };
+};
+type ForeignKeySpec = {
+    name?: string;
+    columns: string[];
+    foreignTable: string;
+    foreignColumns: string[];
+    onDelete?: UpdateDeleteAction;
+    onUpdate?: UpdateDeleteAction;
+};
+type IndexSpec = {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+    where?: SQLExpression;
+};
+declare function unique(name?: string): {
+    on: (...cols: Column<any>[]) => UniqueSpec;
+};
+declare function primaryKey(opts: {
+    name?: string;
+    columns: Column<any>[];
+}): PrimaryKeySpec;
+declare function check(name: string, expr: SQLExpression): CheckSpec;
+declare function foreignKey(opts: {
+    name?: string;
+    columns: Column<any>[];
+    foreignColumns: Column<any>[];
+    onDelete?: UpdateDeleteAction;
+    onUpdate?: UpdateDeleteAction;
+}): ForeignKeySpec;
+declare function index(name: string): {
+    on: (...cols: Column<any>[]) => IndexSpec;
+    where: (expr: SQLExpression) => IndexSpec;
+};
+declare function uniqueIndex(name: string): {
+    on: (...cols: Column<any>[]) => IndexSpec;
+    where: (expr: SQLExpression) => IndexSpec;
+};
 type SchemaDefinition = Record<string, Column<any>>;
 type InferModel<T extends SchemaDefinition> = {
     [K in keyof T]: T[K]["_dataType"];
 };
-declare function defineTable<T extends SchemaDefinition>(tableName: string, schema: T): any & InferModel<T>;
+declare function defineTable<T extends SchemaDefinition>(tableName: string, schema: T, extras?: (t: any) => Array<UniqueSpec | PrimaryKeySpec | CheckSpec | ForeignKeySpec | IndexSpec>): any & InferModel<T>;
 type Table<T extends SchemaDefinition> = ReturnType<typeof defineTable<T>>;
 
 interface SQL {
@@ -92,6 +143,11 @@ interface SQL {
         bindings: any[];
     };
 }
+declare function raw(strings: TemplateStringsArray, ...values: any[]): SQL;
+declare function getQualifiedName(column: Column): string;
+declare const and: (...conditions: SQL[]) => SQL;
+declare const or: (...conditions: SQL[]) => SQL;
+declare const not: (condition: SQL) => SQL;
 declare const eq: (column: Column, value: any) => SQL;
 declare const ne: (column: Column, value: any) => SQL;
 declare const gt: (column: Column, value: number | Date) => SQL;
@@ -99,6 +155,36 @@ declare const gte: (column: Column, value: number | Date) => SQL;
 declare const lt: (column: Column, value: number | Date) => SQL;
 declare const lte: (column: Column, value: number | Date) => SQL;
 declare const like: (column: Column<string>, value: string) => SQL;
+declare const ilike: (column: Column<string>, value: string | Column) => SQL;
+declare const notIlike: (column: Column<string>, value: string | Column) => SQL;
+declare const isNull: (column: Column) => SQL;
+declare const isNotNull: (column: Column) => SQL;
+declare const between: (column: Column, from: number | string | Date | Column, to: number | string | Date | Column) => SQL;
+declare const notBetween: (column: Column, from: number | string | Date | Column, to: number | string | Date | Column) => SQL;
+declare const inArray: (column: Column, valuesOrQuery: any[] | SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
+declare const notInArray: (column: Column, valuesOrQuery: any[] | SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
+declare const exists: (subquery: SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
+declare const notExists: (subquery: SQL | {
+    toSQL: () => {
+        clause: string;
+        bindings: any[];
+    };
+}) => SQL;
 declare const asc: (column: Column) => string;
 declare const desc: (column: Column) => string;
 
@@ -110,16 +196,23 @@ declare class SelectQueryBuilder<T> {
     private _orderBy;
     private _limit;
     private _offset;
-    private _eager;
+    private _groupBy;
+    private _having;
+    private _distinct;
     private _dbProvider;
     constructor(dbProvider: () => Promise<Database>, fields?: Record<string, Column<any>>);
+    distinct(): this;
+    select(fields: Record<string, Column<any> | SQL>): this;
     from(table: Table<any>): this;
-    where(...conditions: SQL[]): this;
+    where(...conditions: (SQL | undefined)[]): this;
     leftJoin(otherTable: Table<any>, on: SQL): this;
-    orderBy(...clauses: string[]): this;
+    groupBy(...exprs: (Column | string)[]): this;
+    having(...conditions: SQL[]): this;
+    orderBy(...clauses: (string | Column<any> | SQL)[]): this;
     limit(value: number): this;
     offset(value: number): this;
     execute(): Promise<T[]>;
+    iterator(): Promise<AsyncIterableIterator<T>>;
 }
 declare class TauriORM {
     query: Record<string, any>;
@@ -130,25 +223,76 @@ declare class TauriORM {
     private getDb;
     configureQuery(tables: Record<string, Table<any>>, relations: Record<string, Record<string, RelationConfig>>): void;
     select<T>(fields?: Record<string, Column<any>>): SelectQueryBuilder<T>;
+    selectDistinct<T>(fields?: Record<string, Column<any>>): SelectQueryBuilder<T>;
     insert(table: Table<any>): {
         _table: any;
         _rows: Record<string, any>[];
+        _selectSql: {
+            clause: string;
+            bindings: any[];
+        } | null;
+        _conflict: null | {
+            kind: "doNothing";
+            target?: string | string[];
+            where?: SQL;
+        } | {
+            kind: "doUpdate";
+            target: string | string[];
+            targetWhere?: SQL;
+            set: Record<string, any>;
+            setWhere?: SQL;
+        };
+        _returning: null | "__RETURNING_ID__" | Record<string, Column<any>>;
         values(rowOrRows: Record<string, any> | Record<string, any>[]): /*elided*/ any;
-        execute(): Promise<void>;
+        select(qb: {
+            toSQL?: () => {
+                clause: string;
+                bindings: any[];
+            };
+        } | SQL): /*elided*/ any;
+        returning(fields?: Record<string, Column<any>>): any;
+        $returningId(): any;
+        onConflictDoNothing(opts?: {
+            target?: Column<any> | Column<any>[];
+            where?: SQL;
+        }): /*elided*/ any;
+        onConflictDoUpdate(opts: {
+            target: Column<any> | Column<any>[];
+            targetWhere?: SQL;
+            set: Record<string, any>;
+            setWhere?: SQL;
+        }): /*elided*/ any;
+        execute(): Promise<any>;
+        _buildConflictClause(): string;
+        _executeWithReturning(db: any, query: string, bindings: any[]): Promise<any>;
     };
     update(table: Table<any>): {
         _table: any;
         _data: Record<string, any> | null;
         _where: Record<string, any> | SQL | null;
+        _orderBy: Array<string | SQL>;
+        _limit: number | null;
+        _from: Table<any> | null;
+        _returning: null | Record<string, Column<any>>;
         set(data: Record<string, any>): /*elided*/ any;
         where(cond: Record<string, any> | SQL): /*elided*/ any;
-        execute(): Promise<void>;
+        orderBy(...clauses: (string | Column<any> | SQL)[]): /*elided*/ any;
+        limit(n: number): /*elided*/ any;
+        from(tbl: Table<any>): /*elided*/ any;
+        returning(fields?: Record<string, Column<any>>): any;
+        execute(): Promise<unknown>;
     };
     delete(table: Table<any>): {
         _table: any;
         _where: Record<string, any> | SQL | null;
+        _orderBy: Array<string | SQL>;
+        _limit: number | null;
+        _returning: null | Record<string, Column<any>>;
         where(cond: Record<string, any> | SQL): /*elided*/ any;
-        execute(): Promise<void>;
+        orderBy(...clauses: (string | Column<any> | SQL)[]): /*elided*/ any;
+        limit(n: number): /*elided*/ any;
+        returning(fields?: Record<string, Column<any>>): any;
+        execute(): Promise<unknown>;
     };
     run(query: string, bindings?: any[]): Promise<void>;
     private generateCreateTableSql;
@@ -262,4 +406,4 @@ declare function makeQueryAPI(tables: Record<string, Table<any>>, relDefs: Recor
     }) => Promise<any | null>;
 }; };
 
-export { type BlobMode, type Column, type ColumnBuilder, type IntegerMode, type ManyRelation, type NumericMode, type OneRelation, type SQL, type SQLExpression, type Table, TauriORM, type UpdateDeleteAction, asc, blob, boolean, defineTable, desc, eq, gt, gte, increments, integer, like, lt, lte, makeQueryAPI, ne, numeric, real, relations, sql, text, timestamp };
+export { type BlobMode, type CheckSpec, type Column, type ColumnBuilder, type ForeignKeySpec, type IndexSpec, type IntegerMode, type ManyRelation, type NumericMode, type OneRelation, type PrimaryKeySpec, type SQL, type SQLExpression, type Table, TauriORM, type UniqueSpec, type UpdateDeleteAction, and, asc, between, blob, boolean, check, defineTable, desc, eq, exists, foreignKey, getQualifiedName, gt, gte, ilike, inArray, increments, index, integer, isNotNull, isNull, like, lt, lte, makeQueryAPI, ne, not, notBetween, notExists, notIlike, notInArray, numeric, or, primaryKey, raw, real, relations, sql, text, timestamp, unique, uniqueIndex };