rado 0.2.21 → 0.2.23

package/dist/lib/Driver.js

@@ -1,8 +1,7 @@
 // src/lib/Driver.ts
-import { Cursor } from "../define/Cursor.js";
 import { Expr, ExprData } from "../define/Expr.js";
 import { ParamData } from "../define/Param.js";
-import { Query, QueryType } from "../define/Query.js";
+import { Query, QueryData, QueryType } from "../define/Query.js";
 import { Schema } from "../define/Schema.js";
 import { Table } from "../define/Table.js";
 import { Callable } from "../util/Callable.js";
@@ -13,13 +12,13 @@ var DriverBase = class extends Callable {
   constructor(formatter) {
     super((...args) => {
       const [input, ...rest] = args;
-      if (input instanceof Cursor && rest.length === 0)
-        return this.executeQuery(input[Cursor.Query]);
+      if (Query.isQuery(input) && rest.length === 0)
+        return this.executeQuery(input[Query.Data]);
       if (isTemplateStringsArray(input))
         return this.executeTemplate(void 0, input, ...rest);
       return this.executeQuery(
-        Query.Batch({
-          queries: args.filter((arg) => arg instanceof Cursor).map((arg) => arg[Cursor.Query])
+        new QueryData.Batch({
+          queries: args.filter(Query.isQuery).map((arg) => arg[Query.Data])
         })
       );
     });
@@ -29,33 +28,32 @@ var DriverBase = class extends Callable {
     const { length } = create;
     const paramNames = Array.from({ length }, (_, i) => `p${i}`);
     const params = paramNames.map(
-      (name) => new Expr(ExprData.Param(ParamData.Named(name)))
+      (name) => new Expr(new ExprData.Param(new ParamData.Named(name)))
     );
     const cursor = create(...params);
-    const query = cursor[Cursor.Query];
+    const query = cursor[Query.Data];
     return [query, this.formatter.compile(query)];
   }
   all(...args) {
     const [input, ...rest] = args;
-    if (input instanceof Cursor.SelectSingle)
-      return this.executeQuery(input.all()[Cursor.Query]);
-    if (input instanceof Cursor)
-      return this.executeQuery(input[Cursor.Query]);
+    if (Query.isSingle(input))
+      return this.executeQuery(input.all()[Query.Data]);
+    if (Query.isQuery(input))
+      return this.executeQuery(input[Query.Data]);
     return this.executeTemplate("rows", input, ...rest);
   }
   get(...args) {
     const [input, ...rest] = args;
-    if (input instanceof Cursor.SelectMultiple)
-      return this.executeQuery(input.maybeFirst()[Cursor.Query]);
-    if (input instanceof Cursor)
-      return this.executeQuery(input[Cursor.Query]);
+    if (Query.isMultiple(input))
+      return this.executeQuery(input.maybeFirst()[Query.Data]);
+    if (Query.isQuery(input))
+      return this.executeQuery(input[Query.Data]);
     return this.executeTemplate("row", input, ...rest);
   }
-  sql(strings, ...params) {
-    return new Cursor(Query.Raw({ strings, params }));
-  }
   executeTemplate(expectedReturn, strings, ...params) {
-    return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
+    return this.executeQuery(
+      new QueryData.Raw({ strings, params, expectedReturn })
+    );
   }
 };
 var SyncDriver = class extends DriverBase {
@@ -71,7 +69,11 @@ var SyncDriver = class extends DriverBase {
       const namedParams = Object.fromEntries(
         params.map((value, i) => [`p${i}`, value])
       );
-      return this.executeQuery(query, prepared, compiled.params(namedParams));
+      return this.executeQuery(
+        query,
+        prepared,
+        compiled.params(namedParams)
+      );
     };
   }
   migrateSchema(...tables) {
@@ -87,7 +89,7 @@ var SyncDriver = class extends DriverBase {
           queries.push(...changes);
       }
     }
-    return this.executeQuery(Query.Batch({ queries }));
+    return this.executeQuery(new QueryData.Batch({ queries }));
   }
   executeQuery(query, stmt, params) {
     switch (query.type) {
@@ -139,7 +141,7 @@ var SyncDriver = class extends DriverBase {
   }
   *iterate(cursor) {
     const stmt = this.prepareStatement(
-      this.formatter.compile(cursor[Cursor.Query]),
+      this.formatter.compile(cursor[Query.Data]),
       true
     );
     for (const row of stmt.iterate()) {
@@ -149,17 +151,23 @@ var SyncDriver = class extends DriverBase {
   transaction(run) {
     const id = `t${this.transactionId++}`;
     this.executeQuery(
-      Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+      new QueryData.Transaction({ op: QueryData.TransactionOperation.Begin, id })
     );
     try {
       const res = run(this);
       this.executeQuery(
-        Query.Transaction({ op: Query.TransactionOperation.Commit, id })
+        new QueryData.Transaction({
+          op: QueryData.TransactionOperation.Commit,
+          id
+        })
       );
       return res;
     } catch (e) {
       this.executeQuery(
-        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+        new QueryData.Transaction({
+          op: QueryData.TransactionOperation.Rollback,
+          id
+        })
       );
       throw e;
     }
@@ -181,7 +189,11 @@ var AsyncDriver = class extends DriverBase {
       const namedParams = Object.fromEntries(
         params.map((value, i) => [`p${i}`, value])
       );
-      return this.executeQuery(query, prepared, compiled.params(namedParams));
+      return this.executeQuery(
+        query,
+        prepared,
+        compiled.params(namedParams)
+      );
     };
   }
   async migrateSchema(...tables) {
@@ -197,7 +209,7 @@ var AsyncDriver = class extends DriverBase {
           queries.push(...changes);
       }
     }
-    return this.executeQuery(Query.Batch({ queries }));
+    return this.executeQuery(new QueryData.Batch({ queries }));
   }
   async executeQuery(query, stmt, params) {
     switch (query.type) {
@@ -251,7 +263,7 @@ var AsyncDriver = class extends DriverBase {
   }
   async *iterate(cursor) {
     const stmt = this.prepareStatement(
-      this.formatter.compile(cursor[Cursor.Query]),
+      this.formatter.compile(cursor[Query.Data]),
       true
     );
     for await (const row of stmt.iterate()) {
@@ -262,17 +274,23 @@ var AsyncDriver = class extends DriverBase {
     const id = `t${this.transactionId++}`;
     const [connection, release] = this.isolate();
     await connection.executeQuery(
-      Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+      new QueryData.Transaction({ op: QueryData.TransactionOperation.Begin, id })
     );
     try {
       const res = await run(connection);
       await connection.executeQuery(
-        Query.Transaction({ op: Query.TransactionOperation.Commit, id })
+        new QueryData.Transaction({
+          op: QueryData.TransactionOperation.Commit,
+          id
+        })
       );
       return res;
     } catch (e) {
       await connection.executeQuery(
-        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+        new QueryData.Transaction({
+          op: QueryData.TransactionOperation.Rollback,
+          id
+        })
       );
       throw e;
     } finally {

package/dist/lib/Formatter.d.ts

@@ -1,7 +1,7 @@
 import { ColumnData, ColumnType } from '../define/Column';
 import { ExprData } from '../define/Expr';
 import { OrderBy } from '../define/OrderBy';
-import { Query } from '../define/Query';
+import { QueryData } from '../define/Query';
 import { Target } from '../define/Target';
 import { Sanitizer } from './Sanitizer';
 import { Statement, StatementOptions } from './Statement';
@@ -33,7 +33,7 @@ export declare abstract class Formatter implements Sanitizer {
     abstract escapeIdentifier(ident: string): string;
     abstract formatParamValue(paramValue: any): any;
     abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    compile<T>(query: Query<T>, options?: CompileOptions): Statement;
+    compile(query: QueryData, options?: CompileOptions): Statement;
     createContext(options?: CompileOptions): {
         stmt: Statement;
         nameResult?: string | undefined;
@@ -47,19 +47,19 @@ export declare abstract class Formatter implements Sanitizer {
         selectAsColumns?: boolean | undefined;
         skipNewlines?: boolean | undefined;
     };
-    format<T>(ctx: FormatContext, query: Query<T>): Statement;
-    formatSelect({ topLevel, ...ctx }: FormatContext, query: Query.Select): Statement;
-    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
-    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
-    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
-    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
-    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
-    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
-    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
-    formatDropTable(ctx: FormatContext, query: Query.DropTable): Statement;
-    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
-    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
-    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
+    format(ctx: FormatContext, query: QueryData): Statement;
+    formatSelect({ topLevel, ...ctx }: FormatContext, query: QueryData.Select): Statement;
+    formatInsert(ctx: FormatContext, query: QueryData.Insert): Statement;
+    formatUpdate(ctx: FormatContext, query: QueryData.Update): Statement;
+    formatDelete(ctx: FormatContext, query: QueryData.Delete): Statement;
+    formatCreateTable(ctx: FormatContext, query: QueryData.CreateTable): Statement;
+    formatCreateIndex(ctx: FormatContext, query: QueryData.CreateIndex): Statement;
+    formatDropIndex(ctx: FormatContext, query: QueryData.DropIndex): Statement;
+    formatAlterTable(ctx: FormatContext, query: QueryData.AlterTable): Statement;
+    formatDropTable(ctx: FormatContext, query: QueryData.DropTable): Statement;
+    formatTransaction(ctx: FormatContext, { op, id }: QueryData.Transaction): Statement;
+    formatBatch(ctx: FormatContext, { queries }: QueryData.Batch): Statement;
+    formatRaw(ctx: FormatContext, { strings, params }: QueryData.Raw): Statement;
     formatColumn(ctx: FormatContext, column: ColumnData): Statement;
     formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
     formatType(ctx: FormatContext, type: ColumnType): Statement;
@@ -70,15 +70,26 @@ export declare abstract class Formatter implements Sanitizer {
     formatHaving({ topLevel, ...ctx }: FormatContext, expr: ExprData | undefined): Statement;
     formatGroupBy(ctx: FormatContext, groupBy: Array<ExprData> | undefined): Statement;
     formatOrderBy(ctx: FormatContext, orderBy: Array<OrderBy> | undefined): Statement;
-    formatLimit(ctx: FormatContext, { limit, offset, singleResult }: Query.QueryBase): Statement;
+    formatLimit(ctx: FormatContext, { limit, offset, singleResult }: QueryData): Statement;
     formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
-    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
-    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
-    retrieveField(expr: ExprData, field: string): ExprData | undefined;
-    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
     formatString(ctx: FormatContext, input: string): Statement;
     formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
     formatValue(ctx: FormatContext, rawValue: any): Statement;
-    formatExpr({ formatAsIn, ...ctx }: FormatContext, expr: ExprData): Statement;
+    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
+    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
+    formatUnOp(ctx: FormatContext, expr: ExprData.UnOp): Statement;
+    formatBinOp(ctx: FormatContext, expr: ExprData.BinOp): Statement;
+    formatParam(ctx: FormatContext, expr: ExprData.Param): Statement;
+    retrieveField(expr: ExprData, field: string): ExprData | undefined;
+    formatFieldOf(ctx: FormatContext, from: ExprData, field: string): Statement;
+    formatField({ formatAsIn, ...ctx }: FormatContext, expr: ExprData.Field): Statement;
+    formatCall(ctx: FormatContext, expr: ExprData.Call): Statement;
+    formatQuery(ctx: FormatContext, expr: ExprData.Query): Statement;
+    formatRow(ctx: FormatContext, expr: ExprData.Row): Statement;
+    formatMerge(ctx: FormatContext, expr: ExprData.Merge): Statement;
+    formatRecord(ctx: FormatContext, expr: ExprData.Record): Statement;
+    formatFilter({ formatAsIn, ...ctx }: FormatContext, expr: ExprData.Filter): Statement;
+    formatMap({ formatAsIn, ...ctx }: FormatContext, expr: ExprData.Map): Statement;
 }
 export {};