rado 0.2.24 → 0.2.25

package/dist/define/Table.d.ts

@@ -1,9 +1,9 @@
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column';
-import { EV } from './Expr';
-import { Fields } from './Fields';
+import { EV, Expr } from './Expr';
+import type { Fields } from './Fields';
 import { Index, IndexData } from './Index';
-import { Query } from './Query';
-import { Selection } from './Selection';
+import type { Selection } from './Selection';
+import { TableSelect } from './query/TableSelect';
 declare const DATA: unique symbol;
 declare const META: unique symbol;
 interface TableDefinition {
@@ -20,9 +20,9 @@ export declare class TableData {
 }
 export interface TableInstance<Definition> {
     (conditions: {
-        [K in keyof Definition]?: Definition[K] extends Column<infer V> ? EV<V> : never;
-    }): Query.TableSelect<Definition>;
-    (...conditions: Array<EV<boolean>>): Query.TableSelect<Definition>;
+        [K in keyof Definition]?: Definition[K] extends Expr<infer V> ? EV<V> : never;
+    }): TableSelect<Definition>;
+    (...conditions: Array<EV<boolean>>): TableSelect<Definition>;
 }
 export declare class TableInstance<Definition> {
     [Selection.TableType](): Table.Select<Definition>;

package/dist/define/Table.js

@@ -4,8 +4,8 @@ import {
   ColumnType
 } from "./Column.js";
 import { BinOpType, Expr, ExprData } from "./Expr.js";
-import { Query } from "./Query.js";
 import { Target } from "./Target.js";
+import { TableSelect } from "./query/TableSelect.js";
 var {
   assign,
   create,
@@ -49,7 +49,7 @@ function virtualTable(name) {
         )
       );
     }) : args;
-    return new Query.TableSelect(data, conditions);
+    return new TableSelect(data, conditions);
   }
   return new Proxy(call, {
     get(_, column) {
@@ -82,7 +82,7 @@ function createTable(data) {
           )
         );
       }) : args;
-      return new Query.TableSelect(data, conditions);
+      return new TableSelect(data, conditions);
     }
   }[data.name];
   const cols = keys(data.columns);

package/dist/define/Target.d.ts

@@ -10,18 +10,18 @@ export declare enum TargetType {
 }
 export type Target = Target.Expr | Target.CTE | Target.Query | Target.Table | Target.Join;
 export declare namespace Target {
-    class CTE {
-        name: string;
-        union: QueryData.Union;
-        type: TargetType.CTE;
-        constructor(name: string, union: QueryData.Union);
-    }
     class Expr {
         expr: ExprData;
         alias?: string | undefined;
         type: TargetType.Expr;
         constructor(expr: ExprData, alias?: string | undefined);
     }
+    class CTE {
+        name: string;
+        union: QueryData.Union;
+        type: TargetType.CTE;
+        constructor(name: string, union: QueryData.Union);
+    }
     class Query {
         query: QueryData;
         alias?: string | undefined;

package/dist/define/Target.js

@@ -9,14 +9,6 @@ var TargetType = /* @__PURE__ */ ((TargetType2) => {
 })(TargetType || {});
 var Target;
 ((Target2) => {
-  class CTE {
-    constructor(name, union) {
-      this.name = name;
-      this.union = union;
-    }
-    type = "Target.CTE" /* CTE */;
-  }
-  Target2.CTE = CTE;
   class Expr {
     constructor(expr, alias) {
       this.expr = expr;
@@ -25,6 +17,14 @@ var Target;
     type = "Target.Expr" /* Expr */;
   }
   Target2.Expr = Expr;
+  class CTE {
+    constructor(name, union) {
+      this.name = name;
+      this.union = union;
+    }
+    type = "Target.CTE" /* CTE */;
+  }
+  Target2.CTE = CTE;
   class Query {
     constructor(query, alias) {
       this.query = query;

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

@@ -0,0 +1,7 @@
+import { Query, QueryData } from '../Query';
+export declare class Batch<T = void> extends Query<T> {
+    protected queries: Array<QueryData>;
+    [Query.Data]: QueryData.Batch;
+    constructor(queries: Array<QueryData>);
+    next<T>(cursor: Query<T>): Query<T>;
+}

package/dist/define/query/Batch.js

@@ -0,0 +1,18 @@
+// src/define/query/Batch.ts
+import { Query, QueryData } from "../Query.js";
+var Batch = class extends Query {
+  constructor(queries) {
+    super(new QueryData.Batch({ queries }));
+    this.queries = queries;
+  }
+  next(cursor) {
+    return new Query(
+      new QueryData.Batch({
+        queries: [...this[Query.Data].queries, cursor[Query.Data]]
+      })
+    );
+  }
+};
+export {
+  Batch
+};

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

@@ -0,0 +1,6 @@
+import { Query } from '../Query';
+import { TableData } from '../Table';
+export declare class CreateTable extends Query<void> {
+    protected table: TableData;
+    constructor(table: TableData);
+}

package/dist/define/query/CreateTable.js

@@ -0,0 +1,12 @@
+// src/define/query/CreateTable.ts
+import { Query } from "../Query.js";
+import { Schema } from "../Schema.js";
+var CreateTable = class extends Query {
+  constructor(table) {
+    super(Schema.create(table));
+    this.table = table;
+  }
+};
+export {
+  CreateTable
+};

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

@@ -0,0 +1,11 @@
+import { EV } from '../Expr';
+import { Query, QueryData } from '../Query';
+export declare class Delete extends Query<{
+    rowsAffected: number;
+}> {
+    [Query.Data]: QueryData.Delete;
+    constructor(query: QueryData.Delete);
+    where(...where: Array<EV<boolean>>): Delete;
+    take(limit: number | undefined): Delete;
+    skip(offset: number | undefined): Delete;
+}

package/dist/define/query/Delete.js

@@ -0,0 +1,19 @@
+// src/define/query/Delete.ts
+import { Query } from "../Query.js";
+var Delete = class extends Query {
+  constructor(query) {
+    super(query);
+  }
+  where(...where) {
+    return new Delete(this.addWhere(where));
+  }
+  take(limit) {
+    return new Delete(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new Delete(this[Query.Data].with({ offset }));
+  }
+};
+export {
+  Delete
+};

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

@@ -0,0 +1,19 @@
+import { Query, QueryData } from '../Query';
+import { Selection } from '../Selection';
+import { Table, TableData } from '../Table';
+import { SelectMultiple } from './Select';
+export declare class InsertValuesReturning<T> extends Query<T> {
+}
+export declare class Inserted extends Query<{
+    rowsAffected: number;
+}> {
+    [Query.Data]: QueryData.Insert;
+    constructor(query: QueryData.Insert);
+    returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+}
+export declare class Insert<Definition> {
+    protected into: TableData;
+    constructor(into: TableData);
+    selection(query: SelectMultiple<Table.Select<Definition>>): Inserted;
+    values(...data: Array<Table.Insert<Definition>>): Inserted;
+}

package/dist/define/query/Insert.js

@@ -0,0 +1,36 @@
+// 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 {
+  constructor(query) {
+    super(query);
+  }
+  returning(selection) {
+    return new InsertValuesReturning(
+      new QueryData.Insert({
+        ...this[Query.Data],
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+};
+var Insert = class {
+  constructor(into) {
+    this.into = into;
+  }
+  selection(query) {
+    return new Inserted(
+      new QueryData.Insert({ into: this.into, select: query[Query.Data] })
+    );
+  }
+  values(...data) {
+    return new Inserted(new QueryData.Insert({ into: this.into, data }));
+  }
+};
+export {
+  Insert,
+  InsertValuesReturning,
+  Inserted
+};

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

@@ -0,0 +1,41 @@
+import { EV, Expr } from '../Expr';
+import { OrderBy } from '../OrderBy';
+import { Query, QueryData } from '../Query';
+import { Selection } from '../Selection';
+import { Table } from '../Table';
+import { TableSelect } from './TableSelect';
+import { Union } from './Union';
+export declare class SelectMultiple<Row> extends Union<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any>): SelectMultiple<Row>;
+    leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
+    innerJoin<C>(that: Table<C> | TableSelect<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 | undefined>;
+    first(): SelectSingle<Row>;
+    where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
+    take(limit: number | undefined): SelectMultiple<Row>;
+    skip(offset: number | undefined): SelectMultiple<Row>;
+    recursiveUnion<T extends {}>(this: SelectMultiple<T>, create: (fields: Record<string, Table.Of<T>>) => SelectMultiple<T> | Union<T>): SelectMultiple<T>;
+    recursiveUnionAll<T extends {}>(this: SelectMultiple<T>, create: (fields: Record<string, Table.Of<T>>) => SelectMultiple<T> | Union<T>): SelectMultiple<T>;
+    [Expr.ToExpr](): Expr<Row>;
+}
+export declare class SelectSingle<Row> extends Query<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any>): SelectMultiple<Row>;
+    leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
+    innerJoin<C>(that: Table<C> | TableSelect<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>;
+    [Expr.ToExpr](): Expr<Row>;
+}

package/dist/define/query/Select.js

@@ -0,0 +1,190 @@
+// src/define/query/Select.ts
+import { makeRecursiveUnion } from "../CTE.js";
+import { Expr, ExprData } from "../Expr.js";
+import { Functions } from "../Functions.js";
+import { Query, QueryData } from "../Query.js";
+import { Table } from "../Table.js";
+import { Target } from "../Target.js";
+import { Union } from "./Union.js";
+function joinTarget(joinType, query, to, on) {
+  const toQuery = Query.isQuery(to) ? to[Query.Data] : void 0;
+  const target = toQuery ? toQuery.from : new Target.Table(to[Table.Data]);
+  if (!query.from || !target)
+    throw new Error("No from clause");
+  const conditions = [...on];
+  if (toQuery) {
+    const where = toQuery.where;
+    if (where)
+      conditions.push(new Expr(where));
+  }
+  return new Target.Join(
+    query.from,
+    target,
+    joinType,
+    Expr.and(...conditions)[Expr.Data]
+  );
+}
+var SelectMultiple = class extends Union {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    return new SelectMultiple(
+      this[Query.Data].with({ from: new Target.Table(table) })
+    );
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectMultiple(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectMultiple(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new SelectMultiple(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  count() {
+    return new SelectSingle(
+      this[Query.Data].with({
+        selection: Functions.count()[Expr.Data],
+        singleResult: true
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new SelectMultiple(
+      this[Query.Data].with({
+        orderBy: orderBy.map((e) => {
+          return Expr.isExpr(e) ? e.asc() : e;
+        })
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new SelectMultiple(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  maybeFirst() {
+    return new SelectSingle(this[Query.Data].with({ singleResult: true }));
+  }
+  first() {
+    return new SelectSingle(
+      this[Query.Data].with({
+        singleResult: true,
+        validate: true
+      })
+    );
+  }
+  where(...where) {
+    return new SelectMultiple(this.addWhere(where));
+  }
+  take(limit) {
+    return new SelectMultiple(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new SelectMultiple(this[Query.Data].with({ offset }));
+  }
+  recursiveUnion(create) {
+    return new SelectMultiple(
+      makeRecursiveUnion(
+        this[Query.Data],
+        create,
+        QueryData.UnionOperation.Union
+      )
+    );
+  }
+  recursiveUnionAll(create) {
+    return new SelectMultiple(
+      makeRecursiveUnion(
+        this[Query.Data],
+        create,
+        QueryData.UnionOperation.UnionAll
+      )
+    );
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+};
+var SelectSingle = class extends Query {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    return new SelectMultiple(
+      this[Query.Data].with({ from: new Target.Table(table) })
+    );
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectSingle(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectSingle(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new SelectSingle(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new SelectSingle(
+      this[Query.Data].with({
+        orderBy
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new SelectSingle(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  where(...where) {
+    return new SelectSingle(this.addWhere(where));
+  }
+  take(limit) {
+    return new SelectSingle(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new SelectSingle(this[Query.Data].with({ offset }));
+  }
+  all() {
+    return new SelectMultiple(this[Query.Data].with({ singleResult: false }));
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+};
+export {
+  SelectMultiple,
+  SelectSingle
+};

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

@@ -0,0 +1,21 @@
+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>> {
+    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<Table.Select<Definition>>;
+    insertAll(data: Array<Table.Insert<Definition>>): Inserted;
+    set(data: Table.Update<Definition>): Update<Definition>;
+    delete(): Delete;
+    get(name: string): Expr<any>;
+}

package/dist/define/query/TableSelect.js

@@ -0,0 +1,71 @@
+// 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 { Update } from "./Update.js";
+var TableSelect = class extends SelectMultiple {
+  constructor(table, conditions = []) {
+    const target = new Target.Table(table);
+    super(
+      new QueryData.Select({
+        from: target,
+        selection: new ExprData.Row(target),
+        where: Expr.and(...conditions)[Expr.Data]
+      })
+    );
+    this.table = table;
+  }
+  as(alias) {
+    return createTable({ ...this.table, alias });
+  }
+  create() {
+    return new CreateTable(this.table);
+  }
+  insertSelect(query) {
+    return new Inserted(
+      new QueryData.Insert({ into: this.table, select: query[Query.Data] })
+    );
+  }
+  insertOne(record) {
+    return new Query(
+      new QueryData.Insert({
+        into: this.table,
+        data: [record],
+        selection: new ExprData.Row(new Target.Table(this.table)),
+        singleResult: true
+      })
+    );
+  }
+  insertAll(data) {
+    return new Insert(this.table).values(...data);
+  }
+  set(data) {
+    return new Update(
+      new QueryData.Update({
+        table: this.table,
+        where: this[Query.Data].where
+      })
+    ).set(data);
+  }
+  delete() {
+    return new Delete(
+      new QueryData.Delete({
+        table: this.table,
+        where: this[Query.Data].where
+      })
+    );
+  }
+  get(name) {
+    return new Expr(
+      new ExprData.Field(new ExprData.Row(new Target.Table(this.table)), name)
+    );
+  }
+};
+export {
+  TableSelect
+};

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

@@ -0,0 +1,10 @@
+import { Query, QueryData } from '../Query';
+import { SelectMultiple } from './Select';
+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>;
+}

package/dist/define/query/Union.js

@@ -0,0 +1,46 @@
+// src/define/query/Union.ts
+import { Query, QueryData } from "../Query.js";
+var Union = class extends Query {
+  constructor(query) {
+    super(query);
+  }
+  union(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.Union,
+        b: query[Query.Data]
+      })
+    );
+  }
+  unionAll(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.UnionAll,
+        b: query[Query.Data]
+      })
+    );
+  }
+  except(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.Except,
+        b: query[Query.Data]
+      })
+    );
+  }
+  intersect(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.Intersect,
+        b: query[Query.Data]
+      })
+    );
+  }
+};
+export {
+  Union
+};

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

@@ -0,0 +1,12 @@
+import { EV } from '../Expr';
+import { Query, QueryData } from '../Query';
+import { Table } from '../Table';
+export declare class Update<Definition> extends Query<{
+    rowsAffected: number;
+}> {
+    [Query.Data]: QueryData.Update;
+    set(set: Table.Update<Definition>): Update<Definition>;
+    where(...where: Array<EV<boolean>>): Update<Definition>;
+    take(limit: number | undefined): Update<Definition>;
+    skip(offset: number | undefined): Update<Definition>;
+}

package/dist/define/query/Update.js

@@ -0,0 +1,19 @@
+// src/define/query/Update.ts
+import { Query } from "../Query.js";
+var Update = class extends Query {
+  set(set) {
+    return new Update(this[Query.Data].with({ set }));
+  }
+  where(...where) {
+    return new Update(this.addWhere(where));
+  }
+  take(limit) {
+    return new Update(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new Update(this[Query.Data].with({ offset }));
+  }
+};
+export {
+  Update
+};

package/dist/driver/bun-sqlite.js

@@ -1,5 +1,6 @@
 // src/driver/bun-sqlite.ts
-import { Query, QueryData } from "../define/Query.js";
+import { QueryData } from "../define/Query.js";
+import { SelectSingle } from "../define/query/Select.js";
 import { Driver } from "../lib/Driver.js";
 import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
@@ -34,7 +35,7 @@ var BunSqliteDriver = class extends Driver.Sync {
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
     this.lastChanges = this.prepare(() => {
-      return new Query.SelectSingle(
+      return new SelectSingle(
         new QueryData.Raw({
           expectedReturn: "row",
           strings: ["SELECT changes() as rowsAffected"],