rado 0.3.2 → 0.3.3

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,41 +0,0 @@
-import { EV, Expr } from '../Expr.js';
-import { IndexData } from '../Index.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>;
-    indexedBy(index: IndexData): Select<unknown>;
-    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,183 +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, TargetType } 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) })
-    );
-  }
-  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]));
-  }
-}
-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/lib/Column.d.ts

@@ -1,57 +0,0 @@
-import { EV, Expr, ExprData } from './Expr';
-export declare enum ColumnType {
-    String = "String",
-    Integer = "Integer",
-    Number = "Number",
-    Boolean = "Boolean",
-    Json = "Json"
-}
-interface PartialColumnData {
-    type: ColumnType;
-    name?: string;
-    nullable?: boolean;
-    defaultValue?: ExprData;
-    autoIncrement?: boolean;
-    primaryKey?: boolean;
-    unique?: boolean;
-    references?: ExprData;
-}
-export interface ColumnData extends PartialColumnData {
-    type: ColumnType;
-    name: string;
-}
-export declare class Column<T> {
-    data: PartialColumnData;
-    constructor(data: PartialColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): Column<Column.IsOptional<T>>;
-    primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
-    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
-    unique(): Column<T>;
-    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
-}
-export type PrimaryKey<T, K> = string extends K ? T : T & {
-    [Column.isPrimary]: K;
-};
-export declare namespace Column {
-    const isOptional: unique symbol;
-    type IsOptional<T> = {
-        [isOptional]: true;
-        __t: T;
-    };
-    const isPrimary: unique symbol;
-    type IsPrimary<T, K> = {
-        [isPrimary]: K;
-        __t: T;
-    };
-}
-export declare const column: {
-    string<T extends string = string>(): Column<T>;
-    integer<T_1 extends number = number>(): Column<T_1>;
-    number<T_2 extends number = number>(): Column<T_2>;
-    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
-    object<T_4 extends object = object>(): Column<T_4>;
-    array<T_5 = any>(): Column<T_5[]>;
-};
-export {};

package/dist/lib/Column.js

@@ -1,68 +0,0 @@
-// src/lib/Column.ts
-import { ExprData } from "./Expr.js";
-var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
-  ColumnType2["String"] = "String";
-  ColumnType2["Integer"] = "Integer";
-  ColumnType2["Number"] = "Number";
-  ColumnType2["Boolean"] = "Boolean";
-  ColumnType2["Json"] = "Json";
-  return ColumnType2;
-})(ColumnType || {});
-var Column = class {
-  constructor(data) {
-    this.data = data;
-  }
-  name(name) {
-    return new Column({ ...this.data, name });
-  }
-  nullable() {
-    return new Column({ ...this.data, nullable: true });
-  }
-  autoIncrement() {
-    return new Column({ ...this.data, autoIncrement: true });
-  }
-  primaryKey() {
-    return new Column({ ...this.data, primaryKey: true });
-  }
-  references(column2) {
-    return new Column({
-      ...this.data,
-      get references() {
-        return ExprData.create(typeof column2 === "function" ? column2() : column2);
-      }
-    });
-  }
-  unique() {
-    return new Column({ ...this.data, unique: true });
-  }
-  defaultValue(value) {
-    return new Column({ ...this.data, defaultValue: ExprData.create(value) });
-  }
-};
-((Column2) => {
-})(Column || (Column = {}));
-var column = {
-  string() {
-    return new Column({ type: "String" /* String */ });
-  },
-  integer() {
-    return new Column({ type: "Integer" /* Integer */ });
-  },
-  number() {
-    return new Column({ type: "Number" /* Number */ });
-  },
-  boolean() {
-    return new Column({ type: "Boolean" /* Boolean */ });
-  },
-  object() {
-    return new Column({ type: "Json" /* Json */ });
-  },
-  array() {
-    return new Column({ type: "Json" /* Json */ });
-  }
-};
-export {
-  Column,
-  ColumnType,
-  column
-};