rado 0.3.1 → 0.3.3

package/dist/define/Query.js

@@ -1,5 +1,14 @@
-import { Expr } from "./Expr.js";
-const { assign } = Object;
+import { randomAlias } from "../util/Alias.js";
+import { Expr, ExprData, ExprType } from "./Expr.js";
+import { Functions } from "./Functions.js";
+import { Schema } from "./Schema.js";
+import { Table, createTable } from "./Table.js";
+import { Target, TargetType } from "./Target.js";
+import {
+  VirtualTable,
+  createVirtualTable
+} from "./VirtualTable.js";
+const { keys, assign, fromEntries } = Object;
 var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Insert"] = "QueryData.Insert";
   QueryType2["Select"] = "QueryData.Select";
@@ -33,30 +42,30 @@ var QueryData;
     UnionOperation2["Intersect"] = "Intersect";
     UnionOperation2["Except"] = "Except";
   })(UnionOperation = QueryData2.UnionOperation || (QueryData2.UnionOperation = {}));
-  class Union extends Data {
+  class Union2 extends Data {
     type = "QueryData.Union" /* Union */;
   }
-  QueryData2.Union = Union;
-  class Select extends Data {
+  QueryData2.Union = Union2;
+  class Select2 extends Data {
     type = "QueryData.Select" /* Select */;
   }
-  QueryData2.Select = Select;
-  class Insert extends Data {
+  QueryData2.Select = Select2;
+  class Insert2 extends Data {
     type = "QueryData.Insert" /* Insert */;
   }
-  QueryData2.Insert = Insert;
-  class Update extends Data {
+  QueryData2.Insert = Insert2;
+  class Update2 extends Data {
     type = "QueryData.Update" /* Update */;
   }
-  QueryData2.Update = Update;
-  class Delete extends Data {
+  QueryData2.Update = Update2;
+  class Delete2 extends Data {
     type = "QueryData.Delete" /* Delete */;
   }
-  QueryData2.Delete = Delete;
-  class CreateTable extends Data {
+  QueryData2.Delete = Delete2;
+  class CreateTable2 extends Data {
     type = "QueryData.CreateTable" /* CreateTable */;
   }
-  QueryData2.CreateTable = CreateTable;
+  QueryData2.CreateTable = CreateTable2;
   class AlterTable extends Data {
     type = "QueryData.AlterTable" /* AlterTable */;
   }
@@ -73,10 +82,10 @@ var QueryData;
     type = "QueryData.DropIndex" /* DropIndex */;
   }
   QueryData2.DropIndex = DropIndex;
-  class Batch extends Data {
+  class Batch2 extends Data {
     type = "QueryData.Batch" /* Batch */;
   }
-  QueryData2.Batch = Batch;
+  QueryData2.Batch = Batch2;
   let TransactionOperation;
   ((TransactionOperation2) => {
     TransactionOperation2["Begin"] = "Begin";
@@ -134,8 +143,454 @@ class Query {
   }
   Query2.isQuery = isQuery;
 })(Query || (Query = {}));
+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]]
+      })
+    );
+  }
+}
+class CreateTable extends Query {
+  constructor(table) {
+    super(Schema.create(table));
+    this.table = table;
+  }
+}
+class Delete extends Query {
+  constructor(query) {
+    super(query);
+  }
+  where(...where) {
+    return new Delete(this.addWhere(where));
+  }
+  orderBy(...orderBy) {
+    return new Delete(this[Query.Data].with({ orderBy }));
+  }
+  take(limit) {
+    return new Delete(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new Delete(this[Query.Data].with({ offset }));
+  }
+}
+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 }));
+  }
+}
+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]
+  );
+}
+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) {
+  const name = randomAlias();
+  const cols = columnsOf(initial.selection);
+  const union = new QueryData.Union({
+    a: initial,
+    operator,
+    b: () => createUnion()[Query.Data]
+  });
+  const target = new Target.CTE(name, union);
+  const row = new ExprData.Row(target);
+  const selection = new ExprData.Record(
+    fromEntries(cols.map((col) => [col, new ExprData.Field(row, col)]))
+  );
+  const select = (conditions) => {
+    const where = Expr.and(...conditions)[Expr.Data];
+    return new Select(
+      new QueryData.Select({
+        selection,
+        from: target,
+        where
+      })
+    );
+  };
+  const cte = createVirtualTable({
+    name,
+    target,
+    select
+  });
+  return cte;
+}
+class RecursiveUnion {
+  constructor(initialSelect) {
+    this.initialSelect = initialSelect;
+  }
+  union(create) {
+    return makeRecursiveUnion(
+      this.initialSelect,
+      create,
+      "Union" /* Union */
+    );
+  }
+  unionAll(create) {
+    return makeRecursiveUnion(
+      this.initialSelect,
+      create,
+      "UnionAll" /* UnionAll */
+    );
+  }
+}
+class Union extends Query {
+  constructor(query) {
+    super(query);
+  }
+  union(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: "Union" /* Union */,
+        b: query[Query.Data]
+      })
+    );
+  }
+  unionAll(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: "UnionAll" /* UnionAll */,
+        b: query[Query.Data]
+      })
+    );
+  }
+  except(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: "Except" /* Except */,
+        b: query[Query.Data]
+      })
+    );
+  }
+  intersect(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: "Intersect" /* Intersect */,
+        b: query[Query.Data]
+      })
+    );
+  }
+}
+class Select extends Union {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    const virtual = table[VirtualTable.Data];
+    return new Select(
+      this[Query.Data].with({ from: virtual?.target || new Target.Table(table) })
+    );
+  }
+  indexedBy(index) {
+    const from = this[Query.Data].from;
+    switch (from?.type) {
+      case TargetType.Table:
+        return new Select(
+          this[Query.Data].with({
+            from: new Target.Table(from.table, index)
+          })
+        );
+      default:
+        throw new Error("Cannot index by without table target");
+    }
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new Select(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new Select(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new Select(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  count() {
+    return new SelectFirst(
+      this[Query.Data].with({
+        selection: Functions.count()[Expr.Data],
+        singleResult: true
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new Select(
+      this[Query.Data].with({
+        orderBy: orderBy.map((e) => {
+          return Expr.isExpr(e) ? e.asc() : e;
+        })
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new Select(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  maybeFirst() {
+    return new SelectFirst(this[Query.Data].with({ singleResult: true }));
+  }
+  first() {
+    return new SelectFirst(
+      this[Query.Data].with({
+        singleResult: true,
+        validate: true
+      })
+    );
+  }
+  where(...where) {
+    return new Select(this.addWhere(where));
+  }
+  take(limit) {
+    return new Select(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new Select(this[Query.Data].with({ offset }));
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+}
+class SelectFirst extends Query {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    return new Select(this[Query.Data].with({ from: new Target.Table(table) }));
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectFirst(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectFirst(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new SelectFirst(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new SelectFirst(
+      this[Query.Data].with({
+        orderBy
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new SelectFirst(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  where(...where) {
+    return new SelectFirst(this.addWhere(where));
+  }
+  take(limit) {
+    return new SelectFirst(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new SelectFirst(this[Query.Data].with({ offset }));
+  }
+  all() {
+    return new Select(this[Query.Data].with({ singleResult: false }));
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+}
+class TableSelect extends Select {
+  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);
+  }
+  insert(input) {
+    if (input instanceof Select) {
+      return this.insertSelect(input);
+    } else if (Array.isArray(input)) {
+      return this.insertAll(input);
+    } else {
+      return this.insertOne(input);
+    }
+  }
+  insertSelect(query) {
+    return new Insert(
+      new QueryData.Insert({ into: this.table, select: query[Query.Data] })
+    );
+  }
+  insertOne(record) {
+    return new InsertOne(
+      new QueryData.Insert({
+        into: this.table,
+        data: [record],
+        selection: new ExprData.Row(new Target.Table(this.table)),
+        singleResult: true
+      })
+    );
+  }
+  insertAll(data) {
+    return new InsertInto(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)
+    );
+  }
+}
+class Update 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 {
+  Batch,
+  CreateTable,
+  Delete,
+  Insert,
+  InsertInto,
+  InsertOne,
   Query,
   QueryData,
-  QueryType
+  QueryType,
+  RecursiveUnion,
+  Select,
+  SelectFirst,
+  TableSelect,
+  Union,
+  Update
 };

package/dist/define/Selection.d.ts

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

package/dist/define/Table.d.ts

@@ -3,9 +3,8 @@ import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column.js';
 import { EV, Expr } from './Expr.js';
 import type { Fields } from './Fields.js';
 import { Index, IndexData } from './Index.js';
+import { SelectFirst, TableSelect } from './Query.js';
 import type { Selection } from './Selection.js';
-import { SelectFirst } from './query/Select.js';
-import { TableSelect } from './query/TableSelect.js';
 export declare class TableData {
     name: string;
     alias?: string;

package/dist/define/Table.js

@@ -3,8 +3,8 @@ import {
   ColumnType
 } from "./Column.js";
 import { BinOpType, Expr, ExprData } from "./Expr.js";
+import { TableSelect } from "./Query.js";
 import { Target } from "./Target.js";
-import { TableSelect } from "./query/TableSelect.js";
 const {
   assign,
   keys,

package/dist/define/VirtualTable.d.ts

@@ -2,10 +2,10 @@ import { Callable } from '../util/Callable.js';
 import { Column } from './Column.js';
 import { EV, Expr } from './Expr.js';
 import { Fields } from './Fields.js';
+import { Select } from './Query.js';
 import { Selection } from './Selection.js';
 import { Table } from './Table.js';
 import { Target } from './Target.js';
-import { Select } from './query/Select.js';
 export interface VirtualTableInstance<Definition> extends Callable {
     (conditions: {
         [K in keyof Definition]?: Definition[K] extends Expr<infer V> ? EV<V> : never;

package/dist/driver/bun-sqlite.js

@@ -1,5 +1,4 @@
-import { QueryData } from "../define/Query.js";
-import { SelectFirst } from "../define/query/Select.js";
+import { QueryData, SelectFirst } from "../define/Query.js";
 import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";

package/dist/index.d.ts

@@ -14,14 +14,6 @@ export * from './define/Sql.js';
 export * from './define/Table.js';
 export * from './define/Target.js';
 export * from './define/VirtualTable.js';
-export * from './define/query/Batch.js';
-export * from './define/query/CreateTable.js';
-export * from './define/query/Delete.js';
-export * from './define/query/Insert.js';
-export * from './define/query/Select.js';
-export * from './define/query/TableSelect.js';
-export * from './define/query/Union.js';
-export * from './define/query/Update.js';
 export type { Driver, DriverOptions } from './lib/Driver.js';
 export type { FormatContext, Formatter } from './lib/Formatter.js';
 export type { Sanitizer } from './lib/Sanitizer.js';

package/dist/index.js

@@ -11,12 +11,4 @@ export * from "./define/Sql.js";
 export * from "./define/Table.js";
 export * from "./define/Target.js";
 export * from "./define/VirtualTable.js";
-export * from "./define/query/Batch.js";
-export * from "./define/query/CreateTable.js";
-export * from "./define/query/Delete.js";
-export * from "./define/query/Insert.js";
-export * from "./define/query/Select.js";
-export * from "./define/query/TableSelect.js";
-export * from "./define/query/Union.js";
-export * from "./define/query/Update.js";
 export * from "./lib/SqlError.js";

package/dist/lib/Driver.d.ts

@@ -1,8 +1,7 @@
 import { Expr } from '../define/Expr.js';
-import { Query, QueryData } from '../define/Query.js';
+import { Query, QueryData, Select } from '../define/Query.js';
 import { SchemaInstructions } from '../define/Schema.js';
 import { Table } from '../define/Table.js';
-import { Select } from '../define/query/Select.js';
 import { Callable } from '../util/Callable.js';
 import { Formatter } from './Formatter.js';
 import { Statement } from './Statement.js';

package/dist/lib/Formatter.d.ts

@@ -62,7 +62,7 @@ export declare abstract class Formatter implements Sanitizer {
     formatBatch(ctx: FormatContext, { queries }: QueryData.Batch): Statement;
     formatRaw(ctx: FormatContext, { strings, params }: QueryData.Raw): Statement;
     formatColumn(ctx: FormatContext, column: ColumnData): Statement;
-    formatConstraintReference(ctx: FormatContext, reference: ExprData): Statement;
+    formatConstraintReference(ctx: FormatContext, { references, onDelete, onUpdate }: ColumnData): Statement;
     formatType(ctx: FormatContext, type: ColumnType): Statement;
     formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
     formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;

package/dist/lib/Formatter.js

@@ -1,4 +1,4 @@
-import { ColumnType } from "../define/Column.js";
+import { Action, ColumnType } from "../define/Column.js";
 import { BinOpType, Expr, ExprData, ExprType, UnOpType } from "../define/Expr.js";
 import { OrderDirection } from "../define/OrderBy.js";
 import { ParamType } from "../define/Param.js";
@@ -36,6 +36,13 @@ const unions = {
   [QueryData.UnionOperation.Intersect]: "INTERSECT",
   [QueryData.UnionOperation.Except]: "EXCEPT"
 };
+const actions = {
+  [Action.NoAction]: "NO ACTION",
+  [Action.Restrict]: "RESTRICT",
+  [Action.Cascade]: "CASCADE",
+  [Action.SetNull]: "SET NULL",
+  [Action.SetDefault]: "SET DEFAULT"
+};
 function formatAsResultObject(stmt, mkSubject) {
   stmt.raw("json_object('result', ");
   mkSubject();
@@ -318,15 +325,23 @@ class Formatter {
       }
     }
     if (column.references)
-      this.formatConstraintReference(ctx, column.references());
+      this.formatConstraintReference(ctx, column);
     return stmt;
   }
-  formatConstraintReference(ctx, reference) {
+  formatConstraintReference(ctx, { references, onDelete, onUpdate }) {
     const { stmt } = ctx;
+    if (!references)
+      return stmt;
+    const reference = references();
     if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
       throw new Error("not supported");
     const from = reference.expr.target;
-    return stmt.add("REFERENCES").addIdentifier(Target.source(from).name).openParenthesis().identifier(reference.field).closeParenthesis();
+    stmt.add("REFERENCES").addIdentifier(Target.source(from).name).openParenthesis().identifier(reference.field).closeParenthesis();
+    if (onDelete && actions[onDelete])
+      stmt.add("ON DELETE").add(actions[onDelete]);
+    if (onUpdate && actions[onUpdate])
+      stmt.add("ON UPDATE").add(actions[onUpdate]);
+    return stmt;
   }
   formatType(ctx, type) {
     const { stmt } = ctx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -1,7 +0,0 @@
-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>;
-}