rado 1.0.0-preview.5 → 1.0.1

package/README.md

@@ -20,7 +20,7 @@ Conditions can be created by accessing the fields of the table:
 
 ```ts
 import {eq} from 'rado'
-eq(User.id.is, 1) // Compare with a value
+eq(User.id, 1) // Compare with a value
 eq(User.id, Post.userId) // Compare to fields on other tables
 ```
 

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/Emitter.d.ts

@@ -1,6 +1,8 @@
 import type { ColumnData } from './Column.js';
 import { type HasQuery, type HasTarget } from './Internal.js';
+import type { Runtime } from './MetaData.js';
 import { type Param } from './Param.js';
+import { type Sql } from './Sql.js';
 import type { TableApi } from './Table.js';
 import type { FieldData } from './expr/Field.js';
 import type { IncludeData } from './expr/Include.js';
@@ -15,16 +17,12 @@ export declare abstract class Emitter {
     get hasParams(): boolean;
     bind(inputs?: Record<string, unknown>): Array<unknown>;
     processValue(value: unknown): unknown;
-    abstract jsonArrayFn: string;
-    abstract jsonGroupFn: string;
+    abstract runtime: Runtime;
     abstract emitIdentifier(value: string): void;
     abstract emitValue(value: unknown): void;
     abstract emitInline(value: unknown): void;
     abstract emitJsonPath(value: Array<number | string>): void;
     abstract emitPlaceholder(value: string): void;
-    abstract emitDefaultValue(): void;
-    abstract emitLastInsertId(): void;
-    abstract emitIdColumn(): void;
     emitUnsafe(value: string): void;
     emitField(field: FieldData): void;
     emitCreateTable(tableApi: TableApi): void;
@@ -37,4 +35,5 @@ export declare abstract class Emitter {
     emitUpdate(update: Update<unknown>): void;
     emitWith(cte: Array<HasQuery & HasTarget>): void;
     emitInclude(data: IncludeData): void;
+    emitUniversal(runtimes: Partial<Record<Runtime | 'default', Sql>>): void;
 }

package/dist/core/Emitter.js

@@ -7,6 +7,8 @@ import {
 } from "./Internal.js";
 import { ValueParam } from "./Param.js";
 import { sql } from "./Sql.js";
+import { callFunction } from "./expr/Functions.js";
+import { jsonAggregateArray, jsonArray } from "./expr/Json.js";
 var Emitter = class {
   sql = "";
   params = [];
@@ -54,13 +56,10 @@ var Emitter = class {
     ]).emitTo(this);
   }
   emitReferences(fields) {
-    sql.join([
+    callFunction(
       sql.identifier(fields[0].targetName),
-      sql`(${sql.join(
-        fields.map((field) => sql.identifier(field.fieldName)),
-        sql`, `
-      )})`
-    ]).emitTo(this);
+      fields.map((field) => sql.identifier(field.fieldName))
+    ).emitTo(this);
   }
   emitDelete(deleteOp) {
     const { cte, from, where, returning } = getData(deleteOp);
@@ -148,13 +147,16 @@ var Emitter = class {
     if (!data.select.selection)
       throw new Error("No selection defined");
     const fields = data.select.selection.fieldNames();
-    let subject = sql`${sql.unsafe(this.jsonArrayFn)}(${sql.join(
-      fields.map((name) => sql`_.${sql.identifier(name)}`),
-      sql`, `
-    )})`;
-    if (!data.first)
-      subject = sql`${sql.unsafe(this.jsonGroupFn)}(${subject})`;
-    sql`(select ${subject} from (${inner}) as _)`.emitTo(this);
+    const subject = jsonArray(
+      ...fields.map((name) => sql`_.${sql.identifier(name)}`)
+    );
+    sql`(select ${data.first ? subject : jsonAggregateArray(subject)} from (${inner}) as _)`.emitTo(this);
+  }
+  emitUniversal(runtimes) {
+    const sql2 = runtimes[this.runtime] ?? runtimes.default;
+    if (!sql2)
+      throw new Error("Unsupported runtime");
+    sql2.emitTo(this);
   }
 };
 export {

package/dist/core/MetaData.d.ts

@@ -1,5 +1,6 @@
 export type QueryMode = 'sync' | 'async' | undefined;
-export type QueryDialect = 'universal' | 'sqlite' | 'mysql' | 'postgres';
+export type Runtime = 'sqlite' | 'mysql' | 'postgres';
+export type QueryDialect = 'universal' | Runtime;
 export type Deliver<Meta extends QueryMeta, Result> = Meta extends Either ? Result | Promise<Result> : Meta extends Sync ? Result : Promise<Result>;
 export interface QueryMeta {
     mode: QueryMode;

package/dist/core/Query.d.ts

@@ -1,4 +1,4 @@
-import { type HasQuery, type HasResolver, type HasSql, type HasTarget, internalData, internalQuery } from './Internal.js';
+import { internalData, internalQuery, type HasQuery, type HasResolver, type HasSql, type HasTarget } from './Internal.js';
 import type { Deliver, QueryMeta } from './MetaData.js';
 import type { PreparedStatement, Resolver } from './Resolver.js';
 import type { Sql } from './Sql.js';
@@ -26,7 +26,7 @@ export declare abstract class Query<Result, Meta extends QueryMeta> extends Exec
     abstract [internalQuery]: Sql;
     constructor(data: QueryData<Meta>);
     all(db?: HasResolver): Deliver<Meta, Array<Result>>;
-    get(db?: HasResolver): Deliver<Meta, Result>;
+    get(db?: HasResolver): Deliver<Meta, Result | null>;
     run(db?: HasResolver): Deliver<Meta, void>;
     prepare<Inputs extends Record<string, unknown>>(name?: string): PreparedQuery<Result, Inputs, Meta>;
     toSQL(): {

package/dist/core/Query.js

@@ -60,9 +60,9 @@ var Query = class extends Executable {
     try {
       const result = prepared[resultType]();
       if (result instanceof Promise)
-        return result.finally(prepared.free.bind(prepared));
+        return result.then((res) => res ?? null).finally(prepared.free.bind(prepared));
       prepared.free();
-      return result;
+      return result ?? null;
     } catch (error) {
       prepared.free();
       throw error;

package/dist/core/Sql.d.ts

@@ -1,6 +1,7 @@
 import type { DriverSpecs } from './Driver.js';
 import type { Emitter } from './Emitter.js';
-import { internalSql, type HasSql } from './Internal.js';
+import { type HasSql, internalSql } from './Internal.js';
+import type { Runtime } from './MetaData.js';
 import type { FieldData } from './expr/Field.js';
 type EmitMethods = {
     [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
@@ -45,6 +46,7 @@ export declare namespace sql {
     export function identifier<T>(identifier: string): Sql<T>;
     export function field<T>(field: FieldData): Sql<T>;
     export function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
+    export function universal(runtimes: Partial<Record<Runtime | 'default', Sql>>): Sql;
     type QueryChunk = HasSql | undefined;
     export function query(ast: Record<string, boolean | QueryChunk | Array<QueryChunk>>): Sql;
     export function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;

package/dist/core/Sql.js

@@ -136,6 +136,10 @@ function sql(strings, ...inner) {
     return empty().chunk(type, inner);
   }
   sql2.chunk = chunk;
+  function universal(runtimes) {
+    return chunk("emitUniversal", runtimes);
+  }
+  sql2.universal = universal;
   function query(ast) {
     return join(
       Object.entries(ast).map(([key, value2]) => {

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

@@ -1,6 +1,6 @@
 import { type HasSql } from '../Internal.js';
 import { type Sql } from '../Sql.js';
-import type { SelectBase } from '../query/Select.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>;
@@ -29,4 +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: SelectBase<T>): Sql<boolean>;
+export declare function exists<T>(query: Select<T>): Sql<boolean>;

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

@@ -1,5 +1,6 @@
 import { type Sql } from '../Sql.js';
 import { type Input } from './Input.js';
+export declare function callFunction<Result>(name: Sql, args: Array<Input<unknown>>): Sql<Result>;
 export declare const Functions: Functions;
 export type Functions = {
     [key: string]: (...args: Array<Input<any>>) => Sql<any>;

package/dist/core/expr/Functions.js

@@ -1,12 +1,16 @@
 // src/core/expr/Functions.ts
 import { sql } from "../Sql.js";
 import { input } from "./Input.js";
+function callFunction(name, args) {
+  return sql`${name}(${sql.join(args.map(input), sql`, `)})`;
+}
 function get(target, method) {
   return target[method] ??= (...args) => {
-    return sql`${sql.identifier(method)}(${sql.join(args.map(input), sql`, `)})`;
+    return callFunction(sql.identifier(method), args);
   };
 }
 var Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });
 export {
-  Functions
+  Functions,
+  callFunction
 };

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

@@ -1,4 +1,5 @@
 import type { HasSql } from '../Internal.js';
+import type { Input } from './Input.js';
 export interface JsonArrayHasSql<Value> extends HasSql<Array<Value>> {
     [index: number]: JsonExpr<Value>;
 }
@@ -10,4 +11,6 @@ type NullableEach<T> = {
 };
 export type JsonExpr<Value> = [NonNullable<Value>] extends [Array<infer V>] ? JsonArrayHasSql<null extends Value ? V | null : V> : [NonNullable<Value>] extends [object] ? JsonRecordHasSql<null extends Value ? NullableEach<Value> : Value> : HasSql<Value>;
 export declare function jsonExpr<Value>(e: HasSql<Value>): JsonExpr<Value>;
+export declare function jsonAggregateArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
+export declare function jsonArray(...args: Array<Input<unknown>>): import("../Sql.ts").Sql<unknown>;
 export {};

package/dist/core/expr/Json.js

@@ -1,5 +1,6 @@
 // src/core/expr/Json.ts
 import { sql } from "../Sql.js";
+import { callFunction } from "./Functions.js";
 var INDEX_PROPERTY = /^\d+$/;
 function jsonExpr(e) {
   return new Proxy(e, {
@@ -11,6 +12,27 @@ function jsonExpr(e) {
     }
   });
 }
+function jsonAggregateArray(...args) {
+  return callFunction(
+    sql.universal({
+      sqlite: sql`json_group_array`,
+      postgres: sql`json_agg`,
+      mysql: sql`json_arrayagg`
+    }),
+    args
+  );
+}
+function jsonArray(...args) {
+  return callFunction(
+    sql.universal({
+      postgres: sql`json_build_array`,
+      default: sql`json_array`
+    }),
+    args
+  );
+}
 export {
+  jsonAggregateArray,
+  jsonArray,
   jsonExpr
 };

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.js

@@ -66,6 +66,10 @@ var InsertCanConflict = class extends InsertCanReturn {
     });
   }
 };
+var defaultKeyword = sql.universal({
+  sqlite: sql`null`,
+  default: sql`default`
+});
 var InsertInto = class {
   [internalData];
   constructor(data) {
@@ -85,7 +89,7 @@ var InsertInto = class {
               return input(mapToDriverValue?.(value) ?? value);
             if (defaultValue)
               return defaultValue();
-            return sql.chunk("emitDefaultValue", void 0);
+            return defaultKeyword;
           }),
           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

@@ -18,7 +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>;
+    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,8 +40,11 @@ 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);

package/dist/driver/mysql2.js

@@ -2,6 +2,7 @@
 import { AsyncDatabase } from "../core/Database.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

@@ -2,6 +2,7 @@
 import { AsyncDatabase } from "../core/Database.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

@@ -2,6 +2,7 @@
 import { AsyncDatabase } from "../index.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/mysql/dialect.js

@@ -10,9 +10,8 @@ var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var mysqlDialect = new Dialect(
   class extends Emitter {
+    runtime = "mysql";
     paramIndex = 0;
-    jsonArrayFn = "json_array";
-    jsonGroupFn = "json_arrayagg";
     emitValue(value) {
       this.sql += "?";
       this.params.push(new ValueParam(value));
@@ -41,15 +40,6 @@ var mysqlDialect = new Dialect(
     emitIdentifier(identifier) {
       this.sql += BACKTICK + identifier.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
     }
-    emitDefaultValue() {
-      this.sql += "default";
-    }
-    emitIdColumn() {
-      this.sql += "int not null auto_increment";
-    }
-    emitLastInsertId() {
-      this.sql += "last_insert_id()";
-    }
   }
 );
 export {

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/postgres/dialect.js

@@ -10,9 +10,8 @@ var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var postgresDialect = new Dialect(
   class extends Emitter {
+    runtime = "postgres";
     paramIndex = 0;
-    jsonArrayFn = "json_build_array";
-    jsonGroupFn = "json_agg";
     emitValue(value) {
       this.sql += `$${++this.paramIndex}`;
       this.params.push(new ValueParam(value));
@@ -49,15 +48,6 @@ var postgresDialect = new Dialect(
     emitIdentifier(identifier) {
       this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
     }
-    emitDefaultValue() {
-      this.sql += "default";
-    }
-    emitIdColumn() {
-      this.sql += "integer generated always as identity";
-    }
-    emitLastInsertId() {
-      this.sql += "lastval()";
-    }
   }
 );
 export {

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/sqlite/dialect.js

@@ -10,8 +10,7 @@ var ESCAPE_SINGLE_QUOTE = "''";
 var MATCH_SINGLE_QUOTE = /'/g;
 var sqliteDialect = new Dialect(
   class extends Emitter {
-    jsonArrayFn = "json_array";
-    jsonGroupFn = "json_group_array";
+    runtime = "sqlite";
     processValue(value) {
       return typeof value === "boolean" ? value ? 1 : 0 : value;
     }
@@ -42,18 +41,9 @@ var sqliteDialect = new Dialect(
     emitIdentifier(identifier) {
       this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
     }
-    emitDefaultValue() {
-      this.sql += "null";
-    }
     quoteString(input) {
       return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
     }
-    emitIdColumn() {
-      this.sql += "integer";
-    }
-    emitLastInsertId() {
-      this.sql += "last_insert_rowid()";
-    }
   }
 );
 export {

package/dist/sqlite/diff.js

@@ -142,7 +142,7 @@ var sqliteDiff = (hasTable) => {
       );
       const selection = { ...hasTable };
       for (const name of missingColumns) {
-        selection[name] = getData(tableApi.columns[name]).defaultValue?.() ?? sql.chunk("emitDefaultValue", void 0);
+        selection[name] = getData(tableApi.columns[name]).defaultValue?.() ?? sql`null`;
       }
       return [
         // Create a new temporary table with the new definition

package/dist/universal/columns.d.ts

@@ -1,4 +1,4 @@
-import { JsonColumn, type Column } from '../core/Column.js';
+import { type Column, JsonColumn } from '../core/Column.js';
 export declare function id(name?: string): Column<number>;
 export declare function text(name?: string): Column<string | null>;
 export declare function integer(name?: string): Column<number | null>;

package/dist/universal/columns.js

@@ -1,10 +1,15 @@
 // src/universal/columns.ts
 import { JsonColumn, column } from "../core/Column.js";
 import { sql } from "../core/Sql.js";
+var idType = sql.universal({
+  sqlite: sql`integer`,
+  postgres: sql`integer generated always as identity`,
+  mysql: sql`int not null auto_increment`
+});
 function id(name) {
   return column({
     name,
-    type: sql.chunk("emitIdColumn", void 0),
+    type: idType,
     primary: true
   });
 }

package/dist/universal/functions.d.ts

@@ -1,4 +1,4 @@
 import { type Sql } from '../core/Sql.js';
-import { type Input } from '../core/expr/Input.js';
+import type { Input } from '../core/expr/Input.js';
 export declare function lastInsertId(): Sql<number>;
 export declare function concat(...slices: Array<Input<string | null>>): Sql<string>;

package/dist/universal/functions.js

@@ -1,11 +1,16 @@
 // src/universal/functions.ts
 import { sql } from "../core/Sql.js";
-import { input } from "../core/expr/Input.js";
+import { callFunction } from "../core/expr/Functions.js";
+var insertId = sql.universal({
+  sqlite: sql`last_insert_rowid()`,
+  postgres: sql`lastval()`,
+  mysql: sql`last_insert_id()`
+}).mapWith(Number);
 function lastInsertId() {
-  return sql.chunk("emitLastInsertId", void 0).mapWith(Number);
+  return insertId;
 }
 function concat(...slices) {
-  return sql`concat(${sql.join(slices.map(input), sql`, `)})`;
+  return callFunction(sql`concat`, slices);
 }
 export {
   concat,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.0.0-preview.5",
+  "version": "1.0.1",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -39,7 +39,7 @@
     "better-sqlite3": "^11.0.0",
     "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",