rado 0.1.6 → 0.1.8

package/dist/Column.d.ts

@@ -1,5 +1,5 @@
 import { Expr, ExprData } from './Expr';
-export declare const enum ColumnType {
+export declare enum ColumnType {
     String = "String",
     Integer = "Integer",
     Number = "Number",

package/dist/Cursor.d.ts

@@ -57,7 +57,7 @@ export declare namespace Cursor {
         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>;
+        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
         groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
         first(): SelectSingle<T | undefined>;
         where(...where: Array<EV<boolean>>): SelectMultiple<T>;
@@ -71,6 +71,7 @@ export declare namespace Cursor {
         orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
         groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
         where(...where: Array<EV<boolean>>): SelectSingle<T>;
+        all(): SelectMultiple<T>;
         toExpr(): Expr<T>;
     }
 }

package/dist/Cursor.js

@@ -136,7 +136,9 @@ var Cursor = class {
     orderBy(...orderBy) {
       return new SelectMultiple({
         ...this.query(),
-        orderBy
+        orderBy: orderBy.map((e) => {
+          return e instanceof Expr ? e.asc() : e;
+        })
       });
     }
     groupBy(...groupBy) {
@@ -205,6 +207,9 @@ var Cursor = class {
     where(...where) {
       return new SelectSingle(super.where(...where).query());
     }
+    all() {
+      return new SelectMultiple({ ...this.query(), singleResult: false });
+    }
     toExpr() {
       return new Expr(ExprData.Query(this.query()));
     }

package/dist/Driver.d.ts

@@ -32,6 +32,7 @@ declare abstract class SyncDriver extends DriverBase {
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
     migrateSchema(...tables: Array<Table<any>>): unknown;
     executeQuery<T>(query: Query<T>): T;
+    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
     all<T>(cursor: Cursor<T>): Array<T>;
     all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
     get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
@@ -57,7 +58,8 @@ declare abstract class AsyncDriver extends DriverBase {
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
     executeQuery<T>(query: Query<T>): Promise<T>;
-    all<T>(cursor: Cursor<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor<T>): Promise<T>;
     all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
     get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
     get<T>(cursor: Cursor<T>): Promise<T>;

package/dist/Driver.js

@@ -33,6 +33,8 @@ var DriverBase = class extends Callable {
   }
   all(...args) {
     const [input, ...rest] = args;
+    if (input instanceof Cursor.SelectSingle)
+      return this.executeQuery(input.all().query());
     if (input instanceof Cursor)
       return this.executeQuery(input.query());
     return this.executeTemplate("rows", input, ...rest);

package/dist/Expr.d.ts

@@ -5,11 +5,11 @@ import { ParamData } from './Param';
 import { Query } from './Query';
 import { Selection } from './Selection';
 import { Target } from './Target';
-export declare const enum UnOp {
+export declare enum UnOp {
     Not = "Not",
     IsNull = "IsNull"
 }
-export declare const enum BinOp {
+export declare enum BinOp {
     Add = "Add",
     Subt = "Subt",
     Mult = "Mult",
@@ -30,7 +30,7 @@ export declare const enum BinOp {
     NotIn = "NotIn",
     Concat = "Concat"
 }
-export declare const enum ExprType {
+export declare enum ExprType {
     UnOp = "UnOp",
     BinOp = "BinOp",
     Field = "Field",

package/dist/Functions.d.ts

@@ -2,7 +2,6 @@ import { EV, Expr } from './Expr';
 export declare const Functions: Functions;
 /** These will have to be supported in every driver */
 export type Functions = {
-    arrayLength(x: EV<Array<any>>): Expr<number>;
     count(x?: Expr<any>): Expr<number>;
     iif<T>(x: EV<boolean>, y: EV<T>, z: EV<T>): Expr<T>;
 };

package/dist/OrderBy.d.ts

@@ -1,5 +1,5 @@
 import { ExprData } from './Expr';
-export declare const enum OrderDirection {
+export declare enum OrderDirection {
     Asc = "Asc",
     Desc = "Desc"
 }

package/dist/Param.d.ts

@@ -1,4 +1,4 @@
-export declare const enum ParamType {
+export declare enum ParamType {
     Value = "Value",
     Named = "Named"
 }

package/dist/Query.d.ts

@@ -3,7 +3,7 @@ import { ExprData } from './Expr';
 import { OrderBy } from './OrderBy';
 import { Index, Schema } from './Schema';
 import { Target } from './Target';
-export declare const enum QueryType {
+export declare enum QueryType {
     Insert = "Insert",
     Select = "Select",
     Update = "Update",

package/dist/Statement.d.ts

@@ -1,5 +1,5 @@
 import { Sanitizer } from './Sanitizer';
-declare const enum TokenType {
+declare enum TokenType {
     Raw = "Raw",
     Identifier = "Identifier",
     Value = "Value",

package/dist/Target.d.ts

@@ -1,6 +1,6 @@
 import { ExprData } from './Expr';
 import { Schema } from './Schema';
-export declare const enum TargetType {
+export declare enum TargetType {
     Each = "Each",
     Table = "Table",
     Join = "Join"

package/dist/sqlite/SqliteFormatter.d.ts

@@ -1,4 +1,5 @@
-import { Formatter } from '../Formatter';
+import { ExprData } from '../Expr';
+import { FormatContext, Formatter } from '../Formatter';
 import { Statement } from '../Statement';
 export declare class SqliteFormatter extends Formatter {
     escapeValue(value: any): string;
@@ -6,4 +7,5 @@ export declare class SqliteFormatter extends Formatter {
     escapeString(input: string): string;
     formatSqlAccess(on: Statement, field: string): Statement;
     formatJsonAccess(on: Statement, field: string): Statement;
+    formatExpr(expr: ExprData, ctx: FormatContext): Statement;
 }

package/dist/sqlite/SqliteFormatter.js

@@ -1,5 +1,8 @@
 // src/sqlite/SqliteFormatter.ts
+import { ExprType } from "../Expr.js";
 import { Formatter } from "../Formatter.js";
+import { identifier } from "../Statement.js";
+import { TargetType } from "../Target.js";
 function escapeWithin(input, outer) {
   let buf = outer;
   for (const char of input) {
@@ -37,6 +40,21 @@ var SqliteFormatter = class extends Formatter {
     const target = this.formatString(`$.${field}`);
     return on.raw("->").concat(target);
   }
+  formatExpr(expr, ctx) {
+    switch (expr.type) {
+      case ExprType.Call:
+        if (expr.method === "match") {
+          const [from, query] = expr.params;
+          if (from.type !== ExprType.Row)
+            throw new Error("not implemented");
+          if (from.target.type !== TargetType.Table)
+            throw new Error("not implemented");
+          return identifier(from.target.table.alias || from.target.table.name).raw(" match ").concat(this.formatExprValue(query, ctx));
+        }
+      default:
+        return super.formatExpr(expr, ctx);
+    }
+  }
 };
 export {
   SqliteFormatter

package/dist/sqlite/SqliteFunctions.d.ts

@@ -1,7 +1,9 @@
 import { EV, Expr } from '../Expr';
+import { Table } from '../Table';
 export declare const SqliteFunctions: SqliteFunctions;
 export type SqliteFunctions = {
-    arrayLength(x: EV<Array<any>>): Expr<number>;
+    /** Use the match operator for the FTS5 module */
+    match(table: Table<any>, searchTerm: EV<string>): Expr<boolean>;
     cast(x: EV<any>, type: 'text'): Expr<string>;
     cast(x: EV<any>, type: 'real'): Expr<number>;
     cast(x: EV<any>, type: 'integer'): Expr<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "license": "MIT",
   "type": "module",
   "exports": {