@type32/tauri-sqlite-orm 0.2.13 → 0.3.0

package/README.md

@@ -7,7 +7,7 @@ A Drizzle-like TypeScript ORM tailored for Tauri v2's `@tauri-apps/plugin-sql` (
 - **Drizzle-like Schema:** Define your database schema using a familiar, chainable API.
 - **Strict Type Inference:** Full TypeScript type safety with no `any` types - nullable columns, custom types, and required/optional fields are accurately inferred.
 - **Type-Safe Query Builder:** Build SQL queries with TypeScript, ensuring type safety and autocompletion.
-- **Relations Support:** Define and query one-to-one, one-to-many, and many-to-many relationships between tables.
+- **Relations Support:** Define and query one-to-one, one-to-many, and many-to-many (via junction tables, Drizzle-style) relationships between tables.
 - **Nested Includes:** Load relations of relations with intuitive nested syntax.
 - **Advanced Operators:** Comprehensive set of operators including `ne`, `between`, `notIn`, `ilike`, `startsWith`, `endsWith`, `contains`, and more.
 - **Subquery Support:** Use subqueries in WHERE and SELECT clauses with full type safety.
@@ -16,6 +16,7 @@ A Drizzle-like TypeScript ORM tailored for Tauri v2's `@tauri-apps/plugin-sql` (
 - **Safety Features:** Automatic WHERE clause validation for UPDATE/DELETE prevents accidental data loss.
 - **Increment/Decrement:** Atomic increment/decrement operations for safe counter updates.
 - **Better Error Handling:** Custom error classes for clear, actionable error messages.
+- **Cascade Actions:** `onDelete` and `onUpdate` (cascade, set null, set default, restrict, no action) for foreign key references.
 - **Simplified Migrations:** Keep your database schema in sync with your application's models using automatic schema detection and migration tools.
 - **Lightweight & Performant:** Designed to be a thin layer over the Tauri SQL plugin, ensuring minimal overhead.
 
@@ -33,20 +34,20 @@ Make sure the SQL plugin is registered on the Rust side (see Tauri docs).
 
 ```typescript
 import Database from '@tauri-apps/plugin-sql'
-import { TauriORM, sqliteTable, int, text, relations } from '@type32/tauri-sqlite-orm'
+import { TauriORM, sqliteTable, integer, text, relations, InferSelectModel, InferRelationalSelectModel } from '@type32/tauri-sqlite-orm'
 
 // Define tables
 const users = sqliteTable('users', {
-  id: int('id').primaryKey().autoincrement(),
+  id: integer('id').primaryKey().autoincrement(),
   name: text('name').notNull(),
   email: text('email').notNull().unique(),
 })
 
 const posts = sqliteTable('posts', {
-  id: int('id').primaryKey().autoincrement(),
+  id: integer('id').primaryKey().autoincrement(),
   title: text('title').notNull(),
   content: text('content').notNull(),
-  userId: int('user_id').notNull().references(users, 'id'),
+  userId: integer('user_id').notNull().references(users, users._.columns.id, { onDelete: 'cascade' }),
 })
 
 // Define relations
@@ -78,6 +79,11 @@ const usersWithPosts = await orm
   .select(users)
   .include({ posts: true })
   .all()
+
+// Type relational results with InferRelationalSelectModel
+type User = InferSelectModel<typeof users>
+const withPosts = { posts: true } as const
+type UserWithPosts = InferRelationalSelectModel<typeof users, typeof usersRelations, typeof withPosts>
 ```
 
 ### Documentation
@@ -88,10 +94,10 @@ const usersWithPosts = await orm
 
 ### Relations
 
-The ORM supports three types of relations:
+The ORM supports relations in a Drizzle-style pattern:
 
-1. **One-to-One / Many-to-One**: Use `one()` to define a relation where the current table references another table
+1. **One-to-One / Many-to-One**: Use `one()` with `fields` and `references` to define a relation where the current table references another table
 2. **One-to-Many**: Use `many()` to define a relation where another table references the current table
-3. **Many-to-Many**: Use `manyToMany()` to define a many-to-many relation through a junction table
+3. **Many-to-Many**: Use `many(junctionTable)` on both sides and define `one()` on the junction with `fields`/`references` to each entity. Load with nested includes: `include({ postTags: { with: { tag: true } } })`
 
 See the [many-to-many example](./docs/many-to-many-example.md) for detailed usage.