rado 1.3.0-preview.3 → 1.3.0-preview.5

package/dist/core/Index.js

@@ -13,14 +13,25 @@ var IndexData = class {
 };
 var IndexApi = class extends IndexData {
   toSql(tableName, indexName, ifNotExists) {
+    const fields = this.fields.map(
+      (field) => sql.join([
+        field,
+        this.order && sql.unsafe(this.order),
+        this.nulls && sql`nulls ${sql.unsafe(this.nulls)}`
+      ])
+    );
     return sql.join([
       sql`create`,
       this.unique && sql`unique`,
       sql`index`,
+      this.concurrently && sql`concurrently`,
       ifNotExists && sql`if not exists`,
       sql.identifier(indexName),
       sql`on`,
-      sql`${sql.identifier(tableName)}(${sql.join(this.fields, sql`, `)})`,
+      this.only && sql`only`,
+      sql.identifier(tableName),
+      this.using && sql`using ${this.using}`,
+      sql`(${sql.join(fields, sql`, `)})`,
       this.where && sql`where ${this.where}`
     ]).inlineFields(false);
   }

package/dist/core/MetaData.d.ts

@@ -1,7 +1,7 @@
 export type QueryMode = 'sync' | 'async' | undefined;
 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 type Deliver<Meta extends QueryMeta, Result> = Meta extends Sync ? Result : Meta extends Async ? Promise<Result> : Result | Promise<Result>;
 export interface QueryMeta {
     mode: QueryMode;
     dialect: QueryDialect;

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

@@ -83,13 +83,13 @@ export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends U
 }
 export interface WithoutSelection<Meta extends QueryMeta> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
-    from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
-    from<Input>(from: VirtualTarget<Input>): SelectionFrom<Input, Meta>;
+    from<Input, Name extends string>(from: SubQuery<Input, Name>): SelectionFromTargets<Input, Meta, Name>;
+    from<Input>(from: VirtualTarget<Input>): SelectionFromTargets<Input, Meta, string>;
 }
 export interface WithSelection<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta>, HasSql<SelectionRow<Input>> {
-    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
-    from(from: HasTarget): SelectionFrom<Input, Meta>;
-    from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
+    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFromTargets<Input, Meta, Name>;
+    from<SubInput, Name extends string>(from: SubQuery<SubInput, Name>): SelectionFromTargets<Input, Meta, Name>;
+    from<Name extends string>(from: HasTarget<Name>): SelectionFromTargets<Input, Meta, Name>;
     from(from: HasSql): Select<Input, Meta>;
 }
 export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends SelectBase<Input, Meta> {
@@ -110,28 +110,30 @@ export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
     fullJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, Input>>>, Meta>;
 }
-type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
+type MarkFieldsAsNullable<Input, TableName extends string> = Input extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input extends Table ? Input : Expand<{
     [K in keyof Input]: Input[K] extends Field<infer T, TableName> ? HasSql<T | null> : Input[K] extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input[K] extends Record<string, Field<unknown, TableName> | HasSql<unknown>> ? Input[K] & IsNullable : Input[K] extends SelectionRecord ? MarkFieldsAsNullable<Input[K], TableName> : Input[K];
 }>;
-export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
-    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    leftJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    leftJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    leftJoinLateral<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoinLateral(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFrom<Input, Meta>;
-    crossJoin(right: HasTarget): SelectionFrom<Input, Meta>;
-    crossJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFrom<Input, Meta>;
-    crossJoinLateral(right: HasTarget): SelectionFrom<Input, Meta>;
-    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    fullJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectionFromTargets<Input, Meta, never> {
+}
+interface SelectionFromTargets<Input, Meta extends QueryMeta, FromNames extends string = never> extends SelectBase<Input, Meta> {
+    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    leftJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames>;
+    leftJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    leftJoinLateral<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, FromNames>, Meta, FromNames | Name>;
+    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, FromNames>, Meta, FromNames>;
+    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames>;
+    innerJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    innerJoinLateral(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames>;
+    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    crossJoin(right: HasTarget): SelectionFromTargets<Input, Meta, FromNames>;
+    crossJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    crossJoinLateral(right: HasTarget): SelectionFromTargets<Input, Meta, FromNames>;
+    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<MarkFieldsAsNullable<Input, FromNames>, Name>, Meta, FromNames | Name>;
+    fullJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<MarkFieldsAsNullable<Input, FromNames>, Name>, Meta, FromNames | Name>;
+    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, FromNames>, Meta, FromNames>;
 }
 export declare function querySelection({ select, from }: SelectQuery): Selection;
 export declare function selectQuery(query: SelectQuery): Sql;

package/dist/driver/better-sqlite3.js

@@ -44,7 +44,10 @@ var BetterSqlite3Driver = class _BetterSqlite3Driver {
     this.client.close();
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client.prepare(sql), options.isSelection);
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   batch(queries) {
     return this.transaction(

package/dist/driver/bun-sqlite.js

@@ -4,10 +4,12 @@ import { sqliteDialect } from "../sqlite.js";
 import { sqliteDiff } from "../sqlite/diff.js";
 import { execTransaction } from "../sqlite/transactions.js";
 var PreparedStatement = class {
-  constructor(stmt) {
+  constructor(stmt, isSelection) {
     this.stmt = stmt;
+    this.isSelection = isSelection;
   }
   stmt;
+  isSelection;
   all(params) {
     return this.stmt.all(...params);
   }
@@ -18,6 +20,10 @@ var PreparedStatement = class {
     return this.stmt.get(...params);
   }
   values(params) {
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
     return this.stmt.values(...params);
   }
   free() {
@@ -39,12 +45,17 @@ var BunSqliteDriver = class _BunSqliteDriver {
   close() {
     this.client.close();
   }
-  prepare(sql) {
-    return new PreparedStatement(this.client.prepare(sql));
+  prepare(sql, options) {
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   batch(queries) {
     return this.transaction((tx) => {
-      return queries.map(({ sql, params }) => tx.prepare(sql).values(params));
+      return queries.map(
+        ({ sql, params, isSelection }) => tx.prepare(sql, { isSelection }).values(params)
+      );
     }, {});
   }
   transaction(run, options) {

package/dist/driver/d1.d.ts

@@ -17,7 +17,7 @@ export declare class D1Driver implements AsyncDriver {
     supportsTransactions: boolean;
     constructor(client: Client);
     exec(query: string): Promise<void>;
-    prepare(sql: string, options: PrepareOptions): PreparedStatement;
+    prepare(sql: string, options?: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
     batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(): Promise<T>;

package/dist/driver/d1.js

@@ -37,7 +37,10 @@ var D1Driver = class {
     await this.client.exec(query);
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client.prepare(sql), options.isSelection);
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   async close() {
   }
@@ -46,7 +49,11 @@ var D1Driver = class {
       ({ sql, params }) => this.client.prepare(sql).bind(...params)
     );
     const rows = await this.client.batch(stmts);
-    return rows.map((row) => row.results);
+    return rows.map((row, index) => {
+      const isSelection = queries[index]?.isSelection;
+      if (!isSelection) return [];
+      return row.results.map(Object.values);
+    });
   }
   async transaction() {
     throw new Error("Transactions are not supported in D1");

package/dist/driver/libsql.d.ts

@@ -19,7 +19,7 @@ export declare class LibSQLClient implements AsyncDriver {
     supportsTransactions: boolean;
     constructor(client: Queryable, depth?: number);
     exec(query: string): Promise<void>;
-    prepare(sql: string, options: PrepareOptions): PreparedStatement;
+    prepare(sql: string, options?: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
     batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['sqlite']): Promise<T>;

package/dist/driver/mysql2.d.ts

@@ -7,8 +7,9 @@ declare class PreparedStatement implements AsyncStatement {
     #private;
     private client;
     private sql;
+    private isSelection;
     private name?;
-    constructor(client: Queryable, sql: string, name?: string | undefined);
+    constructor(client: Queryable, sql: string, isSelection: boolean, name?: string | undefined);
     all(params: Array<unknown>): Promise<Array<object>>;
     run(params: Array<unknown>): Promise<void>;
     get(params: Array<unknown>): Promise<object>;

package/dist/driver/mysql2.js

@@ -4,13 +4,15 @@ 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) {
+  constructor(client, sql, isSelection, name) {
     this.client = client;
     this.sql = sql;
+    this.isSelection = isSelection;
     this.name = name;
   }
   client;
   sql;
+  isSelection;
   name;
   #transformParam = (param) => {
     if (param instanceof Uint8Array) return Buffer.from(param);
@@ -26,6 +28,7 @@ var PreparedStatement = class {
     return this.all(params).then((rows) => rows[0] ?? null);
   }
   values(params) {
+    if (!this.isSelection) return this.run(params).then(() => []);
     return this.client.query({
       sql: this.sql,
       values: params.map(this.#transformParam),
@@ -48,7 +51,12 @@ var Mysql2Driver = class _Mysql2Driver {
     await this.client.query(query);
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client, sql, options?.name);
+    return new PreparedStatement(
+      this.client,
+      sql,
+      options?.isSelection ?? false,
+      options?.name
+    );
   }
   async close() {
     if ("end" in this.client) return this.client.end();
@@ -56,8 +64,8 @@ var Mysql2Driver = class _Mysql2Driver {
   async batch(queries) {
     const transact = async (tx) => {
       const results = [];
-      for (const { sql, params } of queries)
-        results.push(await tx.prepare(sql).values(params));
+      for (const { sql, params, isSelection } of queries)
+        results.push(await tx.prepare(sql, { isSelection }).values(params));
       return results;
     };
     if (this.depth > 0) return transact(this);

package/dist/driver/node-sqlite.js

@@ -50,7 +50,10 @@ var NodeSqliteDriver = class _NodeSqliteDriver {
     this.client.close();
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client.prepare(sql), options.isSelection);
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   batch(queries) {
     return this.transaction(

package/dist/driver/pg.js

@@ -3,6 +3,17 @@ import { AsyncDatabase } from "../core/Database.js";
 import { postgresDialect } from "../postgres/dialect.js";
 import { postgresDiff } from "../postgres/diff.js";
 import { setTransaction } from "../postgres/transactions.js";
+function isPool(client) {
+  return "connect" in client && "totalCount" in client && "idleCount" in client && "waitingCount" in client;
+}
+async function acquireClient(client, depth) {
+  if (depth > 0 || !isPool(client)) return { client };
+  const acquired = await client.connect();
+  return {
+    client: acquired,
+    release: () => acquired.release()
+  };
+}
 var PreparedStatement = class {
   constructor(client, sql, name) {
     this.client = client;
@@ -59,8 +70,9 @@ var PgDriver = class _PgDriver {
     return new PreparedStatement(this.client, sql, options?.name);
   }
   async close() {
-    if ("end" in this.client) return this.client.end();
+    if (this.depth > 0) throw new Error("Cannot close a transaction");
     if ("release" in this.client) return this.client.release();
+    if ("end" in this.client) return this.client.end();
   }
   async batch(queries) {
     return this.transaction(async (tx) => {
@@ -71,7 +83,7 @@ var PgDriver = class _PgDriver {
     }, {});
   }
   async transaction(run, options) {
-    const client = "totalCount" in this.client ? await this.client.connect() : this.client;
+    const { client, release } = await acquireClient(this.client, this.depth);
     try {
       await client.query(this.depth > 0 ? `savepoint d${this.depth}` : "begin");
       if (this.depth === 0) await client.query(setTransaction(options));
@@ -86,7 +98,7 @@ var PgDriver = class _PgDriver {
       );
       throw error;
     } finally {
-      if ("release" in client) client.release();
+      release?.();
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.3.0-preview.3",
+  "version": "1.3.0-preview.5",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -36,6 +36,9 @@
     "format:check": "oxfmt --check .",
     "lint": "oxlint .",
     "check": "bun run format:check && bun run lint",
+    "test:mysql": "bun test --test-filter mysql",
+    "test:postgres": "bun test --test-filter postgres pg",
+    "test:sqlite": "bun test --test-filter sqlite",
     "test:bun": "bun test",
     "test:node": "node --disable-warning=ExperimentalWarning --test-force-exit --test-concurrency=1 --test-reporter=spec --experimental-transform-types --test \"**/*.test.ts\"",
     "test:deno": "deno test --node-modules-dir=false --no-check -A --unstable-ffi",