rado 0.2.24 → 0.2.25

package/dist/define/Expr.d.ts

@@ -1,9 +1,10 @@
 import { Fields } from './Fields';
 import { OrderBy } from './OrderBy';
 import { ParamData } from './Param';
-import { Query, QueryData } from './Query';
+import { QueryData } from './Query';
 import { Selection } from './Selection';
 import { Target } from './Target';
+import { SelectMultiple, SelectSingle } from './query/Select';
 declare const DATA: unique symbol;
 declare const TO_EXPR: unique symbol;
 declare const IS_EXPR: unique symbol;
@@ -127,13 +128,13 @@ export declare class Expr<T> {
     not(): Expr<boolean>;
     or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
     and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    is(that: EV<T> | Query.SelectSingle<T>): Expr<boolean>;
+    is(that: EV<T> | SelectSingle<T>): Expr<boolean>;
     isConstant(value: T): boolean;
     isNot(that: EV<T>): Expr<boolean>;
     isNull(): Expr<boolean>;
     isNotNull(): Expr<boolean>;
-    isIn(that: EV<Array<T>> | Query.SelectMultiple<T>): Expr<boolean>;
-    isNotIn(that: EV<Array<T>> | Query.SelectMultiple<T>): Expr<boolean>;
+    isIn(that: EV<Array<T>> | SelectMultiple<T>): Expr<boolean>;
+    isNotIn(that: EV<Array<T>> | SelectMultiple<T>): Expr<boolean>;
     isGreater(that: EV<any>): Expr<boolean>;
     isGreaterOrEqual(that: EV<any>): Expr<boolean>;
     isLess(that: EV<any>): Expr<boolean>;

package/dist/define/Fields.d.ts

@@ -4,9 +4,9 @@ type ObjectUnion<T> = {
 };
 type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
 type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
-type FieldsOf<Row> = Row extends Record<string, any> ? {
+type FieldsOf<Row> = [Row] extends [Record<string, any>] ? {
     [K in keyof Row]-?: Field<Row[K]>;
 } : never;
 type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
+export type Fields<T> = IsStrictlyAny<T> extends true ? any : [T] extends [object] ? FieldsOf<T> : Field<T>;
 export {};

package/dist/define/Ops.d.ts

@@ -1,9 +1,13 @@
-import { Query } from './Query';
 import { Selection } from './Selection';
 import { Table } from './Table';
-export declare function select<X extends Selection>(selection: X): Query.SelectMultiple<Selection.Infer<X>>;
-export declare function from<Row>(source: Table<Row> | Query.SelectMultiple<Row>): Query.SelectMultiple<Row>;
-export declare function update<Row>(table: Table<Row>): Query.Update<Row>;
-export declare function insertInto<Row>(table: Table<Row>): Query.Insert<Row>;
-export declare function deleteFrom<Row>(table: Table<Row>): Query.Delete;
-export declare function create(...tables: Array<Table<any>>): Query.Batch;
+import { Batch } from './query/Batch';
+import { Delete } from './query/Delete';
+import { Insert } from './query/Insert';
+import { SelectMultiple } from './query/Select';
+import { Update } from './query/Update';
+export declare function select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
+export declare function from<Row>(source: Table<Row> | SelectMultiple<Row>): SelectMultiple<Row>;
+export declare function update<Row>(table: Table<Row>): Update<Row>;
+export declare function insertInto<Row>(table: Table<Row>): Insert<Row>;
+export declare function deleteFrom<Row>(table: Table<Row>): Delete;
+export declare function create(...tables: Array<Table<any>>): Batch;

package/dist/define/Ops.js

@@ -4,8 +4,13 @@ import { Query, QueryData } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Table } from "./Table.js";
 import { Target } from "./Target.js";
+import { Batch } from "./query/Batch.js";
+import { Delete } from "./query/Delete.js";
+import { Insert } from "./query/Insert.js";
+import { SelectMultiple } from "./query/Select.js";
+import { Update } from "./query/Update.js";
 function select(selection) {
-  return new Query.SelectMultiple(
+  return new SelectMultiple(
     new QueryData.Select({
       selection: ExprData.create(selection)
     })
@@ -13,7 +18,7 @@ function select(selection) {
 }
 function from(source) {
   const target = Query.isQuery(source) ? new Target.Query(source[Query.Data]) : new Target.Table(source[Table.Data]);
-  return new Query.SelectMultiple(
+  return new SelectMultiple(
     new QueryData.Select({
       from: target,
       selection: new ExprData.Row(target)
@@ -21,16 +26,16 @@ function from(source) {
   );
 }
 function update(table) {
-  return new Query.Update(new QueryData.Update({ table: table[Table.Data] }));
+  return new Update(new QueryData.Update({ table: table[Table.Data] }));
 }
 function insertInto(table) {
-  return new Query.Insert(table[Table.Data]);
+  return new Insert(table[Table.Data]);
 }
 function deleteFrom(table) {
-  return new Query.Delete(new QueryData.Delete({ table: table[Table.Data] }));
+  return new Delete(new QueryData.Delete({ table: table[Table.Data] }));
 }
 function create(...tables) {
-  return new Query.Batch(
+  return new Batch(
     tables.flatMap((table) => Schema.create(table[Table.Data]).queries)
   );
 }

package/dist/define/Query.d.ts

@@ -1,11 +1,11 @@
 import { Driver } from '../lib/Driver';
 import { CompileOptions } from '../lib/Formatter';
 import { ColumnData } from './Column';
-import { EV, Expr, ExprData } from './Expr';
+import { EV, ExprData } from './Expr';
 import { IndexData } from './Index';
 import { OrderBy } from './OrderBy';
 import { Selection } from './Selection';
-import { Table, TableData } from './Table';
+import { TableData } from './Table';
 import { Target } from './Target';
 declare const DATA: unique symbol;
 export declare enum QueryType {
@@ -139,115 +139,15 @@ export declare class Query<T> {
     [Selection.CursorType]: () => T;
     [DATA]: QueryData;
     constructor(query: QueryData);
-    static all(strings: TemplateStringsArray, ...params: Array<any>): Query<any>;
     next<T>(cursor: Query<T>): Query<T>;
     on(driver: Driver.Sync): T;
     on(driver: Driver.Async): Promise<T>;
     toSql(driver: Driver, options?: CompileOptions): string;
     toJSON(): QueryData;
-}
-export declare namespace Query {
-    class Delete extends Query<{
-        rowsAffected: number;
-    }> {
-        [DATA]: QueryData.Delete;
-        where(...where: Array<EV<boolean>>): Delete;
-        take(limit: number | undefined): Delete;
-        skip(offset: number | undefined): Delete;
-    }
-    class Update<Definition> extends Query<{
-        rowsAffected: number;
-    }> {
-        [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>;
-    }
-    class InsertValuesReturning<T> extends Query<T> {
-    }
-    class Inserted extends Query<{
-        rowsAffected: number;
-    }> {
-        [DATA]: QueryData.Insert;
-        constructor(query: QueryData.Insert);
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<Definition> {
-        protected into: TableData;
-        constructor(into: TableData);
-        selection(query: Query.SelectMultiple<Table.Select<Definition>>): Inserted;
-        values(...data: Array<Table.Insert<Definition>>): Inserted;
-    }
-    class CreateTable extends Query<void> {
-        protected table: TableData;
-        constructor(table: TableData);
-    }
-    class Batch<T = void> extends Query<T> {
-        protected queries: Array<QueryData>;
-        [DATA]: QueryData.Batch;
-        constructor(queries: Array<QueryData>);
-        next<T>(cursor: Query<T>): Query<T>;
-    }
-    class Union<Row> extends Query<Array<Row>> {
-        [DATA]: 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>;
-    }
-    class SelectMultiple<Row> extends Union<Row> {
-        [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>;
-    }
-    class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
-        protected table: TableData;
-        [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>;
-    }
-    class SelectSingle<Row> extends Query<Row> {
-        [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>;
-    }
+    protected addWhere(where: Array<EV<boolean>>): this[typeof DATA];
 }
 export declare namespace Query {
     const Data: typeof DATA;
     function isQuery<T>(input: any): input is Query<T>;
-    function isSingle<T>(input: any): input is Query.SelectSingle<T>;
-    function isMultiple<T>(input: any): input is Query.SelectMultiple<T>;
 }
 export {};

package/dist/define/Query.js

@@ -1,10 +1,5 @@
 // src/define/Query.ts
-import { makeRecursiveUnion } from "./CTE.js";
-import { Expr, ExprData } from "./Expr.js";
-import { Functions } from "./Functions.js";
-import { Schema } from "./Schema.js";
-import { createTable, Table } 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) => {
@@ -109,11 +104,6 @@ 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(
@@ -132,390 +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 Expr.and(...conditions)[Expr.Data];
-}
-((Query2) => {
-  class Delete extends Query2 {
-    where(...where) {
-      return new Delete(this[DATA].with({ where: addWhere(this[DATA], where) }));
-    }
-    take(limit) {
-      return new Delete(this[DATA].with({ limit }));
-    }
-    skip(offset) {
-      return new Delete(this[DATA].with({ offset }));
-    }
-  }
-  Query2.Delete = Delete;
-  class Update extends Query2 {
-    set(set) {
-      return new Update(this[DATA].with({ set }));
-    }
-    where(...where) {
-      return new Update(this[DATA].with({ where: addWhere(this[DATA], where) }));
-    }
-    take(limit) {
-      return new Update(this[DATA].with({ limit }));
-    }
-    skip(offset) {
-      return new Update(this[DATA].with({ 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;
-  class Union extends Query2 {
-    union(query) {
-      return new Union(
-        new QueryData.Union({
-          a: this[DATA],
-          operator: "Union" /* Union */,
-          b: query[DATA]
-        })
-      );
-    }
-    unionAll(query) {
-      return new Union(
-        new QueryData.Union({
-          a: this[DATA],
-          operator: "UnionAll" /* UnionAll */,
-          b: query[DATA]
-        })
-      );
-    }
-    except(query) {
-      return new Union(
-        new QueryData.Union({
-          a: this[DATA],
-          operator: "Except" /* Except */,
-          b: query[DATA]
-        })
-      );
-    }
-    intersect(query) {
-      return new Union(
-        new QueryData.Union({
-          a: this[DATA],
-          operator: "Intersect" /* Intersect */,
-          b: query[DATA]
-        })
-      );
-    }
-  }
-  Query2.Union = Union;
-  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]
-    );
-  }
-  class SelectMultiple extends Union {
-    constructor(query) {
-      super(query);
-    }
-    from(table) {
-      return new SelectMultiple(
-        this[DATA].with({ from: new Target.Table(table) })
-      );
-    }
-    leftJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectMultiple(
-        this[DATA].with({
-          from: joinTarget("left", query, that, on)
-        })
-      );
-    }
-    innerJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectMultiple(
-        this[DATA].with({
-          from: joinTarget("inner", query, that, on)
-        })
-      );
-    }
-    select(selection) {
-      return new SelectMultiple(
-        this[DATA].with({
-          selection: ExprData.create(selection)
-        })
-      );
-    }
-    count() {
-      return new SelectSingle(
-        this[DATA].with({
-          selection: Functions.count()[Expr.Data],
-          singleResult: true
-        })
-      );
-    }
-    orderBy(...orderBy) {
-      return new SelectMultiple(
-        this[DATA].with({
-          orderBy: orderBy.map((e) => {
-            return Expr.isExpr(e) ? e.asc() : e;
-          })
-        })
-      );
-    }
-    groupBy(...groupBy) {
-      return new SelectMultiple(
-        this[DATA].with({
-          groupBy: groupBy.map(ExprData.create)
-        })
-      );
-    }
-    maybeFirst() {
-      return new SelectSingle(this[DATA].with({ singleResult: true }));
-    }
-    first() {
-      return new SelectSingle(
-        this[DATA].with({
-          singleResult: true,
-          validate: true
-        })
-      );
-    }
-    where(...where) {
-      return new SelectMultiple(
-        this[DATA].with({
-          where: addWhere(this[DATA], where)
-        })
-      );
-    }
-    take(limit) {
-      return new SelectMultiple(this[DATA].with({ limit }));
-    }
-    skip(offset) {
-      return new SelectMultiple(this[DATA].with({ offset }));
-    }
-    recursiveUnion(create) {
-      return new SelectMultiple(
-        makeRecursiveUnion(this[DATA], create, "Union" /* Union */)
-      );
-    }
-    recursiveUnionAll(create) {
-      return new SelectMultiple(
-        makeRecursiveUnion(
-          this[DATA],
-          create,
-          "UnionAll" /* UnionAll */
-        )
-      );
-    }
-    [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);
-    }
-    from(table) {
-      return new SelectMultiple(
-        this[DATA].with({ from: new Target.Table(table) })
-      );
-    }
-    leftJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectSingle(
-        this[DATA].with({
-          from: joinTarget("left", query, that, on)
-        })
-      );
-    }
-    innerJoin(that, ...on) {
-      const query = this[DATA];
-      return new SelectSingle(
-        this[DATA].with({
-          from: joinTarget("inner", query, that, on)
-        })
-      );
-    }
-    select(selection) {
-      return new SelectSingle(
-        this[DATA].with({
-          selection: ExprData.create(selection)
-        })
-      );
-    }
-    orderBy(...orderBy) {
-      return new SelectSingle(
-        this[DATA].with({
-          orderBy
-        })
-      );
-    }
-    groupBy(...groupBy) {
-      return new SelectSingle(
-        this[DATA].with({
-          groupBy: groupBy.map(ExprData.create)
-        })
-      );
-    }
-    where(...where) {
-      return new SelectSingle(
-        this[DATA].with({
-          where: addWhere(this[DATA], where)
-        })
-      );
-    }
-    take(limit) {
-      return new SelectSingle(this[DATA].with({ limit }));
-    }
-    skip(offset) {
-      return new SelectSingle(this[DATA].with({ offset }));
-    }
-    all() {
-      return new SelectMultiple(this[DATA].with({ singleResult: false }));
-    }
-    [Expr.ToExpr]() {
-      return new Expr(new ExprData.Query(this[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] });
   }
-  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;