rado 1.0.0-preview.4 → 1.0.0

package/README.md

@@ -73,8 +73,7 @@ import {asc} from 'rado'
 db.select().from(User)
   .orderBy(asc(User.username))
   .groupBy(User.id, User.username)
-  .skip(20)
-  .take(10)
+  .limit(10, 20)
 ```
 
 #### Insert

package/dist/compat.d.ts

@@ -0,0 +1,8 @@
+import type { HasSql } from './core/Internal.js';
+import type { Sql } from './core/Sql.js';
+import type { Table, TableDefinition, TableFields, TableInsert, TableRow } from './core/Table.js';
+export type InferSelectModel<T> = T extends Table<infer Definition> ? TableRow<Definition> : never;
+export type InferInsertModel<T> = T extends Table<infer Definition> ? TableInsert<Definition> : never;
+export type SQL<T = unknown> = Sql<T>;
+export type SQLWrapper<T = unknown> = HasSql<T>;
+export declare function getTableColumns<Definition extends TableDefinition>(table: Table<Definition>): TableFields<Definition>;

package/dist/compat.js

@@ -0,0 +1,7 @@
+// src/compat.ts
+function getTableColumns(table) {
+  return table;
+}
+export {
+  getTableColumns
+};

package/dist/core/Builder.d.ts

@@ -1,4 +1,4 @@
-import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.js';
+import { type HasQuery, type HasSql, type HasTarget, internalData } from './Internal.js';
 import type { IsPostgres, QueryMeta } from './MetaData.js';
 import type { QueryData } from './Query.js';
 import { type SelectionInput } from './Selection.js';
@@ -18,7 +18,7 @@ declare class BuilderBase<Meta extends QueryMeta> {
     selectDistinctOn<Input extends SelectionInput>(this: Builder<IsPostgres>, columns: Array<HasSql>, selection: Input): WithSelection<Input, Meta>;
     update<Definition extends TableDefinition>(table: Table<Definition>): UpdateTable<Definition, Meta>;
     insert<Definition extends TableDefinition>(into: Table<Definition>): InsertInto<Definition, Meta>;
-    delete(from: HasTable): DeleteFrom<Meta>;
+    delete<Definition extends TableDefinition>(from: Table<Definition>): DeleteFrom<Definition, Meta>;
 }
 export type CTE<Input = unknown> = Input & HasTarget & HasQuery;
 export declare class Builder<Meta extends QueryMeta> extends BuilderBase<Meta> {

package/dist/core/Column.d.ts

@@ -1,5 +1,4 @@
 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';
@@ -12,10 +11,10 @@ export interface ColumnData {
     notNull?: boolean;
     isUnique?: boolean;
     autoIncrement?: boolean;
-    defaultValue?(): HasSql;
+    defaultValue?(): Sql;
     references?(): FieldData;
-    onUpdate?: HasSql;
-    onDelete?: HasSql;
+    onUpdate?: Sql;
+    onDelete?: Sql;
     mapFromDriverValue?(value: unknown, specs: DriverSpecs): unknown;
     mapToDriverValue?(value: unknown): unknown;
 }
@@ -23,18 +22,20 @@ type WithoutNull<Value> = Exclude<Value, null>;
 export declare class Column<Value = unknown> {
     readonly [internalData]: ColumnData;
     constructor(data: ColumnData);
-    notNull(): RequiredColumn<WithoutNull<Value>>;
+    notNull(): RequiredColumn<Value>;
     default(value: Input<WithoutNull<Value>> | (() => Input<WithoutNull<Value>>)): Column<WithoutNull<Value>>;
+    defaultNow(): Column<WithoutNull<Value>>;
     primaryKey(): Column<WithoutNull<Value>>;
     unique(name?: string): Column<Value>;
     references(foreignField: Field | (() => Field)): Column<Value>;
+    $type<T>(): Column<null extends Value ? T | null : T>;
 }
 export declare class JsonColumn<Value = unknown> extends Column<Value> {
     private brand;
     constructor(data: ColumnData);
 }
 declare const required: unique symbol;
-export interface RequiredColumn<Value = unknown> extends Column<Value> {
+export interface RequiredColumn<Value = unknown> extends Column<WithoutNull<Value>> {
     [required]: true;
 }
 export interface Columns {

package/dist/core/Column.js

@@ -21,6 +21,14 @@ var Column = class _Column {
       }
     });
   }
+  defaultNow() {
+    return new _Column({
+      ...getData(this),
+      defaultValue() {
+        return sql.unsafe("now()");
+      }
+    });
+  }
   primaryKey() {
     return new _Column({ ...getData(this), primary: true });
   }
@@ -37,6 +45,9 @@ var Column = class _Column {
       }
     });
   }
+  $type() {
+    return this;
+  }
 };
 var JsonColumn = class extends Column {
   constructor(data) {

package/dist/core/Database.d.ts

@@ -22,7 +22,9 @@ export declare class Database<Meta extends QueryMeta = Either> extends Builder<M
     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>;
+    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']]): Deliver<Meta, T>;
 }
 export interface TransactionOptions {
     universal: never;

package/dist/core/Query.d.ts

@@ -1,4 +1,4 @@
-import { internalData, internalQuery, type HasQuery, type HasResolver, type HasSql, type HasTarget } from './Internal.js';
+import { type HasQuery, type HasResolver, type HasSql, type HasTarget, internalData, internalQuery } from './Internal.js';
 import type { Deliver, QueryMeta } from './MetaData.js';
 import type { PreparedStatement, Resolver } from './Resolver.js';
 import type { Sql } from './Sql.js';
@@ -29,6 +29,10 @@ export declare abstract class Query<Result, Meta extends QueryMeta> extends Exec
     get(db?: HasResolver): Deliver<Meta, Result>;
     run(db?: HasResolver): Deliver<Meta, void>;
     prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
+    toSQL(): {
+        sql: string;
+        params: Array<unknown>;
+    };
 }
 export interface PreparedQuery<Result, Inputs extends Record<string, unknown>, Meta extends QueryMeta> extends PreparedStatement<Meta> {
     all(inputs?: Inputs): Deliver<Meta, Array<Result>>;

package/dist/core/Query.js

@@ -80,6 +80,12 @@ var Query = class extends Executable {
   prepare(name) {
     return getData(this).resolver.prepare(this, name);
   }
+  toSQL() {
+    const { resolver } = getData(this);
+    if (!resolver)
+      throw new Error("Query has no resolver");
+    return resolver.toSQL(this);
+  }
 };
 export {
   Query,

package/dist/core/Resolver.d.ts

@@ -8,6 +8,10 @@ export declare class Resolver<Meta extends QueryMeta = QueryMeta> {
     #private;
     private brand;
     constructor(driver: Driver, dialect: Dialect);
+    toSQL(query: HasQuery): {
+        sql: string;
+        params: Array<unknown>;
+    };
     prepare(query: HasQuery, name?: string): PreparedStatement<Meta>;
     batch(queries: Array<HasSql | HasQuery>): Batch<Meta>;
 }

package/dist/core/Resolver.js

@@ -10,6 +10,10 @@ var Resolver = class {
     this.#driver = driver;
     this.#dialect = dialect;
   }
+  toSQL(query) {
+    const emitter = this.#dialect.emit(query);
+    return { sql: emitter.sql, params: emitter.bind() };
+  }
   prepare(query, name) {
     const isSelection = hasSelection(query);
     const mapRow = isSelection ? getSelection(query).mapRow : void 0;

package/dist/core/Schema.d.ts

@@ -1,4 +1,7 @@
 import { type Table, type TableConfig, type TableDefinition } from './Table.js';
-export declare function schema<SchemaName extends string>(schemaName: SchemaName): {
-    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: (self: Table<Definition>) => TableConfig<`${SchemaName}.${TableName}`>): Table<Definition, `${SchemaName}.${TableName}`>;
-};
+type Prefix<SchemaName extends string, TableName extends string> = `${SchemaName}.${TableName}`;
+export interface Schema<SchemaName extends string> {
+    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: (self: Table<Definition>) => TableConfig<Prefix<SchemaName, TableName>>): Table<Definition, Prefix<SchemaName, TableName>>;
+}
+export declare function schema<SchemaName extends string>(schemaName: SchemaName): Schema<SchemaName>;
+export {};

package/dist/core/Table.d.ts

@@ -38,18 +38,12 @@ export type TableFields<Definition extends TableDefinition, TableName extends st
 export type TableRow<Definition extends TableDefinition> = {
     [K in keyof Definition]: Definition[K] extends Column<infer T> ? T : never;
 } & {};
-type IsReq<Col> = Col extends RequiredColumn ? true : false;
-type Required<D> = {
-    [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K];
-};
-type Optional<D> = {
-    [K in keyof D as false extends IsReq<D[K]> ? K : never]: D[K];
-};
+type IsReq<Col> = Col extends RequiredColumn<infer Value> ? null extends Value ? true : false : false;
 type RequiredInput<D> = {
-    readonly [K in keyof Required<D>]: D[K] extends Column<infer V> ? Input<V> : never;
+    readonly [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K] extends Column<infer V> ? Input<V> : never;
 };
 type OptionalInput<D> = {
-    readonly [K in keyof Optional<D>]?: D[K] extends Column<infer V> ? Input<V> : never;
+    readonly [K in keyof D as false extends IsReq<D[K]> ? K : never]?: D[K] extends Column<infer V> ? Input<V> : never;
 };
 export type TableInsert<Definition extends TableDefinition> = RequiredInput<Definition> & OptionalInput<Definition>;
 export type TableUpdate<Definition extends TableDefinition> = {

package/dist/core/expr/Conditions.d.ts

@@ -1,5 +1,6 @@
-import type { HasSql } from '../Internal.js';
+import { type HasSql } from '../Internal.js';
 import { type Sql } from '../Sql.js';
+import type { Select } from '../query/Select.js';
 import { type Input } from './Input.js';
 export declare const eq: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
 export declare const ne: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
@@ -28,3 +29,4 @@ export declare function desc<T>(input: HasSql<T>): Sql;
 export declare function distinct<T>(input: HasSql<T>): Sql;
 export declare function when<In, Out>(compare: Input<In>, ...cases: Array<[condition: Input<In>, result: Input<Out>] | Input<Out>>): Sql<Out>;
 export declare function when<Out>(...cases: Array<[condition: Input<boolean>, result: Input<Out>] | Input<Out>>): Sql<Out>;
+export declare function exists<T>(query: Select<T>): Sql<boolean>;

package/dist/core/expr/Conditions.js

@@ -1,4 +1,5 @@
 // src/core/expr/Conditions.ts
+import { getQuery } from "../Internal.js";
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
 function binop(operator) {
@@ -92,6 +93,9 @@ function when(...cases) {
     sql`end`
   ]);
 }
+function exists(query) {
+  return sql`exists (${getQuery(query)})`;
+}
 export {
   and,
   arrayContained,
@@ -102,6 +106,7 @@ export {
   desc,
   distinct,
   eq,
+  exists,
   gt,
   gte,
   ilike,

package/dist/core/query/Delete.d.ts

@@ -1,8 +1,9 @@
-import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.js';
-import type { QueryMeta } from '../MetaData.js';
+import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
+import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
 import { Query, type QueryData } from '../Query.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
+import type { TableDefinition, TableRow } from '../Table.js';
 export interface DeleteData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
     from: HasTable;
     where?: HasSql;
@@ -14,7 +15,8 @@ export declare class Delete<Result, Meta extends QueryMeta = QueryMeta> extends
     constructor(data: DeleteData<Meta>);
     get [internalQuery](): Sql;
 }
-export declare class DeleteFrom<Meta extends QueryMeta> extends Delete<void, Meta> {
-    where(condition: HasSql<boolean>): DeleteFrom<Meta>;
-    returning<Input extends SelectionInput>(returning: Input): Delete<SelectionRow<Input>, Meta>;
+export declare class DeleteFrom<Definition extends TableDefinition, Meta extends QueryMeta> extends Delete<void, Meta> {
+    where(...where: Array<HasSql<boolean> | undefined>): DeleteFrom<Definition, Meta>;
+    returning(this: DeleteFrom<Definition, IsPostgres | IsSqlite>): Delete<TableRow<Definition>, Meta>;
+    returning<Input extends SelectionInput>(this: DeleteFrom<Definition, IsPostgres | IsSqlite>, returning: Input): Delete<SelectionRow<Input>, Meta>;
 }

package/dist/core/query/Delete.js

@@ -10,6 +10,7 @@ import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
+import { and } from "../expr/Conditions.js";
 var Delete = class extends Query {
   [internalData];
   constructor(data) {
@@ -23,13 +24,14 @@ var Delete = class extends Query {
   }
 };
 var DeleteFrom = class _DeleteFrom extends Delete {
-  where(condition) {
-    return new _DeleteFrom({ ...getData(this), where: condition });
+  where(...where) {
+    return new _DeleteFrom({ ...getData(this), where: and(...where) });
   }
   returning(returning) {
+    const data = getData(this);
     return new Delete({
-      ...getData(this),
-      returning: selection(returning)
+      ...data,
+      returning: selection(returning ?? data.from)
     });
   }
 };

package/dist/core/query/Insert.d.ts

@@ -1,4 +1,4 @@
-import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.js';
+import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
 import { Query, type QueryData } from '../Query.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';

package/dist/core/query/Insert.js

@@ -80,13 +80,11 @@ var InsertInto = class {
         return sql`(${sql.join(
           Object.entries(table.columns).map(([key, column]) => {
             const value = row[key];
-            const { defaultValue, notNull, mapToDriverValue } = getData(column);
+            const { defaultValue, mapToDriverValue } = getData(column);
             if (value !== void 0)
               return input(mapToDriverValue?.(value) ?? value);
             if (defaultValue)
               return defaultValue();
-            if (notNull)
-              throw new Error(`Column "${key}" is not nullable`);
             return sql.chunk("emitDefaultValue", void 0);
           }),
           sql`, `

package/dist/core/query/Select.d.ts

@@ -1,4 +1,4 @@
-import { internalData, internalQuery, internalSelection, type HasSelection, type HasSql, type HasTable, type HasTarget } from '../Internal.js';
+import { type HasSelection, type HasSql, type HasTable, type HasTarget, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { QueryMeta } from '../MetaData.js';
 import type { Query } from '../Query.js';
 import { type IsNullable, type MakeNullable, type Selection, type SelectionRecord, type SelectionRow } from '../Selection.js';
@@ -35,7 +35,7 @@ export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends U
     rightJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
     innerJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
     fullJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
-    where(...where: Array<HasSql<boolean>>): Select<Input, Meta>;
+    where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean>): Select<Input, Meta>;
     orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;

package/dist/core/query/Update.d.ts

@@ -1,9 +1,9 @@
-import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.js';
+import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
 import { Query, type QueryData } from '../Query.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
-import type { TableDefinition, TableUpdate } from '../Table.js';
+import type { TableDefinition, TableRow, TableUpdate } from '../Table.js';
 export interface UpdateData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
     table: HasTable;
     set?: HasSql;
@@ -18,6 +18,7 @@ export declare class Update<Result, Meta extends QueryMeta = QueryMeta> extends
 }
 export declare class UpdateTable<Definition extends TableDefinition, Meta extends QueryMeta> extends Update<void, Meta> {
     set(values: TableUpdate<Definition>): UpdateTable<Definition, Meta>;
-    where(where: HasSql<boolean>): UpdateTable<Definition, Meta>;
-    returning<Input extends SelectionInput>(this: UpdateTable<Definition, IsPostgres | IsSqlite>, returning: Input): Update<SelectionRow<Input>, Meta>;
+    where(...where: Array<HasSql<boolean> | undefined>): UpdateTable<Definition, Meta>;
+    returning(this: UpdateTable<Definition, IsPostgres | IsSqlite>): Update<TableRow<Definition>, Meta>;
+    returning<Input extends SelectionInput>(this: UpdateTable<Definition, IsPostgres | IsSqlite>, returning?: Input): Update<SelectionRow<Input>, Meta>;
 }

package/dist/core/query/Update.js

@@ -11,6 +11,7 @@ import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
+import { and } from "../expr/Conditions.js";
 import { input } from "../expr/Input.js";
 var Update = class extends Query {
   [internalData];
@@ -39,13 +40,17 @@ var UpdateTable = class _UpdateTable extends Update {
     );
     return new _UpdateTable({ ...getData(this), set });
   }
-  where(where) {
-    return new _UpdateTable({ ...getData(this), where });
+  where(...where) {
+    return new _UpdateTable({
+      ...getData(this),
+      where: and(...where)
+    });
   }
   returning(returning) {
+    const data = getData(this);
     return new Update({
-      ...getData(this),
-      returning: selection(returning)
+      ...data,
+      returning: selection(returning ?? data.table)
     });
   }
 };

package/dist/driver/better-sqlite3.js

@@ -1,7 +1,7 @@
 // src/driver/better-sqlite3.ts
 import { SyncDatabase } from "../core/Database.js";
 import { sqliteDialect } from "../sqlite.js";
-import { sqliteDiff } from "../sqlite/SqliteDiff.js";
+import { sqliteDiff } from "../sqlite/diff.js";
 var PreparedStatement = class {
   constructor(stmt, isSelection) {
     this.stmt = stmt;

package/dist/driver/bun-sqlite.js

@@ -1,7 +1,7 @@
 // src/driver/bun-sqlite.ts
 import { SyncDatabase } from "../core/Database.js";
 import { sqliteDialect } from "../sqlite.js";
-import { sqliteDiff } from "../sqlite/SqliteDiff.js";
+import { sqliteDiff } from "../sqlite/diff.js";
 var PreparedStatement = class {
   constructor(stmt) {
     this.stmt = stmt;

package/dist/driver/mysql2.js

@@ -1,7 +1,8 @@
 // src/driver/mysql2.ts
 import { AsyncDatabase } from "../core/Database.js";
-import { mysqlDialect } from "../mysql/MysqlDialect.js";
-import { mysqlDiff } from "../mysql/MysqlDiff.js";
+import { mysqlDialect } from "../mysql/dialect.js";
+import { mysqlDiff } from "../mysql/diff.js";
+import { setTransaction, startTransaction } from "../mysql/transactions.js";
 var PreparedStatement = class {
   constructor(client, sql, name) {
     this.client = client;
@@ -54,7 +55,14 @@ var Mysql2Driver = class _Mysql2Driver {
     const client = isPool(this.client) ? await this.client.getConnection() : this.client;
     const driver = new _Mysql2Driver(client, this.depth + 1);
     try {
-      await client.query(this.depth > 0 ? `savepoint d${this.depth}` : "begin");
+      await client.query(
+        this.depth > 0 ? `savepoint d${this.depth}` : startTransaction(options)
+      );
+      if (this.depth === 0) {
+        const setOptions = setTransaction(options);
+        if (setOptions)
+          await client.query(setOptions);
+      }
       const result = await run(driver);
       await client.query(
         this.depth > 0 ? `release savepoint d${this.depth}` : "commit"

package/dist/driver/pg.js

@@ -1,7 +1,8 @@
 // src/driver/pg.ts
 import { AsyncDatabase } from "../core/Database.js";
-import { postgresDialect } from "../postgres/PostgresDialect.js";
-import { postgresDiff } from "../postgres/PostgresDiff.js";
+import { postgresDialect } from "../postgres/dialect.js";
+import { postgresDiff } from "../postgres/diff.js";
+import { setTransaction } from "../postgres/transactions.js";
 var PreparedStatement = class {
   constructor(client, sql, name) {
     this.client = client;
@@ -69,6 +70,8 @@ var PgDriver = class _PgDriver {
     const client = "totalCount" in this.client ? await this.client.connect() : this.client;
     try {
       await client.query(this.depth > 0 ? `savepoint d${this.depth}` : "begin");
+      if (this.depth === 0)
+        await client.query(setTransaction(options));
       const result = await run(new _PgDriver(client, this.depth + 1));
       await client.query(
         this.depth > 0 ? `release savepoint d${this.depth}` : "commit"

package/dist/driver/pglite.js

@@ -1,7 +1,8 @@
 // src/driver/pglite.ts
 import { AsyncDatabase } from "../index.js";
-import { postgresDialect } from "../postgres/PostgresDialect.js";
-import { postgresDiff } from "../postgres/PostgresDiff.js";
+import { postgresDialect } from "../postgres/dialect.js";
+import { postgresDiff } from "../postgres/diff.js";
+import { setTransaction } from "../postgres/transactions.js";
 var PreparedStatement = class {
   constructor(client, sql) {
     this.client = client;
@@ -59,7 +60,8 @@ var PGliteDriver = class _PGliteDriver {
   }
   async transaction(run, options) {
     if (this.depth === 0 && "transaction" in this.client)
-      return this.client.transaction((tx) => {
+      return this.client.transaction(async (tx) => {
+        await tx.query(setTransaction(options));
         return run(new _PGliteDriver(tx, this.depth + 1));
       });
     await this.exec(`savepoint d${this.depth}`);

package/dist/driver/sql.js.js

@@ -1,7 +1,7 @@
 // src/driver/sql.js.ts
 import { SyncDatabase } from "../core/Database.js";
 import { sqliteDialect } from "../sqlite.js";
-import { sqliteDiff } from "../sqlite/SqliteDiff.js";
+import { sqliteDiff } from "../sqlite/diff.js";
 var PreparedStatement = class {
   constructor(client, stmt) {
     this.client = client;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './compat.js';
 export * from './core/Column.js';
 export * from './core/Constraint.js';
 export * from './core/Database.js';
@@ -15,4 +16,3 @@ export * from './core/query/Update.js';
 export * from './core/Selection.js';
 export * from './core/Sql.js';
 export * from './core/Table.js';
-export * from './interop.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/index.ts
+export * from "./compat.js";
 export * from "./core/Column.js";
 export * from "./core/Constraint.js";
 export * from "./core/Database.js";
@@ -16,4 +17,3 @@ export * from "./core/query/Update.js";
 export * from "./core/Selection.js";
 export * from "./core/Sql.js";
 export * from "./core/Table.js";
-export * from "./interop.js";

package/dist/mysql/{MysqlBuilder.js → builder.js}

@@ -1,4 +1,4 @@
-// src/mysql/MysqlBuilder.ts
+// src/mysql/builder.ts
 import { Builder } from "../core/Builder.js";
 var QueryBuilder = Builder;
 export {

package/dist/mysql/{MysqlColumns.d.ts → columns.d.ts}

@@ -14,10 +14,12 @@ export declare function boolean(name?: string): Column<boolean | null>;
 export declare function char(name?: string, options?: {
     length: number;
 }): Column<string | null>;
+export declare function date(name?: string, options?: {
+    mode: 'string';
+}): Column<string | null>;
 export declare function date(name: string | undefined, options: {
     mode: 'date';
 }): Column<Date | null>;
-export declare function date(name?: string): Column<string | null>;
 export declare function datetime(name?: string, options?: {
     fsp?: Precision;
 }): Column<Date | null>;

package/dist/mysql/{MysqlColumns.js → columns.js}

@@ -1,4 +1,4 @@
-// src/mysql/MysqlColumns.ts
+// src/mysql/columns.ts
 import { JsonColumn, column } from "../core/Column.js";
 function bigint(name, options) {
   return column({

package/dist/mysql/{MysqlDialect.js → dialect.js}

@@ -1,4 +1,4 @@
-// src/mysql/MysqlDialect.ts
+// src/mysql/dialect.ts
 import { Dialect } from "../core/Dialect.js";
 import { Emitter } from "../core/Emitter.js";
 import { NamedParam, ValueParam } from "../core/Param.js";

package/dist/mysql/{MysqlDiff.js → diff.js}

@@ -1,5 +1,5 @@
-// src/mysql/MysqlDiff.ts
-import { mysqlDialect } from "./MysqlDialect.js";
+// src/mysql/diff.ts
+import { mysqlDialect } from "./dialect.js";
 var mysqlDiff = (hasTable) => {
   throw new Error("Diffing for MySQL is not yet implemented");
 };

package/dist/mysql/transactions.d.ts

@@ -0,0 +1,3 @@
+import type { TransactionOptions } from '../core/Database.js';
+export declare function startTransaction(options: TransactionOptions['mysql']): string;
+export declare function setTransaction(options: TransactionOptions['mysql']): string | undefined;

package/dist/mysql/transactions.js

@@ -0,0 +1,20 @@
+// src/mysql/transactions.ts
+function startTransaction(options) {
+  return [
+    "start transaction",
+    options.withConsistentSnapshot && "with consistent snapshot",
+    options.accessMode
+  ].filter(Boolean).join(" ");
+}
+function setTransaction(options) {
+  if (!options.isolationLevel)
+    return;
+  return [
+    "set transaction",
+    options.isolationLevel && `isolation level ${options.isolationLevel}`
+  ].filter(Boolean).join(" ");
+}
+export {
+  setTransaction,
+  startTransaction
+};

package/dist/mysql.d.ts

@@ -2,6 +2,6 @@ export { index, uniqueIndex } from './core/Index.js';
 export { except, exceptAll, intersect, intersectAll, union, unionAll } from './core/query/Union.js';
 export { schema as mysqlSchema } from './core/Schema.js';
 export { alias, table as mysqlTable } from './core/Table.js';
-export * from './mysql/MysqlBuilder.js';
-export * from './mysql/MysqlColumns.js';
-export * from './mysql/MysqlDialect.js';
+export * from './mysql/builder.js';
+export * from './mysql/columns.js';
+export * from './mysql/dialect.js';

package/dist/mysql.js

@@ -10,9 +10,9 @@ import {
 } from "./core/query/Union.js";
 import { schema } from "./core/Schema.js";
 import { alias, table } from "./core/Table.js";
-export * from "./mysql/MysqlBuilder.js";
-export * from "./mysql/MysqlColumns.js";
-export * from "./mysql/MysqlDialect.js";
+export * from "./mysql/builder.js";
+export * from "./mysql/columns.js";
+export * from "./mysql/dialect.js";
 export {
   alias,
   except,

package/dist/{sqlite/SqliteBuilder.js → postgres/builder.js}

@@ -1,4 +1,4 @@
-// src/sqlite/SqliteBuilder.ts
+// src/postgres/builder.ts
 import { Builder } from "../core/Builder.js";
 var QueryBuilder = Builder;
 export {

package/dist/postgres/{PostgresColumns.d.ts → columns.d.ts}

@@ -1,4 +1,4 @@
-import { JsonColumn, type Column } from '../core/Column.js';
+import { type Column, JsonColumn } from '../core/Column.js';
 type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 type IntervalFields = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'year to month' | 'day to hour' | 'day to minute' | 'day to second' | 'hour to minute' | 'hour to second' | 'minute to second';
 export declare function bigint(name: string | undefined, options: {
@@ -13,10 +13,12 @@ export declare function char(name?: string, options?: {
     length: number;
 }): Column<string | null>;
 export declare function cidr(name?: string): Column<string | null>;
+export declare function date(name?: string, options?: {
+    mode: 'string';
+}): Column<string | null>;
 export declare function date(name: string | undefined, options: {
     mode: 'date';
 }): Column<Date | null>;
-export declare function date(name?: string): Column<string | null>;
 export declare function doublePrecision(name?: string): Column<number | null>;
 export declare function inet(name?: string): Column<string | null>;
 export declare function integer(name?: string): Column<number | null>;
@@ -26,7 +28,7 @@ export declare function interval(name?: string, options?: {
     fields?: IntervalFields;
     precision?: Precision;
 }): Column<string | null>;
-export declare function serial(name?: string): Column<number | null>;
+export declare function serial(name?: string): Column<number>;
 export declare function boolean(name?: string): Column<boolean | null>;
 export declare function blob(name?: string): Column<Uint8Array | null>;
 export declare function text(name?: string): Column<string | null>;

package/dist/postgres/{PostgresColumns.js → columns.js}

@@ -1,4 +1,4 @@
-// src/postgres/PostgresColumns.ts
+// src/postgres/columns.ts
 import { JsonColumn, column } from "../core/Column.js";
 function bigint(name, options) {
   return column({

package/dist/postgres/{PostgresDialect.js → dialect.js}

@@ -1,4 +1,4 @@
-// src/postgres/PostgresDialect.ts
+// src/postgres/dialect.ts
 import { Dialect } from "../core/Dialect.js";
 import { Emitter } from "../core/Emitter.js";
 import { NamedParam, ValueParam } from "../core/Param.js";

package/dist/postgres/{PostgresDiff.js → diff.js}

@@ -1,4 +1,4 @@
-// src/postgres/PostgresDiff.ts
+// src/postgres/diff.ts
 import { getData, getTable } from "../core/Internal.js";
 import { sql } from "../core/Sql.js";
 import { table } from "../core/Table.js";
@@ -15,8 +15,8 @@ import {
   when
 } from "../core/expr/Conditions.js";
 import { concat, txGenerator } from "../universal.js";
-import * as column from "./PostgresColumns.js";
-import { postgresDialect } from "./PostgresDialect.js";
+import * as column from "./columns.js";
+import { postgresDialect } from "./dialect.js";
 var Attr = table("pg_attribute", {
   name: column.text("attname").notNull(),
   typId: column.oid("atttypid").notNull(),

package/dist/postgres/transactions.d.ts

@@ -0,0 +1,2 @@
+import type { TransactionOptions } from '../core/Database.js';
+export declare function setTransaction(options: TransactionOptions['postgres']): string;

package/dist/postgres/transactions.js

@@ -0,0 +1,12 @@
+// src/postgres/transactions.ts
+function setTransaction(options) {
+  return [
+    "set transaction",
+    options.isolationLevel && `isolation level ${options.isolationLevel}`,
+    options.accessMode,
+    options.deferrable ? "deferrable" : "not deferrable"
+  ].filter(Boolean).join(" ");
+}
+export {
+  setTransaction
+};

package/dist/postgres.d.ts

@@ -2,6 +2,6 @@ export { index, uniqueIndex } from './core/Index.js';
 export { except, exceptAll, intersect, intersectAll, union, unionAll } from './core/query/Union.js';
 export { schema as pgSchema } from './core/Schema.js';
 export { alias, table as pgTable } from './core/Table.js';
-export * from './postgres/PostgresBuilder.js';
-export * from './postgres/PostgresColumns.js';
-export * from './postgres/PostgresDialect.js';
+export * from './postgres/builder.js';
+export * from './postgres/columns.js';
+export * from './postgres/dialect.js';

package/dist/postgres.js

@@ -10,9 +10,9 @@ import {
 } from "./core/query/Union.js";
 import { schema } from "./core/Schema.js";
 import { alias, table } from "./core/Table.js";
-export * from "./postgres/PostgresBuilder.js";
-export * from "./postgres/PostgresColumns.js";
-export * from "./postgres/PostgresDialect.js";
+export * from "./postgres/builder.js";
+export * from "./postgres/columns.js";
+export * from "./postgres/dialect.js";
 export {
   alias,
   except,

package/dist/{postgres/PostgresBuilder.js → sqlite/builder.js}

@@ -1,4 +1,4 @@
-// src/postgres/PostgresBuilder.ts
+// src/sqlite/builder.ts
 import { Builder } from "../core/Builder.js";
 var QueryBuilder = Builder;
 export {

package/dist/sqlite/{SqliteColumns.js → columns.js}

@@ -1,4 +1,4 @@
-// src/sqlite/SqliteColumns.ts
+// src/sqlite/columns.ts
 import { JsonColumn, column } from "../core/Column.js";
 function boolean(name) {
   return column({

package/dist/sqlite/{SqliteDialect.js → dialect.js}

@@ -1,4 +1,4 @@
-// src/sqlite/SqliteDialect.ts
+// src/sqlite/dialect.ts
 import { Dialect } from "../core/Dialect.js";
 import { Emitter } from "../core/Emitter.js";
 import { NamedParam, ValueParam } from "../core/Param.js";

package/dist/sqlite/{SqliteDiff.js → diff.js}

@@ -1,12 +1,12 @@
-// src/sqlite/SqliteDiff.ts
+// src/sqlite/diff.ts
 import { Rollback } from "../core/Database.js";
 import { getData, getQuery, getTable } from "../core/Internal.js";
 import { sql } from "../core/Sql.js";
 import { table } from "../core/Table.js";
 import { eq } from "../core/expr/Conditions.js";
 import { txGenerator } from "../universal.js";
-import * as column from "./SqliteColumns.js";
-import { sqliteDialect } from "./SqliteDialect.js";
+import * as column from "./columns.js";
+import { sqliteDialect } from "./dialect.js";
 var TableInfo = table("TableInfo", {
   cid: column.integer().notNull(),
   name: column.text().notNull(),

package/dist/sqlite/{SqliteFunctions.js → functions.js}

@@ -1,4 +1,4 @@
-// src/sqlite/SqliteFunctions.ts
+// src/sqlite/functions.ts
 import { sql } from "../core/Sql.js";
 import { Functions } from "../core/expr/Functions.js";
 import { input } from "../core/expr/Input.js";

package/dist/sqlite.d.ts

@@ -1,7 +1,7 @@
 export { index, uniqueIndex } from './core/Index.js';
 export { except, intersect, union, unionAll } from './core/query/Union.js';
 export { alias, table as sqliteTable } from './core/Table.js';
-export * from './sqlite/SqliteBuilder.js';
-export * from './sqlite/SqliteColumns.js';
-export * from './sqlite/SqliteDialect.js';
-export * from './sqlite/SqliteFunctions.js';
+export * from './sqlite/builder.js';
+export * from './sqlite/columns.js';
+export * from './sqlite/dialect.js';
+export * from './sqlite/functions.js';

package/dist/sqlite.js

@@ -7,10 +7,10 @@ import {
   unionAll
 } from "./core/query/Union.js";
 import { alias, table } from "./core/Table.js";
-export * from "./sqlite/SqliteBuilder.js";
-export * from "./sqlite/SqliteColumns.js";
-export * from "./sqlite/SqliteDialect.js";
-export * from "./sqlite/SqliteFunctions.js";
+export * from "./sqlite/builder.js";
+export * from "./sqlite/columns.js";
+export * from "./sqlite/dialect.js";
+export * from "./sqlite/functions.js";
 export {
   alias,
   except,

package/dist/universal/{UniversalColumns.js → columns.js}

@@ -1,4 +1,4 @@
-// src/universal/UniversalColumns.ts
+// src/universal/columns.ts
 import { JsonColumn, column } from "../core/Column.js";
 import { sql } from "../core/Sql.js";
 function id(name) {

package/dist/universal/{UniversalFunctions.js → functions.js}

@@ -1,4 +1,4 @@
-// src/universal/UniversalFunctions.ts
+// src/universal/functions.ts
 import { sql } from "../core/Sql.js";
 import { input } from "../core/expr/Input.js";
 function lastInsertId() {

package/dist/universal/{UniversalTransaction.js → transactions.js}

@@ -1,4 +1,4 @@
-// src/universal/UniversalTransaction.ts
+// src/universal/transactions.ts
 function txGenerator(create) {
   function run(tx) {
     const iter = create(tx);

package/dist/universal.d.ts

@@ -1,3 +1,3 @@
-export * from './universal/UniversalColumns.js';
-export * from './universal/UniversalFunctions.js';
-export * from './universal/UniversalTransaction.js';
+export * from './universal/columns.js';
+export * from './universal/functions.js';
+export * from './universal/transactions.js';

package/dist/universal.js

@@ -1,4 +1,4 @@
 // src/universal.ts
-export * from "./universal/UniversalColumns.js";
-export * from "./universal/UniversalFunctions.js";
-export * from "./universal/UniversalTransaction.js";
+export * from "./universal/columns.js";
+export * from "./universal/functions.js";
+export * from "./universal/transactions.js";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "rado",
-  "version": "1.0.0-preview.4",
+  "version": "1.0.0",
   "license": "MIT",
   "type": "module",
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json && bun build.ts",
     "size": "esbuild src/index.ts --bundle --minify --format=esm --outdir=dist",
-    "profile": "cross-env PROFILE=true tsx build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
+    "profile": "PROFILE=true bun build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
     "prepublishOnly": "rm -rf dist && bun run build",
     "cycles": "madge --warning --circular src/index.ts",
     "test:bun": "bun test",
@@ -32,15 +32,14 @@
     "@electric-sql/pglite": "^0.1.5",
     "@sqlite.org/sqlite-wasm": "^3.42.0-build4",
     "@types/better-sqlite3": "^5.4.1",
+    "@types/bun": "^1.1.6",
     "@types/glob": "^8.0.0",
     "@types/pg": "^8.11.5",
     "@types/sql.js": "^1.4.2",
     "better-sqlite3": "^11.0.0",
-    "bun-types": "^0.5.0",
-    "cross-env": "^7.0.3",
     "esbuild": "^0.18.11",
     "glob": "^8.0.3",
-    "madge": "^6.1.0",
+    "madge": "^8.0.0",
     "mysql2": "^3.9.7",
     "pg": "^8.11.5",
     "rimraf": "^4.1.2",

package/dist/interop.d.ts

@@ -1,3 +0,0 @@
-import type { TableApi, TableInsert, TableRow } from './core/Table.js';
-export type InferSelectModel<Table> = Table extends TableApi<infer Definition> ? TableRow<Definition> : never;
-export type InferInsertModel<Table> = Table extends TableApi<infer Definition> ? TableInsert<Definition> : never;