rado 0.3.3 → 0.3.4

package/dist/define/Cursor.d.ts

@@ -0,0 +1,108 @@
+import { Driver } from '../lib/Driver';
+import { CompileOptions } from '../lib/Formatter';
+import { EV, Expr } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Query } from './Query';
+import { Selection } from './Selection';
+import { Table, TableData } from './Table';
+declare const QUERY: unique symbol;
+export declare class Cursor<T> {
+    [Selection.CursorType]: () => T;
+    [QUERY]: Query<T>;
+    static Query: typeof QUERY;
+    constructor(query: Query<T>);
+    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
+    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 {
+    class Delete extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Delete;
+        where(...where: Array<EV<boolean>>): Delete;
+        take(limit: number | undefined): Delete;
+        skip(offset: number | undefined): Delete;
+    }
+    class Update<Definition> extends Cursor<{
+        rowsAffected: number;
+    }> {
+        [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 Inserted extends Cursor<{
+        rowsAffected: number;
+    }> {
+        [QUERY]: Query.Insert;
+        constructor(query: Query.Insert);
+        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+    }
+    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: 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<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<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 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<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

@@ -0,0 +1,338 @@
+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 QUERY = Symbol("Cursor.Query");
+var _Cursor = class {
+  [(Selection.CursorType, QUERY)];
+  constructor(query) {
+    this[QUERY] = query;
+  }
+  static all(strings, ...params) {
+    return new _Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
+  }
+  next(cursor) {
+    return new _Cursor(
+      Query.Batch({
+        queries: [this[QUERY], cursor[QUERY]]
+      })
+    );
+  }
+  on(driver) {
+    return driver.executeQuery(this[QUERY]);
+  }
+  toSql(driver, options = { forceInline: true }) {
+    return driver.formatter.compile(this[QUERY], options).sql;
+  }
+  toJSON() {
+    return this[QUERY];
+  }
+};
+var Cursor = _Cursor;
+__publicField(Cursor, "Query", QUERY);
+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]
+  };
+}
+((Cursor2) => {
+  class Delete extends Cursor2 {
+    query() {
+      return super[QUERY];
+    }
+    where(...where) {
+      return new Delete(addWhere(this[QUERY], where));
+    }
+    take(limit) {
+      return new Delete({ ...this[QUERY], limit });
+    }
+    skip(offset) {
+      return new Delete({ ...this[QUERY], offset });
+    }
+  }
+  Cursor2.Delete = Delete;
+  const _Update = class extends Cursor2 {
+    set(set) {
+      return new _Update({ ...this[QUERY], set });
+    }
+    where(...where) {
+      return new _Update(addWhere(this[QUERY], where));
+    }
+    take(limit) {
+      return new _Update({ ...this[QUERY], limit });
+    }
+    skip(offset) {
+      return new _Update({ ...this[QUERY], offset });
+    }
+  };
+  let Update = _Update;
+  QUERY;
+  Cursor2.Update = Update;
+  class InsertValuesReturning extends Cursor2 {
+  }
+  Cursor2.InsertValuesReturning = InsertValuesReturning;
+  class Inserted extends Cursor2 {
+    constructor(query) {
+      super(query);
+    }
+    returning(selection) {
+      return new InsertValuesReturning(
+        Query.Insert({ ...this[QUERY], selection: ExprData.create(selection) })
+      );
+    }
+  }
+  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 Inserted(Query.Insert({ into: this.into, data }));
+    }
+  }
+  Cursor2.Insert = Insert;
+  class CreateTable extends Cursor2 {
+    constructor(table) {
+      super(Schema.create(table));
+      this.table = table;
+    }
+  }
+  Cursor2.CreateTable = CreateTable;
+  class Batch extends Cursor2 {
+    constructor(queries) {
+      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 {
+    constructor(query) {
+      super(query);
+    }
+    leftJoin(that, ...on) {
+      const query = this[QUERY];
+      return new SelectMultiple({
+        ...query,
+        from: joinTarget("left", query, that, on)
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this[QUERY];
+      return new SelectMultiple({
+        ...query,
+        from: joinTarget("inner", query, that, on)
+      });
+    }
+    select(selection) {
+      return new SelectMultiple({
+        ...this[QUERY],
+        selection: ExprData.create(selection)
+      });
+    }
+    count() {
+      return new SelectSingle({
+        ...this[QUERY],
+        selection: Functions.count()[Expr.Data],
+        singleResult: true
+      });
+    }
+    orderBy(...orderBy) {
+      return new SelectMultiple({
+        ...this[QUERY],
+        orderBy: orderBy.map((e) => {
+          return Expr.isExpr(e) ? e.asc() : e;
+        })
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectMultiple({
+        ...this[QUERY],
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    first() {
+      return new SelectSingle({ ...this[QUERY], singleResult: true });
+    }
+    sure() {
+      return new SelectSingle({
+        ...this[QUERY],
+        singleResult: true,
+        validate: true
+      });
+    }
+    where(...where) {
+      return new SelectMultiple(addWhere(this[QUERY], where));
+    }
+    take(limit) {
+      return new SelectMultiple({ ...this[QUERY], limit });
+    }
+    skip(offset) {
+      return new SelectMultiple({ ...this[QUERY], offset });
+    }
+    [(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 {
+    constructor(query) {
+      super(query);
+    }
+    leftJoin(that, ...on) {
+      const query = this[QUERY];
+      return new SelectSingle({
+        ...query,
+        from: joinTarget("left", query, that, on)
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this[QUERY];
+      return new SelectSingle({
+        ...query,
+        from: joinTarget("inner", query, that, on)
+      });
+    }
+    select(selection) {
+      return new SelectSingle({
+        ...this[QUERY],
+        selection: ExprData.create(selection)
+      });
+    }
+    orderBy(...orderBy) {
+      return new SelectSingle({
+        ...this[QUERY],
+        orderBy
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectSingle({
+        ...this[QUERY],
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    where(...where) {
+      return new SelectSingle(addWhere(this[QUERY], where));
+    }
+    take(limit) {
+      return new SelectSingle({ ...this[QUERY], limit });
+    }
+    skip(offset) {
+      return new SelectSingle({ ...this[QUERY], offset });
+    }
+    all() {
+      return new SelectMultiple({ ...this[QUERY], singleResult: false });
+    }
+    [(QUERY, Expr.ToExpr)]() {
+      return new Expr(ExprData.Query(this[QUERY]));
+    }
+  }
+  Cursor2.SelectSingle = SelectSingle;
+})(Cursor || (Cursor = {}));
+export {
+  Cursor
+};

package/dist/define/Table.d.ts

@@ -1,6 +1,6 @@
 import { Callable } from '../util/Callable.js';
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column.js';
-import { EV, Expr } from './Expr.js';
+import { EV, Expr, ExprData } from './Expr.js';
 import type { Fields } from './Fields.js';
 import { Index, IndexData } from './Index.js';
 import { SelectFirst, TableSelect } from './Query.js';
@@ -11,6 +11,7 @@ export declare class TableData {
     definition: {};
     columns: Record<string, ColumnData>;
     meta: () => {
+        primaryKey?: Array<ExprData>;
         indexes: Record<string, IndexData>;
     };
     constructor(data: TableData);
@@ -42,6 +43,7 @@ type UpdateOf<Definition> = Partial<{
 export declare namespace Table {
     export const Data: unique symbol;
     export const Indexes: unique symbol;
+    export const PrimaryKey: unique symbol;
     export type Of<Row> = TableOf<Row>;
     export type Select<Definition> = RowOf<Definition>;
     export type Update<Definition> = UpdateOf<Definition>;
@@ -64,8 +66,10 @@ export declare function createTable<Definition>(data: TableData): Table<Definiti
 export declare function table<T extends {}, Indexes extends Record<string, Index>>(define: {
     [key: string]: T | Define<T>;
     [Table.Indexes]?: (this: T) => Indexes;
+    [Table.PrimaryKey]?: (this: T) => Array<Column<any>>;
 }): {} extends Indexes ? Table<T> : IndexedTable<T, keyof Indexes>;
 export declare namespace table {
     const indexes: typeof Table.Indexes;
+    const primaryKey: typeof Table.PrimaryKey;
 }
 export {};

package/dist/define/Table.js

@@ -24,6 +24,7 @@ var Table;
 ((Table2) => {
   Table2.Data = Symbol("Table.Data");
   Table2.Indexes = Symbol("Table.Indexes");
+  Table2.PrimaryKey = Symbol("Table.PrimaryKey");
 })(Table || (Table = {}));
 function createTable(data) {
   const target = new Target.Table(data);
@@ -109,7 +110,10 @@ function table(define) {
       meta() {
         const createIndexes = define[Table.Indexes];
         const indexes = createIndexes ? createIndexes.apply(res) : {};
+        const createPrimaryKey = define[Table.PrimaryKey];
+        const primaryKey = createPrimaryKey ? createPrimaryKey.apply(res).map(ExprData.create) : void 0;
         return {
+          primaryKey,
           indexes: fromEntries(
             entries(indexes || {}).map(([key, index]) => {
               const indexName = `${name}.${key}`;
@@ -124,6 +128,7 @@ function table(define) {
 }
 ((table2) => {
   table2.indexes = Table.Indexes;
+  table2.primaryKey = Table.PrimaryKey;
 })(table || (table = {}));
 export {
   Table,

package/dist/define/Update.d.ts

@@ -0,0 +1,4 @@
+import type { EV } from './Expr';
+export type Update<Row> = Partial<{
+    [K in keyof Row]: EV<Row[K]>;
+}>;

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

@@ -0,0 +1,7 @@
+import { Query, QueryData } from '../Query.js';
+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,17 @@
+import { Query, QueryData } from "../Query.js";
+class Batch 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.js';
+import { TableData } from '../Table.js';
+export declare class CreateTable extends Query<void> {
+    protected table: TableData;
+    constructor(table: TableData);
+}

package/dist/define/query/CreateTable.js

@@ -0,0 +1,11 @@
+import { Query } from "../Query.js";
+import { Schema } from "../Schema.js";
+class CreateTable 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.js';
+import { Query, QueryData } from '../Query.js';
+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,18 @@
+import { Query } from "../Query.js";
+class Delete 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,22 @@
+import { Query, QueryData } from '../Query.js';
+import { Selection } from '../Selection.js';
+import { Table, TableData } from '../Table.js';
+import { Select } from './Select.js';
+export declare class Insert<T = {
+    rowsAffected: number;
+}> extends Query<T> {
+    [Query.Data]: QueryData.Insert;
+    constructor(query: QueryData.Insert);
+    returning<X extends Selection>(selection: X): Insert<Array<Selection.Infer<X>>>;
+}
+export declare class InsertOne<T> extends Query<T> {
+    [Query.Data]: QueryData.Insert;
+    constructor(query: QueryData.Insert);
+    returning<X extends Selection>(selection: X): Insert<Selection.Infer<X>>;
+}
+export declare class InsertInto<Definition> {
+    protected into: TableData;
+    constructor(into: TableData);
+    selection(query: Select<Table.Select<Definition>>): Insert;
+    values(...data: Array<Table.Insert<Definition>>): Insert;
+}

package/dist/define/query/Insert.js

@@ -0,0 +1,47 @@
+import { ExprData } from "../Expr.js";
+import { Query, QueryData } from "../Query.js";
+class Insert extends Query {
+  constructor(query) {
+    super(query);
+  }
+  returning(selection) {
+    return new Insert(
+      new QueryData.Insert({
+        ...this[Query.Data],
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+}
+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 Insert(
+      new QueryData.Insert({ into: this.into, select: query[Query.Data] })
+    );
+  }
+  values(...data) {
+    return new Insert(new QueryData.Insert({ into: this.into, data }));
+  }
+}
+export {
+  Insert,
+  InsertInto,
+  InsertOne
+};