rado 0.3.1 → 0.3.3

package/README.md

@@ -1,3 +1,5 @@
+[![npm](https://img.shields.io/npm/v/rado.svg)](https://npmjs.org/package/rado)
+
 # rado
 
 Fully typed, lightweight TypeScript query builder.

package/dist/define/Column.d.ts

@@ -17,6 +17,8 @@ export interface PartialColumnData {
     primaryKey?: boolean;
     unique?: boolean;
     references?: () => ExprData;
+    onUpdate?: Action;
+    onDelete?: Action;
     enumerable?: boolean;
 }
 export interface ColumnData extends PartialColumnData {
@@ -46,9 +48,20 @@ export declare class ValueColumn<T> extends Callable implements Column<T> {
     get unique(): ValueColumn<T>;
     get autoIncrement(): OptionalColumn<T>;
     primaryKey<K = string>(create?: () => EV<T>): PrimaryColumn<T, K>;
-    references<X extends T>(column: Expr<X> | (() => Expr<X>)): ValueColumn<X>;
+    references<X extends T>(column: Expr<X> | (() => Expr<X>)): ForeignKey<X>;
     default(value: DefaultValue<T>): OptionalColumn<T>;
 }
+export declare enum Action {
+    NoAction = "no action",
+    Restrict = "restrict",
+    SetNull = "set null",
+    SetDefault = "set default",
+    Cascade = "cascade"
+}
+export declare class ForeignKey<T> extends ValueColumn<T> {
+    onUpdate(value: `${Action}`): ForeignKey<unknown>;
+    onDelete(value: `${Action}`): ForeignKey<unknown>;
+}
 export declare class OptionalColumn<T> extends ValueColumn<T> {
     [Column.IsOptional]: true;
 }

package/dist/define/Column.js

@@ -40,7 +40,7 @@ class ValueColumn extends Callable {
     });
   }
   references(column2) {
-    return new ValueColumn({
+    return new ForeignKey({
       ...this[Column.Data],
       references() {
         return ExprData.create(Expr.isExpr(column2) ? column2 : column2());
@@ -57,6 +57,28 @@ class ValueColumn extends Callable {
 function createDefaultValue(value) {
   return typeof value === "function" && !Expr.isExpr(value) ? () => ExprData.create(value()) : ExprData.create(value);
 }
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2["NoAction"] = "no action";
+  Action2["Restrict"] = "restrict";
+  Action2["SetNull"] = "set null";
+  Action2["SetDefault"] = "set default";
+  Action2["Cascade"] = "cascade";
+  return Action2;
+})(Action || {});
+class ForeignKey extends ValueColumn {
+  onUpdate(value) {
+    return new ForeignKey({
+      ...this[Column.Data],
+      onUpdate: value
+    });
+  }
+  onDelete(value) {
+    return new ForeignKey({
+      ...this[Column.Data],
+      onDelete: value
+    });
+  }
+}
 class OptionalColumn extends ValueColumn {
   [Column.IsOptional];
 }
@@ -147,8 +169,10 @@ class UnTyped extends Callable {
 }
 const column = new UnTyped();
 export {
+  Action,
   Column,
   ColumnType,
+  ForeignKey,
   ObjectColumn,
   OptionalColumn,
   OptionalObjectColumn,

package/dist/define/Expr.d.ts

@@ -1,10 +1,9 @@
 import { Fields } from './Fields.js';
 import { OrderBy } from './OrderBy.js';
 import { ParamData } from './Param.js';
-import { QueryData } from './Query.js';
+import { QueryData, Select, SelectFirst } from './Query.js';
 import { Selection } from './Selection.js';
 import { Target } from './Target.js';
-import { Select, SelectFirst } from './query/Select.js';
 export declare enum UnOpType {
     Not = "Not",
     IsNull = "IsNull"
@@ -161,6 +160,7 @@ export declare class Expr<T> {
     map<T, X extends Selection>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => X): Expr<Array<Selection.Infer<X>>>;
     sure(): Expr<NonNullable<T>>;
     get<T>(name: string): Expr<T>;
+    static [Symbol.hasInstance](instance: any): any;
 }
 export interface ObjectExpr {
     [Expr.Data]: ExprData;

package/dist/define/Expr.js

@@ -386,6 +386,9 @@ class Expr {
   get(name) {
     return new Expr(new ExprData.Field(this[Expr.Data], name));
   }
+  static [Symbol.hasInstance](instance) {
+    return instance?.[Expr.IsExpr];
+  }
 }
 ((Expr2) => {
   Expr2.Data = Symbol("Expr.Data");
@@ -419,7 +422,7 @@ class Expr {
   }
   Expr2.hasExpr = hasExpr;
   function isExpr(input) {
-    return input !== null && (typeof input === "object" || typeof input === "function") && input[Expr2.IsExpr];
+    return input instanceof Expr2;
   }
   Expr2.isExpr = isExpr;
 })(Expr || (Expr = {}));

package/dist/define/Ops.d.ts

@@ -1,11 +1,6 @@
+import { Batch, Delete, InsertInto, RecursiveUnion, Select, Update } from './Query.js';
 import { Selection } from './Selection.js';
 import { Table } from './Table.js';
-import { Batch } from './query/Batch.js';
-import { Delete } from './query/Delete.js';
-import { InsertInto } from './query/Insert.js';
-import { Select } from './query/Select.js';
-import { RecursiveUnion } from './query/Union.js';
-import { Update } from './query/Update.js';
 export declare function withRecursive<Row>(initialSelect: Select<Row>): RecursiveUnion<Row>;
 export declare function alias<T extends Table<{}>>(table: T): Record<string, T>;
 export declare function select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;

package/dist/define/Ops.js

@@ -1,14 +1,17 @@
 import { ExprData } from "./Expr.js";
-import { Query, QueryData } from "./Query.js";
+import {
+  Batch,
+  Delete,
+  InsertInto,
+  Query,
+  QueryData,
+  RecursiveUnion,
+  Select,
+  Update
+} from "./Query.js";
 import { Schema } from "./Schema.js";
 import { Table, createTable } from "./Table.js";
 import { Target } from "./Target.js";
-import { Batch } from "./query/Batch.js";
-import { Delete } from "./query/Delete.js";
-import { InsertInto } from "./query/Insert.js";
-import { Select } from "./query/Select.js";
-import { RecursiveUnion } from "./query/Union.js";
-import { Update } from "./query/Update.js";
 function withRecursive(initialSelect) {
   return new RecursiveUnion(initialSelect[Query.Data]);
 }

package/dist/define/Query.d.ts

@@ -1,12 +1,13 @@
 import { Driver } from '../lib/Driver.js';
 import { CompileOptions } from '../lib/Formatter.js';
 import { ColumnData } from './Column.js';
-import { EV, ExprData } from './Expr.js';
+import { EV, Expr, ExprData } from './Expr.js';
 import { IndexData } from './Index.js';
 import { OrderBy } from './OrderBy.js';
 import { Selection } from './Selection.js';
-import { TableData } from './Table.js';
+import { Table, TableData } from './Table.js';
 import { Target } from './Target.js';
+import { VirtualTable } from './VirtualTable.js';
 export declare enum QueryType {
     Insert = "QueryData.Insert",
     Select = "QueryData.Select",
@@ -151,3 +152,117 @@ export declare namespace Query {
     const Data: unique symbol;
     function isQuery<T>(input: any): input is Query<T>;
 }
+export declare class Batch<T = void> extends Query<T> {
+    protected queries: Array<QueryData>;
+    [Query.Data]: QueryData.Batch;
+    constructor(queries: Array<QueryData>);
+    next<T>(cursor: Query<T>): Query<T>;
+}
+export declare class CreateTable extends Query<void> {
+    protected table: TableData;
+    constructor(table: TableData);
+}
+export declare class Delete extends Query<{
+    rowsAffected: number;
+}> {
+    [Query.Data]: QueryData.Delete;
+    constructor(query: QueryData.Delete);
+    where(...where: Array<EV<boolean>>): Delete;
+    orderBy(...orderBy: Array<OrderBy>): Delete;
+    take(limit: number | undefined): Delete;
+    skip(offset: number | undefined): Delete;
+}
+export declare class Insert<T = {
+    rowsAffected: number;
+}> extends Query<T> {
+    [Query.Data]: QueryData.Insert;
+    constructor(query: QueryData.Insert);
+    returning<X extends Selection>(selection: X): Insert<Array<Selection.Infer<X>>>;
+}
+export declare class InsertOne<T> extends Query<T> {
+    [Query.Data]: QueryData.Insert;
+    constructor(query: QueryData.Insert);
+    returning<X extends Selection>(selection: X): Insert<Selection.Infer<X>>;
+}
+export declare class InsertInto<Definition> {
+    protected into: TableData;
+    constructor(into: TableData);
+    selection(query: Select<Table.Select<Definition>>): Insert;
+    values(...data: Array<Table.Insert<Definition>>): Insert;
+}
+export declare class RecursiveUnion<Row> {
+    initialSelect: QueryData.Select;
+    constructor(initialSelect: QueryData.Select);
+    union(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
+    unionAll(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
+}
+export declare class Union<Row> extends Query<Array<Row>> {
+    [Query.Data]: QueryData.Union | QueryData.Select;
+    constructor(query: QueryData.Union | QueryData.Select);
+    union(query: Select<Row> | Union<Row>): Union<Row>;
+    unionAll(query: Select<Row> | Union<Row>): Union<Row>;
+    except(query: Select<Row> | Union<Row>): Union<Row>;
+    intersect(query: Select<Row> | Union<Row>): Union<Row>;
+}
+export declare class Select<Row> extends Union<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any> | VirtualTable<any>): Select<Row>;
+    indexedBy(index: IndexData): Select<unknown>;
+    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
+    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
+    select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;
+    count(): SelectFirst<number>;
+    orderBy(...orderBy: Array<Expr<any> | OrderBy>): Select<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): Select<Row>;
+    maybeFirst(): SelectFirst<Row | null>;
+    first(): SelectFirst<Row>;
+    where(...where: Array<EV<boolean>>): Select<Row>;
+    take(limit: number | undefined): Select<Row>;
+    skip(offset: number | undefined): Select<Row>;
+    [Expr.ToExpr](): Expr<Row>;
+}
+export declare class SelectFirst<Row> extends Query<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any>): Select<Row>;
+    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
+    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
+    select<X extends Selection>(selection: X): SelectFirst<Selection.Infer<X>>;
+    orderBy(...orderBy: Array<OrderBy>): SelectFirst<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): SelectFirst<Row>;
+    where(...where: Array<EV<boolean>>): SelectFirst<Row>;
+    take(limit: number | undefined): SelectFirst<Row>;
+    skip(offset: number | undefined): SelectFirst<Row>;
+    all(): Select<Row>;
+    [Expr.ToExpr](): Expr<Row>;
+}
+export declare class TableSelect<Definition> extends Select<Table.Select<Definition>> {
+    protected table: TableData;
+    [Query.Data]: QueryData.Select;
+    constructor(table: TableData, conditions?: Array<EV<boolean>>);
+    as(alias: string): Table<Definition>;
+    create(): CreateTable;
+    insert(query: Select<Table.Insert<Definition>>): Insert;
+    insert(rows: Array<Table.Insert<Definition>>): Insert;
+    insert(row: Table.Insert<Definition>): InsertOne<Table.Select<Definition>>;
+    insertSelect(query: Select<Table.Insert<Definition>>): Insert<{
+        rowsAffected: number;
+    }>;
+    insertOne(record: Table.Insert<Definition>): InsertOne<{ [K in keyof Definition as Definition[K] extends import("./Column.js").Column<any> ? K : never]: Definition[K] extends import("./Column.js").Column<infer T> ? T : never; }>;
+    insertAll(data: Array<Table.Insert<Definition>>): Insert<{
+        rowsAffected: number;
+    }>;
+    set(data: Table.Update<Definition>): Update<Definition>;
+    delete(): Delete;
+    get(name: string): Expr<any>;
+}
+export declare class Update<Definition> extends Query<{
+    rowsAffected: number;
+}> {
+    [Query.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>;
+}