rado 0.2.24 → 0.2.26

package/dist/lib/Driver.d.ts

@@ -2,6 +2,7 @@ import { Expr } from '../define/Expr';
 import { Query, QueryData } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 import { Table } from '../define/Table';
+import { SelectMultiple } from '../define/query/Select';
 import { Callable } from '../util/Callable';
 import { Formatter } from './Formatter';
 import { Statement } from './Statement';
@@ -9,8 +10,6 @@ declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
     compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): [QueryData, Statement];
-    all(...args: Array<any>): any;
-    get(...args: Array<any>): any;
     executeTemplate(expectedReturn: QueryData.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
     abstract executeQuery(query: QueryData): any;
 }
@@ -32,13 +31,7 @@ declare abstract class SyncDriver extends DriverBase {
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => R;
     migrateSchema(...tables: Array<Table<any>>): unknown;
     executeQuery(query: QueryData, stmt?: SyncPreparedStatement, params?: Array<any>): unknown;
-    all<T>(cursor: Query.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Query<T>): T;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    get<T>(cursor: Query.SelectMultiple<T>): T | null;
-    get<T>(cursor: Query<T>): T;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-    iterate<T>(cursor: Query.SelectMultiple<T>): Iterable<T>;
+    iterate<T>(cursor: SelectMultiple<T>): Iterable<T>;
     transaction<T>(run: (query: SyncDriver) => T): T;
     toAsync(): SyncWrapper;
 }
@@ -65,13 +58,7 @@ declare abstract class AsyncDriver extends DriverBase {
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => Promise<R>;
     migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
     executeQuery(query: QueryData, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<unknown>;
-    all<T>(cursor: Query.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Query<T>): Promise<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-    get<T>(cursor: Query.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Query<T>): Promise<T>;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-    iterate<T>(cursor: Query.SelectMultiple<T>): AsyncIterable<T>;
+    iterate<T>(cursor: SelectMultiple<T>): AsyncIterable<T>;
     transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
 }
 declare class SyncWrapper extends AsyncDriver {

package/dist/lib/Driver.js

@@ -34,22 +34,6 @@ var DriverBase = class extends Callable {
     const query = cursor[Query.Data];
     return [query, this.formatter.compile(query)];
   }
-  all(...args) {
-    const [input, ...rest] = args;
-    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 (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);
-  }
   executeTemplate(expectedReturn, strings, ...params) {
     return this.executeQuery(
       new QueryData.Raw({ strings, params, expectedReturn })
@@ -133,12 +117,6 @@ var SyncDriver = class extends DriverBase {
         }
     }
   }
-  all(...args) {
-    return super.all(...args);
-  }
-  get(...args) {
-    return super.get(...args);
-  }
   *iterate(cursor) {
     const stmt = this.prepareStatement(
       this.formatter.compile(cursor[Query.Data]),
@@ -255,12 +233,6 @@ var AsyncDriver = class extends DriverBase {
         }
     }
   }
-  all(...args) {
-    return super.all(...args);
-  }
-  get(...args) {
-    return super.get(...args);
-  }
   async *iterate(cursor) {
     const stmt = this.prepareStatement(
       this.formatter.compile(cursor[Query.Data]),

package/dist/lib/Formatter.d.ts

@@ -23,6 +23,7 @@ export interface FormatContext {
     formatAsIn?: boolean;
     topLevel?: boolean;
     selectAsColumns?: boolean;
+    formattingCte?: string;
 }
 type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
 export interface CompileOptions extends Partial<FormatContext>, StatementOptions {
@@ -45,6 +46,7 @@ export declare abstract class Formatter implements Sanitizer {
         formatAsIn?: boolean | undefined;
         topLevel?: boolean | undefined;
         selectAsColumns?: boolean | undefined;
+        formattingCte?: string | undefined;
         skipNewlines?: boolean | undefined;
     };
     format(ctx: FormatContext, query: QueryData): Statement;
@@ -62,7 +64,7 @@ export declare abstract class Formatter implements Sanitizer {
     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;
+    formatConstraintReference(ctx: FormatContext, reference: ExprData): Statement;
     formatType(ctx: FormatContext, type: ColumnType): Statement;
     formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
     formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;

package/dist/lib/Formatter.js

@@ -89,12 +89,19 @@ var Formatter = class {
     const { stmt } = ctx;
     switch (query.from?.type) {
       case TargetType.CTE:
-        stmt.add("WITH RECURSIVE").addIdentifier(query.from.name).add("AS").space().openParenthesis();
-        this.formatUnion(
-          { ...ctx, topLevel: false, selectAsColumns: true },
-          query.from.union
-        );
-        stmt.closeParenthesis().space();
+        if (ctx.formattingCte !== query.from.name) {
+          stmt.add("WITH RECURSIVE").addIdentifier(query.from.name).add("AS").space().openParenthesis();
+          this.formatUnion(
+            {
+              ...ctx,
+              topLevel: false,
+              selectAsColumns: true,
+              formattingCte: query.from.name
+            },
+            query.from.union
+          );
+          stmt.closeParenthesis().space();
+        }
       default:
         stmt.raw("SELECT").space();
         this.formatSelection(
@@ -118,7 +125,7 @@ var Formatter = class {
     const { stmt } = ctx;
     this.format(ctx, a);
     stmt.add(unions[operator]).space();
-    this.format(ctx, b);
+    this.format(ctx, typeof b === "function" ? b() : b);
     return stmt;
   }
   formatInsert(ctx, query) {
@@ -306,10 +313,10 @@ var Formatter = class {
       }
     }
     if (column.references)
-      this.formatContraintReference(ctx, column.references());
+      this.formatConstraintReference(ctx, column.references());
     return stmt;
   }
-  formatContraintReference(ctx, reference) {
+  formatConstraintReference(ctx, reference) {
     const { stmt } = ctx;
     if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
       throw new Error("not supported");
@@ -602,6 +609,8 @@ var Formatter = class {
     switch (from.type) {
       case ExprType.Row:
         switch (from.target.type) {
+          case TargetType.CTE:
+            return stmt.identifier(from.target.name).raw(".").identifier(field);
           case TargetType.Table:
             const column = from.target.table.columns[field];
             const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
@@ -685,6 +694,16 @@ var Formatter = class {
           throw new Error(`Cannot select empty target`);
         if (ctx.tableAsExpr)
           return stmt.identifier(table.alias || table.name);
+        if (ctx.selectAsColumns) {
+          const inner = { ...ctx, selectAsColumns: false };
+          for (const [key, column] of stmt.separate(
+            Object.entries(table.columns)
+          )) {
+            this.formatFieldOf(inner, expr, column.name);
+            stmt.add("AS").addIdentifier(key);
+          }
+          return stmt;
+        }
         stmt.identifier("json_object");
         for (const [key, column] of stmt.call(Object.entries(table.columns))) {
           this.formatString(ctx, key).raw(", ");

package/dist/sqlite/SqliteSchema.js

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

package/dist/util/Alias.d.ts

@@ -0,0 +1 @@
+export declare function randomAlias(): string;

package/dist/util/Alias.js

@@ -0,0 +1,7 @@
+// src/util/Alias.ts
+function randomAlias() {
+  return `__${Math.random().toString(36).slice(2, 9)}`;
+}
+export {
+  randomAlias
+};

package/dist/util/Callable.d.ts

@@ -1,3 +1,11 @@
 export declare class Callable {
     constructor(fn: Function);
 }
+export declare class ClearFunctionProto {
+    get name(): unknown;
+    get length(): unknown;
+    get call(): unknown;
+    get apply(): unknown;
+    get bind(): unknown;
+    get prototype(): unknown;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "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
-};