rado 0.1.23 → 0.1.25

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>;
-}

package/dist/Expr.js

@@ -1,284 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-
-// src/Expr.ts
-import { OrderDirection } from "./OrderBy";
-import { ParamData, ParamType } from "./Param";
-import { Target } from "./Target";
-var UnOp = /* @__PURE__ */ ((UnOp2) => {
-  UnOp2["Not"] = "Not";
-  UnOp2["IsNull"] = "IsNull";
-  return UnOp2;
-})(UnOp || {});
-var BinOp = /* @__PURE__ */ ((BinOp2) => {
-  BinOp2["Add"] = "Add";
-  BinOp2["Subt"] = "Subt";
-  BinOp2["Mult"] = "Mult";
-  BinOp2["Mod"] = "Mod";
-  BinOp2["Div"] = "Div";
-  BinOp2["Greater"] = "Greater";
-  BinOp2["GreaterOrEqual"] = "GreaterOrEqual";
-  BinOp2["Less"] = "Less";
-  BinOp2["LessOrEqual"] = "LessOrEqual";
-  BinOp2["Equals"] = "Equals";
-  BinOp2["NotEquals"] = "NotEquals";
-  BinOp2["And"] = "And";
-  BinOp2["Or"] = "Or";
-  BinOp2["Like"] = "Like";
-  BinOp2["Glob"] = "Glob";
-  BinOp2["Match"] = "Match";
-  BinOp2["In"] = "In";
-  BinOp2["NotIn"] = "NotIn";
-  BinOp2["Concat"] = "Concat";
-  return BinOp2;
-})(BinOp || {});
-var ExprType = /* @__PURE__ */ ((ExprType2) => {
-  ExprType2["UnOp"] = "UnOp";
-  ExprType2["BinOp"] = "BinOp";
-  ExprType2["Field"] = "Field";
-  ExprType2["Param"] = "Param";
-  ExprType2["Call"] = "Call";
-  ExprType2["Query"] = "Query";
-  ExprType2["Record"] = "Record";
-  ExprType2["Row"] = "Row";
-  ExprType2["Map"] = "Map";
-  ExprType2["Filter"] = "Filter";
-  ExprType2["Merge"] = "Merge";
-  ExprType2["Case"] = "Case";
-  return ExprType2;
-})(ExprType || {});
-var ExprData = {
-  UnOp(op, expr) {
-    return { type: "UnOp" /* UnOp */, op, expr };
-  },
-  BinOp(op, a, b) {
-    return { type: "BinOp" /* BinOp */, op, a, b };
-  },
-  Field(expr, field) {
-    return { type: "Field" /* Field */, expr, field };
-  },
-  Param(param) {
-    return { type: "Param" /* Param */, param };
-  },
-  Call(method, params) {
-    return { type: "Call" /* Call */, method, params };
-  },
-  Query(query) {
-    return { type: "Query" /* Query */, query };
-  },
-  Record(fields) {
-    return { type: "Record" /* Record */, fields };
-  },
-  Merge(a, b) {
-    return { type: "Merge" /* Merge */, a, b };
-  },
-  Row(target) {
-    return { type: "Row" /* Row */, target };
-  },
-  Map(target, result) {
-    return { type: "Map" /* Map */, target, result };
-  },
-  Filter(target, condition) {
-    return { type: "Filter" /* Filter */, target, condition };
-  },
-  Case(expr, cases, defaultCase) {
-    return { type: "Case" /* Case */, expr, cases, defaultCase };
-  },
-  create(input) {
-    if (input === null || input === void 0)
-      return ExprData.Param(ParamData.Value(null));
-    if (input && typeof input === "object" && typeof input.toExpr === "function")
-      input = input.toExpr();
-    if (input instanceof Expr)
-      return input.expr;
-    if (input && typeof input === "object" && !Array.isArray(input))
-      return ExprData.Record(
-        Object.fromEntries(
-          Object.entries(input).map(([key, value]) => [
-            key,
-            ExprData.create(value)
-          ])
-        )
-      );
-    return ExprData.Param(ParamData.Value(input));
-  }
-};
-var toExpr = ExprData.create;
-function isConstant(e, value) {
-  switch (e.type) {
-    case "Param" /* Param */:
-      switch (e.param.type) {
-        case ParamType.Value:
-          return e.param.value == value;
-        default:
-          return false;
-      }
-    default:
-      return false;
-  }
-}
-var _Expr = class {
-  constructor(expr) {
-    this.expr = expr;
-    return new Proxy(this, {
-      get(target, key) {
-        return key in target ? target[key] : target.get(key);
-      }
-    });
-  }
-  static value(value) {
-    return new _Expr(ExprData.Param(ParamData.Value(value)));
-  }
-  static create(input) {
-    if (input instanceof _Expr)
-      return input;
-    return new _Expr(ExprData.create(input));
-  }
-  static and(...conditions) {
-    return conditions.map(_Expr.create).reduce((condition, expr) => condition.and(expr), _Expr.value(true));
-  }
-  static or(...conditions) {
-    return conditions.map(_Expr.create).reduce((condition, expr) => condition.or(expr), _Expr.value(false));
-  }
-  asc() {
-    return { expr: this.expr, order: OrderDirection.Asc };
-  }
-  desc() {
-    return { expr: this.expr, order: OrderDirection.Desc };
-  }
-  not() {
-    return unop(this, "Not" /* Not */);
-  }
-  or(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
-      return new _Expr(b);
-    if (isConstant(a, true) || isConstant(b, false))
-      return this;
-    return new _Expr(ExprData.BinOp("Or" /* Or */, a, b));
-  }
-  and(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
-      return this;
-    if (isConstant(a, true) || isConstant(b, false))
-      return new _Expr(b);
-    return new _Expr(ExprData.BinOp("And" /* And */, a, b));
-  }
-  isNull() {
-    return unop(this, "IsNull" /* IsNull */);
-  }
-  isNotNull() {
-    return this.isNull().not();
-  }
-  isNot(that) {
-    if (that == null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNotNull();
-    return binop(this, "NotEquals" /* NotEquals */, that);
-  }
-  is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNull();
-    return binop(this, "Equals" /* Equals */, that);
-  }
-  isIn(that) {
-    return binop(this, "In" /* In */, that);
-  }
-  isNotIn(that) {
-    return binop(this, "NotIn" /* NotIn */, that);
-  }
-  add(that) {
-    return binop(this, "Add" /* Add */, that);
-  }
-  substract(that) {
-    return binop(this, "Subt" /* Subt */, that);
-  }
-  multiply(that) {
-    return binop(this, "Mult" /* Mult */, that);
-  }
-  remainder(that) {
-    return binop(this, "Mod" /* Mod */, that);
-  }
-  divide(that) {
-    return binop(this, "Div" /* Div */, that);
-  }
-  greater(that) {
-    return binop(this, "Greater" /* Greater */, that);
-  }
-  greaterOrEqual(that) {
-    return binop(this, "GreaterOrEqual" /* GreaterOrEqual */, that);
-  }
-  less(that) {
-    return binop(this, "Less" /* Less */, that);
-  }
-  lessOrEqual(that) {
-    return binop(this, "LessOrEqual" /* LessOrEqual */, that);
-  }
-  concat(that) {
-    return binop(this, "Concat" /* Concat */, that);
-  }
-  like(that) {
-    return binop(this, "Like" /* Like */, that);
-  }
-  glob(that) {
-    return binop(this, "Glob" /* Glob */, that);
-  }
-  match(that) {
-    return binop(this, "Match" /* Match */, that);
-  }
-  with(that) {
-    return new _Expr(
-      ExprData.Merge(this.expr, ExprData.create(that))
-    );
-  }
-  at(index) {
-    return this.get(`[${Number(index)}]`);
-  }
-  filter(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Each(this.expr, alias);
-    return new _Expr(
-      ExprData.Filter(
-        target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
-      )
-    );
-  }
-  map(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Each(this.expr, alias);
-    return new _Expr(
-      ExprData.Map(
-        target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
-      )
-    );
-  }
-  sure() {
-    return this;
-  }
-  get(name) {
-    return new _Expr(ExprData.Field(this.expr, name));
-  }
-};
-var Expr = _Expr;
-__publicField(Expr, "NULL", toExpr(null));
-function unop(self, type) {
-  return new Expr(ExprData.UnOp(type, self.expr));
-}
-function binop(self, type, that) {
-  return new Expr(ExprData.BinOp(type, self.expr, toExpr(that)));
-}
-export {
-  BinOp,
-  Expr,
-  ExprData,
-  ExprType,
-  UnOp
-};

package/dist/Fields.d.ts

@@ -1,9 +0,0 @@
-import { Column } from './Column';
-import { Expr } from './Expr';
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.Optional & infer V] ? Field<V> : [T] extends [Record<string, any>] ? FieldsOf<T> : Expr<T>;
-type FieldsOf<Row> = Row extends Record<string, any> ? {
-    [K in keyof Row]-?: Field<Row[K]>;
-} : never;
-type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : Field<T>;
-export {};

package/dist/Formatter.d.ts

@@ -1,50 +0,0 @@
-import { ColumnData, ColumnType } from './Column';
-import { ExprData } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Sanitizer } from './Sanitizer';
-import { Statement } from './Statement';
-import { Target } from './Target';
-export interface FormatContext {
-    nameResult?: string;
-    formatAsJson?: boolean;
-    formatSubject?: (subject: Statement) => Statement;
-}
-export declare abstract class Formatter implements Sanitizer {
-    constructor();
-    abstract escapeValue(value: any): string;
-    abstract escapeIdentifier(ident: string): string;
-    abstract formatSqlAccess(on: Statement, field: string): Statement;
-    abstract formatJsonAccess(on: Statement, field: string): Statement;
-    formatAccess(on: Statement, field: string, formatAsJson?: boolean): Statement;
-    compile<T>(query: Query<T>, formatInline?: boolean): Statement.Compiled;
-    format<T>(query: Query<T>, ctx?: FormatContext): Statement;
-    formatSelect(query: Query.Select, ctx: FormatContext): Statement;
-    formatInsert(query: Query.Insert, ctx: FormatContext): Statement;
-    formatUpdate(query: Query.Update, ctx: FormatContext): Statement;
-    formatDelete(query: Query.Delete, ctx: FormatContext): Statement;
-    formatCreateTable(query: Query.CreateTable, ctx: FormatContext): Statement;
-    formatTransaction({ op, id }: Query.Transaction, ctx: FormatContext): Statement;
-    formatBatch(queries: Query[], ctx: FormatContext): Statement;
-    formatRaw({ strings, params }: Query.Raw, ctx: FormatContext): Statement;
-    formatColumn(column: ColumnData): Statement;
-    formatType(type: ColumnType): Statement;
-    formatInsertRow(columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
-    formatColumnValue(column: ColumnData, columnValue: any): Statement;
-    formatTarget(target: Target, ctx: FormatContext): Statement;
-    formatWhere(expr: ExprData | undefined, ctx: FormatContext): Statement | undefined;
-    formatHaving(expr: ExprData | undefined, ctx: FormatContext): Statement | undefined;
-    formatGroupBy(groupBy: Array<ExprData> | undefined, ctx: FormatContext): Statement | undefined;
-    formatOrderBy(orderBy: Array<OrderBy> | undefined, ctx: FormatContext): Statement | undefined;
-    formatLimit({ limit, offset, singleResult }: Query.QueryBase, ctx: FormatContext): Statement | undefined;
-    formatSelection(selection: ExprData, ctx: FormatContext): Statement;
-    formatExprValue(expr: ExprData, ctx: FormatContext): Statement;
-    formatIn(expr: ExprData, ctx: FormatContext): Statement;
-    formatUnwrapArray(stmt: Statement): Statement;
-    retrieveField(expr: ExprData, field: string): ExprData | undefined;
-    formatField(expr: ExprData, field: string, ctx: FormatContext): Statement;
-    formatString(input: string): Statement;
-    formatInlineValue(rawValue: any): Statement;
-    formatValue(rawValue: any, formatAsJson?: boolean): Statement;
-    formatExpr(expr: ExprData, ctx: FormatContext): Statement;
-}