rado 0.4.6 → 0.4.8

package/dist/lib/Driver.js

@@ -307,8 +307,8 @@ class AsyncDriver extends DriverBase {
     }
   }
   async transaction(run) {
-    const id = `t${this.transactionId++}`;
     const [connection, release] = await this.isolate();
+    const id = `t${this.transactionId++}`;
     await connection.executeQuery(
       new QueryData.Transaction({ op: QueryData.TransactionOperation.Begin, id })
     );

package/dist/sqlite/SqliteFormatter.js

@@ -49,6 +49,7 @@ class SqliteFormatter extends Formatter {
         stmt.raw(" MATCH ");
         this.formatExprValue(ctx, query);
         return stmt;
+      case "bm25":
       case "highlight":
       case "snippet":
         stmt.identifier(expr.method);

package/dist/sqlite/SqliteFunctions.d.ts

@@ -13,6 +13,8 @@ export type SqliteFunctions = {
     exists(cursor: Query<any>): Expr<boolean>;
     /** Use the match operator for the FTS5 module */
     match(table: Table<any>, searchTerm: EV<string>): Expr<boolean>;
+    /** Returns a real value reflecting the accuracy of the current match */
+    bm25(table: Table<any>, ...weights: Array<EV<number>>): Expr<number>;
     /** The highlight() function returns a copy of the text from a specified column of the current row with extra markup text inserted to mark the start and end of phrase matches. */
     highlight(table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>): Expr<string>;
     /** The snippet() function is similar to highlight(), except that instead of returning entire column values, it automatically selects and extracts a short fragment of document text to process and return. */
@@ -157,7 +159,7 @@ export type SqliteFunctions = {
     julianday(timeValue: EV<any>, ...rest: Array<EV<string>>): Expr<string>;
     strftime(format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>): Expr<string>;
 };
-export declare const count: (x?: Expr<any>) => Expr<number>, iif: <T>(x: EV<boolean>, y: EV<T>, z: EV<T>) => Expr<T>, exists: (cursor: Query<any>) => Expr<boolean>, match: (table: Table<any>, searchTerm: EV<string>) => Expr<boolean>, highlight: (table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>) => Expr<string>, snippet: (table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>, snip: EV<string>, maxTokens: EV<number>) => Expr<string>, cast: {
+export declare const count: (x?: Expr<any>) => Expr<number>, iif: <T>(x: EV<boolean>, y: EV<T>, z: EV<T>) => Expr<T>, exists: (cursor: Query<any>) => Expr<boolean>, match: (table: Table<any>, searchTerm: EV<string>) => Expr<boolean>, bm25: (table: Table<any>, ...weights: Array<EV<number>>) => Expr<number>, highlight: (table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>) => Expr<string>, snippet: (table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>, snip: EV<string>, maxTokens: EV<number>) => Expr<string>, cast: {
     (x: EV<any>, type: 'text'): Expr<string>;
     (x: EV<any>, type: 'real'): Expr<number>;
     (x: EV<any>, type: 'integer'): Expr<number>;

package/dist/sqlite/SqliteFunctions.js

@@ -5,6 +5,7 @@ const {
   iif,
   exists,
   match,
+  bm25,
   highlight,
   snippet,
   cast,
@@ -84,6 +85,7 @@ export {
   atan2,
   atanh,
   avg,
+  bm25,
   cast,
   ceil,
   changes,

package/package.json

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

package/dist/define/CTE.d.ts

@@ -1,2 +0,0 @@
-import { Query, QueryData } from './Query';
-export declare function makeRecursiveUnion<T extends Query<any>>(initial: QueryData.Select, createUnion: (target: any) => T, operator: QueryData.UnionOperation): QueryData.Select;

package/dist/define/CTE.js

@@ -1,51 +0,0 @@
-// src/define/CTE.ts
-import { Expr, ExprData, ExprType } from "./Expr.js";
-import { Query, QueryData } from "./Query.js";
-import { virtualTable } from "./Table.js";
-import { Target, TargetType } from "./Target.js";
-var { keys, create, fromEntries } = Object;
-function columnsOf(expr) {
-  switch (expr.type) {
-    case ExprType.Record:
-      return keys(expr.fields);
-    case ExprType.Row:
-      switch (expr.target.type) {
-        case TargetType.Table:
-          return keys(expr.target.table.columns);
-        default:
-          throw new Error("Could not retrieve CTE columns");
-      }
-    default:
-      throw new Error("Could not retrieve CTE columns");
-  }
-}
-function makeRecursiveUnion(initial, createUnion, operator) {
-  let name;
-  const alias = new Proxy(create(null), {
-    get(_, key) {
-      name = key;
-      return virtualTable(name);
-    }
-  });
-  const right = createUnion(alias)[Query.Data];
-  if (!name)
-    throw new TypeError("No CTE name provided");
-  const cte = alias[name];
-  const cols = columnsOf(initial.selection);
-  const selection = new ExprData.Record(
-    fromEntries(cols.map((col) => [col, cte[col][Expr.Data]]))
-  );
-  const union = new QueryData.Union({
-    a: initial,
-    operator,
-    b: right
-  });
-  const from = new Target.CTE(name, union);
-  return new QueryData.Select({
-    selection,
-    from
-  });
-}
-export {
-  makeRecursiveUnion
-};

package/dist/define/Cursor.d.ts

@@ -1,108 +0,0 @@
-import { Driver } from '../lib/Driver';
-import { CompileOptions } from '../lib/Formatter';
-import { EV, Expr } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Selection } from './Selection';
-import { Table, TableData } from './Table';
-declare const QUERY: unique symbol;
-export declare class Cursor<T> {
-    [Selection.CursorType]: () => T;
-    [QUERY]: Query<T>;
-    static Query: typeof QUERY;
-    constructor(query: Query<T>);
-    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
-    next<T>(cursor: Cursor<T>): Cursor<T>;
-    on(driver: Driver.Sync): T;
-    on(driver: Driver.Async): Promise<T>;
-    toSql(driver: Driver, options?: CompileOptions): string;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Delete extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-        where(...where: Array<EV<boolean>>): Delete;
-        take(limit: number | undefined): Delete;
-        skip(offset: number | undefined): Delete;
-    }
-    class Update<Definition> extends Cursor<{
-        rowsAffected: number;
-    }> {
-        [QUERY]: Query.Update;
-        set(set: Table.Update<Definition>): Update<Definition>;
-        where(...where: Array<EV<boolean>>): Update<Definition>;
-        take(limit: number | undefined): Update<Definition>;
-        skip(offset: number | undefined): Update<Definition>;
-    }
-    class InsertValuesReturning<T> extends Cursor<T> {
-    }
-    class Inserted extends Cursor<{
-        rowsAffected: number;
-    }> {
-        [QUERY]: Query.Insert;
-        constructor(query: Query.Insert);
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<Definition> {
-        protected into: TableData;
-        constructor(into: TableData);
-        selection(query: Cursor.SelectMultiple<Table.Select<Definition>>): Inserted;
-        values(...data: Array<Table.Insert<Definition>>): Inserted;
-    }
-    class CreateTable extends Cursor<void> {
-        protected table: TableData;
-        constructor(table: TableData);
-    }
-    class Batch<T = void> extends Cursor<T> {
-        protected queries: Array<Query>;
-        [QUERY]: Query.Batch;
-        constructor(queries: Array<Query>);
-        next<T>(cursor: Cursor<T>): Cursor<T>;
-    }
-    class SelectMultiple<Row> extends Cursor<Array<Row>> {
-        [QUERY]: Query.Select;
-        constructor(query: Query.Select);
-        leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
-        innerJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
-        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-        count(): SelectSingle<number>;
-        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<Row>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<Row>;
-        first(): SelectSingle<Row | undefined>;
-        sure(): SelectSingle<Row>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
-        take(limit: number | undefined): SelectMultiple<Row>;
-        skip(offset: number | undefined): SelectMultiple<Row>;
-        [Expr.ToExpr](): Expr<Row>;
-    }
-    class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
-        protected table: TableData;
-        [QUERY]: Query.Select;
-        constructor(table: TableData, conditions?: Array<EV<boolean>>);
-        as(alias: string): Table<Definition>;
-        create(): CreateTable;
-        insertSelect(query: SelectMultiple<Table.Insert<Definition>>): Inserted;
-        insertOne(record: Table.Insert<Definition>): Cursor<Table.Select<Definition>>;
-        insertAll(data: Array<Table.Insert<Definition>>): Inserted;
-        set(data: Table.Update<Definition>): Update<Definition>;
-        delete(): Delete;
-        get(name: string): Expr<any>;
-    }
-    class SelectSingle<Row> extends Cursor<Row> {
-        [QUERY]: Query.Select;
-        constructor(query: Query.Select);
-        leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
-        innerJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
-        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-        orderBy(...orderBy: Array<OrderBy>): SelectSingle<Row>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<Row>;
-        where(...where: Array<EV<boolean>>): SelectSingle<Row>;
-        take(limit: number | undefined): SelectSingle<Row>;
-        skip(offset: number | undefined): SelectSingle<Row>;
-        all(): SelectMultiple<Row>;
-        [Expr.ToExpr](): Expr<Row>;
-    }
-}
-export {};

package/dist/define/Cursor.js

@@ -1,338 +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/define/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 { Table, createTable } from "./Table.js";
-import { Target } from "./Target.js";
-var QUERY = Symbol("Cursor.Query");
-var _Cursor = class {
-  [(Selection.CursorType, QUERY)];
-  constructor(query) {
-    this[QUERY] = query;
-  }
-  static all(strings, ...params) {
-    return new _Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
-  }
-  next(cursor) {
-    return new _Cursor(
-      Query.Batch({
-        queries: [this[QUERY], cursor[QUERY]]
-      })
-    );
-  }
-  on(driver) {
-    return driver.executeQuery(this[QUERY]);
-  }
-  toSql(driver, options = { forceInline: true }) {
-    return driver.formatter.compile(this[QUERY], options).sql;
-  }
-  toJSON() {
-    return this[QUERY];
-  }
-};
-var Cursor = _Cursor;
-__publicField(Cursor, "Query", QUERY);
-function addWhere(query, where) {
-  const conditions = where.slice();
-  if (query.where)
-    conditions.push(new Expr(query.where));
-  return {
-    ...query,
-    where: Expr.and(...conditions)[Expr.Data]
-  };
-}
-((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;
-  const _Update = class extends Cursor2 {
-    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 });
-    }
-  };
-  let Update = _Update;
-  QUERY;
-  Cursor2.Update = Update;
-  class InsertValuesReturning extends Cursor2 {
-  }
-  Cursor2.InsertValuesReturning = InsertValuesReturning;
-  class Inserted extends Cursor2 {
-    constructor(query) {
-      super(query);
-    }
-    returning(selection) {
-      return new InsertValuesReturning(
-        Query.Insert({ ...this[QUERY], selection: ExprData.create(selection) })
-      );
-    }
-  }
-  QUERY;
-  Cursor2.Inserted = Inserted;
-  class Insert {
-    constructor(into) {
-      this.into = into;
-    }
-    selection(query) {
-      return new Inserted(Query.Insert({ into: this.into, select: query[QUERY] }));
-    }
-    values(...data) {
-      return new Inserted(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;
-    }
-    next(cursor) {
-      return new Cursor2(
-        Query.Batch({
-          queries: [...this[QUERY].queries, cursor[QUERY]]
-        })
-      );
-    }
-  }
-  QUERY;
-  Cursor2.Batch = Batch;
-  function joinTarget(joinType, query, to, on) {
-    const toQuery = to instanceof Cursor2 ? to[QUERY] : void 0;
-    const target = toQuery ? toQuery.from : Target.Table(to[Table.Data]);
-    if (!query.from || !target)
-      throw new Error("No from clause");
-    const conditions = [...on];
-    if (toQuery) {
-      const where = toQuery.where;
-      if (where)
-        conditions.push(new Expr(where));
-    }
-    return Target.Join(
-      query.from,
-      target,
-      joinType,
-      Expr.and(...conditions)[Expr.Data]
-    );
-  }
-  class SelectMultiple extends Cursor2 {
-    constructor(query) {
-      super(query);
-    }
-    leftJoin(that, ...on) {
-      const query = this[QUERY];
-      return new SelectMultiple({
-        ...query,
-        from: joinTarget("left", query, that, on)
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this[QUERY];
-      return new SelectMultiple({
-        ...query,
-        from: joinTarget("inner", query, that, on)
-      });
-    }
-    select(selection) {
-      return new SelectMultiple({
-        ...this[QUERY],
-        selection: ExprData.create(selection)
-      });
-    }
-    count() {
-      return new SelectSingle({
-        ...this[QUERY],
-        selection: Functions.count()[Expr.Data],
-        singleResult: true
-      });
-    }
-    orderBy(...orderBy) {
-      return new SelectMultiple({
-        ...this[QUERY],
-        orderBy: orderBy.map((e) => {
-          return Expr.isExpr(e) ? 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 });
-    }
-    [(QUERY, Expr.ToExpr)]() {
-      return new Expr(ExprData.Query(this[QUERY]));
-    }
-  }
-  Cursor2.SelectMultiple = SelectMultiple;
-  class TableSelect extends SelectMultiple {
-    constructor(table, conditions = []) {
-      const target = Target.Table(table);
-      super(
-        Query.Select({
-          from: target,
-          selection: ExprData.Row(target),
-          where: Expr.and(...conditions)[Expr.Data]
-        })
-      );
-      this.table = table;
-    }
-    as(alias) {
-      return createTable({ ...this.table, alias });
-    }
-    create() {
-      return new Cursor2.CreateTable(this.table);
-    }
-    insertSelect(query) {
-      return new Cursor2.Inserted(
-        Query.Insert({ into: this.table, select: query[QUERY] })
-      );
-    }
-    insertOne(record) {
-      return new Cursor2(
-        Query.Insert({
-          into: this.table,
-          data: [record],
-          selection: ExprData.Row(Target.Table(this.table)),
-          singleResult: true
-        })
-      );
-    }
-    insertAll(data) {
-      return new Cursor2.Insert(this.table).values(...data);
-    }
-    set(data) {
-      return new Cursor2.Update(
-        Query.Update({
-          table: this.table,
-          where: this[QUERY].where
-        })
-      ).set(data);
-    }
-    delete() {
-      return new Cursor2.Delete(
-        Query.Delete({
-          table: this.table,
-          where: this[QUERY].where
-        })
-      );
-    }
-    get(name) {
-      return new Expr(
-        ExprData.Field(ExprData.Row(Target.Table(this.table)), name)
-      );
-    }
-  }
-  QUERY;
-  Cursor2.TableSelect = TableSelect;
-  class SelectSingle extends Cursor2 {
-    constructor(query) {
-      super(query);
-    }
-    leftJoin(that, ...on) {
-      const query = this[QUERY];
-      return new SelectSingle({
-        ...query,
-        from: joinTarget("left", query, that, on)
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this[QUERY];
-      return new SelectSingle({
-        ...query,
-        from: joinTarget("inner", query, that, on)
-      });
-    }
-    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 });
-    }
-    [(QUERY, Expr.ToExpr)]() {
-      return new Expr(ExprData.Query(this[QUERY]));
-    }
-  }
-  Cursor2.SelectSingle = SelectSingle;
-})(Cursor || (Cursor = {}));
-export {
-  Cursor
-};

package/dist/define/Update.d.ts

@@ -1,4 +0,0 @@
-import type { EV } from './Expr';
-export type Update<Row> = Partial<{
-    [K in keyof Row]: EV<Row[K]>;
-}>;

package/dist/define/query/Batch.d.ts

@@ -1,7 +0,0 @@
-import { Query, QueryData } from '../Query.js';
-export declare class Batch<T = void> extends Query<T> {
-    protected queries: Array<QueryData>;
-    [Query.Data]: QueryData.Batch;
-    constructor(queries: Array<QueryData>);
-    next<T>(cursor: Query<T>): Query<T>;
-}

package/dist/define/query/Batch.js

@@ -1,17 +0,0 @@
-import { Query, QueryData } from "../Query.js";
-class Batch extends Query {
-  constructor(queries) {
-    super(new QueryData.Batch({ queries }));
-    this.queries = queries;
-  }
-  next(cursor) {
-    return new Query(
-      new QueryData.Batch({
-        queries: [...this[Query.Data].queries, cursor[Query.Data]]
-      })
-    );
-  }
-}
-export {
-  Batch
-};

package/dist/define/query/CreateTable.d.ts

@@ -1,6 +0,0 @@
-import { Query } from '../Query.js';
-import { TableData } from '../Table.js';
-export declare class CreateTable extends Query<void> {
-    protected table: TableData;
-    constructor(table: TableData);
-}

package/dist/define/query/CreateTable.js

@@ -1,11 +0,0 @@
-import { Query } from "../Query.js";
-import { Schema } from "../Schema.js";
-class CreateTable extends Query {
-  constructor(table) {
-    super(Schema.create(table));
-    this.table = table;
-  }
-}
-export {
-  CreateTable
-};

package/dist/define/query/Delete.d.ts

@@ -1,11 +0,0 @@
-import { EV } from '../Expr.js';
-import { Query, QueryData } from '../Query.js';
-export declare class Delete extends Query<{
-    rowsAffected: number;
-}> {
-    [Query.Data]: QueryData.Delete;
-    constructor(query: QueryData.Delete);
-    where(...where: Array<EV<boolean>>): Delete;
-    take(limit: number | undefined): Delete;
-    skip(offset: number | undefined): Delete;
-}

package/dist/define/query/Delete.js

@@ -1,18 +0,0 @@
-import { Query } from "../Query.js";
-class Delete extends Query {
-  constructor(query) {
-    super(query);
-  }
-  where(...where) {
-    return new Delete(this.addWhere(where));
-  }
-  take(limit) {
-    return new Delete(this[Query.Data].with({ limit }));
-  }
-  skip(offset) {
-    return new Delete(this[Query.Data].with({ offset }));
-  }
-}
-export {
-  Delete
-};

package/dist/define/query/Insert.d.ts

@@ -1,22 +0,0 @@
-import { Query, QueryData } from '../Query.js';
-import { Selection } from '../Selection.js';
-import { Table, TableData } from '../Table.js';
-import { Select } from './Select.js';
-export declare class Insert<T = {
-    rowsAffected: number;
-}> extends Query<T> {
-    [Query.Data]: QueryData.Insert;
-    constructor(query: QueryData.Insert);
-    returning<X extends Selection>(selection: X): Insert<Array<Selection.Infer<X>>>;
-}
-export declare class InsertOne<T> extends Query<T> {
-    [Query.Data]: QueryData.Insert;
-    constructor(query: QueryData.Insert);
-    returning<X extends Selection>(selection: X): Insert<Selection.Infer<X>>;
-}
-export declare class InsertInto<Definition> {
-    protected into: TableData;
-    constructor(into: TableData);
-    selection(query: Select<Table.Select<Definition>>): Insert;
-    values(...data: Array<Table.Insert<Definition>>): Insert;
-}