rado 0.1.63 → 0.1.64

package/dist/define/Cursor.js

@@ -117,6 +117,8 @@ function addWhere(query, where) {
     }
     leftJoin(that, ...on) {
       const query = this.query();
+      if (!query.from)
+        throw new Error("No from clause");
       return new SelectMultiple({
         ...query,
         from: Target.Join(
@@ -129,6 +131,8 @@ function addWhere(query, where) {
     }
     innerJoin(that, ...on) {
       const query = this.query();
+      if (!query.from)
+        throw new Error("No from clause");
       return new SelectMultiple({
         ...query,
         from: Target.Join(
@@ -196,6 +200,8 @@ function addWhere(query, where) {
     }
     leftJoin(that, ...on) {
       const query = this.query();
+      if (!query.from)
+        throw new Error("No from clause");
       return new SelectSingle({
         ...query,
         from: Target.Join(
@@ -208,6 +214,8 @@ function addWhere(query, where) {
     }
     innerJoin(that, ...on) {
       const query = this.query();
+      if (!query.from)
+        throw new Error("No from clause");
       return new SelectSingle({
         ...query,
         from: Target.Join(

package/dist/define/Expr.d.ts

@@ -139,27 +139,28 @@ export declare class Expr<T> {
     not(): Expr<boolean>;
     or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
     and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
+    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
+    isNot(that: EV<T>): 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>;
+    isIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isNotIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
+    isGreater(that: EV<any>): Expr<boolean>;
+    isGreaterOrEqual(that: EV<any>): Expr<boolean>;
+    isLess(that: EV<any>): Expr<boolean>;
+    isLessOrEqual(that: EV<any>): 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>;
+    includes<T>(this: Expr<Array<T>>, value: EV<T>): Expr<boolean>;
     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>>;

package/dist/define/Expr.js

@@ -151,7 +151,7 @@ var _Expr = class {
     return { expr: this.expr, order: OrderDirection.Desc };
   }
   not() {
-    return unop(this, "Not" /* Not */);
+    return new _Expr(ExprData.UnOp("Not" /* Not */, this.expr));
   }
   or(that) {
     const a = this.expr;
@@ -171,66 +171,72 @@ var _Expr = class {
       return new _Expr(b);
     return new _Expr(ExprData.BinOp("And" /* And */, a, b));
   }
+  is(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNull();
+    return new _Expr(ExprData.BinOp("Equals" /* Equals */, this.expr, toExpr(that)));
+  }
+  isNot(that) {
+    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
+      return this.isNotNull();
+    return new _Expr(
+      ExprData.BinOp("NotEquals" /* NotEquals */, this.expr, toExpr(that))
+    );
+  }
   isNull() {
-    return unop(this, "IsNull" /* IsNull */);
+    return new _Expr(ExprData.UnOp("IsNull" /* IsNull */, this.expr));
   }
   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);
+  isIn(that) {
+    return new _Expr(ExprData.BinOp("In" /* In */, this.expr, toExpr(that)));
   }
-  is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNull();
-    return binop(this, "Equals" /* Equals */, that);
+  isNotIn(that) {
+    return new _Expr(ExprData.BinOp("NotIn" /* NotIn */, this.expr, toExpr(that)));
+  }
+  isGreater(that) {
+    return new _Expr(ExprData.BinOp("Greater" /* Greater */, this.expr, toExpr(that)));
   }
-  in(that) {
-    return binop(this, "In" /* In */, that);
+  isGreaterOrEqual(that) {
+    return new _Expr(
+      ExprData.BinOp("GreaterOrEqual" /* GreaterOrEqual */, this.expr, toExpr(that))
+    );
   }
-  notIn(that) {
-    return binop(this, "NotIn" /* NotIn */, that);
+  isLess(that) {
+    return new _Expr(ExprData.BinOp("Less" /* Less */, this.expr, toExpr(that)));
+  }
+  isLessOrEqual(that) {
+    return new _Expr(
+      ExprData.BinOp("LessOrEqual" /* LessOrEqual */, this.expr, toExpr(that))
+    );
   }
   add(that) {
-    return binop(this, "Add" /* Add */, that);
+    return new _Expr(ExprData.BinOp("Add" /* Add */, this.expr, toExpr(that)));
   }
   substract(that) {
-    return binop(this, "Subt" /* Subt */, that);
+    return new _Expr(ExprData.BinOp("Subt" /* Subt */, this.expr, toExpr(that)));
   }
   multiply(that) {
-    return binop(this, "Mult" /* Mult */, that);
+    return new _Expr(ExprData.BinOp("Mult" /* Mult */, this.expr, toExpr(that)));
   }
   remainder(that) {
-    return binop(this, "Mod" /* Mod */, that);
+    return new _Expr(ExprData.BinOp("Mod" /* Mod */, this.expr, toExpr(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);
+    return new _Expr(ExprData.BinOp("Div" /* Div */, this.expr, toExpr(that)));
   }
   concat(that) {
-    return binop(this, "Concat" /* Concat */, that);
+    return new _Expr(ExprData.BinOp("Concat" /* Concat */, this.expr, toExpr(that)));
   }
   like(that) {
-    return binop(this, "Like" /* Like */, that);
+    return new _Expr(ExprData.BinOp("Like" /* Like */, this.expr, toExpr(that)));
   }
   glob(that) {
-    return binop(this, "Glob" /* Glob */, that);
+    return new _Expr(ExprData.BinOp("Glob" /* Glob */, this.expr, toExpr(that)));
   }
   match(that) {
-    return binop(this, "Match" /* Match */, that);
+    return new _Expr(ExprData.BinOp("Match" /* Match */, this.expr, toExpr(that)));
   }
   with(that) {
     return new _Expr(
@@ -240,6 +246,9 @@ var _Expr = class {
   at(index) {
     return this.get(`[${Number(index)}]`);
   }
+  includes(value) {
+    return _Expr.create(value).isIn(this);
+  }
   filter(fn) {
     const alias = `__${Math.random().toString(36).slice(2, 9)}`;
     const target = Target.Expr(this.expr, alias);
@@ -269,12 +278,6 @@ var _Expr = class {
 };
 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 {
   BinOpType,
   Expr,

package/dist/define/Ops.d.ts

@@ -1,5 +1,7 @@
 import { Cursor } from './Cursor';
+import { Selection } from './Selection';
 import { Table } from './Table';
+export declare function select<X extends Selection>(selection: X): Cursor.SelectMultiple<Selection.Infer<X>>;
 export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
 export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
 export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;

package/dist/define/Ops.js

@@ -4,6 +4,13 @@ import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
+function select(selection) {
+  return new Cursor.SelectMultiple(
+    Query.Select({
+      selection: ExprData.create(selection)
+    })
+  );
+}
 function from(source) {
   const target = "schema" in source ? Target.Table(source.schema()) : Target.Query(source.query());
   return new Cursor.SelectMultiple(
@@ -32,5 +39,6 @@ export {
   deleteFrom,
   from,
   insertInto,
+  select,
   update
 };

package/dist/define/Query.d.ts

@@ -40,7 +40,7 @@ export declare namespace Query {
     interface Select extends QueryBase {
         type: QueryType.Select;
         selection: ExprData;
-        from: Target;
+        from?: Target;
     }
     function Select(select: Omit<Select, 'type'>): Query.Select;
     interface Update extends QueryBase {

package/dist/lib/Formatter.js

@@ -83,8 +83,10 @@ var Formatter = class {
       query.selection,
       topLevel ? formatAsResultObject : void 0
     );
-    stmt.addLine("FROM").space();
-    this.formatTarget(ctx, query.from);
+    if (query.from) {
+      stmt.addLine("FROM").space();
+      this.formatTarget(ctx, query.from);
+    }
     this.formatWhere(ctx, query.where);
     this.formatGroupBy(ctx, query.groupBy);
     this.formatHaving(ctx, query.having);
@@ -321,8 +323,6 @@ var Formatter = class {
           throw new TypeError(`Expected boolean for column ${column.name}`);
         return stmt.raw(this.escapeValue(columnValue));
       case ColumnType.Json:
-        if (typeof columnValue !== "object")
-          throw new TypeError(`Expected object for column ${column.name}`);
         return stmt.value(JSON.stringify(columnValue));
     }
   }
@@ -390,12 +390,15 @@ var Formatter = class {
     return stmt;
   }
   formatLimit(ctx, { limit, offset, singleResult }) {
-    const { stmt } = ctx;
+    const { stmt, forceInline } = ctx;
     if (!limit && !offset && !singleResult)
       return stmt;
-    stmt.newline().raw("LIMIT").addValue(singleResult ? 1 : limit);
-    if (offset && offset > 0)
-      stmt.raw("OFFSET").addValue(offset);
+    stmt.newline().raw("LIMIT");
+    this.formatValue(ctx, singleResult ? 1 : limit);
+    if (offset && offset > 0) {
+      stmt.raw("OFFSET");
+      this.formatValue(ctx, offset);
+    }
     return stmt;
   }
   formatSelection(ctx, selection, formatSubject) {
@@ -441,7 +444,8 @@ var Formatter = class {
           case TargetType.Table:
             const column = expr.target.table.columns[field];
             const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
-            const asJson = column?.type === ColumnType.Json && ctx.formatAsJson;
+            const jsonColumn = column?.type === ColumnType.Json;
+            const asJson = jsonColumn && ctx.formatAsJson;
             if (asJson) {
               stmt.raw("json");
               stmt.openParenthesis();
@@ -456,6 +460,8 @@ var Formatter = class {
               stmt.add(`, 'true', 'false'))`);
             if (asJson)
               stmt.closeParenthesis();
+            if (jsonColumn && !asJson)
+              stmt.raw("->>'$'");
             return stmt;
         }
       default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",