rado 0.1.51 → 0.1.53

package/dist/Expr.d.ts

@@ -0,0 +1,149 @@
+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 enum UnOp {
+    Not = "Not",
+    IsNull = "IsNull"
+}
+export declare 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 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

@@ -0,0 +1,284 @@
+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.js";
+import { ParamData, ParamType } from "./Param.js";
+import { Target } from "./Target.js";
+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

@@ -0,0 +1,11 @@
+import { Column } from './Column';
+import { Expr } from './Expr';
+type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.Primary<infer K, infer V>] ? Expr<string extends K ? V : V & {
+    [Column.isPrimary]: K;
+}> : [T] extends [Column.Optional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [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

@@ -0,0 +1,55 @@
+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;
+    skipTableName?: boolean;
+    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;
+    formatCreateIndex(query: Query.CreateIndex, ctx?: FormatContext): Statement;
+    formatDropIndex(query: Query.DropIndex, ctx: FormatContext): Statement;
+    formatAlterTable(query: Query.AlterTable, 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;
+    formatContraintReference(reference: ExprData): 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;
+}