rado 0.2.31 → 0.2.33

package/dist/define/query/Insert.js

@@ -1,36 +1,47 @@
-// src/define/query/Insert.ts
 import { ExprData } from "../Expr.js";
 import { Query, QueryData } from "../Query.js";
-var InsertValuesReturning = class extends Query {
-};
-var Inserted = class extends Query {
+class Insert extends Query {
   constructor(query) {
     super(query);
   }
   returning(selection) {
-    return new InsertValuesReturning(
+    return new Insert(
       new QueryData.Insert({
         ...this[Query.Data],
         selection: ExprData.create(selection)
       })
     );
   }
-};
-var Insert = class {
+}
+class InsertOne extends Query {
+  constructor(query) {
+    super(query);
+  }
+  returning(selection) {
+    return new Insert(
+      new QueryData.Insert({
+        ...this[Query.Data],
+        selection: ExprData.create(selection),
+        singleResult: true
+      })
+    );
+  }
+}
+class InsertInto {
   constructor(into) {
     this.into = into;
   }
   selection(query) {
-    return new Inserted(
+    return new Insert(
       new QueryData.Insert({ into: this.into, select: query[Query.Data] })
     );
   }
   values(...data) {
-    return new Inserted(new QueryData.Insert({ into: this.into, data }));
+    return new Insert(new QueryData.Insert({ into: this.into, data }));
   }
-};
+}
 export {
   Insert,
-  InsertValuesReturning,
-  Inserted
+  InsertInto,
+  InsertOne
 };

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

@@ -1,39 +1,39 @@
-import { EV, Expr } from '../Expr';
-import { OrderBy } from '../OrderBy';
-import { Query, QueryData } from '../Query';
-import { Selection } from '../Selection';
-import { Table } from '../Table';
-import { VirtualTable } from '../VirtualTable';
-import { Union } from './Union';
-export declare class SelectMultiple<Row> extends Union<Row> {
+import { EV, Expr } from '../Expr.js';
+import { OrderBy } from '../OrderBy.js';
+import { Query, QueryData } from '../Query.js';
+import { Selection } from '../Selection.js';
+import { Table } from '../Table.js';
+import { VirtualTable } from '../VirtualTable.js';
+import { Union } from './Union.js';
+export declare class Select<Row> extends Union<Row> {
     [Query.Data]: QueryData.Select;
     constructor(query: QueryData.Select);
-    from(table: Table<any> | VirtualTable<any>): SelectMultiple<Row>;
-    leftJoin<C>(that: Table<C> | SelectMultiple<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
-    innerJoin<C>(that: Table<C> | SelectMultiple<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
-    select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-    count(): SelectSingle<number>;
-    orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<Row>;
-    groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<Row>;
-    maybeFirst(): SelectSingle<Row | null>;
-    first(): SelectSingle<Row>;
-    where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
-    take(limit: number | undefined): SelectMultiple<Row>;
-    skip(offset: number | undefined): SelectMultiple<Row>;
+    from(table: Table<any> | VirtualTable<any>): Select<Row>;
+    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
+    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
+    select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;
+    count(): SelectFirst<number>;
+    orderBy(...orderBy: Array<Expr<any> | OrderBy>): Select<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): Select<Row>;
+    maybeFirst(): SelectFirst<Row | null>;
+    first(): SelectFirst<Row>;
+    where(...where: Array<EV<boolean>>): Select<Row>;
+    take(limit: number | undefined): Select<Row>;
+    skip(offset: number | undefined): Select<Row>;
     [Expr.ToExpr](): Expr<Row>;
 }
-export declare class SelectSingle<Row> extends Query<Row> {
+export declare class SelectFirst<Row> extends Query<Row> {
     [Query.Data]: QueryData.Select;
     constructor(query: QueryData.Select);
-    from(table: Table<any>): SelectMultiple<Row>;
-    leftJoin<C>(that: Table<C> | SelectMultiple<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
-    innerJoin<C>(that: Table<C> | SelectMultiple<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
-    select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-    orderBy(...orderBy: Array<OrderBy>): SelectSingle<Row>;
-    groupBy(...groupBy: Array<Expr<any>>): SelectSingle<Row>;
-    where(...where: Array<EV<boolean>>): SelectSingle<Row>;
-    take(limit: number | undefined): SelectSingle<Row>;
-    skip(offset: number | undefined): SelectSingle<Row>;
-    all(): SelectMultiple<Row>;
+    from(table: Table<any>): Select<Row>;
+    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
+    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
+    select<X extends Selection>(selection: X): SelectFirst<Selection.Infer<X>>;
+    orderBy(...orderBy: Array<OrderBy>): SelectFirst<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): SelectFirst<Row>;
+    where(...where: Array<EV<boolean>>): SelectFirst<Row>;
+    take(limit: number | undefined): SelectFirst<Row>;
+    skip(offset: number | undefined): SelectFirst<Row>;
+    all(): Select<Row>;
     [Expr.ToExpr](): Expr<Row>;
 }

package/dist/define/query/Select.js

@@ -1,4 +1,3 @@
-// src/define/query/Select.ts
 import { Expr, ExprData } from "../Expr.js";
 import { Functions } from "../Functions.js";
 import { Query } from "../Query.js";
@@ -24,19 +23,19 @@ function joinTarget(joinType, query, to, on) {
     Expr.and(...conditions)[Expr.Data]
   );
 }
-var SelectMultiple = class extends Union {
+class Select extends Union {
   constructor(query) {
     super(query);
   }
   from(table) {
     const virtual = table[VirtualTable.Data];
-    return new SelectMultiple(
+    return new Select(
       this[Query.Data].with({ from: virtual?.target || new Target.Table(table) })
     );
   }
   leftJoin(that, ...on) {
     const query = this[Query.Data];
-    return new SelectMultiple(
+    return new Select(
       this[Query.Data].with({
         from: joinTarget("left", query, that, on)
       })
@@ -44,21 +43,21 @@ var SelectMultiple = class extends Union {
   }
   innerJoin(that, ...on) {
     const query = this[Query.Data];
-    return new SelectMultiple(
+    return new Select(
       this[Query.Data].with({
         from: joinTarget("inner", query, that, on)
       })
     );
   }
   select(selection) {
-    return new SelectMultiple(
+    return new Select(
       this[Query.Data].with({
         selection: ExprData.create(selection)
       })
     );
   }
   count() {
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         selection: Functions.count()[Expr.Data],
         singleResult: true
@@ -66,7 +65,7 @@ var SelectMultiple = class extends Union {
     );
   }
   orderBy(...orderBy) {
-    return new SelectMultiple(
+    return new Select(
       this[Query.Data].with({
         orderBy: orderBy.map((e) => {
           return Expr.isExpr(e) ? e.asc() : e;
@@ -75,17 +74,17 @@ var SelectMultiple = class extends Union {
     );
   }
   groupBy(...groupBy) {
-    return new SelectMultiple(
+    return new Select(
       this[Query.Data].with({
         groupBy: groupBy.map(ExprData.create)
       })
     );
   }
   maybeFirst() {
-    return new SelectSingle(this[Query.Data].with({ singleResult: true }));
+    return new SelectFirst(this[Query.Data].with({ singleResult: true }));
   }
   first() {
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         singleResult: true,
         validate: true
@@ -93,30 +92,28 @@ var SelectMultiple = class extends Union {
     );
   }
   where(...where) {
-    return new SelectMultiple(this.addWhere(where));
+    return new Select(this.addWhere(where));
   }
   take(limit) {
-    return new SelectMultiple(this[Query.Data].with({ limit }));
+    return new Select(this[Query.Data].with({ limit }));
   }
   skip(offset) {
-    return new SelectMultiple(this[Query.Data].with({ offset }));
+    return new Select(this[Query.Data].with({ offset }));
   }
   [Expr.ToExpr]() {
     return new Expr(new ExprData.Query(this[Query.Data]));
   }
-};
-var SelectSingle = class extends Query {
+}
+class SelectFirst extends Query {
   constructor(query) {
     super(query);
   }
   from(table) {
-    return new SelectMultiple(
-      this[Query.Data].with({ from: new Target.Table(table) })
-    );
+    return new Select(this[Query.Data].with({ from: new Target.Table(table) }));
   }
   leftJoin(that, ...on) {
     const query = this[Query.Data];
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         from: joinTarget("left", query, that, on)
       })
@@ -124,50 +121,50 @@ var SelectSingle = class extends Query {
   }
   innerJoin(that, ...on) {
     const query = this[Query.Data];
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         from: joinTarget("inner", query, that, on)
       })
     );
   }
   select(selection) {
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         selection: ExprData.create(selection)
       })
     );
   }
   orderBy(...orderBy) {
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         orderBy
       })
     );
   }
   groupBy(...groupBy) {
-    return new SelectSingle(
+    return new SelectFirst(
       this[Query.Data].with({
         groupBy: groupBy.map(ExprData.create)
       })
     );
   }
   where(...where) {
-    return new SelectSingle(this.addWhere(where));
+    return new SelectFirst(this.addWhere(where));
   }
   take(limit) {
-    return new SelectSingle(this[Query.Data].with({ limit }));
+    return new SelectFirst(this[Query.Data].with({ limit }));
   }
   skip(offset) {
-    return new SelectSingle(this[Query.Data].with({ offset }));
+    return new SelectFirst(this[Query.Data].with({ offset }));
   }
   all() {
-    return new SelectMultiple(this[Query.Data].with({ singleResult: false }));
+    return new Select(this[Query.Data].with({ singleResult: false }));
   }
   [Expr.ToExpr]() {
     return new Expr(new ExprData.Query(this[Query.Data]));
   }
-};
+}
 export {
-  SelectMultiple,
-  SelectSingle
+  Select,
+  SelectFirst
 };

package/dist/define/query/TableSelect.d.ts

@@ -1,20 +1,27 @@
-import { EV, Expr } from '../Expr';
-import { Query, QueryData } from '../Query';
-import { Table, TableData } from '../Table';
-import { CreateTable } from './CreateTable';
-import { Delete } from './Delete';
-import { Inserted } from './Insert';
-import { SelectMultiple } from './Select';
-import { Update } from './Update';
-export declare class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
+import { EV, Expr } from '../Expr.js';
+import { Query, QueryData } from '../Query.js';
+import { Table, TableData } from '../Table.js';
+import { CreateTable } from './CreateTable.js';
+import { Delete } from './Delete.js';
+import { Insert, InsertOne } from './Insert.js';
+import { Select } from './Select.js';
+import { Update } from './Update.js';
+export declare class TableSelect<Definition> extends Select<Table.Select<Definition>> {
     protected table: TableData;
     [Query.Data]: QueryData.Select;
     constructor(table: TableData, conditions?: Array<EV<boolean>>);
     as(alias: string): Table<Definition>;
     create(): CreateTable;
-    insertSelect(query: SelectMultiple<Table.Insert<Definition>>): Inserted;
-    insertOne(record: Table.Insert<Definition>): Query<{ [K in keyof Definition as Definition[K] extends import("../Column").Column<any> ? K : never]: Definition[K] extends import("../Column").Column<infer T> ? T : never; }>;
-    insertAll(data: Array<Table.Insert<Definition>>): Inserted;
+    insert(query: Select<Table.Insert<Definition>>): Insert;
+    insert(rows: Array<Table.Insert<Definition>>): Insert;
+    insert(row: Table.Insert<Definition>): InsertOne<Table.Select<Definition>>;
+    insertSelect(query: Select<Table.Insert<Definition>>): Insert<{
+        rowsAffected: number;
+    }>;
+    insertOne(record: Table.Insert<Definition>): InsertOne<{ [K in keyof Definition as Definition[K] extends import("../Column.js").Column<any> ? K : never]: Definition[K] extends import("../Column.js").Column<infer T> ? T : never; }>;
+    insertAll(data: Array<Table.Insert<Definition>>): Insert<{
+        rowsAffected: number;
+    }>;
     set(data: Table.Update<Definition>): Update<Definition>;
     delete(): Delete;
     get(name: string): Expr<any>;

package/dist/define/query/TableSelect.js

@@ -1,14 +1,13 @@
-// src/define/query/TableSelect.ts
 import { Expr, ExprData } from "../Expr.js";
 import { Query, QueryData } from "../Query.js";
 import { createTable } from "../Table.js";
 import { Target } from "../Target.js";
 import { CreateTable } from "./CreateTable.js";
 import { Delete } from "./Delete.js";
-import { Insert, Inserted } from "./Insert.js";
-import { SelectMultiple } from "./Select.js";
+import { Insert, InsertInto, InsertOne } from "./Insert.js";
+import { Select } from "./Select.js";
 import { Update } from "./Update.js";
-var TableSelect = class extends SelectMultiple {
+class TableSelect extends Select {
   constructor(table, conditions = []) {
     const target = new Target.Table(table);
     super(
@@ -26,13 +25,22 @@ var TableSelect = class extends SelectMultiple {
   create() {
     return new CreateTable(this.table);
   }
+  insert(input) {
+    if (input instanceof Select) {
+      return this.insertSelect(input);
+    } else if (Array.isArray(input)) {
+      return this.insertAll(input);
+    } else {
+      return this.insertOne(input);
+    }
+  }
   insertSelect(query) {
-    return new Inserted(
+    return new Insert(
       new QueryData.Insert({ into: this.table, select: query[Query.Data] })
     );
   }
   insertOne(record) {
-    return new Query(
+    return new InsertOne(
       new QueryData.Insert({
         into: this.table,
         data: [record],
@@ -42,7 +50,7 @@ var TableSelect = class extends SelectMultiple {
     );
   }
   insertAll(data) {
-    return new Insert(this.table).values(...data);
+    return new InsertInto(this.table).values(...data);
   }
   set(data) {
     return new Update(
@@ -65,7 +73,7 @@ var TableSelect = class extends SelectMultiple {
       new ExprData.Field(new ExprData.Row(new Target.Table(this.table)), name)
     );
   }
-};
+}
 export {
   TableSelect
 };

package/dist/define/query/Union.d.ts

@@ -1,17 +1,17 @@
-import { Query, QueryData } from '../Query';
-import { VirtualTable } from '../VirtualTable';
-import { SelectMultiple } from './Select';
+import { Query, QueryData } from '../Query.js';
+import { VirtualTable } from '../VirtualTable.js';
+import { Select } from './Select.js';
 export declare class RecursiveUnion<Row> {
     initialSelect: QueryData.Select;
     constructor(initialSelect: QueryData.Select);
-    union(create: () => SelectMultiple<Row> | Union<Row>): VirtualTable.Of<Row>;
-    unionAll(create: () => SelectMultiple<Row> | Union<Row>): VirtualTable.Of<Row>;
+    union(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
+    unionAll(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
 }
 export declare class Union<Row> extends Query<Array<Row>> {
     [Query.Data]: QueryData.Union | QueryData.Select;
     constructor(query: QueryData.Union | QueryData.Select);
-    union(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
-    unionAll(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
-    except(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
-    intersect(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
+    union(query: Select<Row> | Union<Row>): Union<Row>;
+    unionAll(query: Select<Row> | Union<Row>): Union<Row>;
+    except(query: Select<Row> | Union<Row>): Union<Row>;
+    intersect(query: Select<Row> | Union<Row>): Union<Row>;
 }

package/dist/define/query/Union.js

@@ -1,11 +1,10 @@
-// src/define/query/Union.ts
 import { randomAlias } from "../../util/Alias.js";
 import { Expr, ExprData, ExprType } from "../Expr.js";
 import { Query, QueryData } from "../Query.js";
 import { Target, TargetType } from "../Target.js";
 import { createVirtualTable } from "../VirtualTable.js";
-import { SelectMultiple } from "./Select.js";
-var { keys, create, fromEntries } = Object;
+import { Select } from "./Select.js";
+const { keys, create, fromEntries } = Object;
 function columnsOf(expr) {
   switch (expr.type) {
     case ExprType.Record:
@@ -36,7 +35,7 @@ function makeRecursiveUnion(initial, createUnion, operator) {
   );
   const select = (conditions) => {
     const where = Expr.and(...conditions)[Expr.Data];
-    return new SelectMultiple(
+    return new Select(
       new QueryData.Select({
         selection,
         from: target,
@@ -51,7 +50,7 @@ function makeRecursiveUnion(initial, createUnion, operator) {
   });
   return cte;
 }
-var RecursiveUnion = class {
+class RecursiveUnion {
   constructor(initialSelect) {
     this.initialSelect = initialSelect;
   }
@@ -69,8 +68,8 @@ var RecursiveUnion = class {
       QueryData.UnionOperation.UnionAll
     );
   }
-};
-var Union = class extends Query {
+}
+class Union extends Query {
   constructor(query) {
     super(query);
   }
@@ -110,7 +109,7 @@ var Union = class extends Query {
       })
     );
   }
-};
+}
 export {
   RecursiveUnion,
   Union

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

@@ -1,6 +1,6 @@
-import { EV } from '../Expr';
-import { Query, QueryData } from '../Query';
-import { Table } from '../Table';
+import { EV } from '../Expr.js';
+import { Query, QueryData } from '../Query.js';
+import { Table } from '../Table.js';
 export declare class Update<Definition> extends Query<{
     rowsAffected: number;
 }> {

package/dist/define/query/Update.js

@@ -1,6 +1,5 @@
-// src/define/query/Update.ts
 import { Query } from "../Query.js";
-var Update = class extends Query {
+class Update extends Query {
   set(set) {
     return new Update(this[Query.Data].with({ set }));
   }
@@ -13,7 +12,7 @@ var Update = class extends Query {
   skip(offset) {
     return new Update(this[Query.Data].with({ offset }));
   }
-};
+}
 export {
   Update
 };

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

@@ -1,8 +1,8 @@
 import type { Database } from 'better-sqlite3';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
+import { SchemaInstructions } from '../define/Schema.js';
+import { Driver } from '../lib/Driver.js';
+import { Statement } from '../lib/Statement.js';
+import { SqliteSchema } from '../sqlite/SqliteSchema.js';
 export declare class BetterSqlite3Driver extends Driver.Sync {
     db: Database;
     tableData: (tableName: string) => Array<SqliteSchema.Column>;

package/dist/driver/better-sqlite3.js

@@ -1,9 +1,8 @@
-// src/driver/better-sqlite3.ts
 import { Driver } from "../lib/Driver.js";
 import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var PreparedStatement = class {
+class PreparedStatement {
   constructor(stmt) {
     this.stmt = stmt;
   }
@@ -22,8 +21,8 @@ var PreparedStatement = class {
   execute(params = []) {
     this.stmt.run(...params);
   }
-};
-var BetterSqlite3Driver = class extends Driver.Sync {
+}
+class BetterSqlite3Driver extends Driver.Sync {
   constructor(db) {
     super(new SqliteFormatter());
     this.db = db;
@@ -47,7 +46,7 @@ var BetterSqlite3Driver = class extends Driver.Sync {
   export() {
     return this.db.serialize();
   }
-};
+}
 function connect(db) {
   return new BetterSqlite3Driver(db);
 }

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

@@ -1,9 +1,9 @@
 /// <reference types="bun-types" />
 import type { Database } from 'bun:sqlite';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
+import { SchemaInstructions } from '../define/Schema.js';
+import { Driver } from '../lib/Driver.js';
+import { Statement } from '../lib/Statement.js';
+import { SqliteSchema } from '../sqlite/SqliteSchema.js';
 export declare class BunSqliteDriver extends Driver.Sync {
     db: Database;
     tableData: (tableName: string) => Array<SqliteSchema.Column>;

package/dist/driver/bun-sqlite.js

@@ -1,11 +1,10 @@
-// src/driver/bun-sqlite.ts
 import { QueryData } from "../define/Query.js";
-import { SelectSingle } from "../define/query/Select.js";
+import { SelectFirst } from "../define/query/Select.js";
 import { Driver } from "../lib/Driver.js";
 import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var PreparedStatement = class {
+class PreparedStatement {
   constructor(lastChanges, stmt) {
     this.lastChanges = lastChanges;
     this.stmt = stmt;
@@ -27,15 +26,15 @@ var PreparedStatement = class {
   execute(params = []) {
     this.stmt.run(...params);
   }
-};
-var BunSqliteDriver = class extends Driver.Sync {
+}
+class BunSqliteDriver extends Driver.Sync {
   constructor(db) {
     super(new SqliteFormatter());
     this.db = db;
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
     this.lastChanges = this.prepare(() => {
-      return new SelectSingle(
+      return new SelectFirst(
         new QueryData.Raw({
           expectedReturn: "row",
           strings: ["SELECT changes() as rowsAffected"],
@@ -59,7 +58,7 @@ var BunSqliteDriver = class extends Driver.Sync {
     const indexData = this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);
   }
-};
+}
 function connect(db) {
   return new BunSqliteDriver(db);
 }

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

@@ -1,8 +1,8 @@
 import type { Database } from 'sql.js';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
+import { SchemaInstructions } from '../define/Schema.js';
+import { Driver } from '../lib/Driver.js';
+import { Statement } from '../lib/Statement.js';
+import { SqliteSchema } from '../sqlite/SqliteSchema.js';
 export declare class SqlJsDriver extends Driver.Sync {
     db: Database;
     tableData?: (tableName: string) => Array<SqliteSchema.Column>;