rado 1.0.0-preview.2 → 1.0.0-preview.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ben Merckx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -3,11 +3,9 @@
 # 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
@@ -18,39 +16,21 @@ Currently focused on SQLite.
 
 #### Where
 
-Conditions can be created by accessing the fields of the table
-instances and using the operators of `Expr`:
+Conditions can be created by accessing the fields of the table:
 
 ```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
+import {eq} from 'rado'
+eq(User.id.is, 1) // Compare with a value
+eq(User.id, 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))
+import {eq, or, gt, lt} from 'rado'
+db.select().from(User).where(eq(User.id, 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))
+db.select().from(User).where(or(gt(User.id, 1), lt(User.id, 5)))
 ```
 
 #### Select
@@ -58,75 +38,40 @@ User().innerJoin(Post, Post.userId.is(User.id)).where(User.id.is(1))
 Retrieve a single field
 
 ```ts
-User().select(User.name)
+db.select(User.name).from(User)
 ```
 
 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({
+import {eq, include} from 'rado'
+db.select({
+   // Get all user fields: id, username
   ...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
-  })
-})
+  // Aggregate posts of this user
+  posts: include(db.select().from(Post).where(eq(Post.userId, User.id))) 
+}).from(User)
 ```
 
 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()
-})
+db
+  .select({
+    username: User.username
+    post: Post
+  })
+  .from(User)
+  .innerJoin(Post, eq(Post.userId, User.id))
+  .where(eq(User.id, 1))
 ```
 
 Order, group, limit queries:
 
 ```ts
-User()
-  .orderBy(User.username.asc())
+import {asc} from 'rado'
+db.select().from(User)
+  .orderBy(asc(User.username))
   .groupBy(User.id, User.username)
   .skip(20)
   .take(10)
@@ -134,16 +79,16 @@ User()
 
 #### Insert
 
-Insert a single row and return the result:
+Insert a single row:
 
 ```ts
-User().insertOne({username: 'Mario'})
+db.insert(User).values({username: 'Mario'})
 ```
 
 Insert multiple rows:
 
 ```ts
-User().insertAll([{username: 'Mario'}, {username: 'Luigi'}])
+db.insert(User).values([{username: 'Mario'}, {username: 'Luigi'}])
 ```
 
 #### Update
@@ -151,14 +96,17 @@ User().insertAll([{username: 'Mario'}, {username: 'Luigi'}])
 Set values
 
 ```ts
-User({id: 1}).set({username: 'Bowser'})
+db.update(User)
+  .set({username: 'Bowser'})
+  .where(eq(User.id, 1))
 ```
 
 Use expressions to update complex values:
 
 ```ts
-User()
-  .set({username: User.username.concat(' [removed]')})
+import {concat} from 'rado/sqlite'
+db.update(User)
+  .set({username: concat(User.username, ' [removed]')})
   .where(User.deleted)
 ```
 
@@ -167,62 +115,49 @@ User()
 Delete rows
 
 ```ts
-User({id: 1}).delete()
+db.delete(User).where(eq(User.id, 1))
 ```
 
 ## Schema definition
 
 ```ts
-import {table, column} from 'rado'
+import * as sqlite from 'rado/sqlite'
+import {sqliteTable as table} from 'rado/sqlite'
 
 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})
-    }
-  }
+  id: sqlite.integer().primaryKey(),
+  userName: sqlite.text('user') // Column names are optional
 })
 
 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}))
-    }
-  }
+  id: sqlite.integer().primaryKey(),
+  userId: sqlite.integer().references(() => User.id),
+  content: sqlite.text()
 })
 
 const Tag = table({
-  tag: class {
-    id = column.integer.primaryKey()
-    name = column.string
-  }
+  id: sqlite.integer().primaryKey(),
+  name: sqlite.text()
 })
 
 const PostTags = table({
-  post_tag: class {
-    postId = column.integer.references(() => Post.id)
-    tagId = column.integer.references(() => Tag.id)
-  }
+  postId: sqlite.integer().references(() => Post.id),
+  tagId: sqlite.integer().references(() => Tag.id)
 })
 ```
 
 ## Connections
 
-Currently supported SQLite drivers:
-`better-sqlite3`, `sql.js`, `sqlite3`, `bun:sqlite`, `@sqlite.org/sqlite-wasm`
+Currently supported drivers:
+
+| Driver           | import                         |
+| ---------------- | ------------------------------ |
+| `better-sqlite3` | `'rado/driver/better-sqlite3'` |
+| `bun-sqlite`     | `'rado/driver/bun-sqlite'`     |
+| `mysql2`         | `'rado/driver/mysql2'`         |
+| `pg`             | `'rado/driver/pg'`             |
+| `pglite`         | `'rado/driver/pglite'`         |
+| `sql.js`         | `'rado/driver/sql.js'`         |
 
 Pass an instance of the database to the `connect` function to get started:
 
@@ -233,32 +168,16 @@ 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 sync drivers this will be an array:
+const posts = db.select().from(Post).all()
 // 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)
-}
+const posts = await db.select().from(Post)
 ```
 
 #### Transactions
@@ -268,10 +187,9 @@ and can optionally return a result:
 
 ```ts
 const firstUserId = db.transaction(tx => {
-  const createTable = User().create()
+  const createTable = db.create(User)
   tx(createTable)
-  const insertUser = User().insertOne({username: 'Mario'})
-  tx(insertUser)
-  return insertUser.id
+  const insertUser = db.insert(User).values({username: 'Mario'}).returning(User.id)
+  return tx(insertUser)
 })
 ```

package/dist/core/Builder.d.ts

@@ -1,19 +1,15 @@
 import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.js';
 import type { IsPostgres, QueryMeta } from './MetaData.js';
 import type { QueryData } from './Query.js';
-import type { SelectionInput } from './Selection.js';
+import { type SelectionInput } from './Selection.js';
 import type { Table, TableDefinition } from './Table.js';
-import { Create } from './query/CreateTable.js';
 import { DeleteFrom } from './query/Delete.js';
-import { Drop } from './query/DropTable.js';
 import { InsertInto } from './query/Insert.js';
 import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.js';
 import { UpdateTable } from './query/Update.js';
 declare class BuilderBase<Meta extends QueryMeta> {
     readonly [internalData]: QueryData<Meta>;
-    constructor(data: QueryData<Meta>);
-    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
-    dropTable(table: HasTable): Drop<Meta>;
+    constructor(data?: QueryData<Meta>);
     select(): WithoutSelection<Meta>;
     select<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
     selectDistinct(): WithoutSelection<Meta>;
@@ -30,7 +26,5 @@ export declare class Builder<Meta extends QueryMeta> extends BuilderBase<Meta> {
         as<Input extends SelectionInput>(query: SelectBase<Input, Meta>): CTE<Input>;
     };
     with(...cte: Array<CTE>): BuilderBase<Meta>;
-    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
-    dropTable(table: HasTable): Drop<Meta>;
 }
 export {};

package/dist/core/Builder.js

@@ -7,32 +7,24 @@ import {
   internalQuery,
   internalTarget
 } from "./Internal.js";
+import { selection } from "./Selection.js";
 import { sql } from "./Sql.js";
-import { Create } from "./query/CreateTable.js";
 import { DeleteFrom } from "./query/Delete.js";
-import { Drop } from "./query/DropTable.js";
 import { InsertInto } from "./query/Insert.js";
 import { Select } from "./query/Select.js";
 import { UpdateTable } from "./query/Update.js";
 var BuilderBase = class {
   [internalData];
-  constructor(data) {
+  constructor(data = {}) {
     this[internalData] = data;
   }
-  createTable(table) {
-    return new Create({ ...getData(this), table });
-  }
-  dropTable(table) {
-    return new Drop({ ...getData(this), table });
-  }
   select(input) {
     return new Select({
       ...getData(this),
       select: {
         type: input ? "selection" : "allFrom",
-        input,
-        tables: [],
-        nullable: []
+        selection: input && selection(input),
+        tables: []
       }
     });
   }
@@ -41,21 +33,19 @@ var BuilderBase = class {
       ...getData(this),
       select: {
         type: input ? "selection" : "allFrom",
-        input,
-        tables: [],
-        nullable: []
+        selection: input && selection(input),
+        tables: []
       },
       distinct: true
     });
   }
-  selectDistinctOn(columns, selection) {
+  selectDistinctOn(columns, input) {
     return new Select({
       ...getData(this),
       select: {
-        type: selection ? "selection" : "allFrom",
-        input: selection,
-        tables: [],
-        nullable: []
+        type: input ? "selection" : "allFrom",
+        selection: input && selection(input),
+        tables: []
       },
       distinctOn: columns
     });
@@ -88,12 +78,6 @@ var Builder = class extends BuilderBase {
       cte
     });
   }
-  createTable(table) {
-    return new Create({ ...getData(this), table });
-  }
-  dropTable(table) {
-    return new Drop({ ...getData(this), table });
-  }
 };
 export {
   Builder

package/dist/core/Column.d.ts

@@ -1,9 +1,10 @@
-import type { HasColumn, HasSql } from './Internal.js';
-import { internalColumn } from './Internal.js';
-import type { Sql } from './Sql.js';
+import type { DriverSpecs } from './Driver.js';
+import type { HasSql } from './Internal.js';
+import { internalData } from './Internal.js';
+import { type Sql } from './Sql.js';
 import type { Field, FieldData } from './expr/Field.js';
 import { type Input } from './expr/Input.js';
-export declare class ColumnData {
+export interface ColumnData {
     type: Sql;
     name?: string;
     json?: boolean;
@@ -15,15 +16,16 @@ export declare class ColumnData {
     references?(): FieldData;
     onUpdate?: HasSql;
     onDelete?: HasSql;
-    mapFromDriverValue?(value: unknown): unknown;
+    mapFromDriverValue?(value: unknown, specs: DriverSpecs): unknown;
     mapToDriverValue?(value: unknown): unknown;
 }
-export declare class Column<Value = unknown> implements HasColumn {
-    readonly [internalColumn]: ColumnData;
+type WithoutNull<Value> = Exclude<Value, null>;
+export declare class Column<Value = unknown> {
+    readonly [internalData]: ColumnData;
     constructor(data: ColumnData);
-    notNull(): RequiredColumn<NonNullable<Value>>;
-    default(value: Input<NonNullable<Value>> | (() => Input<NonNullable<Value>>)): Column<NonNullable<Value>>;
-    primaryKey(): Column<NonNullable<Value>>;
+    notNull(): RequiredColumn<WithoutNull<Value>>;
+    default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
+    primaryKey(): Column<WithoutNull<Value>>;
     unique(name?: string): Column<Value>;
     references(foreignField: Field | (() => Field)): Column<Value>;
 }
@@ -35,4 +37,9 @@ declare const required: unique symbol;
 export interface RequiredColumn<Value = unknown> extends Column<Value> {
     [required]: true;
 }
+export interface Columns {
+    <T>(data: ColumnData): Column<T>;
+    [key: string]: (...args: Array<Input<any>>) => Sql<any>;
+}
+export declare const column: Columns;
 export {};

package/dist/core/Column.js

@@ -1,45 +1,35 @@
 // src/core/Column.ts
-import { getField, internalColumn } from "./Internal.js";
+import { getData, getField, internalData } from "./Internal.js";
+import { sql } from "./Sql.js";
 import { input } from "./expr/Input.js";
-var ColumnData = class {
-  type;
-  name;
-  json;
-  primary;
-  notNull;
-  isUnique;
-  autoIncrement;
-  onUpdate;
-  onDelete;
-};
 var Column = class _Column {
-  [internalColumn];
+  [internalData];
   constructor(data) {
-    this[internalColumn] = data;
+    this[internalData] = data;
   }
   notNull() {
     return new _Column({
-      ...this[internalColumn],
+      ...getData(this),
       notNull: true
     });
   }
   default(value) {
     return new _Column({
-      ...this[internalColumn],
+      ...getData(this),
       defaultValue() {
         return input(value instanceof Function ? value() : value);
       }
     });
   }
   primaryKey() {
-    return new _Column({ ...this[internalColumn], primary: true });
+    return new _Column({ ...getData(this), primary: true });
   }
   unique(name) {
-    return new _Column({ ...this[internalColumn], isUnique: true });
+    return new _Column({ ...getData(this), isUnique: true });
   }
   references(foreignField) {
     return new _Column({
-      ...this[internalColumn],
+      ...getData(this),
       references() {
         return getField(
           typeof foreignField === "function" ? foreignField() : foreignField
@@ -53,8 +43,26 @@ var JsonColumn = class extends Column {
     super({ ...data, json: true });
   }
 };
+function createColumn(data) {
+  return new Column(data);
+}
+var column = new Proxy(createColumn, {
+  get(target, method) {
+    return target[method] ??= (...args) => {
+      while (args.length > 0)
+        if (args.at(-1) === void 0)
+          args.pop();
+      if (args.length === 0)
+        return sql.unsafe(method);
+      return sql`${sql.unsafe(method)}(${sql.join(
+        args.map(sql.inline),
+        sql`, `
+      )})`;
+    };
+  }
+});
 export {
   Column,
-  ColumnData,
-  JsonColumn
+  JsonColumn,
+  column
 };

package/dist/core/Constraint.d.ts

@@ -1,4 +1,5 @@
 import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.js';
+import { type Sql } from './Sql.js';
 import type { Field, FieldData } from './expr/Field.js';
 export interface UniqueConstraintData {
     fields: Array<FieldData>;
@@ -9,10 +10,10 @@ export declare class UniqueConstraint<TableName extends string = string> impleme
     [internalData]: UniqueConstraintData;
     constructor(data: UniqueConstraintData);
     on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): UniqueConstraint<TableName>;
-    nullsNotDistinct(): UniqueConstraint<string>;
-    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+    nullsNotDistinct(): UniqueConstraint<TableName>;
+    get [internalConstraint](): Sql;
 }
-export declare function unique(): UniqueConstraint<string>;
+export declare function unique(): UniqueConstraint;
 export interface PrimaryKeyConstraintData {
     fields: Array<FieldData>;
 }
@@ -21,7 +22,7 @@ export declare class PrimaryKeyConstraint<TableName extends string = string> imp
     private brand;
     [internalData]: PrimaryKeyConstraintData;
     constructor(data: PrimaryKeyConstraintData);
-    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+    get [internalConstraint](): Sql;
 }
 export declare function primaryKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): PrimaryKeyConstraint<TableName>;
 export interface ForeignKeyConstraintData {
@@ -33,7 +34,7 @@ export declare class ForeignKeyConstraint<TableName extends string = string> imp
     [internalData]: ForeignKeyConstraintData;
     constructor(data: ForeignKeyConstraintData);
     references<ForeignTable extends string>(...fields: Array<Field<unknown, ForeignTable>>): ForeignKeyConstraint<TableName>;
-    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+    get [internalConstraint](): Sql;
 }
 export declare function foreignKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): ForeignKeyConstraint<TableName>;
 export type Constraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint;

package/dist/core/Database.d.ts

@@ -1,20 +1,28 @@
 import { Builder } from './Builder.js';
 import type { Dialect } from './Dialect.js';
+import type { Diff } from './Diff.js';
 import type { Driver } from './Driver.js';
-import { internalResolver, type HasResolver } from './Internal.js';
-import type { Async, Either, QueryDialect, QueryMeta, Sync } from './MetaData.js';
+import { type HasQuery, type HasResolver, type HasSql, type HasTable, internalResolver } from './Internal.js';
+import type { Async, Deliver, Either, QueryDialect, QueryMeta, Sync } from './MetaData.js';
+import { QueryBatch } from './Query.js';
 import { Resolver } from './Resolver.js';
+import type { Table } from './Table.js';
 export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
-    #private;
+    driver: Driver;
+    dialect: Dialect;
+    diff: Diff;
     readonly [internalResolver]: Resolver<Meta>;
-    constructor(driver: Driver, dialect: Dialect, transactionDepth?: number);
+    constructor(driver: Driver, dialect: Dialect, diff: Diff);
     close(this: Database<Async>): Promise<void>;
     close(this: Database<Sync>): void;
     [Symbol.dispose](this: Database<Sync>): void;
     [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
-    transaction<T>(this: Database<Sync>, run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): T;
-    transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
-    transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): T | Promise<T>;
+    create(...tables: Array<HasTable>): QueryBatch<unknown, Meta>;
+    drop(...tables: Array<HasTable>): QueryBatch<unknown, Meta>;
+    migrate(...tables: Array<Table>): Deliver<Meta, void>;
+    batch<Queries extends Array<HasSql | HasQuery>>(queries: Queries): QueryBatch<unknown, Meta>;
+    execute(input: HasSql): Deliver<Meta, void>;
+    transaction<T>(run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): Deliver<Meta, T>;
 }
 export interface TransactionOptions {
     universal: never;
@@ -32,10 +40,12 @@ export interface TransactionOptions {
         withConsistentSnapshot?: boolean;
     };
 }
-export declare class Rollback extends Error {
+export declare class Rollback<Data = never> extends Error {
+    data: Data;
+    constructor(data: Data);
 }
 export declare class Transaction<Meta extends QueryMeta> extends Database<Meta> {
-    rollback(): never;
+    rollback<Data>(data?: Data): never;
 }
 export declare class SyncDatabase<Dialect extends QueryDialect> extends Database<Sync<Dialect>> {
 }