rado 0.2.21 → 0.2.23

package/dist/lib/Formatter.js

@@ -3,7 +3,7 @@ import { ColumnType } from "../define/Column.js";
 import { BinOpType, Expr, ExprData, ExprType, UnOpType } from "../define/Expr.js";
 import { OrderDirection } from "../define/OrderBy.js";
 import { ParamType } from "../define/Param.js";
-import { Query, QueryType } from "../define/Query.js";
+import { QueryData, QueryType } from "../define/Query.js";
 import { Target, TargetType } from "../define/Target.js";
 import { Statement } from "./Statement.js";
 var binOps = {
@@ -225,11 +225,11 @@ var Formatter = class {
   formatTransaction(ctx, { op, id }) {
     const { stmt } = ctx;
     switch (op) {
-      case Query.TransactionOperation.Begin:
+      case QueryData.TransactionOperation.Begin:
         return stmt.raw("SAVEPOINT").addIdentifier(id);
-      case Query.TransactionOperation.Commit:
+      case QueryData.TransactionOperation.Commit:
         return stmt.raw("RELEASE").addIdentifier(id);
-      case Query.TransactionOperation.Rollback:
+      case QueryData.TransactionOperation.Rollback:
         return stmt.raw("ROLLBACK TO").addIdentifier(id);
     }
   }
@@ -446,57 +446,6 @@ var Formatter = class {
       stmt.add("AS").addIdentifier("result");
     return stmt;
   }
-  formatExprJson(ctx, expr) {
-    return this.formatExpr({ ...ctx, formatAsJson: true }, expr);
-  }
-  formatExprValue(ctx, expr) {
-    return this.formatExpr({ ...ctx, formatAsJson: false }, expr);
-  }
-  retrieveField(expr, field) {
-    switch (expr.type) {
-      case ExprType.Record:
-        return expr.fields[field];
-      case ExprType.Merge:
-        return this.retrieveField(expr.a, field) || this.retrieveField(expr.b, field);
-      default:
-        return void 0;
-    }
-  }
-  formatField(ctx, expr, field) {
-    const { stmt } = ctx;
-    const fieldExpr = this.retrieveField(expr, field);
-    if (fieldExpr)
-      return this.formatExpr(ctx, fieldExpr);
-    switch (expr.type) {
-      case ExprType.Row:
-        switch (expr.target.type) {
-          case TargetType.Table:
-            const column = expr.target.table.columns[field];
-            const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
-            const jsonColumn = column?.type === ColumnType.Json;
-            const asJson = jsonColumn && ctx.formatAsJson;
-            if (asJson) {
-              stmt.raw("json");
-              stmt.openParenthesis();
-            }
-            if (asBoolean)
-              stmt.add(`json(iif(`);
-            if (!ctx.skipTableName) {
-              stmt.identifier(expr.target.table.alias || expr.target.table.name).raw(".");
-            }
-            stmt.identifier(field);
-            if (asBoolean)
-              stmt.add(`, 'true', 'false'))`);
-            if (asJson)
-              stmt.closeParenthesis();
-            if (jsonColumn && !asJson)
-              stmt.raw("->>'$'");
-            return stmt;
-        }
-      default:
-        return this.formatAccess(ctx, () => this.formatExpr(ctx, expr), field);
-    }
-  }
   formatString(ctx, input) {
     const { stmt } = ctx;
     return stmt.raw(this.escapeValue(String(input)));
@@ -548,164 +497,248 @@ var Formatter = class {
         return stmt;
     }
   }
-  formatExpr({ formatAsIn, ...ctx }, expr) {
-    const { stmt } = ctx;
+  formatExprJson(ctx, expr) {
+    return this.formatExpr({ ...ctx, formatAsJson: true }, expr);
+  }
+  formatExprValue(ctx, expr) {
+    return this.formatExpr({ ...ctx, formatAsJson: false }, expr);
+  }
+  formatExpr(ctx, expr) {
     switch (expr.type) {
       case ExprType.UnOp:
-        switch (expr.op) {
-          case UnOpType.IsNull:
-            return this.formatExprValue(ctx, expr.expr).add("IS NULL");
-          case UnOpType.Not:
-            stmt.raw("NOT").openParenthesis();
-            this.formatExprValue(ctx, expr.expr);
-            return stmt.closeParenthesis();
-        }
+        return this.formatUnOp(ctx, expr);
       case ExprType.BinOp:
-        stmt.openParenthesis();
-        this.formatExprValue(ctx, expr.a).add(binOps[expr.op]).space();
-        const asIn = expr.op === BinOpType.In || expr.op === BinOpType.NotIn;
-        this.formatExprValue({ ...ctx, formatAsIn: asIn }, expr.b);
-        return stmt.closeParenthesis();
+        return this.formatBinOp(ctx, expr);
       case ExprType.Param:
-        switch (expr.param.type) {
-          case ParamType.Value:
-            return this.formatValue(ctx, expr.param.value);
-          case ParamType.Named:
-            return stmt.param(expr.param);
-        }
+        return this.formatParam(ctx, expr);
       case ExprType.Field:
-        if (formatAsIn) {
-          stmt.openParenthesis();
-          stmt.raw("SELECT value FROM json_each");
-          stmt.openParenthesis();
-          this.formatExprJson(ctx, expr);
-          stmt.closeParenthesis();
-          return stmt.closeParenthesis();
-        }
-        return this.formatField(ctx, expr.expr, expr.field);
-      case ExprType.Call: {
-        if (expr.method === "cast") {
-          const [e, type] = expr.params;
-          const typeName = type.type === ExprType.Param && type.param.type === ParamType.Value && type.param.value;
-          stmt.raw("cast").openParenthesis();
-          this.formatExprValue(ctx, e).add("as").space();
-          this.formatString(ctx, typeName);
-          return stmt.closeParenthesis();
-        } else if (expr.method === "exists") {
-          stmt.raw("exists").space();
-          return this.formatExprValue(ctx, expr.params[0]);
-        } else {
-          stmt.identifier(expr.method);
-          for (const param of stmt.call(expr.params))
-            this.formatExprValue(ctx, param);
-          return stmt;
-        }
-      }
+        return this.formatField(ctx, expr);
+      case ExprType.Call:
+        return this.formatCall(ctx, expr);
       case ExprType.Query:
-        if (!ctx.formatAsJson) {
-          stmt.openParenthesis();
-          this.format(ctx, expr.query);
-          return stmt.closeParenthesis();
-        }
-        if (expr.query.singleResult) {
-          stmt.openParenthesis();
-          this.format({ ...ctx, topLevel: true }, expr.query);
-          return stmt.closeParenthesis().raw(`->'$.result'`);
-        }
-        stmt.openParenthesis().raw(`SELECT json_group_array(result->'$.result')`).newline().raw("FROM").space().openParenthesis();
-        this.format({ ...ctx, topLevel: true }, expr.query);
-        return stmt.closeParenthesis().closeParenthesis();
+        return this.formatQuery(ctx, expr);
       case ExprType.Row:
-        switch (expr.target.type) {
-          case TargetType.Table:
-            const table = Target.source(expr.target);
-            if (!table)
-              throw new Error(`Cannot select empty target`);
-            if (ctx.tableAsExpr)
-              return stmt.identifier(table.alias || table.name);
-            stmt.identifier("json_object");
-            for (const [key, column] of stmt.call(
-              Object.entries(table.columns)
-            )) {
-              this.formatString(ctx, key).raw(", ");
-              this.formatField(ctx, expr, column.name);
-            }
-            return stmt;
-          case TargetType.Query:
-          case TargetType.Expr:
-            return stmt.identifier(expr.target.alias).raw(".value");
-          default:
-            throw new Error(`Cannot select from ${expr.target.type}`);
-        }
+        return this.formatRow(ctx, expr);
       case ExprType.Merge:
-        stmt.identifier("json_patch").openParenthesis();
-        this.formatExpr({ ...ctx, formatAsJson: true }, expr.a);
-        stmt.raw(", ");
-        this.formatExpr({ ...ctx, formatAsJson: true }, expr.b);
+        return this.formatMerge(ctx, expr);
+      case ExprType.Record:
+        return this.formatRecord(ctx, expr);
+      case ExprType.Filter:
+        return this.formatFilter(ctx, expr);
+      case ExprType.Map:
+        return this.formatMap(ctx, expr);
+    }
+  }
+  formatUnOp(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.op) {
+      case UnOpType.IsNull:
+        return this.formatExprValue(ctx, expr.expr).add("IS NULL");
+      case UnOpType.Not:
+        stmt.raw("NOT").openParenthesis();
+        this.formatExprValue(ctx, expr.expr);
         return stmt.closeParenthesis();
+    }
+  }
+  formatBinOp(ctx, expr) {
+    const { stmt } = ctx;
+    stmt.openParenthesis();
+    this.formatExprValue(ctx, expr.a).add(binOps[expr.op]).space();
+    const asIn = expr.op === BinOpType.In || expr.op === BinOpType.NotIn;
+    this.formatExprValue({ ...ctx, formatAsIn: asIn }, expr.b);
+    return stmt.closeParenthesis();
+  }
+  formatParam(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.param.type) {
+      case ParamType.Value:
+        return this.formatValue(ctx, expr.param.value);
+      case ParamType.Named:
+        return stmt.param(expr.param);
+    }
+  }
+  retrieveField(expr, field) {
+    switch (expr.type) {
       case ExprType.Record:
-        if (ctx.selectAsColumns) {
-          const inner = { ...ctx, selectAsColumns: false };
-          for (const [key, value] of stmt.separate(
-            Object.entries(expr.fields)
-          )) {
-            this.formatExprJson(inner, value);
-          }
-          return stmt;
+        return expr.fields[field];
+      case ExprType.Merge:
+        return this.retrieveField(expr.a, field) || this.retrieveField(expr.b, field);
+      default:
+        return void 0;
+    }
+  }
+  formatFieldOf(ctx, from, field) {
+    const { stmt } = ctx;
+    const fieldExpr = this.retrieveField(from, field);
+    if (fieldExpr)
+      return this.formatExpr(ctx, fieldExpr);
+    switch (from.type) {
+      case ExprType.Row:
+        switch (from.target.type) {
+          case TargetType.Table:
+            const column = from.target.table.columns[field];
+            const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
+            const jsonColumn = column?.type === ColumnType.Json;
+            const asJson = jsonColumn && ctx.formatAsJson;
+            if (asJson) {
+              stmt.raw("json");
+              stmt.openParenthesis();
+            }
+            if (asBoolean)
+              stmt.add(`json(iif(`);
+            if (!ctx.skipTableName) {
+              stmt.identifier(from.target.table.alias || from.target.table.name).raw(".");
+            }
+            stmt.identifier(field);
+            if (asBoolean)
+              stmt.add(`, 'true', 'false'))`);
+            if (asJson)
+              stmt.closeParenthesis();
+            if (jsonColumn && !asJson)
+              stmt.raw("->>'$'");
+            return stmt;
         }
-        stmt.identifier("json_object").openParenthesis();
-        for (const [key, value] of stmt.separate(Object.entries(expr.fields))) {
+      default:
+        return this.formatAccess(ctx, () => this.formatExpr(ctx, from), field);
+    }
+  }
+  formatField({ formatAsIn, ...ctx }, expr) {
+    const { stmt } = ctx;
+    if (formatAsIn) {
+      stmt.openParenthesis();
+      stmt.raw("SELECT value FROM json_each");
+      stmt.openParenthesis();
+      this.formatExprJson(ctx, expr);
+      stmt.closeParenthesis();
+      return stmt.closeParenthesis();
+    }
+    return this.formatFieldOf(ctx, expr.expr, expr.field);
+  }
+  formatCall(ctx, expr) {
+    const { stmt } = ctx;
+    if (expr.method === "cast") {
+      const [e, type] = expr.params;
+      const typeName = type.type === ExprType.Param && type.param.type === ParamType.Value && type.param.value;
+      stmt.raw("CAST").openParenthesis();
+      this.formatExprValue(ctx, e).add("AS").space();
+      this.formatString(ctx, typeName);
+      return stmt.closeParenthesis();
+    } else if (expr.method === "exists") {
+      stmt.raw("EXISTS").space();
+      return this.formatExprValue(ctx, expr.params[0]);
+    } else {
+      stmt.identifier(expr.method);
+      for (const param of stmt.call(expr.params))
+        this.formatExprValue(ctx, param);
+      return stmt;
+    }
+  }
+  formatQuery(ctx, expr) {
+    const { stmt } = ctx;
+    if (!ctx.formatAsJson) {
+      stmt.openParenthesis();
+      this.format(ctx, expr.query);
+      return stmt.closeParenthesis();
+    }
+    if (expr.query.singleResult) {
+      stmt.openParenthesis();
+      this.format({ ...ctx, topLevel: true }, expr.query);
+      return stmt.closeParenthesis().raw(`->'$.result'`);
+    }
+    stmt.openParenthesis().raw(`SELECT json_group_array(result->'$.result')`).newline().raw("FROM").space().openParenthesis();
+    this.format({ ...ctx, topLevel: true }, expr.query);
+    return stmt.closeParenthesis().closeParenthesis();
+  }
+  formatRow(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.target.type) {
+      case TargetType.Table:
+        const table = Target.source(expr.target);
+        if (!table)
+          throw new Error(`Cannot select empty target`);
+        if (ctx.tableAsExpr)
+          return stmt.identifier(table.alias || table.name);
+        stmt.identifier("json_object");
+        for (const [key, column] of stmt.call(Object.entries(table.columns))) {
           this.formatString(ctx, key).raw(", ");
-          this.formatExprJson(ctx, value);
+          this.formatFieldOf(ctx, expr, column.name);
+        }
+        return stmt;
+      case TargetType.Query:
+      case TargetType.Expr:
+        return stmt.identifier(expr.target.alias).raw(".value");
+      default:
+        throw new Error(`Cannot select from ${expr.target.type}`);
+    }
+  }
+  formatMerge(ctx, expr) {
+    const { stmt } = ctx;
+    stmt.identifier("json_patch").openParenthesis();
+    this.formatExpr({ ...ctx, formatAsJson: true }, expr.a);
+    stmt.raw(", ");
+    this.formatExpr({ ...ctx, formatAsJson: true }, expr.b);
+    return stmt.closeParenthesis();
+  }
+  formatRecord(ctx, expr) {
+    const { stmt } = ctx;
+    if (ctx.selectAsColumns) {
+      const inner = { ...ctx, selectAsColumns: false };
+      for (const [key, value] of stmt.separate(Object.entries(expr.fields))) {
+        this.formatExprJson(inner, value);
+      }
+      return stmt;
+    }
+    stmt.identifier("json_object").openParenthesis();
+    for (const [key, value] of stmt.separate(Object.entries(expr.fields))) {
+      this.formatString(ctx, key).raw(", ");
+      this.formatExprJson(ctx, value);
+    }
+    return stmt.closeParenthesis();
+  }
+  formatFilter({ formatAsIn, ...ctx }, expr) {
+    const { stmt } = ctx;
+    const { target, condition } = expr;
+    switch (target.type) {
+      case TargetType.Expr:
+        stmt.openParenthesis();
+        if (!formatAsIn) {
+          stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
+        }
+        stmt.raw("SELECT value AS result").add("FROM json_each").openParenthesis();
+        this.formatExpr(ctx, target.expr);
+        stmt.closeParenthesis();
+        if (target.alias)
+          stmt.add("AS").addIdentifier(target.alias);
+        stmt.add("WHERE").space();
+        this.formatExprValue(ctx, condition);
+        if (!formatAsIn) {
+          stmt.closeParenthesis();
         }
         return stmt.closeParenthesis();
-      case ExprType.Filter: {
-        const { target, condition } = expr;
-        switch (target.type) {
-          case TargetType.Expr:
-            stmt.openParenthesis();
-            if (!formatAsIn) {
-              stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
-            }
-            stmt.raw("SELECT value AS result").add("FROM json_each").openParenthesis();
-            this.formatExpr(ctx, target.expr);
-            stmt.closeParenthesis();
-            if (target.alias)
-              stmt.add("AS").addIdentifier(target.alias);
-            stmt.add("WHERE").space();
-            this.formatExprValue(ctx, condition);
-            if (!formatAsIn) {
-              stmt.closeParenthesis();
-            }
-            return stmt.closeParenthesis();
-          default:
-            throw new Error("todo");
+      default:
+        throw new Error("todo");
+    }
+  }
+  formatMap({ formatAsIn, ...ctx }, expr) {
+    const { stmt } = ctx;
+    const { target, result } = expr;
+    switch (target.type) {
+      case TargetType.Expr:
+        stmt.openParenthesis();
+        if (!formatAsIn) {
+          stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
         }
-      }
-      case ExprType.Map: {
-        const { target, result } = expr;
-        switch (target.type) {
-          case TargetType.Expr:
-            stmt.openParenthesis();
-            if (!formatAsIn) {
-              stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
-            }
-            stmt.raw("SELECT").space();
-            this.formatExpr(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
-            this.formatExprJson(ctx, target.expr);
-            stmt.closeParenthesis();
-            if (target.alias)
-              stmt.add("AS").addIdentifier(target.alias);
-            if (!formatAsIn) {
-              stmt.closeParenthesis();
-            }
-            return stmt.closeParenthesis();
-          default:
-            throw new Error("todo");
+        stmt.raw("SELECT").space();
+        this.formatExpr(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
+        this.formatExprJson(ctx, target.expr);
+        stmt.closeParenthesis();
+        if (target.alias)
+          stmt.add("AS").addIdentifier(target.alias);
+        if (!formatAsIn) {
+          stmt.closeParenthesis();
         }
-      }
+        return stmt.closeParenthesis();
       default:
-        console.log(expr);
         throw new Error("todo");
     }
   }

package/dist/lib/Statement.js

@@ -47,7 +47,7 @@ var Statement = class {
     return this.space().identifier(name);
   }
   value(value) {
-    this.paramData.push(ParamData.Value(value));
+    this.paramData.push(new ParamData.Value(value));
     return this.raw(INSERT_PARAM);
   }
   addValue(value) {

package/dist/sqlite/SqliteFormatter.d.ts

@@ -7,5 +7,5 @@ export declare class SqliteFormatter extends Formatter {
     escapeIdentifier(input: string): string;
     escapeString(input: string): string;
     formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
+    formatCall(ctx: FormatContext, expr: ExprData.Call): Statement;
 }

package/dist/sqlite/SqliteFormatter.js

@@ -1,5 +1,4 @@
 // src/sqlite/SqliteFormatter.ts
-import { ExprType } from "../define/Expr.js";
 import { Formatter } from "../lib/Formatter.js";
 var BACKTICK = "`";
 var ESCAPE_BACKTICK = "``";
@@ -42,26 +41,23 @@ var SqliteFormatter = class extends Formatter {
     stmt.raw(formatAsJson ? "->" : "->>");
     return this.formatString(ctx, `$.${field}`);
   }
-  formatExpr(ctx, expr) {
+  formatCall(ctx, expr) {
     const { stmt } = ctx;
-    switch (expr.type) {
-      case ExprType.Call:
-        switch (expr.method) {
-          case "match":
-            const [from, query] = expr.params;
-            this.formatExprValue({ ...ctx, tableAsExpr: true }, from);
-            stmt.raw(" MATCH ");
-            this.formatExprValue(ctx, query);
-            return stmt;
-          case "highlight":
-          case "snippet":
-            stmt.identifier(expr.method);
-            for (const param of stmt.call(expr.params))
-              this.formatExprValue({ ...ctx, tableAsExpr: true }, param);
-            return stmt;
-        }
+    switch (expr.method) {
+      case "match":
+        const [from, query] = expr.params;
+        this.formatExprValue({ ...ctx, tableAsExpr: true }, from);
+        stmt.raw(" MATCH ");
+        this.formatExprValue(ctx, query);
+        return stmt;
+      case "highlight":
+      case "snippet":
+        stmt.identifier(expr.method);
+        for (const param of stmt.call(expr.params))
+          this.formatExprValue({ ...ctx, tableAsExpr: true }, param);
+        return stmt;
       default:
-        return super.formatExpr(ctx, expr);
+        return super.formatCall(ctx, expr);
     }
   }
 };

package/dist/sqlite/SqliteFunctions.d.ts

@@ -1,5 +1,5 @@
-import { Cursor } from '../define/Cursor';
 import { EV, Expr } from '../define/Expr';
+import { Query } from '../define/Query';
 import { Table } from '../define/Table';
 export declare const SqliteFunctions: SqliteFunctions;
 export type SqliteFunctions = {
@@ -10,7 +10,7 @@ export type SqliteFunctions = {
     /**
      * The EXISTS operator always evaluates to one of the integer values 0 and 1. If executing the SELECT statement specified as the right-hand operand of the EXISTS operator would return one or more rows, then the EXISTS operator evaluates to 1. If executing the SELECT would return no rows at all, then the EXISTS operator evaluates to 0.
      */
-    exists(cursor: Cursor<any>): Expr<boolean>;
+    exists(cursor: Query<any>): Expr<boolean>;
     /** Use the match operator for the FTS5 module */
     match(table: Table<any>, searchTerm: EV<string>): Expr<boolean>;
     /** 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. */
@@ -157,7 +157,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: Cursor<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>, 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/SqliteSchema.d.ts

@@ -1,5 +1,5 @@
-import { Cursor } from '../define/Cursor';
 import { Expr } from '../define/Expr';
+import { Query } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 export declare namespace SqliteSchema {
     type Column = {
@@ -17,8 +17,8 @@ export declare namespace SqliteSchema {
         rootpage: number;
         sql: string;
     }
-    function tableData(tableName: Expr<string>): Cursor<Array<SqliteSchema.Column>>;
-    function indexData(tableName: Expr<string>): Cursor<Array<SqliteSchema.Index>>;
+    function tableData(tableName: Expr<string>): Query<Array<SqliteSchema.Column>>;
+    function indexData(tableName: Expr<string>): Query<Array<SqliteSchema.Index>>;
     function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions | undefined;
     function columnInstruction(column: Column): [string, string];
     function indexInstruction(index: Index): [string, string];

package/dist/sqlite/SqliteSchema.js

@@ -1,16 +1,16 @@
 // src/sqlite/SqliteSchema.ts
-import { Cursor } from "../define/Cursor.js";
+import { Query } from "../define/Query.js";
 import { Statement } from "../lib/Statement.js";
 import { SqliteFormatter } from "./SqliteFormatter.js";
 var SqliteSchema;
 ((SqliteSchema2) => {
   const formatter = new SqliteFormatter();
   function tableData(tableName) {
-    return Cursor.all`select * from pragma_table_info(${tableName}) order by cid`;
+    return Query.all`select * from pragma_table_info(${tableName}) order by cid`;
   }
   SqliteSchema2.tableData = tableData;
   function indexData(tableName) {
-    return Cursor.all`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
+    return Query.all`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
   }
   SqliteSchema2.indexData = indexData;
   function createInstructions(columnData, indexData2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "better-sqlite3": "^7.5.1",
     "bun-types": "^0.5.0",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.17.7",
+    "esbuild": "^0.17.10",
     "glob": "^8.0.3",
     "rimraf": "^4.1.2",
     "sade": "^1.8.1",
@@ -47,7 +47,7 @@
     "sql.js": "^1.8.0",
     "sqlite3": "^5.1.4",
     "tsx": "^3.12.3",
-    "typescript": "next",
+    "typescript": "beta",
     "uvu": "^0.5.6"
   },
   "volta": {
@@ -55,6 +55,6 @@
   },
   "packageManager": "yarn@3.3.1",
   "resolutions": {
-    "esbuild": "0.17.7"
+    "esbuild": "0.17.10"
   }
 }