rado 0.2.21 → 0.2.23

package/dist/define/Ops.js

@@ -1,37 +1,36 @@
 // src/define/Ops.ts
-import { Cursor } from "./Cursor.js";
 import { ExprData } from "./Expr.js";
-import { Query } from "./Query.js";
+import { Query, QueryData } from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Table } from "./Table.js";
 import { Target } from "./Target.js";
 function select(selection) {
-  return new Cursor.SelectMultiple(
-    Query.Select({
+  return new Query.SelectMultiple(
+    new QueryData.Select({
       selection: ExprData.create(selection)
     })
   );
 }
 function from(source) {
-  const target = source instanceof Cursor ? Target.Query(source[Cursor.Query]) : Target.Table(source[Table.Data]);
-  return new Cursor.SelectMultiple(
-    Query.Select({
+  const target = Query.isQuery(source) ? new Target.Query(source[Query.Data]) : new Target.Table(source[Table.Data]);
+  return new Query.SelectMultiple(
+    new QueryData.Select({
       from: target,
-      selection: ExprData.Row(target)
+      selection: new ExprData.Row(target)
     })
   );
 }
 function update(table) {
-  return new Cursor.Update(Query.Update({ table: table[Table.Data] }));
+  return new Query.Update(new QueryData.Update({ table: table[Table.Data] }));
 }
 function insertInto(table) {
-  return new Cursor.Insert(table[Table.Data]);
+  return new Query.Insert(table[Table.Data]);
 }
 function deleteFrom(table) {
-  return new Cursor.Delete(Query.Delete({ table: table[Table.Data] }));
+  return new Query.Delete(new QueryData.Delete({ table: table[Table.Data] }));
 }
 function create(...tables) {
-  return new Cursor.Batch(
+  return new Query.Batch(
     tables.flatMap((table) => Schema.create(table[Table.Data]).queries)
   );
 }

package/dist/define/Param.d.ts

@@ -1,15 +1,17 @@
 export declare enum ParamType {
-    Value = "Value",
-    Named = "Named"
+    Value = "ParamData.Value",
+    Named = "ParamData.Named"
 }
-export type ParamData = {
-    type: ParamType.Value;
-    value: any;
-} | {
-    type: ParamType.Named;
-    name: string;
-};
-export declare const ParamData: {
-    Value(value: any): ParamData;
-    Named(name: string): ParamData;
-};
+export declare namespace ParamData {
+    class Value {
+        value: any;
+        type: ParamType.Value;
+        constructor(value: any);
+    }
+    class Named {
+        name: string;
+        type: ParamType.Named;
+        constructor(name: string);
+    }
+}
+export type ParamData = ParamData.Value | ParamData.Named;

package/dist/define/Param.js

@@ -1,17 +1,26 @@
 // src/define/Param.ts
 var ParamType = /* @__PURE__ */ ((ParamType2) => {
-  ParamType2["Value"] = "Value";
-  ParamType2["Named"] = "Named";
+  ParamType2["Value"] = "ParamData.Value";
+  ParamType2["Named"] = "ParamData.Named";
   return ParamType2;
 })(ParamType || {});
-var ParamData = {
-  Value(value) {
-    return { type: "Value" /* Value */, value };
-  },
-  Named(name) {
-    return { type: "Named" /* Named */, name };
+var ParamData;
+((ParamData2) => {
+  class Value {
+    constructor(value) {
+      this.value = value;
+    }
+    type = "ParamData.Value" /* Value */;
   }
-};
+  ParamData2.Value = Value;
+  class Named {
+    constructor(name) {
+      this.name = name;
+    }
+    type = "ParamData.Named" /* Named */;
+  }
+  ParamData2.Named = Named;
+})(ParamData || (ParamData = {}));
 export {
   ParamData,
   ParamType

package/dist/define/Query.d.ts

@@ -1,29 +1,33 @@
+import { Driver } from '../lib/Driver';
+import { CompileOptions } from '../lib/Formatter';
 import { ColumnData } from './Column';
-import { ExprData } from './Expr';
+import { EV, Expr, ExprData } from './Expr';
 import { IndexData } from './Index';
 import { OrderBy } from './OrderBy';
-import { TableData } from './Table';
+import { Selection } from './Selection';
+import { Table, TableData } from './Table';
 import { Target } from './Target';
+declare const DATA: unique symbol;
 export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    AlterTable = "AlterTable",
-    DropTable = "DropTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
+    Insert = "QueryData.Insert",
+    Select = "QueryData.Select",
+    Update = "QueryData.Update",
+    Delete = "QueryData.Delete",
+    CreateTable = "QueryData.CreateTable",
+    AlterTable = "QueryData.AlterTable",
+    DropTable = "QueryData.DropTable",
+    CreateIndex = "QueryData.CreateIndex",
+    DropIndex = "QueryData.DropIndex",
+    Batch = "QueryData.Batch",
+    Transaction = "QueryData.Transaction",
+    Raw = "QueryData.Raw"
 }
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.AlterTable | Query.DropTable | Query.CreateIndex | Query.DropIndex | Query.Batch | Query.Transaction | Query.Raw;
-export declare namespace Query {
-    interface QueryBase {
+export type QueryData = QueryData.Insert | QueryData.Select | QueryData.Update | QueryData.Delete | QueryData.CreateTable | QueryData.AlterTable | QueryData.DropTable | QueryData.CreateIndex | QueryData.DropIndex | QueryData.Batch | QueryData.Transaction | QueryData.Raw;
+export declare namespace QueryData {
+    abstract class Data<T> {
+        abstract type: QueryType;
         limit?: number;
         offset?: number;
-        type: QueryType;
         where?: ExprData;
         orderBy?: Array<OrderBy>;
         groupBy?: Array<ExprData>;
@@ -31,38 +35,34 @@ export declare namespace Query {
         selection?: ExprData;
         singleResult?: boolean;
         validate?: boolean;
+        constructor(data: Omit<T, 'type'>);
     }
-    interface Insert extends QueryBase {
-        type: QueryType.Insert;
-        into: TableData;
-        data?: Array<any>;
-        select?: Query.Select;
-    }
-    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
-    interface Select extends QueryBase {
+    export class Select extends Data<Select> {
         type: QueryType.Select;
         selection: ExprData;
         from?: Target;
     }
-    function Select(select: Omit<Select, 'type'>): Query.Select;
-    interface Update extends QueryBase {
+    export class Insert extends Data<Insert> {
+        type: QueryType.Insert;
+        into: TableData;
+        data?: Array<any>;
+        select?: QueryData.Select;
+    }
+    export class Update extends Data<Update> {
         type: QueryType.Update;
         table: TableData;
         set?: Record<string, any>;
     }
-    function Update(update: Omit<Update, 'type'>): Query.Update;
-    interface Delete extends QueryBase {
+    export class Delete extends Data<Delete> {
         type: QueryType.Delete;
         table: TableData;
     }
-    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
-    interface CreateTable extends QueryBase {
+    export class CreateTable extends Data<CreateTable> {
         type: QueryType.CreateTable;
         table: TableData;
         ifNotExists?: boolean;
     }
-    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
-    interface AlterTable extends QueryBase {
+    export class AlterTable extends Data<AlterTable> {
         type: QueryType.AlterTable;
         table: TableData;
         alterColumn?: ColumnData;
@@ -76,49 +76,149 @@ export declare namespace Query {
             from: string;
         };
     }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-    interface DropTable extends QueryBase {
+    export class DropTable extends Data<DropTable> {
         type: QueryType.DropTable;
         table: TableData;
         ifExists?: boolean;
     }
-    function DropTable(drop: Omit<DropTable, 'type'>): Query.DropTable;
-    interface CreateIndex extends QueryBase {
+    export class CreateIndex extends Data<CreateIndex> {
         type: QueryType.CreateIndex;
         table: TableData;
         index: IndexData;
         ifNotExists?: boolean;
     }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
+    export class DropIndex extends Data<DropIndex> {
         type: QueryType.DropIndex;
         table: TableData;
         name: string;
         ifExists?: boolean;
     }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    interface Batch extends QueryBase {
+    export class Batch extends Data<Batch> {
         type: QueryType.Batch;
-        queries: Array<Query<any>>;
+        queries: Array<QueryData>;
     }
-    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
-    enum TransactionOperation {
+    export enum TransactionOperation {
         Begin = "Begin",
         Commit = "Commit",
         Rollback = "Rollback"
     }
-    interface Transaction extends QueryBase {
+    export class Transaction extends Data<Transaction> {
         type: QueryType.Transaction;
         id: string;
         op: TransactionOperation;
     }
-    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
-    type RawReturn = 'row' | 'rows' | undefined;
-    interface Raw extends QueryBase {
+    export type RawReturn = 'row' | 'rows' | undefined;
+    export class Raw extends Data<Raw> {
         type: QueryType.Raw;
         expectedReturn?: 'row' | 'rows';
         strings: ReadonlyArray<string>;
         params: Array<any>;
+        constructor(data: Omit<Raw, 'type'>);
+    }
+    export {};
+}
+export declare class Query<T> {
+    [Selection.CursorType]: () => T;
+    [DATA]: QueryData;
+    constructor(query: QueryData);
+    static all(strings: TemplateStringsArray, ...params: Array<any>): Query<any>;
+    next<T>(cursor: Query<T>): Query<T>;
+    on(driver: Driver.Sync): T;
+    on(driver: Driver.Async): Promise<T>;
+    toSql(driver: Driver, options?: CompileOptions): string;
+    toJSON(): QueryData;
+}
+export declare namespace Query {
+    class Delete extends Query<{
+        rowsAffected: number;
+    }> {
+        [DATA]: QueryData.Delete;
+        where(...where: Array<EV<boolean>>): Delete;
+        take(limit: number | undefined): Delete;
+        skip(offset: number | undefined): Delete;
+    }
+    class Update<Definition> extends Query<{
+        rowsAffected: number;
+    }> {
+        [DATA]: QueryData.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 Query<T> {
+    }
+    class Inserted extends Query<{
+        rowsAffected: number;
+    }> {
+        [DATA]: QueryData.Insert;
+        constructor(query: QueryData.Insert);
+        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+    }
+    class Insert<Definition> {
+        protected into: TableData;
+        constructor(into: TableData);
+        selection(query: Query.SelectMultiple<Table.Select<Definition>>): Inserted;
+        values(...data: Array<Table.Insert<Definition>>): Inserted;
+    }
+    class CreateTable extends Query<void> {
+        protected table: TableData;
+        constructor(table: TableData);
     }
-    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    class Batch<T = void> extends Query<T> {
+        protected queries: Array<QueryData>;
+        [DATA]: QueryData.Batch;
+        constructor(queries: Array<QueryData>);
+        next<T>(cursor: Query<T>): Query<T>;
+    }
+    class SelectMultiple<Row> extends Query<Array<Row>> {
+        [DATA]: QueryData.Select;
+        constructor(query: QueryData.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>;
+        maybeFirst(): SelectSingle<Row | undefined>;
+        first(): 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;
+        [DATA]: QueryData.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>): Query<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 Query<Row> {
+        [DATA]: QueryData.Select;
+        constructor(query: QueryData.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 declare namespace Query {
+    const Data: typeof DATA;
+    function isQuery<T>(input: any): input is Query<T>;
+    function isSingle<T>(input: any): input is Query.SelectSingle<T>;
+    function isMultiple<T>(input: any): input is Query.SelectMultiple<T>;
 }
+export {};