rado 0.3.2 → 0.3.4

package/README.md

@@ -1,3 +1,5 @@
+[![npm](https://img.shields.io/npm/v/rado.svg)](https://npmjs.org/package/rado)
+
 # rado
 
 Fully typed, lightweight TypeScript query builder.

package/dist/define/CTE.d.ts

@@ -0,0 +1,2 @@
+import { Query, QueryData } from './Query';
+export declare function makeRecursiveUnion<T extends Query<any>>(initial: QueryData.Select, createUnion: (target: any) => T, operator: QueryData.UnionOperation): QueryData.Select;

package/dist/define/CTE.js

@@ -0,0 +1,51 @@
+// src/define/CTE.ts
+import { Expr, ExprData, ExprType } from "./Expr.js";
+import { Query, QueryData } from "./Query.js";
+import { virtualTable } from "./Table.js";
+import { Target, TargetType } from "./Target.js";
+var { keys, create, fromEntries } = Object;
+function columnsOf(expr) {
+  switch (expr.type) {
+    case ExprType.Record:
+      return keys(expr.fields);
+    case ExprType.Row:
+      switch (expr.target.type) {
+        case TargetType.Table:
+          return keys(expr.target.table.columns);
+        default:
+          throw new Error("Could not retrieve CTE columns");
+      }
+    default:
+      throw new Error("Could not retrieve CTE columns");
+  }
+}
+function makeRecursiveUnion(initial, createUnion, operator) {
+  let name;
+  const alias = new Proxy(create(null), {
+    get(_, key) {
+      name = key;
+      return virtualTable(name);
+    }
+  });
+  const right = createUnion(alias)[Query.Data];
+  if (!name)
+    throw new TypeError("No CTE name provided");
+  const cte = alias[name];
+  const cols = columnsOf(initial.selection);
+  const selection = new ExprData.Record(
+    fromEntries(cols.map((col) => [col, cte[col][Expr.Data]]))
+  );
+  const union = new QueryData.Union({
+    a: initial,
+    operator,
+    b: right
+  });
+  const from = new Target.CTE(name, union);
+  return new QueryData.Select({
+    selection,
+    from
+  });
+}
+export {
+  makeRecursiveUnion
+};

package/dist/define/Cursor.d.ts

@@ -1,18 +1,21 @@
 import { Driver } from '../lib/Driver';
+import { CompileOptions } from '../lib/Formatter';
 import { EV, Expr } from './Expr';
 import { OrderBy } from './OrderBy';
 import { Query } from './Query';
-import { Schema } from './Schema';
 import { Selection } from './Selection';
-import { Table } from './Table';
-import { Update as UpdateSet } from './Update';
+import { Table, TableData } from './Table';
+declare const QUERY: unique symbol;
 export declare class Cursor<T> {
-    [Selection.__cursorType](): T;
+    [Selection.CursorType]: () => T;
+    [QUERY]: Query<T>;
+    static Query: typeof QUERY;
     constructor(query: Query<T>);
     static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
-    query(): Query<T>;
+    next<T>(cursor: Cursor<T>): Cursor<T>;
     on(driver: Driver.Sync): T;
     on(driver: Driver.Async): Promise<T>;
+    toSql(driver: Driver, options?: CompileOptions): string;
     toJSON(): Query<T>;
 }
 export declare namespace Cursor {
@@ -24,62 +27,82 @@ export declare namespace Cursor {
         take(limit: number | undefined): Delete;
         skip(offset: number | undefined): Delete;
     }
-    class Update<T> extends Cursor<{
+    class Update<Definition> extends Cursor<{
         rowsAffected: number;
     }> {
-        query(): Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-        where(...where: Array<EV<boolean>>): Update<T>;
-        take(limit: number | undefined): Update<T>;
-        skip(offset: number | undefined): Update<T>;
+        [QUERY]: Query.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 Cursor<T> {
     }
-    class InsertValues extends Cursor<{
+    class Inserted extends Cursor<{
         rowsAffected: number;
     }> {
-        query(): Query.Insert;
+        [QUERY]: Query.Insert;
+        constructor(query: Query.Insert);
         returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
     }
-    class Insert<T> {
-        protected into: Schema;
-        constructor(into: Schema);
-        values(...data: Array<Table.Insert<T>>): InsertValues;
+    class Insert<Definition> {
+        protected into: TableData;
+        constructor(into: TableData);
+        selection(query: Cursor.SelectMultiple<Table.Select<Definition>>): Inserted;
+        values(...data: Array<Table.Insert<Definition>>): Inserted;
     }
     class CreateTable extends Cursor<void> {
-        protected table: Schema;
-        constructor(table: Schema);
+        protected table: TableData;
+        constructor(table: TableData);
     }
     class Batch<T = void> extends Cursor<T> {
         protected queries: Array<Query>;
+        [QUERY]: Query.Batch;
         constructor(queries: Array<Query>);
+        next<T>(cursor: Cursor<T>): Cursor<T>;
     }
-    class SelectMultiple<T> extends Cursor<Array<T>> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+    class SelectMultiple<Row> extends Cursor<Array<Row>> {
+        [QUERY]: Query.Select;
+        constructor(query: Query.Select);
+        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<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        sure(): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        take(limit: number | undefined): SelectMultiple<T>;
-        skip(offset: number | undefined): SelectMultiple<T>;
-        toExpr(): Expr<T>;
+        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<Row>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<Row>;
+        first(): SelectSingle<Row | undefined>;
+        sure(): SelectSingle<Row>;
+        where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
+        take(limit: number | undefined): SelectMultiple<Row>;
+        skip(offset: number | undefined): SelectMultiple<Row>;
+        [Expr.ToExpr](): Expr<Row>;
     }
-    class SelectSingle<T> extends Cursor<T> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+    class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
+        protected table: TableData;
+        [QUERY]: Query.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>): Cursor<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 Cursor<Row> {
+        [QUERY]: Query.Select;
+        constructor(query: Query.Select);
+        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<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectSingle<T>;
-        take(limit: number | undefined): SelectSingle<T>;
-        skip(offset: number | undefined): SelectSingle<T>;
-        all(): SelectMultiple<T>;
-        toExpr(): Expr<T>;
+        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>;
     }
 }
+export {};

package/dist/define/Cursor.js

@@ -1,96 +1,112 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
 // src/define/Cursor.ts
 import { Expr, ExprData } from "./Expr.js";
 import { Functions } from "./Functions.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Selection } from "./Selection.js";
+import { Table, createTable } from "./Table.js";
 import { Target } from "./Target.js";
-var Cursor = class {
-  [Selection.__cursorType]() {
-    throw "assert";
-  }
+var QUERY = Symbol("Cursor.Query");
+var _Cursor = class {
+  [(Selection.CursorType, QUERY)];
   constructor(query) {
-    Object.defineProperty(this, "query", {
-      enumerable: false,
-      value: () => query
-    });
+    this[QUERY] = query;
   }
   static all(strings, ...params) {
-    return new Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
+    return new _Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
   }
-  query() {
-    throw new Error("Not implemented");
+  next(cursor) {
+    return new _Cursor(
+      Query.Batch({
+        queries: [this[QUERY], cursor[QUERY]]
+      })
+    );
   }
   on(driver) {
-    return driver.executeQuery(this.query());
+    return driver.executeQuery(this[QUERY]);
+  }
+  toSql(driver, options = { forceInline: true }) {
+    return driver.formatter.compile(this[QUERY], options).sql;
   }
   toJSON() {
-    return this.query();
+    return this[QUERY];
   }
 };
+var Cursor = _Cursor;
+__publicField(Cursor, "Query", QUERY);
 function addWhere(query, where) {
   const conditions = where.slice();
   if (query.where)
-    conditions.push(query.where);
+    conditions.push(new Expr(query.where));
   return {
     ...query,
-    where: Expr.and(...conditions).expr
+    where: Expr.and(...conditions)[Expr.Data]
   };
 }
 ((Cursor2) => {
   class Delete extends Cursor2 {
     query() {
-      return super.query();
+      return super[QUERY];
     }
     where(...where) {
-      return new Delete(addWhere(this.query(), where));
+      return new Delete(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new Delete({ ...this.query(), limit });
+      return new Delete({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new Delete({ ...this.query(), offset });
+      return new Delete({ ...this[QUERY], offset });
     }
   }
   Cursor2.Delete = Delete;
-  class Update extends Cursor2 {
-    query() {
-      return super.query();
-    }
+  const _Update = class extends Cursor2 {
     set(set) {
-      return new Update({ ...this.query(), set });
+      return new _Update({ ...this[QUERY], set });
     }
     where(...where) {
-      return new Update(addWhere(this.query(), where));
+      return new _Update(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new Update({ ...this.query(), limit });
+      return new _Update({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new Update({ ...this.query(), offset });
+      return new _Update({ ...this[QUERY], offset });
     }
-  }
+  };
+  let Update = _Update;
+  QUERY;
   Cursor2.Update = Update;
   class InsertValuesReturning extends Cursor2 {
   }
   Cursor2.InsertValuesReturning = InsertValuesReturning;
-  class InsertValues extends Cursor2 {
-    query() {
-      return super.query();
+  class Inserted extends Cursor2 {
+    constructor(query) {
+      super(query);
     }
     returning(selection) {
       return new InsertValuesReturning(
-        Query.Insert({ ...this.query(), selection: ExprData.create(selection) })
+        Query.Insert({ ...this[QUERY], selection: ExprData.create(selection) })
       );
     }
   }
-  Cursor2.InsertValues = InsertValues;
+  QUERY;
+  Cursor2.Inserted = Inserted;
   class Insert {
     constructor(into) {
       this.into = into;
     }
+    selection(query) {
+      return new Inserted(Query.Insert({ into: this.into, select: query[QUERY] }));
+    }
     values(...data) {
-      return new InsertValues(Query.Insert({ into: this.into, data }));
+      return new Inserted(Query.Insert({ into: this.into, data }));
     }
   }
   Cursor2.Insert = Insert;
@@ -106,147 +122,213 @@ function addWhere(query, where) {
       super(Query.Batch({ queries }));
       this.queries = queries;
     }
+    next(cursor) {
+      return new Cursor2(
+        Query.Batch({
+          queries: [...this[QUERY].queries, cursor[QUERY]]
+        })
+      );
+    }
   }
+  QUERY;
   Cursor2.Batch = Batch;
+  function joinTarget(joinType, query, to, on) {
+    const toQuery = to instanceof Cursor2 ? to[QUERY] : void 0;
+    const target = toQuery ? toQuery.from : 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 Target.Join(
+      query.from,
+      target,
+      joinType,
+      Expr.and(...conditions)[Expr.Data]
+    );
+  }
   class SelectMultiple extends Cursor2 {
-    query() {
-      return super.query();
+    constructor(query) {
+      super(query);
     }
     leftJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectMultiple({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "left",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("left", query, that, on)
       });
     }
     innerJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectMultiple({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "inner",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("inner", query, that, on)
       });
     }
     select(selection) {
       return new SelectMultiple({
-        ...this.query(),
+        ...this[QUERY],
         selection: ExprData.create(selection)
       });
     }
     count() {
       return new SelectSingle({
-        ...this.query(),
-        selection: Functions.count().expr,
+        ...this[QUERY],
+        selection: Functions.count()[Expr.Data],
         singleResult: true
       });
     }
     orderBy(...orderBy) {
       return new SelectMultiple({
-        ...this.query(),
+        ...this[QUERY],
         orderBy: orderBy.map((e) => {
-          return e instanceof Expr ? e.asc() : e;
+          return Expr.isExpr(e) ? e.asc() : e;
         })
       });
     }
     groupBy(...groupBy) {
       return new SelectMultiple({
-        ...this.query(),
+        ...this[QUERY],
         groupBy: groupBy.map(ExprData.create)
       });
     }
     first() {
-      return new SelectSingle({ ...this.query(), singleResult: true });
+      return new SelectSingle({ ...this[QUERY], singleResult: true });
     }
     sure() {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         singleResult: true,
         validate: true
       });
     }
     where(...where) {
-      return new SelectMultiple(addWhere(this.query(), where));
+      return new SelectMultiple(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new SelectMultiple({ ...this.query(), limit });
+      return new SelectMultiple({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new SelectMultiple({ ...this.query(), offset });
+      return new SelectMultiple({ ...this[QUERY], offset });
     }
-    toExpr() {
-      return new Expr(ExprData.Query(this.query()));
+    [(QUERY, Expr.ToExpr)]() {
+      return new Expr(ExprData.Query(this[QUERY]));
     }
   }
   Cursor2.SelectMultiple = SelectMultiple;
+  class TableSelect extends SelectMultiple {
+    constructor(table, conditions = []) {
+      const target = Target.Table(table);
+      super(
+        Query.Select({
+          from: target,
+          selection: ExprData.Row(target),
+          where: Expr.and(...conditions)[Expr.Data]
+        })
+      );
+      this.table = table;
+    }
+    as(alias) {
+      return createTable({ ...this.table, alias });
+    }
+    create() {
+      return new Cursor2.CreateTable(this.table);
+    }
+    insertSelect(query) {
+      return new Cursor2.Inserted(
+        Query.Insert({ into: this.table, select: query[QUERY] })
+      );
+    }
+    insertOne(record) {
+      return new Cursor2(
+        Query.Insert({
+          into: this.table,
+          data: [record],
+          selection: ExprData.Row(Target.Table(this.table)),
+          singleResult: true
+        })
+      );
+    }
+    insertAll(data) {
+      return new Cursor2.Insert(this.table).values(...data);
+    }
+    set(data) {
+      return new Cursor2.Update(
+        Query.Update({
+          table: this.table,
+          where: this[QUERY].where
+        })
+      ).set(data);
+    }
+    delete() {
+      return new Cursor2.Delete(
+        Query.Delete({
+          table: this.table,
+          where: this[QUERY].where
+        })
+      );
+    }
+    get(name) {
+      return new Expr(
+        ExprData.Field(ExprData.Row(Target.Table(this.table)), name)
+      );
+    }
+  }
+  QUERY;
+  Cursor2.TableSelect = TableSelect;
   class SelectSingle extends Cursor2 {
-    query() {
-      return super.query();
+    constructor(query) {
+      super(query);
     }
     leftJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectSingle({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "left",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("left", query, that, on)
       });
     }
     innerJoin(that, ...on) {
-      const query = this.query();
+      const query = this[QUERY];
       return new SelectSingle({
         ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.schema()),
-          "inner",
-          Expr.and(...on).expr
-        )
+        from: joinTarget("inner", query, that, on)
       });
     }
     select(selection) {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         selection: ExprData.create(selection)
       });
     }
     orderBy(...orderBy) {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         orderBy
       });
     }
     groupBy(...groupBy) {
       return new SelectSingle({
-        ...this.query(),
+        ...this[QUERY],
         groupBy: groupBy.map(ExprData.create)
       });
     }
     where(...where) {
-      return new SelectSingle(addWhere(this.query(), where));
+      return new SelectSingle(addWhere(this[QUERY], where));
     }
     take(limit) {
-      return new SelectSingle({ ...this.query(), limit });
+      return new SelectSingle({ ...this[QUERY], limit });
     }
     skip(offset) {
-      return new SelectSingle({ ...this.query(), offset });
+      return new SelectSingle({ ...this[QUERY], offset });
     }
     all() {
-      return new SelectMultiple({ ...this.query(), singleResult: false });
+      return new SelectMultiple({ ...this[QUERY], singleResult: false });
     }
-    toExpr() {
-      return new Expr(ExprData.Query(this.query()));
+    [(QUERY, Expr.ToExpr)]() {
+      return new Expr(ExprData.Query(this[QUERY]));
     }
   }
   Cursor2.SelectSingle = SelectSingle;

package/dist/define/Expr.d.ts

@@ -1,10 +1,9 @@
 import { Fields } from './Fields.js';
 import { OrderBy } from './OrderBy.js';
 import { ParamData } from './Param.js';
-import { QueryData } from './Query.js';
+import { QueryData, Select, SelectFirst } from './Query.js';
 import { Selection } from './Selection.js';
 import { Target } from './Target.js';
-import { Select, SelectFirst } from './query/Select.js';
 export declare enum UnOpType {
     Not = "Not",
     IsNull = "IsNull"
@@ -161,6 +160,7 @@ export declare class Expr<T> {
     map<T, X extends Selection>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => X): Expr<Array<Selection.Infer<X>>>;
     sure(): Expr<NonNullable<T>>;
     get<T>(name: string): Expr<T>;
+    static [Symbol.hasInstance](instance: any): any;
 }
 export interface ObjectExpr {
     [Expr.Data]: ExprData;

package/dist/define/Expr.js

@@ -386,6 +386,9 @@ class Expr {
   get(name) {
     return new Expr(new ExprData.Field(this[Expr.Data], name));
   }
+  static [Symbol.hasInstance](instance) {
+    return instance?.[Expr.IsExpr];
+  }
 }
 ((Expr2) => {
   Expr2.Data = Symbol("Expr.Data");
@@ -419,7 +422,7 @@ class Expr {
   }
   Expr2.hasExpr = hasExpr;
   function isExpr(input) {
-    return input !== null && (typeof input === "object" || typeof input === "function") && input[Expr2.IsExpr];
+    return input instanceof Expr2;
   }
   Expr2.isExpr = isExpr;
 })(Expr || (Expr = {}));

package/dist/define/Ops.d.ts

@@ -1,11 +1,6 @@
+import { Batch, Delete, InsertInto, RecursiveUnion, Select, Update } from './Query.js';
 import { Selection } from './Selection.js';
 import { Table } from './Table.js';
-import { Batch } from './query/Batch.js';
-import { Delete } from './query/Delete.js';
-import { InsertInto } from './query/Insert.js';
-import { Select } from './query/Select.js';
-import { RecursiveUnion } from './query/Union.js';
-import { Update } from './query/Update.js';
 export declare function withRecursive<Row>(initialSelect: Select<Row>): RecursiveUnion<Row>;
 export declare function alias<T extends Table<{}>>(table: T): Record<string, T>;
 export declare function select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;