rado 0.3.4 → 0.3.6

package/dist/define/query/Batch.js

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

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

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

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

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

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

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

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

@@ -1,39 +0,0 @@
-import { EV, Expr } from '../Expr.js';
-import { OrderBy } from '../OrderBy.js';
-import { Query, QueryData } from '../Query.js';
-import { Selection } from '../Selection.js';
-import { Table } from '../Table.js';
-import { VirtualTable } from '../VirtualTable.js';
-import { Union } from './Union.js';
-export declare class Select<Row> extends Union<Row> {
-    [Query.Data]: QueryData.Select;
-    constructor(query: QueryData.Select);
-    from(table: Table<any> | VirtualTable<any>): Select<Row>;
-    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
-    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
-    select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;
-    count(): SelectFirst<number>;
-    orderBy(...orderBy: Array<Expr<any> | OrderBy>): Select<Row>;
-    groupBy(...groupBy: Array<Expr<any>>): Select<Row>;
-    maybeFirst(): SelectFirst<Row | null>;
-    first(): SelectFirst<Row>;
-    where(...where: Array<EV<boolean>>): Select<Row>;
-    take(limit: number | undefined): Select<Row>;
-    skip(offset: number | undefined): Select<Row>;
-    [Expr.ToExpr](): Expr<Row>;
-}
-export declare class SelectFirst<Row> extends Query<Row> {
-    [Query.Data]: QueryData.Select;
-    constructor(query: QueryData.Select);
-    from(table: Table<any>): Select<Row>;
-    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
-    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
-    select<X extends Selection>(selection: X): SelectFirst<Selection.Infer<X>>;
-    orderBy(...orderBy: Array<OrderBy>): SelectFirst<Row>;
-    groupBy(...groupBy: Array<Expr<any>>): SelectFirst<Row>;
-    where(...where: Array<EV<boolean>>): SelectFirst<Row>;
-    take(limit: number | undefined): SelectFirst<Row>;
-    skip(offset: number | undefined): SelectFirst<Row>;
-    all(): Select<Row>;
-    [Expr.ToExpr](): Expr<Row>;
-}

package/dist/define/query/Select.js

@@ -1,170 +0,0 @@
-import { Expr, ExprData } from "../Expr.js";
-import { Functions } from "../Functions.js";
-import { Query } from "../Query.js";
-import { Table } from "../Table.js";
-import { Target } from "../Target.js";
-import { VirtualTable } from "../VirtualTable.js";
-import { Union } from "./Union.js";
-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]
-  );
-}
-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) })
-    );
-  }
-  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]));
-  }
-}
-export {
-  Select,
-  SelectFirst
-};

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

@@ -1,28 +0,0 @@
-import { EV, Expr } from '../Expr.js';
-import { Query, QueryData } from '../Query.js';
-import { Table, TableData } from '../Table.js';
-import { CreateTable } from './CreateTable.js';
-import { Delete } from './Delete.js';
-import { Insert, InsertOne } from './Insert.js';
-import { Select } from './Select.js';
-import { Update } from './Update.js';
-export declare class TableSelect<Definition> extends Select<Table.Select<Definition>> {
-    protected table: TableData;
-    [Query.Data]: QueryData.Select;
-    constructor(table: TableData, conditions?: Array<EV<boolean>>);
-    as(alias: string): Table<Definition>;
-    create(): CreateTable;
-    insert(query: Select<Table.Insert<Definition>>): Insert;
-    insert(rows: Array<Table.Insert<Definition>>): Insert;
-    insert(row: Table.Insert<Definition>): InsertOne<Table.Select<Definition>>;
-    insertSelect(query: Select<Table.Insert<Definition>>): Insert<{
-        rowsAffected: number;
-    }>;
-    insertOne(record: Table.Insert<Definition>): InsertOne<{ [K in keyof Definition as Definition[K] extends import("../Column.js").Column<any> ? K : never]: Definition[K] extends import("../Column.js").Column<infer T> ? T : never; }>;
-    insertAll(data: Array<Table.Insert<Definition>>): Insert<{
-        rowsAffected: number;
-    }>;
-    set(data: Table.Update<Definition>): Update<Definition>;
-    delete(): Delete;
-    get(name: string): Expr<any>;
-}

package/dist/define/query/TableSelect.js

@@ -1,79 +0,0 @@
-import { Expr, ExprData } from "../Expr.js";
-import { Query, QueryData } from "../Query.js";
-import { createTable } from "../Table.js";
-import { Target } from "../Target.js";
-import { CreateTable } from "./CreateTable.js";
-import { Delete } from "./Delete.js";
-import { Insert, InsertInto, InsertOne } from "./Insert.js";
-import { Select } from "./Select.js";
-import { Update } from "./Update.js";
-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)
-    );
-  }
-}
-export {
-  TableSelect
-};

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

@@ -1,17 +0,0 @@
-import { Query, QueryData } from '../Query.js';
-import { VirtualTable } from '../VirtualTable.js';
-import { Select } from './Select.js';
-export declare class RecursiveUnion<Row> {
-    initialSelect: QueryData.Select;
-    constructor(initialSelect: QueryData.Select);
-    union(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
-    unionAll(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
-}
-export declare class Union<Row> extends Query<Array<Row>> {
-    [Query.Data]: QueryData.Union | QueryData.Select;
-    constructor(query: QueryData.Union | QueryData.Select);
-    union(query: Select<Row> | Union<Row>): Union<Row>;
-    unionAll(query: Select<Row> | Union<Row>): Union<Row>;
-    except(query: Select<Row> | Union<Row>): Union<Row>;
-    intersect(query: Select<Row> | Union<Row>): Union<Row>;
-}

package/dist/define/query/Union.js

@@ -1,116 +0,0 @@
-import { randomAlias } from "../../util/Alias.js";
-import { Expr, ExprData, ExprType } from "../Expr.js";
-import { Query, QueryData } from "../Query.js";
-import { Target, TargetType } from "../Target.js";
-import { createVirtualTable } from "../VirtualTable.js";
-import { Select } from "./Select.js";
-const { 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) {
-  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(create2) {
-    return makeRecursiveUnion(
-      this.initialSelect,
-      create2,
-      QueryData.UnionOperation.Union
-    );
-  }
-  unionAll(create2) {
-    return makeRecursiveUnion(
-      this.initialSelect,
-      create2,
-      QueryData.UnionOperation.UnionAll
-    );
-  }
-}
-class Union extends Query {
-  constructor(query) {
-    super(query);
-  }
-  union(query) {
-    return new Union(
-      new QueryData.Union({
-        a: this[Query.Data],
-        operator: QueryData.UnionOperation.Union,
-        b: query[Query.Data]
-      })
-    );
-  }
-  unionAll(query) {
-    return new Union(
-      new QueryData.Union({
-        a: this[Query.Data],
-        operator: QueryData.UnionOperation.UnionAll,
-        b: query[Query.Data]
-      })
-    );
-  }
-  except(query) {
-    return new Union(
-      new QueryData.Union({
-        a: this[Query.Data],
-        operator: QueryData.UnionOperation.Except,
-        b: query[Query.Data]
-      })
-    );
-  }
-  intersect(query) {
-    return new Union(
-      new QueryData.Union({
-        a: this[Query.Data],
-        operator: QueryData.UnionOperation.Intersect,
-        b: query[Query.Data]
-      })
-    );
-  }
-}
-export {
-  RecursiveUnion,
-  Union
-};

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

@@ -1,12 +0,0 @@
-import { EV } from '../Expr.js';
-import { Query, QueryData } from '../Query.js';
-import { Table } from '../Table.js';
-export declare class Update<Definition> extends Query<{
-    rowsAffected: number;
-}> {
-    [Query.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>;
-}

package/dist/define/query/Update.js

@@ -1,18 +0,0 @@
-import { Query } from "../Query.js";
-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 {
-  Update
-};

package/dist/deno/driver/better-sqlite3.js

@@ -1,57 +0,0 @@
-// src/driver/better-sqlite3.ts
-import { Driver } from "../lib/Driver.ts";
-import { SqlError } from "../lib/SqlError.ts";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.ts";
-import { SqliteSchema } from "../sqlite/SqliteSchema.ts";
-var PreparedStatement = class {
-  constructor(stmt) {
-    this.stmt = stmt;
-  }
-  iterate(params = []) {
-    return this.stmt.iterate(...params);
-  }
-  all(params = []) {
-    return this.stmt.all(...params);
-  }
-  run(params = []) {
-    return { rowsAffected: this.stmt.run(...params).changes };
-  }
-  get(params = []) {
-    return this.stmt.get(...params);
-  }
-  execute(params = []) {
-    this.stmt.run(...params);
-  }
-};
-var BetterSqlite3Driver = class extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-  }
-  tableData;
-  indexData;
-  prepareStatement(stmt) {
-    try {
-      return new PreparedStatement(this.db.prepare(stmt.sql));
-    } catch (e) {
-      throw new SqlError(e, stmt.sql);
-    }
-  }
-  schemaInstructions(tableName) {
-    const columnData = this.tableData(tableName);
-    const indexData = this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
-  }
-  export() {
-    return this.db.serialize();
-  }
-};
-function connect(db) {
-  return new BetterSqlite3Driver(db);
-}
-export {
-  BetterSqlite3Driver,
-  connect
-};