rado 0.3.1 → 0.3.2

package/dist/lib/Cursor.js

@@ -0,0 +1,256 @@
+// src/lib/Cursor.ts
+import { Expr, ExprData } from "./Expr.js";
+import { Functions } from "./Functions.js";
+import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
+import { Selection } from "./Selection.js";
+import { Target } from "./Target.js";
+var Cursor = class {
+  [Selection.__cursorType]() {
+    throw "assert";
+  }
+  constructor(query) {
+    Object.defineProperty(this, "query", {
+      enumerable: false,
+      value: () => query
+    });
+  }
+  static all(strings, ...params) {
+    return new Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
+  }
+  query() {
+    throw new Error("Not implemented");
+  }
+  on(driver) {
+    return driver.executeQuery(this.query());
+  }
+  toJSON() {
+    return this.query();
+  }
+};
+function addWhere(query, where) {
+  const conditions = where.slice();
+  if (query.where)
+    conditions.push(query.where);
+  return {
+    ...query,
+    where: Expr.and(...conditions).expr
+  };
+}
+((Cursor2) => {
+  class Delete extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    where(...where) {
+      return new Delete(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new Delete({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Delete({ ...this.query(), offset });
+    }
+  }
+  Cursor2.Delete = Delete;
+  class Update extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    set(set) {
+      return new Update({ ...this.query(), set });
+    }
+    where(...where) {
+      return new Update(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new Update({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Update({ ...this.query(), offset });
+    }
+  }
+  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 CreateTable extends Cursor2 {
+    constructor(table) {
+      super(Schema.create(table));
+      this.table = table;
+    }
+  }
+  Cursor2.CreateTable = CreateTable;
+  class Batch extends Cursor2 {
+    constructor(queries) {
+      super(Query.Batch({ queries }));
+      this.queries = queries;
+    }
+  }
+  Cursor2.Batch = Batch;
+  class SelectMultiple extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    leftJoin(that, ...on) {
+      const query = this.query();
+      return new SelectMultiple({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this.query();
+      return new SelectMultiple({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "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: orderBy.map((e) => {
+          return e instanceof Expr ? e.asc() : e;
+        })
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectMultiple({
+        ...this.query(),
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    first() {
+      return new SelectSingle({ ...this.query(), singleResult: true });
+    }
+    sure() {
+      return new SelectSingle({
+        ...this.query(),
+        singleResult: true,
+        validate: true
+      });
+    }
+    where(...where) {
+      return new SelectMultiple(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new SelectMultiple({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new SelectMultiple({ ...this.query(), offset });
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectMultiple = SelectMultiple;
+  class SelectSingle extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    leftJoin(that, ...on) {
+      const query = this.query();
+      return new SelectSingle({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this.query();
+      return new SelectSingle({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "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(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new SelectSingle({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new SelectSingle({ ...this.query(), offset });
+    }
+    all() {
+      return new SelectMultiple({ ...this.query(), singleResult: false });
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectSingle = SelectSingle;
+})(Cursor || (Cursor = {}));
+export {
+  Cursor
+};

package/dist/lib/Expr.d.ts

@@ -0,0 +1,154 @@
+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>;
+    in(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    notIn(that: EV<Array<T>> | Cursor.SelectMultiple<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>;
+}
+export declare namespace Expr {
+    type Record<T> = Expr<T> & {
+        [K in keyof T]: Expr<T[K]>;
+    };
+}

package/dist/lib/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/lib/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);
+  }
+  in(that) {
+    return binop(this, "In" /* In */, that);
+  }
+  notIn(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.Expr(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.Expr(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/lib/Fields.d.ts

@@ -0,0 +1,13 @@
+import { Column, PrimaryKey } from './Column';
+import { Expr } from './Expr';
+type ObjectUnion<T> = {
+    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
+};
+type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
+type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<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 : T extends object ? FieldsOf<T> : Field<T>;
+export {};