rado 0.2.23 → 0.2.25

package/dist/define/Query.js

@@ -1,14 +1,11 @@
 // src/define/Query.ts
-import { Expr, ExprData } from "./Expr.js";
-import { Functions } from "./Functions.js";
-import { Schema } from "./Schema.js";
-import { Table, createTable } from "./Table.js";
-import { Target } from "./Target.js";
+import { Expr } from "./Expr.js";
 var { assign } = Object;
 var DATA = Symbol("Query.Data");
 var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Insert"] = "QueryData.Insert";
   QueryType2["Select"] = "QueryData.Select";
+  QueryType2["Union"] = "QueryData.Union";
   QueryType2["Update"] = "QueryData.Update";
   QueryType2["Delete"] = "QueryData.Delete";
   QueryType2["CreateTable"] = "QueryData.CreateTable";
@@ -27,7 +24,21 @@ var QueryData;
     constructor(data) {
       assign(this, data);
     }
+    with(data) {
+      return new this.constructor({ ...this, ...data });
+    }
+  }
+  let UnionOperation;
+  ((UnionOperation2) => {
+    UnionOperation2["Union"] = "Union";
+    UnionOperation2["UnionAll"] = "UnionAll";
+    UnionOperation2["Intersect"] = "Intersect";
+    UnionOperation2["Except"] = "Except";
+  })(UnionOperation = QueryData2.UnionOperation || (QueryData2.UnionOperation = {}));
+  class Union extends Data {
+    type = "QueryData.Union" /* Union */;
   }
+  QueryData2.Union = Union;
   class Select extends Data {
     type = "QueryData.Select" /* Select */;
   }
@@ -93,16 +104,13 @@ var Query = class {
   constructor(query) {
     this[DATA] = query;
   }
-  static all(strings, ...params) {
-    return new Query(
-      new QueryData.Raw({ expectedReturn: "rows", strings, params })
-    );
-  }
   next(cursor) {
     return new Query(
-      new QueryData.Batch({
-        queries: [this[DATA], cursor[DATA]]
-      })
+      new QueryData.Batch(
+        this[DATA].with({
+          queries: [this[DATA], cursor[DATA]]
+        })
+      )
     );
   }
   on(driver) {
@@ -114,310 +122,20 @@ var Query = class {
   toJSON() {
     return this[DATA];
   }
-};
-function addWhere(query, where) {
-  const conditions = where.slice();
-  if (query.where)
-    conditions.push(new Expr(query.where));
-  return {
-    ...query,
-    where: Expr.and(...conditions)[Expr.Data]
-  };
-}
-((Query2) => {
-  class Delete extends Query2 {
-    where(...where) {
-      return new Delete(addWhere(this[DATA], where));
-    }
-    take(limit) {
-      return new Delete({ ...this[DATA], limit });
-    }
-    skip(offset) {
-      return new Delete({ ...this[DATA], offset });
-    }
-  }
-  Query2.Delete = Delete;
-  class Update extends Query2 {
-    set(set) {
-      return new Update({ ...this[DATA], set });
-    }
-    where(...where) {
-      return new Update(addWhere(this[DATA], where));
-    }
-    take(limit) {
-      return new Update({ ...this[DATA], limit });
-    }
-    skip(offset) {
-      return new Update({ ...this[DATA], offset });
-    }
-  }
-  Query2.Update = Update;
-  class InsertValuesReturning extends Query2 {
-  }
-  Query2.InsertValuesReturning = InsertValuesReturning;
-  class Inserted extends Query2 {
-    constructor(query) {
-      super(query);
-    }
-    returning(selection) {
-      return new InsertValuesReturning(
-        new QueryData.Insert({
-          ...this[DATA],
-          selection: ExprData.create(selection)
-        })
-      );
-    }
-  }
-  Query2.Inserted = Inserted;
-  class Insert {
-    constructor(into) {
-      this.into = into;
-    }
-    selection(query) {
-      return new Inserted(
-        new QueryData.Insert({ into: this.into, select: query[DATA] })
-      );
-    }
-    values(...data) {
-      return new Inserted(new QueryData.Insert({ into: this.into, data }));
-    }
-  }
-  Query2.Insert = Insert;
-  class CreateTable extends Query2 {
-    constructor(table) {
-      super(Schema.create(table));
-      this.table = table;
-    }
-  }
-  Query2.CreateTable = CreateTable;
-  class Batch extends Query2 {
-    constructor(queries) {
-      super(new QueryData.Batch({ queries }));
-      this.queries = queries;
-    }
-    next(cursor) {
-      return new Query2(
-        new QueryData.Batch({
-          queries: [...this[DATA].queries, cursor[DATA]]
-        })
-      );
-    }
-  }
-  Query2.Batch = Batch;
-  function joinTarget(joinType, query, to, on) {
-    const toQuery = Query2.isQuery(to) ? to[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]
-    );
+  addWhere(where) {
+    const query = this[DATA];
+    const conditions = where.slice();
+    if (query.where)
+      conditions.push(new Expr(query.where));
+    return query.with({ where: Expr.and(...conditions)[Expr.Data] });
   }
-  class SelectMultiple extends Query2 {
-    constructor(query) {
-      super(query);
-    }
-    leftJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectMultiple({
-        ...query,
-        from: joinTarget("left", query, that, on)
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectMultiple({
-        ...query,
-        from: joinTarget("inner", query, that, on)
-      });
-    }
-    select(selection) {
-      return new SelectMultiple({
-        ...this[DATA],
-        selection: ExprData.create(selection)
-      });
-    }
-    count() {
-      return new SelectSingle({
-        ...this[DATA],
-        selection: Functions.count()[Expr.Data],
-        singleResult: true
-      });
-    }
-    orderBy(...orderBy) {
-      return new SelectMultiple({
-        ...this[DATA],
-        orderBy: orderBy.map((e) => {
-          return Expr.isExpr(e) ? e.asc() : e;
-        })
-      });
-    }
-    groupBy(...groupBy) {
-      return new SelectMultiple({
-        ...this[DATA],
-        groupBy: groupBy.map(ExprData.create)
-      });
-    }
-    maybeFirst() {
-      return new SelectSingle({ ...this[DATA], singleResult: true });
-    }
-    first() {
-      return new SelectSingle({
-        ...this[DATA],
-        singleResult: true,
-        validate: true
-      });
-    }
-    where(...where) {
-      return new SelectMultiple(addWhere(this[DATA], where));
-    }
-    take(limit) {
-      return new SelectMultiple({ ...this[DATA], limit });
-    }
-    skip(offset) {
-      return new SelectMultiple({ ...this[DATA], offset });
-    }
-    [Expr.ToExpr]() {
-      return new Expr(new ExprData.Query(this[DATA]));
-    }
-  }
-  Query2.SelectMultiple = SelectMultiple;
-  class TableSelect 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 Query2.CreateTable(this.table);
-    }
-    insertSelect(query) {
-      return new Query2.Inserted(
-        new QueryData.Insert({ into: this.table, select: query[DATA] })
-      );
-    }
-    insertOne(record) {
-      return new Query2(
-        new QueryData.Insert({
-          into: this.table,
-          data: [record],
-          selection: new ExprData.Row(new Target.Table(this.table)),
-          singleResult: true
-        })
-      );
-    }
-    insertAll(data) {
-      return new Query2.Insert(this.table).values(...data);
-    }
-    set(data) {
-      return new Query2.Update(
-        new QueryData.Update({
-          table: this.table,
-          where: this[DATA].where
-        })
-      ).set(data);
-    }
-    delete() {
-      return new Query2.Delete(
-        new QueryData.Delete({
-          table: this.table,
-          where: this[DATA].where
-        })
-      );
-    }
-    get(name) {
-      return new Expr(
-        new ExprData.Field(new ExprData.Row(new Target.Table(this.table)), name)
-      );
-    }
-  }
-  Query2.TableSelect = TableSelect;
-  class SelectSingle extends Query2 {
-    constructor(query) {
-      super(query);
-    }
-    leftJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectSingle({
-        ...query,
-        from: joinTarget("left", query, that, on)
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectSingle({
-        ...query,
-        from: joinTarget("inner", query, that, on)
-      });
-    }
-    select(selection) {
-      return new SelectSingle({
-        ...this[DATA],
-        selection: ExprData.create(selection)
-      });
-    }
-    orderBy(...orderBy) {
-      return new SelectSingle({
-        ...this[DATA],
-        orderBy
-      });
-    }
-    groupBy(...groupBy) {
-      return new SelectSingle({
-        ...this[DATA],
-        groupBy: groupBy.map(ExprData.create)
-      });
-    }
-    where(...where) {
-      return new SelectSingle(addWhere(this[DATA], where));
-    }
-    take(limit) {
-      return new SelectSingle({ ...this[DATA], limit });
-    }
-    skip(offset) {
-      return new SelectSingle({ ...this[DATA], offset });
-    }
-    all() {
-      return new SelectMultiple({ ...this[DATA], singleResult: false });
-    }
-    [Expr.ToExpr]() {
-      return new Expr(new ExprData.Query(this[DATA]));
-    }
-  }
-  Query2.SelectSingle = SelectSingle;
-})(Query || (Query = {}));
+};
 ((Query2) => {
   Query2.Data = DATA;
   function isQuery(input) {
     return input !== null && Boolean(DATA in input);
   }
   Query2.isQuery = isQuery;
-  function isSingle(input) {
-    return input instanceof Query2.SelectSingle;
-  }
-  Query2.isSingle = isSingle;
-  function isMultiple(input) {
-    return input instanceof Query2.SelectSingle;
-  }
-  Query2.isMultiple = isMultiple;
 })(Query || (Query = {}));
 export {
   Query,

package/dist/define/Selection.d.ts

@@ -1,6 +1,6 @@
 import type { Expr } from './Expr';
-import type { Query } from './Query';
-type SelectionBase = unknown | (() => any) | Expr<any> | Query.SelectMultiple<any> | Query.SelectSingle<any>;
+import type { SelectMultiple, SelectSingle } from './query/Select';
+type SelectionBase = unknown | (() => any) | Expr<any> | SelectMultiple<any> | SelectSingle<any>;
 interface SelectionRecord extends Record<string, Selection> {
 }
 export type Selection = SelectionBase | SelectionRecord;

package/dist/define/Table.d.ts

@@ -1,8 +1,9 @@
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column';
-import { EV } from './Expr';
+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 {
@@ -19,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>;
@@ -38,7 +39,7 @@ export declare namespace Table {
     export const Data: typeof DATA;
     export const Meta: typeof META;
     export type Of<Row> = Table<{
-        [K in keyof Row as K extends string ? K : never]: Column<Row[K]>;
+        [K in keyof Row as K extends string ? K : never]: Fields<Row[K]>;
     }>;
     export type Select<Definition> = {
         [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? T : never;
@@ -61,6 +62,7 @@ interface Define<T> {
     new (): T;
 }
 export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
+export declare function virtualTable<Definition>(name: string): Table<Definition>;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
 export declare function table<T extends {}>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {

package/dist/define/Table.js

@@ -4,10 +4,11 @@ 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,
   keys,
   entries,
   fromEntries,
@@ -28,6 +29,42 @@ var Table;
   Table2.Data = DATA;
   Table2.Meta = META;
 })(Table || (Table = {}));
+function virtualTable(name) {
+  const data = new TableData({
+    name,
+    columns: {},
+    definition: create(null),
+    meta: () => ({ indexes: {} })
+  });
+  const target = new Target.Table(data);
+  const cache = create(null);
+  function call(...args) {
+    const isConditionalRecord = args.length === 1 && !Expr.isExpr(args[0]);
+    const conditions = isConditionalRecord ? entries(args[0]).map(([key, value]) => {
+      return new Expr(
+        new ExprData.BinOp(
+          BinOpType.Equals,
+          new ExprData.Field(new ExprData.Row(target), key),
+          ExprData.create(value)
+        )
+      );
+    }) : args;
+    return new TableSelect(data, conditions);
+  }
+  return new Proxy(call, {
+    get(_, column) {
+      if (column === DATA)
+        return data;
+      if (column === Expr.ToExpr)
+        return new Expr(new ExprData.Row(target));
+      if (column in cache)
+        return cache[column];
+      return (cache[column] = new Expr(
+        new ExprData.Field(new ExprData.Row(target), column)
+      )).dynamic();
+    }
+  });
+}
 function createTable(data) {
   const target = new Target.Table(data);
   const call = {
@@ -45,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);
@@ -123,5 +160,6 @@ export {
   Table,
   TableData,
   createTable,
-  table
+  table,
+  virtualTable
 };

package/dist/define/Target.d.ts

@@ -3,11 +3,12 @@ import type { QueryData } from './Query';
 import type { TableData } from './Table';
 export declare enum TargetType {
     Expr = "Target.Expr",
+    CTE = "Target.CTE",
     Query = "Target.Query",
     Table = "Target.Table",
     Join = "Target.Join"
 }
-export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
+export type Target = Target.Expr | Target.CTE | Target.Query | Target.Table | Target.Join;
 export declare namespace Target {
     class Expr {
         expr: ExprData;
@@ -15,6 +16,12 @@ export declare namespace Target {
         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

@@ -1,6 +1,7 @@
 // src/define/Target.ts
 var TargetType = /* @__PURE__ */ ((TargetType2) => {
   TargetType2["Expr"] = "Target.Expr";
+  TargetType2["CTE"] = "Target.CTE";
   TargetType2["Query"] = "Target.Query";
   TargetType2["Table"] = "Target.Table";
   TargetType2["Join"] = "Target.Join";
@@ -16,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
+};