rado 0.2.21 → 0.2.23

package/dist/define/Table.d.ts

@@ -1,26 +1,27 @@
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column';
-import { Cursor } from './Cursor';
 import { EV } from './Expr';
 import { Index, IndexData } from './Index';
+import { Query } from './Query';
 import { Selection } from './Selection';
 declare const DATA: unique symbol;
 declare const META: unique symbol;
 interface TableDefinition {
 }
-export interface TableData {
+export declare class TableData {
     name: string;
     alias?: string;
     definition: TableDefinition;
     columns: Record<string, ColumnData>;
-    meta(): {
+    meta: () => {
         indexes: Record<string, IndexData>;
     };
+    constructor(data: TableData);
 }
 export interface TableInstance<Definition> {
     (conditions: {
         [K in keyof Definition]?: Definition[K] extends Column<infer V> ? EV<V> : never;
-    }): Cursor.TableSelect<Definition>;
-    (...conditions: Array<EV<boolean>>): Cursor.TableSelect<Definition>;
+    }): Query.TableSelect<Definition>;
+    (...conditions: Array<EV<boolean>>): Query.TableSelect<Definition>;
 }
 export declare class TableInstance<Definition> {
     [Selection.TableType](): Table.Select<Definition>;
@@ -56,15 +57,12 @@ export declare namespace Table {
 export interface TableMeta {
     indexes?: Record<string, Index>;
 }
-type Blueprint<T> = {
-    [K in keyof T as K extends string ? K : never]: Column<any> | (() => any);
-};
 interface Define<T> {
     new (): T;
 }
 export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
-export declare function table<T extends Blueprint<T>>(define: Record<string, T | Define<T>>): Table<T>;
+export declare function table<T extends {}>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {
     const meta: typeof META;
 }

package/dist/define/Table.js

@@ -3,28 +3,33 @@ import {
   Column,
   ColumnType
 } from "./Column.js";
-import { Cursor } from "./Cursor.js";
 import { BinOpType, Expr, ExprData } from "./Expr.js";
+import { Query } from "./Query.js";
 import { Target } from "./Target.js";
-var DATA = Symbol("Table.Data");
-var META = Symbol("Table.Meta");
 var {
+  assign,
   keys,
   entries,
   fromEntries,
   getOwnPropertyDescriptors,
   getPrototypeOf,
   setPrototypeOf,
-  defineProperty,
-  getOwnPropertyNames
+  defineProperty
 } = Object;
+var DATA = Symbol("Table.Data");
+var META = Symbol("Table.Meta");
+var TableData = class {
+  constructor(data) {
+    assign(this, data);
+  }
+};
 var Table;
 ((Table2) => {
   Table2.Data = DATA;
   Table2.Meta = META;
 })(Table || (Table = {}));
 function createTable(data) {
-  const target = Target.Table(data);
+  const target = new Target.Table(data);
   const call = {
     [data.name]: function(...args) {
       const isConditionalRecord = args.length === 1 && !Expr.isExpr(args[0]);
@@ -33,21 +38,21 @@ function createTable(data) {
         if (!column)
           throw new Error(`Column ${key} not found`);
         return new Expr(
-          ExprData.BinOp(
+          new ExprData.BinOp(
             BinOpType.Equals,
-            ExprData.Field(ExprData.Row(target), key),
+            new ExprData.Field(new ExprData.Row(target), key),
             ExprData.create(value)
           )
         );
       }) : args;
-      return new Cursor.TableSelect(data, conditions);
+      return new Query.TableSelect(data, conditions);
     }
   }[data.name];
   const cols = keys(data.columns);
-  const row = ExprData.Row(target);
+  const row = new ExprData.Row(target);
   const expressions = fromEntries(
     cols.map((name) => {
-      let expr = new Expr(ExprData.Field(row, name));
+      let expr = new Expr(new ExprData.Field(row, name));
       if (data.columns[name].type === ColumnType.Json)
         expr = expr.dynamic();
       return [name, expr];
@@ -71,39 +76,44 @@ function table(define) {
   const target = define[name];
   const definition = "prototype" in target ? new target() : target;
   const columns = definition;
-  const res = createTable({
-    name,
-    definition,
-    columns: fromEntries(
-      entries(getOwnPropertyDescriptors(columns)).map(([name2, descriptor]) => {
-        const column = columns[name2];
-        const data = column[Column.Data];
-        if (!data.type)
-          throw new Error(`Column ${name2} has no type`);
-        return [
-          name2,
-          {
-            ...data,
-            type: data.type,
-            name: data.name || name2,
-            enumerable: descriptor.enumerable
-          }
-        ];
-      })
-    ),
-    meta() {
-      const createMeta = res[table.meta];
-      const meta = createMeta ? createMeta.apply(res) : {};
-      return {
-        indexes: fromEntries(
-          entries(meta?.indexes || {}).map(([key, index]) => {
-            const indexName = `${name}.${key}`;
-            return [indexName, { name: indexName, ...index.data }];
-          })
-        )
-      };
-    }
-  });
+  const res = createTable(
+    new TableData({
+      name,
+      definition,
+      columns: fromEntries(
+        entries(getOwnPropertyDescriptors(columns)).filter(([name2]) => {
+          const column = columns[name2];
+          return Column.isColumn(column);
+        }).map(([name2, descriptor]) => {
+          const column = columns[name2];
+          const data = column[Column.Data];
+          if (!data.type)
+            throw new Error(`Column ${name2} has no type`);
+          return [
+            name2,
+            {
+              ...data,
+              type: data.type,
+              name: data.name || name2,
+              enumerable: descriptor.enumerable
+            }
+          ];
+        })
+      ),
+      meta() {
+        const createMeta = res[table.meta];
+        const meta = createMeta ? createMeta.apply(res) : {};
+        return {
+          indexes: fromEntries(
+            entries(meta?.indexes || {}).map(([key, index]) => {
+              const indexName = `${name}.${key}`;
+              return [indexName, { name: indexName, ...index.data }];
+            })
+          )
+        };
+      }
+    })
+  );
   return res;
 }
 ((table2) => {
@@ -111,6 +121,7 @@ function table(define) {
 })(table || (table = {}));
 export {
   Table,
+  TableData,
   createTable,
   table
 };

package/dist/define/Target.d.ts

@@ -1,38 +1,38 @@
-import { ExprData } from './Expr';
-import { Query as QueryData } from './Query';
-import { TableData } from './Table';
+import type { ExprData } from './Expr';
+import type { QueryData } from './Query';
+import type { TableData } from './Table';
 export declare enum TargetType {
-    Expr = "Expr",
-    Query = "Query",
-    Table = "Table",
-    Join = "Join"
+    Expr = "Target.Expr",
+    Query = "Target.Query",
+    Table = "Target.Table",
+    Join = "Target.Join"
 }
 export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
 export declare namespace Target {
-    interface Expr {
-        type: TargetType.Expr;
+    class Expr {
         expr: ExprData;
-        alias?: string;
+        alias?: string | undefined;
+        type: TargetType.Expr;
+        constructor(expr: ExprData, alias?: string | undefined);
     }
-    function Expr(expr: ExprData, alias?: string): Expr;
-    interface Query {
-        type: TargetType.Query;
+    class Query {
         query: QueryData;
-        alias?: string;
+        alias?: string | undefined;
+        type: TargetType.Query;
+        constructor(query: QueryData, alias?: string | undefined);
     }
-    function Query(query: QueryData, alias?: string): Query;
-    interface Table {
-        type: TargetType.Table;
+    class Table {
         table: TableData;
+        type: TargetType.Table;
+        constructor(table: TableData);
     }
-    function Table(table: TableData): Table;
-    interface Join {
-        type: TargetType.Join;
+    class Join {
         left: Target;
         right: Target;
         joinType: 'left' | 'inner';
         on: ExprData;
+        type: TargetType.Join;
+        constructor(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData);
     }
-    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
     function source(from: Target): TableData | undefined;
 }

package/dist/define/Target.js

@@ -1,34 +1,51 @@
 // src/define/Target.ts
 var TargetType = /* @__PURE__ */ ((TargetType2) => {
-  TargetType2["Expr"] = "Expr";
-  TargetType2["Query"] = "Query";
-  TargetType2["Table"] = "Table";
-  TargetType2["Join"] = "Join";
+  TargetType2["Expr"] = "Target.Expr";
+  TargetType2["Query"] = "Target.Query";
+  TargetType2["Table"] = "Target.Table";
+  TargetType2["Join"] = "Target.Join";
   return TargetType2;
 })(TargetType || {});
 var Target;
 ((Target2) => {
-  function Expr(expr, alias) {
-    return { type: "Expr" /* Expr */, expr, alias };
+  class Expr {
+    constructor(expr, alias) {
+      this.expr = expr;
+      this.alias = alias;
+    }
+    type = "Target.Expr" /* Expr */;
   }
   Target2.Expr = Expr;
-  function Query(query, alias) {
-    return { type: "Query" /* Query */, query, alias };
+  class Query {
+    constructor(query, alias) {
+      this.query = query;
+      this.alias = alias;
+    }
+    type = "Target.Query" /* Query */;
   }
   Target2.Query = Query;
-  function Table(table) {
-    return { type: "Table" /* Table */, table };
+  class Table {
+    constructor(table) {
+      this.table = table;
+    }
+    type = "Target.Table" /* Table */;
   }
   Target2.Table = Table;
-  function Join(left, right, joinType, on) {
-    return { type: "Join" /* Join */, left, right, joinType, on };
+  class Join {
+    constructor(left, right, joinType, on) {
+      this.left = left;
+      this.right = right;
+      this.joinType = joinType;
+      this.on = on;
+    }
+    type = "Target.Join" /* Join */;
   }
   Target2.Join = Join;
   function source(from) {
     switch (from.type) {
-      case "Table" /* Table */:
+      case "Target.Table" /* Table */:
         return from.table;
-      case "Join" /* Join */:
+      case "Target.Join" /* Join */:
         return source(from.left);
       default:
         return void 0;

package/dist/driver/bun-sqlite.js

@@ -1,6 +1,5 @@
 // src/driver/bun-sqlite.ts
-import { Cursor } from "../define/Cursor.js";
-import { Query } from "../define/Query.js";
+import { Query, QueryData } from "../define/Query.js";
 import { Driver } from "../lib/Driver.js";
 import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
@@ -35,8 +34,8 @@ var BunSqliteDriver = class extends Driver.Sync {
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
     this.lastChanges = this.prepare(() => {
-      return new Cursor.SelectSingle(
-        Query.Raw({
+      return new Query.SelectSingle(
+        new QueryData.Raw({
           expectedReturn: "row",
           strings: ["SELECT changes() as rowsAffected"],
           params: []

package/dist/driver/sqlite3.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from 'sqlite3';
-import { Query } from '../define/Query';
+import { QueryData } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 import { Driver } from '../lib/Driver';
 import { Statement } from '../lib/Statement';
@@ -10,7 +10,7 @@ export declare class Sqlite3Driver extends Driver.Async {
     tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
     indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
     constructor(db: Database);
-    executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
+    executeQuery(query: QueryData, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<unknown>;
     prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: Driver.Async, release: () => Promise<void>];

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from './define/Column';
-export * from './define/Cursor';
 export * from './define/Expr';
 export type { Fields } from './define/Fields';
 export * from './define/Functions';
@@ -11,6 +10,7 @@ export * from './define/Param';
 export * from './define/Query';
 export * from './define/Schema';
 export type { Selection } from './define/Selection';
+export * from './define/Sql';
 export * from './define/Table';
 export * from './define/Target';
 export type { Driver } from './lib/Driver';

package/dist/index.js

@@ -1,6 +1,5 @@
 // src/index.ts
 export * from "./define/Column.js";
-export * from "./define/Cursor.js";
 export * from "./define/Expr.js";
 export * from "./define/Functions.js";
 export * from "./define/Index.js";
@@ -9,6 +8,7 @@ export * from "./define/OrderBy.js";
 export * from "./define/Param.js";
 export * from "./define/Query.js";
 export * from "./define/Schema.js";
+export * from "./define/Sql.js";
 export * from "./define/Table.js";
 export * from "./define/Target.js";
 export * from "./lib/SqlError.js";

package/dist/lib/Driver.d.ts

@@ -1,6 +1,5 @@
-import { Cursor } from '../define/Cursor';
 import { Expr } from '../define/Expr';
-import { Query } from '../define/Query';
+import { Query, QueryData } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 import { Table } from '../define/Table';
 import { Callable } from '../util/Callable';
@@ -9,12 +8,11 @@ import { Statement } from './Statement';
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
-    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
+    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): [QueryData, Statement];
     all(...args: Array<any>): any;
     get(...args: Array<any>): any;
-    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
+    executeTemplate(expectedReturn: QueryData.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: QueryData): any;
 }
 type ParamTypes<Params extends [...any[]]> = {
     [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
@@ -22,8 +20,8 @@ type ParamTypes<Params extends [...any[]]> = {
     length: Params['length'];
 };
 interface SyncDriver {
-    <T>(query: Cursor<T>): T;
-    <T>(...queries: Array<Cursor<any>>): T;
+    <T>(query: Query<T>): T;
+    <T>(...queries: Array<Query<any>>): T;
     (strings: TemplateStringsArray, ...values: any[]): any;
 }
 declare abstract class SyncDriver extends DriverBase {
@@ -31,16 +29,16 @@ declare abstract class SyncDriver extends DriverBase {
     constructor(formatter: Formatter);
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => R;
     migrateSchema(...tables: Array<Table<any>>): unknown;
-    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
-    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): T;
+    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: Cursor.SelectMultiple<T>): T | null;
-    get<T>(cursor: Cursor<T>): 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: Cursor.SelectMultiple<T>): Iterable<T>;
+    iterate<T>(cursor: Query.SelectMultiple<T>): Iterable<T>;
     transaction<T>(run: (query: SyncDriver) => T): T;
     toAsync(): SyncWrapper;
 }
@@ -54,8 +52,8 @@ interface SyncPreparedStatement {
     execute(params?: Array<any>): void;
 }
 interface AsyncDriver {
-    <T>(query: Cursor<T>): Promise<T>;
-    <T>(...queries: Array<Cursor<any>>): Promise<T>;
+    <T>(query: Query<T>): Promise<T>;
+    <T>(...queries: Array<Query<any>>): Promise<T>;
     (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
 }
 declare abstract class AsyncDriver extends DriverBase {
@@ -64,23 +62,23 @@ declare abstract class AsyncDriver extends DriverBase {
     abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
     abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
+    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<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Cursor<T>): Promise<T>;
+    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: Cursor.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Cursor<T>): Promise<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: Cursor.SelectMultiple<T>): AsyncIterable<T>;
+    iterate<T>(cursor: Query.SelectMultiple<T>): AsyncIterable<T>;
     transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
 }
 declare class SyncWrapper extends AsyncDriver {
     private sync;
     lock: Promise<void> | undefined;
     constructor(sync: SyncDriver);
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    executeQuery(query: QueryData, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<unknown>;
     prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: AsyncDriver, release: () => Promise<void>];