rado 0.2.20 → 0.2.22

package/dist/define/Query.js

@@ -1,79 +1,426 @@
 // 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";
+var { assign } = Object;
+var DATA = Symbol("Query.Data");
 var QueryType = /* @__PURE__ */ ((QueryType2) => {
-  QueryType2["Insert"] = "Insert";
-  QueryType2["Select"] = "Select";
-  QueryType2["Update"] = "Update";
-  QueryType2["Delete"] = "Delete";
-  QueryType2["CreateTable"] = "CreateTable";
-  QueryType2["AlterTable"] = "AlterTable";
-  QueryType2["DropTable"] = "DropTable";
-  QueryType2["CreateIndex"] = "CreateIndex";
-  QueryType2["DropIndex"] = "DropIndex";
-  QueryType2["Batch"] = "Batch";
-  QueryType2["Transaction"] = "Transaction";
-  QueryType2["Raw"] = "Raw";
+  QueryType2["Insert"] = "QueryData.Insert";
+  QueryType2["Select"] = "QueryData.Select";
+  QueryType2["Update"] = "QueryData.Update";
+  QueryType2["Delete"] = "QueryData.Delete";
+  QueryType2["CreateTable"] = "QueryData.CreateTable";
+  QueryType2["AlterTable"] = "QueryData.AlterTable";
+  QueryType2["DropTable"] = "QueryData.DropTable";
+  QueryType2["CreateIndex"] = "QueryData.CreateIndex";
+  QueryType2["DropIndex"] = "QueryData.DropIndex";
+  QueryType2["Batch"] = "QueryData.Batch";
+  QueryType2["Transaction"] = "QueryData.Transaction";
+  QueryType2["Raw"] = "QueryData.Raw";
   return QueryType2;
 })(QueryType || {});
-var Query;
-((Query2) => {
-  function Insert(insert) {
-    return { type: "Insert" /* Insert */, ...insert };
+var QueryData;
+((QueryData2) => {
+  class Data {
+    constructor(data) {
+      assign(this, data);
+    }
   }
-  Query2.Insert = Insert;
-  function Select(select) {
-    return { type: "Select" /* Select */, ...select };
+  class Select extends Data {
+    type = "QueryData.Select" /* Select */;
   }
-  Query2.Select = Select;
-  function Update(update) {
-    return { type: "Update" /* Update */, ...update };
+  QueryData2.Select = Select;
+  class Insert extends Data {
+    type = "QueryData.Insert" /* Insert */;
   }
-  Query2.Update = Update;
-  function Delete(del) {
-    return { type: "Delete" /* Delete */, ...del };
+  QueryData2.Insert = Insert;
+  class Update extends Data {
+    type = "QueryData.Update" /* Update */;
   }
-  Query2.Delete = Delete;
-  function CreateTable(create) {
-    return { type: "CreateTable" /* CreateTable */, ...create };
+  QueryData2.Update = Update;
+  class Delete extends Data {
+    type = "QueryData.Delete" /* Delete */;
   }
-  Query2.CreateTable = CreateTable;
-  function AlterTable(alter) {
-    return { type: "AlterTable" /* AlterTable */, ...alter };
+  QueryData2.Delete = Delete;
+  class CreateTable extends Data {
+    type = "QueryData.CreateTable" /* CreateTable */;
   }
-  Query2.AlterTable = AlterTable;
-  function DropTable(drop) {
-    return { type: "DropTable" /* DropTable */, ...drop };
+  QueryData2.CreateTable = CreateTable;
+  class AlterTable extends Data {
+    type = "QueryData.AlterTable" /* AlterTable */;
   }
-  Query2.DropTable = DropTable;
-  function CreateIndex(create) {
-    return { type: "CreateIndex" /* CreateIndex */, ...create };
+  QueryData2.AlterTable = AlterTable;
+  class DropTable extends Data {
+    type = "QueryData.DropTable" /* DropTable */;
   }
-  Query2.CreateIndex = CreateIndex;
-  function DropIndex(drop) {
-    return { type: "DropIndex" /* DropIndex */, ...drop };
+  QueryData2.DropTable = DropTable;
+  class CreateIndex extends Data {
+    type = "QueryData.CreateIndex" /* CreateIndex */;
   }
-  Query2.DropIndex = DropIndex;
-  function Batch(batch) {
-    return { type: "Batch" /* Batch */, ...batch };
+  QueryData2.CreateIndex = CreateIndex;
+  class DropIndex extends Data {
+    type = "QueryData.DropIndex" /* DropIndex */;
   }
-  Query2.Batch = Batch;
+  QueryData2.DropIndex = DropIndex;
+  class Batch extends Data {
+    type = "QueryData.Batch" /* Batch */;
+  }
+  QueryData2.Batch = Batch;
   let TransactionOperation;
   ((TransactionOperation2) => {
     TransactionOperation2["Begin"] = "Begin";
     TransactionOperation2["Commit"] = "Commit";
     TransactionOperation2["Rollback"] = "Rollback";
-  })(TransactionOperation = Query2.TransactionOperation || (Query2.TransactionOperation = {}));
-  function Transaction(transaction) {
-    return { type: "Transaction" /* Transaction */, ...transaction };
+  })(TransactionOperation = QueryData2.TransactionOperation || (QueryData2.TransactionOperation = {}));
+  class Transaction extends Data {
+    type = "QueryData.Transaction" /* Transaction */;
+  }
+  QueryData2.Transaction = Transaction;
+  class Raw extends Data {
+    type = "QueryData.Raw" /* Raw */;
+    constructor(data) {
+      if (data.strings.some((chunk) => chunk.includes("?")))
+        throw new TypeError("SQL injection hazard");
+      super(data);
+    }
+  }
+  QueryData2.Raw = Raw;
+})(QueryData || (QueryData = {}));
+var Query = class {
+  [DATA];
+  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]]
+      })
+    );
+  }
+  on(driver) {
+    return driver.executeQuery(this[DATA]);
+  }
+  toSql(driver, options = { forceInline: true }) {
+    return driver.formatter.compile(this[DATA], options).sql;
+  }
+  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]
+    );
+  }
+  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.Transaction = Transaction;
-  function Raw(raw) {
-    if (raw.strings.some((chunk) => chunk.includes("?")))
-      throw new TypeError("SQL injection hazard");
-    return { type: "Raw" /* Raw */, ...raw };
+  Query2.isSingle = isSingle;
+  function isMultiple(input) {
+    return input instanceof Query2.SelectSingle;
   }
-  Query2.Raw = Raw;
+  Query2.isMultiple = isMultiple;
 })(Query || (Query = {}));
 export {
   Query,
+  QueryData,
   QueryType
 };

package/dist/define/Schema.d.ts

@@ -1,11 +1,12 @@
 import { Formatter } from '../lib/Formatter';
-import { Query } from './Query';
-import { TableData } from './Table';
+import { QueryData } from './Query';
+import { Table, TableData } from './Table';
 export interface SchemaInstructions {
     columns: Record<string, string>;
     indexes: Record<string, string>;
 }
 export declare namespace Schema {
-    function create(schema: TableData): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData): Array<Query>;
+    function create(schema: TableData): QueryData.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: TableData): Array<QueryData>;
 }
+export declare function schema(...tables: Array<Table<any>>): void;

package/dist/define/Schema.js

@@ -1,20 +1,20 @@
 // src/define/Schema.ts
 import { Statement } from "../lib/Statement.js";
 import { Expr, ExprData } from "./Expr.js";
-import { Query, QueryType } from "./Query.js";
+import { QueryData, QueryType } from "./Query.js";
 import { Target } from "./Target.js";
 var Schema;
 ((Schema2) => {
-  function create(schema) {
+  function create(schema2) {
     const queries = [];
-    queries.push(Query.CreateTable({ table: schema, ifNotExists: true }));
-    const meta = schema.meta();
+    queries.push(new QueryData.CreateTable({ table: schema2, ifNotExists: true }));
+    const meta = schema2.meta();
     if (meta.indexes)
       for (const index of Object.values(meta.indexes))
         queries.push(
-          Query.CreateIndex({ table: schema, index, ifNotExists: true })
+          new QueryData.CreateIndex({ table: schema2, index, ifNotExists: true })
         );
-    return Query.Batch({ queries });
+    return new QueryData.Batch({ queries });
   }
   Schema2.create = create;
   function removeLeadingWhitespace(str) {
@@ -23,48 +23,55 @@ var Schema;
   function recreateTable(table, addedColumns) {
     const queries = [];
     const tempTable = { ...table, name: `$$new_${table.name}` };
-    queries.push(Query.CreateTable({ table: tempTable }));
+    queries.push(new QueryData.CreateTable({ table: tempTable }));
     queries.push(
-      Query.Insert({
+      new QueryData.Insert({
         into: tempTable,
-        select: Query.Select({
-          from: Target.Table(table),
-          selection: ExprData.Record(
+        select: new QueryData.Select({
+          from: new Target.Table(table),
+          selection: new ExprData.Record(
             Object.fromEntries(
               Object.entries(table.columns).map(([key, column]) => [
                 key,
-                addedColumns.has(key) ? (typeof column.defaultValue === "function" ? column.defaultValue() : column.defaultValue) || Expr.NULL[Expr.Data] : ExprData.Field(ExprData.Row(Target.Table(table)), key)
+                addedColumns.has(key) ? (typeof column.defaultValue === "function" ? column.defaultValue() : column.defaultValue) || Expr.NULL[Expr.Data] : new ExprData.Field(
+                  new ExprData.Row(new Target.Table(table)),
+                  key
+                )
               ])
             )
           )
         })
       })
     );
-    queries.push(Query.DropTable({ table, ifExists: true }));
+    queries.push(new QueryData.DropTable({ table, ifExists: true }));
     queries.push(
-      Query.AlterTable({
+      new QueryData.AlterTable({
         table,
         renameTable: { from: tempTable.name }
       })
     );
     for (const index of Object.values(table.meta().indexes))
-      queries.push(Query.CreateIndex({ table, index }));
+      queries.push(new QueryData.CreateIndex({ table, index }));
     return queries;
   }
-  function upgrade(formatter, local, schema) {
+  function upgrade(formatter, local, schema2) {
     const columnNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.columns),
-      ...Object.keys(schema.columns)
+      ...Object.keys(schema2.columns)
     ]);
     const res = [];
     let recreate = false;
     for (const columnName of columnNames) {
       const localInstruction = local.columns[columnName];
-      const schemaCol = schema.columns[columnName];
+      const schemaCol = schema2.columns[columnName];
       if (!localInstruction) {
-        res.push(Query.AlterTable({ table: schema, addColumn: schemaCol }));
+        res.push(
+          new QueryData.AlterTable({ table: schema2, addColumn: schemaCol })
+        );
       } else if (!schemaCol) {
-        res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
+        res.push(
+          new QueryData.AlterTable({ table: schema2, dropColumn: columnName })
+        );
       } else {
         const { sql: instruction } = formatter.formatColumn(
           { stmt: new Statement(formatter) },
@@ -79,9 +86,9 @@ var Schema;
       const added = res.filter(
         (query) => query.type === QueryType.AlterTable && Boolean(query.addColumn)
       ).map((query) => query.addColumn.name);
-      return recreateTable(schema, new Set(added));
+      return recreateTable(schema2, new Set(added));
     }
-    const meta = schema.meta();
+    const meta = schema2.meta();
     const indexNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.indexes),
       ...Object.keys(meta.indexes)
@@ -90,16 +97,18 @@ var Schema;
       const localInstruction = local.indexes[indexName];
       const schemaIndex = meta.indexes[indexName];
       if (!localInstruction) {
-        res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+        res.push(new QueryData.CreateIndex({ table: schema2, index: schemaIndex }));
       } else if (!schemaIndex) {
-        res.unshift(Query.DropIndex({ table: schema, name: indexName }));
+        res.unshift(new QueryData.DropIndex({ table: schema2, name: indexName }));
       } else {
         const { sql: instruction } = formatter.compile(
-          Query.CreateIndex({ table: schema, index: schemaIndex })
+          new QueryData.CreateIndex({ table: schema2, index: schemaIndex })
         );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
-          res.unshift(Query.DropIndex({ table: schema, name: indexName }));
-          res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+          res.unshift(new QueryData.DropIndex({ table: schema2, name: indexName }));
+          res.push(
+            new QueryData.CreateIndex({ table: schema2, index: schemaIndex })
+          );
         }
       }
     }
@@ -107,6 +116,9 @@ var Schema;
   }
   Schema2.upgrade = upgrade;
 })(Schema || (Schema = {}));
+function schema(...tables) {
+}
 export {
-  Schema
+  Schema,
+  schema
 };

package/dist/define/Selection.d.ts

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

package/dist/define/Sql.d.ts

@@ -0,0 +1,6 @@
+import { Query } from './Query';
+export declare function sql<T>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
+export declare namespace sql {
+    function all<T>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
+    function get<T>(strings: TemplateStringsArray, ...params: Array<unknown>): Query<T>;
+}

package/dist/define/Sql.js

@@ -0,0 +1,22 @@
+// src/define/Sql.ts
+import { Query, QueryData } from "./Query.js";
+function sql(strings, ...params) {
+  return new Query(new QueryData.Raw({ strings, params }));
+}
+((sql2) => {
+  function all(strings, ...params) {
+    return new Query(
+      new QueryData.Raw({ strings, params, expectedReturn: "rows" })
+    );
+  }
+  sql2.all = all;
+  function get(strings, ...params) {
+    return new Query(
+      new QueryData.Raw({ strings, params, expectedReturn: "row" })
+    );
+  }
+  sql2.get = get;
+})(sql || (sql = {}));
+export {
+  sql
+};