rado 0.1.23 → 0.1.24

package/dist/Cursor.d.ts

@@ -1,77 +0,0 @@
-import { EV, Expr } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Table } from './Table';
-import { Update as UpdateSet } from './Update';
-export declare class Cursor<T> {
-    /** @internal */
-    protected __cursorType: T;
-    constructor(query: Query<T>);
-    query(): Query<T>;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Limitable<T> extends Cursor<T> {
-        take(limit: number | undefined): Limitable<T>;
-        skip(offset: number | undefined): Limitable<T>;
-    }
-    class Filterable<T> extends Limitable<T> {
-        where(...where: Array<EV<boolean>>): Filterable<T>;
-    }
-    class Delete<T> extends Filterable<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-    }
-    class Update<T> extends Filterable<{
-        rowsAffected: number;
-    }> {
-        query: () => Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-    }
-    class InsertValuesReturning<T> extends Cursor<T> {
-    }
-    class InsertValues extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Insert;
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<T> {
-        protected into: Schema;
-        constructor(into: Schema);
-        values(...data: Array<Table.Insert<T>>): InsertValues;
-    }
-    class Create extends Cursor<void> {
-        protected table: Schema;
-        constructor(table: Schema);
-    }
-    class Batch<T = void> extends Cursor<T> {
-        protected queries: Array<Query>;
-        constructor(queries: Array<Query>);
-    }
-    class SelectMultiple<T> extends Filterable<Array<T>> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-        count(): SelectSingle<number>;
-        orderBy(...orderBy: Array<OrderBy>): SelectMultiple<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-    class SelectSingle<T> extends Filterable<T> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectSingle<T>;
-        toExpr(): Expr<T>;
-    }
-}

package/dist/Cursor.js

@@ -1,211 +0,0 @@
-// src/Cursor.ts
-import { Expr, ExprData } from "./Expr";
-import { Functions } from "./Functions";
-import { Query } from "./Query";
-import { Target } from "./Target";
-var Cursor = class {
-  constructor(query) {
-    Object.defineProperty(this, "query", {
-      enumerable: false,
-      value: () => query
-    });
-  }
-  query() {
-    throw new Error("Not implemented");
-  }
-  toJSON() {
-    return this.query();
-  }
-};
-((Cursor2) => {
-  class Limitable extends Cursor2 {
-    take(limit) {
-      return new Limitable({ ...this.query(), limit });
-    }
-    skip(offset) {
-      return new Limitable({ ...this.query(), offset });
-    }
-  }
-  Cursor2.Limitable = Limitable;
-  class Filterable extends Limitable {
-    where(...where) {
-      const condition = Expr.and(...where);
-      const query = this.query();
-      return new Filterable({
-        ...query,
-        where: (query.where ? condition.and(new Expr(query.where)) : condition).expr
-      });
-    }
-  }
-  Cursor2.Filterable = Filterable;
-  class Delete extends Filterable {
-    query() {
-      return super.query();
-    }
-  }
-  Cursor2.Delete = Delete;
-  class Update extends Filterable {
-    set(set) {
-      return new Update({ ...this.query(), set });
-    }
-  }
-  Cursor2.Update = Update;
-  class InsertValuesReturning extends Cursor2 {
-  }
-  Cursor2.InsertValuesReturning = InsertValuesReturning;
-  class InsertValues extends Cursor2 {
-    query() {
-      return super.query();
-    }
-    returning(selection) {
-      return new InsertValuesReturning(
-        Query.Insert({ ...this.query(), selection: ExprData.create(selection) })
-      );
-    }
-  }
-  Cursor2.InsertValues = InsertValues;
-  class Insert {
-    constructor(into) {
-      this.into = into;
-    }
-    values(...data) {
-      return new InsertValues(Query.Insert({ into: this.into, data }));
-    }
-  }
-  Cursor2.Insert = Insert;
-  class Create extends Cursor2 {
-    constructor(table) {
-      super(Query.CreateTable({ table, ifNotExists: true }));
-      this.table = table;
-    }
-  }
-  Cursor2.Create = Create;
-  class Batch extends Cursor2 {
-    constructor(queries) {
-      super(Query.Batch({ queries }));
-      this.queries = queries;
-    }
-  }
-  Cursor2.Batch = Batch;
-  class SelectMultiple extends Filterable {
-    query() {
-      return super.query();
-    }
-    leftJoin(that, ...on) {
-      const query = this.query();
-      return new SelectMultiple({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "left",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this.query();
-      return new SelectMultiple({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "inner",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    select(selection) {
-      return new SelectMultiple({
-        ...this.query(),
-        selection: ExprData.create(selection)
-      });
-    }
-    count() {
-      return new SelectSingle({
-        ...this.query(),
-        selection: Functions.count().expr,
-        singleResult: true
-      });
-    }
-    orderBy(...orderBy) {
-      return new SelectMultiple({
-        ...this.query(),
-        orderBy
-      });
-    }
-    groupBy(...groupBy) {
-      return new SelectMultiple({
-        ...this.query(),
-        groupBy: groupBy.map(ExprData.create)
-      });
-    }
-    first() {
-      return new SelectSingle({ ...this.query(), singleResult: true });
-    }
-    where(...where) {
-      return new SelectMultiple(super.where(...where).query());
-    }
-    toExpr() {
-      return new Expr(ExprData.Query(this.query()));
-    }
-  }
-  Cursor2.SelectMultiple = SelectMultiple;
-  class SelectSingle extends Filterable {
-    query() {
-      return super.query();
-    }
-    leftJoin(that, ...on) {
-      const query = this.query();
-      return new SelectSingle({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "left",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this.query();
-      return new SelectSingle({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "inner",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    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(super.where(...where).query());
-    }
-    toExpr() {
-      return new Expr(ExprData.Query(this.query()));
-    }
-  }
-  Cursor2.SelectSingle = SelectSingle;
-})(Cursor || (Cursor = {}));
-export {
-  Cursor
-};

package/dist/Driver.d.ts

@@ -1,72 +0,0 @@
-import { Cursor } from './Cursor';
-import { Formatter } from './Formatter';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
-declare abstract class DriverBase extends Callable {
-    formatter: Formatter;
-    constructor(formatter: Formatter);
-    all(strings: TemplateStringsArray, ...params: Array<any>): any;
-    get(strings: TemplateStringsArray, ...params: Array<any>): any;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
-}
-export declare namespace Driver {
-    export interface Sync {
-        <T>(query: Cursor<T>): T;
-        (strings: TemplateStringsArray, ...values: any[]): any;
-    }
-    export abstract class Sync extends DriverBase {
-        transactionId: number;
-        abstract rows(stmt: Statement.Compiled): Array<object>;
-        abstract values(stmt: Statement.Compiled): Array<Array<any>>;
-        abstract execute(stmt: Statement.Compiled): void;
-        abstract mutate(stmt: Statement.Compiled): {
-            rowsAffected: number;
-        };
-        abstract schema(tableName: string): Schema;
-        executeQuery<T>(query: Query<T>): T;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-        transaction<T>(run: (query: Sync) => T): T;
-        toAsync(): SyncWrapper;
-    }
-    export interface Async {
-        <T>(query: Cursor<T>): Promise<T>;
-        (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-    }
-    export abstract class Async extends DriverBase {
-        transactionId: number;
-        abstract isolate(): [connection: Async, release: () => Promise<void>];
-        abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
-        abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-        abstract execute(stmt: Statement.Compiled): Promise<void>;
-        abstract mutate(stmt: Statement.Compiled): Promise<{
-            rowsAffected: number;
-        }>;
-        abstract schema(tableName: string): Promise<Schema>;
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-        transaction<T>(run: (query: Async) => T): Promise<T>;
-    }
-    class SyncWrapper extends Async {
-        private sync;
-        lock: Promise<void> | undefined;
-        constructor(sync: Sync);
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        rows(stmt: Statement.Compiled): Promise<Array<object>>;
-        values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-        execute(stmt: Statement.Compiled): Promise<void>;
-        mutate(stmt: Statement.Compiled): Promise<{
-            rowsAffected: number;
-        }>;
-        schema(tableName: string): Promise<Schema>;
-        isolate(): [connection: Async, release: () => Promise<void>];
-    }
-    export {};
-}
-export {};

package/dist/Driver.js

@@ -1,145 +0,0 @@
-// src/Driver.ts
-import { Cursor } from "./Cursor";
-import { Query, QueryType } from "./Query";
-var Callable = class extends Function {
-  constructor(fn) {
-    super();
-    return new Proxy(this, {
-      apply(_, thisArg, input) {
-        return fn.apply(thisArg, input);
-      }
-    });
-  }
-};
-var DriverBase = class extends Callable {
-  constructor() {
-    super((...args) => {
-      const [input, ...rest] = args;
-      if (input instanceof Cursor)
-        return this.executeQuery(input.query());
-      return this.executeTemplate(void 0, input, ...rest);
-    });
-  }
-  all(strings, ...params) {
-    return this.executeTemplate("rows", strings, ...params);
-  }
-  get(strings, ...params) {
-    return this.executeTemplate("row", strings, ...params);
-  }
-  executeTemplate(expectedReturn, strings, ...params) {
-    if (strings.some((chunk) => chunk.includes("?")))
-      throw new TypeError("SQL injection hazard");
-    return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
-  }
-};
-var Driver;
-((Driver2) => {
-  class Sync extends DriverBase {
-    transactionId = 0;
-    executeQuery(query) {
-      switch (query.type) {
-        case QueryType.Batch:
-          let result;
-          const stmts = query.queries;
-          for (const query2 of stmts)
-            result = this.execute(query2);
-          return result;
-        default:
-          return this.execute(query);
-      }
-    }
-    all(strings, ...params) {
-      return super.all(strings, ...params);
-    }
-    get(strings, ...params) {
-      return super.get(strings, ...params);
-    }
-    transaction(run) {
-      const id = `t${this.transactionId++}`;
-      this.execute(
-        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
-      );
-      try {
-        const res = run(this);
-        this.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
-        );
-        return res;
-      } catch (e) {
-        this.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
-        );
-        throw e;
-      }
-    }
-    toAsync() {
-      return new SyncWrapper(this);
-    }
-  }
-  Driver2.Sync = Sync;
-  class Async extends DriverBase {
-    transactionId = 0;
-    async executeQuery(query) {
-      switch (query.type) {
-        case QueryType.Batch:
-          let result;
-          const stmts = query.queries;
-          for (const query2 of stmts)
-            result = await this.execute(query2);
-          return result;
-        default:
-          return this.execute(query);
-      }
-    }
-    all(strings, ...params) {
-      return super.all(strings, ...params);
-    }
-    get(strings, ...params) {
-      return super.get(strings, ...params);
-    }
-    async transaction(run) {
-      const id = `t${this.transactionId++}`;
-      const [connection, release] = this.isolate();
-      await connection.execute(
-        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
-      );
-      try {
-        const res = await run(connection);
-        await connection.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
-        );
-        return res;
-      } catch (e) {
-        await connection.execute(
-          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
-        );
-        throw e;
-      } finally {
-        await release();
-      }
-    }
-  }
-  Driver2.Async = Async;
-  class SyncWrapper extends Async {
-    constructor(sync) {
-      super();
-      this.sync = sync;
-    }
-    lock;
-    async execute(query) {
-      await this.lock;
-      return this.sync.execute(query);
-    }
-    isolate() {
-      const connection = new SyncWrapper(this.sync);
-      let release, trigger = new Promise((resolve) => {
-        release = async () => resolve();
-      });
-      this.lock = Promise.resolve(this.lock).then(() => trigger);
-      return [connection, release];
-    }
-  }
-})(Driver || (Driver = {}));
-export {
-  Driver
-};

package/dist/Expr.d.ts

@@ -1,149 +0,0 @@
-import { Cursor } from './Cursor';
-import { Fields } from './Fields';
-import { OrderBy } from './OrderBy';
-import { ParamData } from './Param';
-import { Query } from './Query';
-import { Selection } from './Selection';
-import { Target } from './Target';
-export declare const enum UnOp {
-    Not = "Not",
-    IsNull = "IsNull"
-}
-export declare const enum BinOp {
-    Add = "Add",
-    Subt = "Subt",
-    Mult = "Mult",
-    Mod = "Mod",
-    Div = "Div",
-    Greater = "Greater",
-    GreaterOrEqual = "GreaterOrEqual",
-    Less = "Less",
-    LessOrEqual = "LessOrEqual",
-    Equals = "Equals",
-    NotEquals = "NotEquals",
-    And = "And",
-    Or = "Or",
-    Like = "Like",
-    Glob = "Glob",
-    Match = "Match",
-    In = "In",
-    NotIn = "NotIn",
-    Concat = "Concat"
-}
-export declare const enum ExprType {
-    UnOp = "UnOp",
-    BinOp = "BinOp",
-    Field = "Field",
-    Param = "Param",
-    Call = "Call",
-    Query = "Query",
-    Record = "Record",
-    Row = "Row",
-    Map = "Map",
-    Filter = "Filter",
-    Merge = "Merge",
-    Case = "Case"
-}
-export type ExprData = {
-    type: ExprType.UnOp;
-    op: UnOp;
-    expr: ExprData;
-} | {
-    type: ExprType.BinOp;
-    op: BinOp;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Field;
-    expr: ExprData;
-    field: string;
-} | {
-    type: ExprType.Param;
-    param: ParamData;
-} | {
-    type: ExprType.Call;
-    method: string;
-    params: Array<ExprData>;
-} | {
-    type: ExprType.Query;
-    query: Query.Select;
-} | {
-    type: ExprType.Record;
-    fields: Record<string, ExprData>;
-} | {
-    type: ExprType.Merge;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Row;
-    target: Target;
-} | {
-    type: ExprType.Map;
-    target: Target;
-    result: ExprData;
-} | {
-    type: ExprType.Filter;
-    target: Target;
-    condition: ExprData;
-} | {
-    type: ExprType.Case;
-    expr: ExprData;
-    cases: Record<string, ExprData>;
-    defaultCase?: ExprData;
-};
-export declare const ExprData: {
-    UnOp(op: UnOp, expr: ExprData): ExprData;
-    BinOp(op: BinOp, a: ExprData, b: ExprData): ExprData;
-    Field(expr: ExprData, field: string): ExprData;
-    Param(param: ParamData): ExprData;
-    Call(method: string, params: Array<ExprData>): ExprData;
-    Query(query: Query.Select): ExprData;
-    Record(fields: Record<string, ExprData>): ExprData;
-    Merge(a: ExprData, b: ExprData): ExprData;
-    Row(target: Target): ExprData;
-    Map(target: Target, result: ExprData): ExprData;
-    Filter(target: Target, condition: ExprData): ExprData;
-    Case(expr: ExprData, cases: Record<string, ExprData>, defaultCase?: ExprData): ExprData;
-    create(input: any): ExprData;
-};
-/** Expression or value of type T */
-export type EV<T> = Expr<T> | T;
-export declare class Expr<T> {
-    expr: ExprData;
-    static NULL: ExprData;
-    static value<T>(value: T): Expr<T>;
-    static create<T>(input: EV<T>): Expr<T>;
-    static and(...conditions: Array<EV<boolean>>): Expr<boolean>;
-    static or(...conditions: Array<EV<boolean>>): Expr<boolean>;
-    constructor(expr: ExprData);
-    asc(): OrderBy;
-    desc(): OrderBy;
-    not(): Expr<boolean>;
-    or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    isNull(): Expr<boolean>;
-    isNotNull(): Expr<boolean>;
-    isNot(that: EV<T>): Expr<boolean>;
-    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
-    isIn(that: EV<Array<T>> | Cursor<T>): Expr<boolean>;
-    isNotIn(that: EV<Array<T>> | Cursor<T>): Expr<boolean>;
-    add(this: Expr<number>, that: EV<number>): Expr<number>;
-    substract(this: Expr<number>, that: EV<number>): Expr<number>;
-    multiply(this: Expr<number>, that: EV<number>): Expr<number>;
-    remainder(this: Expr<number>, that: EV<number>): Expr<number>;
-    divide(this: Expr<number>, that: EV<number>): Expr<number>;
-    greater(that: EV<any>): Expr<boolean>;
-    greaterOrEqual(that: EV<any>): Expr<boolean>;
-    less(that: EV<any>): Expr<boolean>;
-    lessOrEqual(that: EV<any>): Expr<boolean>;
-    concat(this: Expr<string>, that: EV<string>): Expr<string>;
-    like(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    match(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    with<X extends Selection>(that: X): Selection.With<T, X>;
-    at<T>(this: Expr<Array<T>>, index: number): Expr<T | null>;
-    filter<T>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => Expr<boolean>): Expr<Array<T>>;
-    map<T, X extends Selection>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => X): Expr<Array<Selection.Infer<X>>>;
-    sure(): Expr<NonNullable<T>>;
-    get<T>(name: string): Expr<T>;
-}