rado 0.3.4 → 0.3.6

package/README.md

@@ -1,277 +1,277 @@
-[![npm](https://img.shields.io/npm/v/rado.svg)](https://npmjs.org/package/rado)
-
-# rado
-
-Fully typed, lightweight TypeScript query builder.
-Currently focused on SQLite.
-
-- Definition via TypeScript types
-- Composable queries
-- Aggregate rows in selects
-- First class JSON columns
-- No code generation step
-- No dependencies
-
-<pre>npm install <a href="https://www.npmjs.com/package/rado">rado</a></pre>
-
-## Queries
-
-#### Where
-
-Conditions can be created by accessing the fields of the table
-instances and using the operators of `Expr`:
-
-```ts
-User.id // This is an Expr<number> which has an `is` method to compare
-User.id.is(1) // Compare with a value, results in an Expr<boolean>
-User.id.is(Post.userId) // Compare to fields on other tables
-```
-
-Rows can be selected by passing the condition in the where method:
-
-```ts
-// Call a table instance to start a query selecting from that table
-User().where(User.id.is(1))
-// Conditions can be as complex as you want
-User().where(User.id.isGreater(1).and(User.id.isLess(5)))
-// `And` conditions can also be comma separated in `where` to improve readability
-User().where(User.id.isGreater(1), User.id.isLess(5))
-```
-
-There's a shortcut for comparing columns of a table directly in its call.
-The first comparison above can be simplified to:
-
-```ts
-User({id: 1}) // Is the same as User().where(User.id.is(1))
-```
-
-This comes in handy when joining tables too:
-
-```ts
-User({id: 1}).innerJoin(Post({userId: User.id}))
-// Is equal to:
-User().innerJoin(Post, Post.userId.is(User.id)).where(User.id.is(1))
-```
-
-#### Select
-
-Retrieve a single field
-
-```ts
-User().select(User.name)
-```
-
-Or an object of data
-
-```ts
-User().select({
-  ...User, // Get all user fields: id, username
-  posts: Post({userId: User.id}) // Aggregate posts of this user
-})
-```
-
-You can call the `posts` helper method defined in the example schema below
-to achieve the same:
-
-```ts
-User().select({
-  ...User,
-  posts: User.posts()
-})
-```
-
-Retrieve all posts with their author and tags and count the tag usage in other
-posts:
-
-```ts
-import {count} from 'rado/sqlite'
-// Alias tables using `as`
-const pt = PostTags().as('pt')
-Post().select({
-  ...Post,
-  author: Post.author().select(User.username),
-  tags: Post.tags().select({
-    count: pt({tagId: Tag.id}).select(count()).first(),
-    name: Tag.name
-  })
-})
-```
-
-Join other tables and select fields from either table:
-
-```ts
-User({id: 1}).innerJoin(Post({userId: User.id})).select({
-  username: User.username
-  post: Post
-})
-```
-
-Create expressions to select complex values:
-
-```ts
-import {iif} from 'rado/sqlite'
-Person().select({
-  name: Person.firstName.concat(' ').concat(Person.lastName),
-  isMario: Person.firstName.is('Mario'),
-  isActor: Person.id.isIn(Actor().select(Actor.personId)),
-  email: iif(Person.email.isNotNull(), Person.email, 'its.me@mario'),
-  twitterHandle: Person.socialMedia
-    .filter(media => media.type.is('twitter'))
-    .map(media => media.handle)
-    .maybeFirst()
-})
-```
-
-Order, group, limit queries:
-
-```ts
-User()
-  .orderBy(User.username.asc())
-  .groupBy(User.id, User.username)
-  .skip(20)
-  .take(10)
-```
-
-#### Insert
-
-Insert a single row and return the result:
-
-```ts
-User().insertOne({username: 'Mario'})
-```
-
-Insert multiple rows:
-
-```ts
-User().insertAll([{username: 'Mario'}, {username: 'Luigi'}])
-```
-
-#### Update
-
-Set values
-
-```ts
-User({id: 1}).set({username: 'Bowser'})
-```
-
-Use expressions to update complex values:
-
-```ts
-User()
-  .set({username: User.username.concat(' [removed]')})
-  .where(User.deleted)
-```
-
-#### Delete
-
-Delete rows
-
-```ts
-User({id: 1}).delete()
-```
-
-## Schema definition
-
-```ts
-import {table, column} from 'rado'
-
-const User = table({
-  // Pass a definition under a key with the actual name of the table in database
-  user: class {
-    id = column.integer.primaryKey()
-    username = column.string
-
-    // Define helper methods directly on the model
-    posts() {
-      return Post({userId: this.id})
-    }
-  }
-})
-
-const Post = table({
-  post: class {
-    id = column.integer.primaryKey()
-    userId = column.integer.references(() => User.id)
-    content = column.string
-
-    author() {
-      return User({id: this.userId}).first()
-    }
-
-    tags() {
-      return Tag({id: PostTags.tagId}).innerJoin(PostTags({postId: this.id}))
-    }
-  }
-})
-
-const Tag = table({
-  tag: class {
-    id = column.integer.primaryKey()
-    name = column.string
-  }
-})
-
-const PostTags = table({
-  post_tag: class {
-    postId = column.integer.references(() => Post.id)
-    tagId = column.integer.references(() => Tag.id)
-  }
-})
-```
-
-## Connections
-
-Currently supported SQLite drivers:
-`better-sqlite3`, `sql.js`, `sqlite3`, `bun:sqlite`
-
-Pass an instance of the database to the `connect` function to get started:
-
-```ts
-import Database from 'better-sqlite3'
-import {connect} from 'rado/driver/better-sqlite3'
-
-const db = connect(new Database('foobar.db'))
-```
-
-Currently all drivers are synchronous except for the `sqlite3` driver which is
-async.
-
-#### Run queries
-
-Call the connection with a query to retrieve its results:
-
-```ts
-const posts = db(Post())
-// For async drivers this will be a Promise:
-const posts = await db(Post())
-```
-
-#### Iterate results
-
-Iterate over query results:
-
-```ts
-const allPosts = Post()
-for (const row of db.iterate(allPosts)) {
-  console.log(row)
-}
-// For async drivers:
-for await (const row of db.iterate(allPosts)) {
-  console.log(row)
-}
-```
-
-#### Transactions
-
-Run transactions within the `transaction` method which will isolate a connection
-and can optionally return a result:
-
-```ts
-const firstUserId = db.transaction(tx => {
-  const createTable = User().create()
-  tx(createTable)
-  const insertUser = User().insertOne({username: 'Mario'})
-  tx(insertUser)
-  return insertUser.id
-})
-```
+[![npm](https://img.shields.io/npm/v/rado.svg)](https://npmjs.org/package/rado)
+
+# rado
+
+Fully typed, lightweight TypeScript query builder.
+Currently focused on SQLite.
+
+- Definition via TypeScript types
+- Composable queries
+- Aggregate rows in selects
+- First class JSON columns
+- No code generation step
+- No dependencies
+
+<pre>npm install <a href="https://www.npmjs.com/package/rado">rado</a></pre>
+
+## Queries
+
+#### Where
+
+Conditions can be created by accessing the fields of the table
+instances and using the operators of `Expr`:
+
+```ts
+User.id // This is an Expr<number> which has an `is` method to compare
+User.id.is(1) // Compare with a value, results in an Expr<boolean>
+User.id.is(Post.userId) // Compare to fields on other tables
+```
+
+Rows can be selected by passing the condition in the where method:
+
+```ts
+// Call a table instance to start a query selecting from that table
+User().where(User.id.is(1))
+// Conditions can be as complex as you want
+User().where(User.id.isGreater(1).and(User.id.isLess(5)))
+// `And` conditions can also be comma separated in `where` to improve readability
+User().where(User.id.isGreater(1), User.id.isLess(5))
+```
+
+There's a shortcut for comparing columns of a table directly in its call.
+The first comparison above can be simplified to:
+
+```ts
+User({id: 1}) // Is the same as User().where(User.id.is(1))
+```
+
+This comes in handy when joining tables too:
+
+```ts
+User({id: 1}).innerJoin(Post({userId: User.id}))
+// Is equal to:
+User().innerJoin(Post, Post.userId.is(User.id)).where(User.id.is(1))
+```
+
+#### Select
+
+Retrieve a single field
+
+```ts
+User().select(User.name)
+```
+
+Or an object of data
+
+```ts
+User().select({
+  ...User, // Get all user fields: id, username
+  posts: Post({userId: User.id}) // Aggregate posts of this user
+})
+```
+
+You can call the `posts` helper method defined in the example schema below
+to achieve the same:
+
+```ts
+User().select({
+  ...User,
+  posts: User.posts()
+})
+```
+
+Retrieve all posts with their author and tags and count the tag usage in other
+posts:
+
+```ts
+import {count} from 'rado/sqlite'
+// Alias tables using `as`
+const pt = PostTags().as('pt')
+Post().select({
+  ...Post,
+  author: Post.author().select(User.username),
+  tags: Post.tags().select({
+    count: pt({tagId: Tag.id}).select(count()).first(),
+    name: Tag.name
+  })
+})
+```
+
+Join other tables and select fields from either table:
+
+```ts
+User({id: 1}).innerJoin(Post({userId: User.id})).select({
+  username: User.username
+  post: Post
+})
+```
+
+Create expressions to select complex values:
+
+```ts
+import {iif} from 'rado/sqlite'
+Person().select({
+  name: Person.firstName.concat(' ').concat(Person.lastName),
+  isMario: Person.firstName.is('Mario'),
+  isActor: Person.id.isIn(Actor().select(Actor.personId)),
+  email: iif(Person.email.isNotNull(), Person.email, 'its.me@mario'),
+  twitterHandle: Person.socialMedia
+    .filter(media => media.type.is('twitter'))
+    .map(media => media.handle)
+    .maybeFirst()
+})
+```
+
+Order, group, limit queries:
+
+```ts
+User()
+  .orderBy(User.username.asc())
+  .groupBy(User.id, User.username)
+  .skip(20)
+  .take(10)
+```
+
+#### Insert
+
+Insert a single row and return the result:
+
+```ts
+User().insertOne({username: 'Mario'})
+```
+
+Insert multiple rows:
+
+```ts
+User().insertAll([{username: 'Mario'}, {username: 'Luigi'}])
+```
+
+#### Update
+
+Set values
+
+```ts
+User({id: 1}).set({username: 'Bowser'})
+```
+
+Use expressions to update complex values:
+
+```ts
+User()
+  .set({username: User.username.concat(' [removed]')})
+  .where(User.deleted)
+```
+
+#### Delete
+
+Delete rows
+
+```ts
+User({id: 1}).delete()
+```
+
+## Schema definition
+
+```ts
+import {table, column} from 'rado'
+
+const User = table({
+  // Pass a definition under a key with the actual name of the table in database
+  user: class {
+    id = column.integer.primaryKey()
+    username = column.string
+
+    // Define helper methods directly on the model
+    posts() {
+      return Post({userId: this.id})
+    }
+  }
+})
+
+const Post = table({
+  post: class {
+    id = column.integer.primaryKey()
+    userId = column.integer.references(() => User.id)
+    content = column.string
+
+    author() {
+      return User({id: this.userId}).first()
+    }
+
+    tags() {
+      return Tag({id: PostTags.tagId}).innerJoin(PostTags({postId: this.id}))
+    }
+  }
+})
+
+const Tag = table({
+  tag: class {
+    id = column.integer.primaryKey()
+    name = column.string
+  }
+})
+
+const PostTags = table({
+  post_tag: class {
+    postId = column.integer.references(() => Post.id)
+    tagId = column.integer.references(() => Tag.id)
+  }
+})
+```
+
+## Connections
+
+Currently supported SQLite drivers:
+`better-sqlite3`, `sql.js`, `sqlite3`, `bun:sqlite`
+
+Pass an instance of the database to the `connect` function to get started:
+
+```ts
+import Database from 'better-sqlite3'
+import {connect} from 'rado/driver/better-sqlite3'
+
+const db = connect(new Database('foobar.db'))
+```
+
+Currently all drivers are synchronous except for the `sqlite3` driver which is
+async.
+
+#### Run queries
+
+Call the connection with a query to retrieve its results:
+
+```ts
+const posts = db(Post())
+// For async drivers this will be a Promise:
+const posts = await db(Post())
+```
+
+#### Iterate results
+
+Iterate over query results:
+
+```ts
+const allPosts = Post()
+for (const row of db.iterate(allPosts)) {
+  console.log(row)
+}
+// For async drivers:
+for await (const row of db.iterate(allPosts)) {
+  console.log(row)
+}
+```
+
+#### Transactions
+
+Run transactions within the `transaction` method which will isolate a connection
+and can optionally return a result:
+
+```ts
+const firstUserId = db.transaction(tx => {
+  const createTable = User().create()
+  tx(createTable)
+  const insertUser = User().insertOne({username: 'Mario'})
+  tx(insertUser)
+  return insertUser.id
+})
+```

package/dist/driver/better-sqlite3.d.ts

@@ -8,6 +8,7 @@ export declare class BetterSqlite3Driver extends Driver.Sync {
     tableData: (tableName: string) => Array<SqliteSchema.Column>;
     indexData: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database, options?: DriverOptions);
+    close(): void;
     prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;

package/dist/driver/better-sqlite3.js

@@ -30,6 +30,9 @@ class BetterSqlite3Driver extends Driver.Sync {
   }
   tableData;
   indexData;
+  close() {
+    this.db.close();
+  }
   prepareStatement(stmt) {
     return new PreparedStatement(this.db.prepare(stmt.sql));
   }

package/dist/driver/bun-sqlite.d.ts

@@ -12,6 +12,7 @@ export declare class BunSqliteDriver extends Driver.Sync {
         rowsAffected: number;
     };
     constructor(db: Database, options?: DriverOptions);
+    close(): void;
     prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
 }

package/dist/driver/bun-sqlite.js

@@ -44,6 +44,9 @@ class BunSqliteDriver extends Driver.Sync {
   tableData;
   indexData;
   lastChanges;
+  close() {
+    this.db.close();
+  }
   prepareStatement(stmt) {
     return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
   }

package/dist/driver/sql.js.d.ts

@@ -8,6 +8,7 @@ export declare class SqlJsDriver extends Driver.Sync {
     tableData?: (tableName: string) => Array<SqliteSchema.Column>;
     indexData?: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database, options?: DriverOptions);
+    close(): void;
     prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;

package/dist/driver/sql.js.js

@@ -39,6 +39,9 @@ class SqlJsDriver extends Driver.Sync {
   }
   tableData;
   indexData;
+  close() {
+    this.db.close();
+  }
   prepareStatement(stmt, discardAfter) {
     return new PreparedStatement(
       this.db,

package/dist/driver/sqlite3.d.ts

@@ -14,5 +14,6 @@ export declare class Sqlite3Driver extends Driver.Async {
     prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: Driver.Async, release: () => Promise<void>];
+    close(): Promise<void>;
 }
 export declare function connect(db: Database, options?: DriverOptions): Sqlite3Driver;

package/dist/driver/sqlite3.js

@@ -109,6 +109,17 @@ class Sqlite3Driver extends Driver.Async {
     this.lock = Promise.resolve(this.lock).then(() => trigger);
     return [connection, release];
   }
+  async close() {
+    await this.lock;
+    return new Promise((resolve, reject) => {
+      this.db.close((err) => {
+        if (err)
+          reject(err);
+        else
+          resolve();
+      });
+    });
+  }
 }
 function connect(db, options) {
   return new Sqlite3Driver(db, options);

package/dist/lib/Driver.d.ts

@@ -29,6 +29,7 @@ interface SyncDriver {
 declare abstract class SyncDriver extends DriverBase {
     transactionId: number;
     constructor(formatter: Formatter, options?: DriverOptions);
+    abstract close(): void;
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
     createStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
@@ -57,6 +58,7 @@ interface AsyncDriver {
 declare abstract class AsyncDriver extends DriverBase {
     transactionId: number;
     constructor(formatter: Formatter, options?: DriverOptions);
+    abstract close(): Promise<void>;
     abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
@@ -72,6 +74,7 @@ declare class SyncWrapper extends AsyncDriver {
     private sync;
     lock: Promise<void> | undefined;
     constructor(sync: SyncDriver);
+    close(): Promise<void>;
     executeQuery(query: QueryData, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<unknown>;
     prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;

package/dist/lib/Driver.js

@@ -361,6 +361,9 @@ class SyncWrapper extends AsyncDriver {
     this.sync = sync;
   }
   lock;
+  async close() {
+    this.sync.close();
+  }
   async executeQuery(query, stmt, params) {
     await this.lock;
     return super.executeQuery(query, stmt, params);