rado 0.3.2 → 0.3.4

package/dist/lib/Expr.d.ts

@@ -1,154 +0,0 @@
-import { Cursor } from './Cursor';
-import { Fields } from './Fields';
-import { OrderBy } from './OrderBy';
-import { ParamData } from './Param';
-import { Query } from './Query';
-import { Selection } from './Selection';
-import { Target } from './Target';
-export declare enum UnOp {
-    Not = "Not",
-    IsNull = "IsNull"
-}
-export declare enum BinOp {
-    Add = "Add",
-    Subt = "Subt",
-    Mult = "Mult",
-    Mod = "Mod",
-    Div = "Div",
-    Greater = "Greater",
-    GreaterOrEqual = "GreaterOrEqual",
-    Less = "Less",
-    LessOrEqual = "LessOrEqual",
-    Equals = "Equals",
-    NotEquals = "NotEquals",
-    And = "And",
-    Or = "Or",
-    Like = "Like",
-    Glob = "Glob",
-    Match = "Match",
-    In = "In",
-    NotIn = "NotIn",
-    Concat = "Concat"
-}
-export declare enum ExprType {
-    UnOp = "UnOp",
-    BinOp = "BinOp",
-    Field = "Field",
-    Param = "Param",
-    Call = "Call",
-    Query = "Query",
-    Record = "Record",
-    Row = "Row",
-    Map = "Map",
-    Filter = "Filter",
-    Merge = "Merge",
-    Case = "Case"
-}
-export type ExprData = {
-    type: ExprType.UnOp;
-    op: UnOp;
-    expr: ExprData;
-} | {
-    type: ExprType.BinOp;
-    op: BinOp;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Field;
-    expr: ExprData;
-    field: string;
-} | {
-    type: ExprType.Param;
-    param: ParamData;
-} | {
-    type: ExprType.Call;
-    method: string;
-    params: Array<ExprData>;
-} | {
-    type: ExprType.Query;
-    query: Query.Select;
-} | {
-    type: ExprType.Record;
-    fields: Record<string, ExprData>;
-} | {
-    type: ExprType.Merge;
-    a: ExprData;
-    b: ExprData;
-} | {
-    type: ExprType.Row;
-    target: Target;
-} | {
-    type: ExprType.Map;
-    target: Target;
-    result: ExprData;
-} | {
-    type: ExprType.Filter;
-    target: Target;
-    condition: ExprData;
-} | {
-    type: ExprType.Case;
-    expr: ExprData;
-    cases: Record<string, ExprData>;
-    defaultCase?: ExprData;
-};
-export declare const ExprData: {
-    UnOp(op: UnOp, expr: ExprData): ExprData;
-    BinOp(op: BinOp, a: ExprData, b: ExprData): ExprData;
-    Field(expr: ExprData, field: string): ExprData;
-    Param(param: ParamData): ExprData;
-    Call(method: string, params: Array<ExprData>): ExprData;
-    Query(query: Query.Select): ExprData;
-    Record(fields: Record<string, ExprData>): ExprData;
-    Merge(a: ExprData, b: ExprData): ExprData;
-    Row(target: Target): ExprData;
-    Map(target: Target, result: ExprData): ExprData;
-    Filter(target: Target, condition: ExprData): ExprData;
-    Case(expr: ExprData, cases: Record<string, ExprData>, defaultCase?: ExprData): ExprData;
-    create(input: any): ExprData;
-};
-/** Expression or value of type T */
-export type EV<T> = Expr<T> | T;
-export declare class Expr<T> {
-    expr: ExprData;
-    static NULL: ExprData;
-    static value<T>(value: T): Expr<T>;
-    static create<T>(input: EV<T>): Expr<T>;
-    static and(...conditions: Array<EV<boolean>>): Expr<boolean>;
-    static or(...conditions: Array<EV<boolean>>): Expr<boolean>;
-    constructor(expr: ExprData);
-    asc(): OrderBy;
-    desc(): OrderBy;
-    not(): Expr<boolean>;
-    or(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    and(this: Expr<boolean>, that: EV<boolean>): Expr<boolean>;
-    isNull(): Expr<boolean>;
-    isNotNull(): Expr<boolean>;
-    isNot(that: EV<T>): Expr<boolean>;
-    is(that: EV<T> | Cursor.SelectSingle<T>): Expr<boolean>;
-    in(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
-    notIn(that: EV<Array<T>> | Cursor.SelectMultiple<T>): Expr<boolean>;
-    add(this: Expr<number>, that: EV<number>): Expr<number>;
-    substract(this: Expr<number>, that: EV<number>): Expr<number>;
-    multiply(this: Expr<number>, that: EV<number>): Expr<number>;
-    remainder(this: Expr<number>, that: EV<number>): Expr<number>;
-    divide(this: Expr<number>, that: EV<number>): Expr<number>;
-    greater(that: EV<any>): Expr<boolean>;
-    greaterOrEqual(that: EV<any>): Expr<boolean>;
-    less(that: EV<any>): Expr<boolean>;
-    lessOrEqual(that: EV<any>): Expr<boolean>;
-    concat(this: Expr<string>, that: EV<string>): Expr<string>;
-    like(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    match(this: Expr<string>, that: EV<string>): Expr<boolean>;
-    with<X extends Selection>(that: X): Selection.With<T, X>;
-    at<T>(this: Expr<Array<T>>, index: number): Expr<T | null>;
-    filter<T>(this: Expr<Array<T>>, fn: (cursor: Fields<T>) => Expr<boolean>): Expr<Array<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>;
-}
-export declare namespace Expr {
-    type Record<T> = Expr<T> & {
-        [K in keyof T]: Expr<T[K]>;
-    };
-}

package/dist/lib/Fields.d.ts

@@ -1,13 +0,0 @@
-import { Column, PrimaryKey } from './Column';
-import { Expr } from './Expr';
-type ObjectUnion<T> = {
-    [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
-};
-type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
-type FieldsOf<Row> = Row extends Record<string, any> ? {
-    [K in keyof Row]-?: Field<Row[K]>;
-} : never;
-type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
-export {};

package/dist/lib/Functions.d.ts

@@ -1,5 +0,0 @@
-import { Expr } from './Expr';
-export declare const Functions: Functions;
-export type Functions = {
-    [key: string]: (...args: Array<any>) => Expr<any>;
-};

package/dist/lib/Id.d.ts

@@ -1,3 +0,0 @@
-export type Id<T> = T extends {
-    id: any;
-} ? T['id'] : never;

package/dist/lib/Index.d.ts

@@ -1,17 +0,0 @@
-import { Expr, ExprData } from './Expr';
-interface PartialIndexData {
-    on: Array<ExprData>;
-    unique?: boolean;
-    where?: ExprData;
-}
-export interface IndexData extends PartialIndexData {
-    name: string;
-}
-export declare class Index {
-    data: PartialIndexData;
-    constructor(data: PartialIndexData);
-    unique(): Index;
-    where(where: Expr<boolean>): Index;
-}
-export declare function index(...on: Array<Expr<any>>): Index;
-export {};

package/dist/lib/Ops.d.ts

@@ -1,7 +0,0 @@
-import { Cursor } from './Cursor';
-import { Table } from './Table';
-export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
-export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
-export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
-export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
-export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/lib/OrderBy.d.ts

@@ -1,9 +0,0 @@
-import { ExprData } from './Expr';
-export declare enum OrderDirection {
-    Asc = "Asc",
-    Desc = "Desc"
-}
-export type OrderBy = {
-    expr: ExprData;
-    order: OrderDirection;
-};

package/dist/lib/Param.d.ts

@@ -1,20 +0,0 @@
-import { Expr } from './Expr';
-export declare enum ParamType {
-    Value = "Value",
-    Named = "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 type Params<T> = {
-    [K in keyof T]: Expr<T[K]>;
-};
-export declare function createParams<T>(): Params<T>;

package/dist/lib/Query.d.ts

@@ -1,109 +0,0 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { IndexData } from './Index';
-import { OrderBy } from './OrderBy';
-import { Schema } from './Schema';
-import { Target } from './Target';
-export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    AlterTable = "AlterTable",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
-}
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
-export declare namespace Query {
-    interface QueryBase {
-        limit?: number;
-        offset?: number;
-        type: QueryType;
-        where?: ExprData;
-        orderBy?: Array<OrderBy>;
-        groupBy?: Array<ExprData>;
-        having?: ExprData;
-        selection?: ExprData;
-        singleResult?: boolean;
-        validate?: boolean;
-    }
-    interface Insert extends QueryBase {
-        type: QueryType.Insert;
-        into: Schema;
-        data: Array<any>;
-    }
-    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
-    interface Select extends QueryBase {
-        type: QueryType.Select;
-        selection: ExprData;
-        from: Target;
-    }
-    function Select(select: Omit<Select, 'type'>): Query.Select;
-    interface Update extends QueryBase {
-        type: QueryType.Update;
-        table: Schema;
-        set?: Record<string, any>;
-    }
-    function Update(update: Omit<Update, 'type'>): Query.Update;
-    interface Delete extends QueryBase {
-        type: QueryType.Delete;
-        table: Schema;
-    }
-    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
-    interface CreateTable extends QueryBase {
-        type: QueryType.CreateTable;
-        table: Schema;
-        ifNotExists?: boolean;
-    }
-    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
-    interface CreateIndex extends QueryBase {
-        type: QueryType.CreateIndex;
-        table: Schema;
-        index: IndexData;
-        ifNotExists?: boolean;
-    }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
-        type: QueryType.DropIndex;
-        table: Schema;
-        name: string;
-        ifExists?: boolean;
-    }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    interface Batch extends QueryBase {
-        type: QueryType.Batch;
-        queries: Array<Query<any>>;
-    }
-    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
-    enum TransactionOperation {
-        Begin = "Begin",
-        Commit = "Commit",
-        Rollback = "Rollback"
-    }
-    interface Transaction extends QueryBase {
-        type: QueryType.Transaction;
-        id: string;
-        op: TransactionOperation;
-    }
-    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
-    type RawReturn = 'row' | 'rows' | undefined;
-    interface Raw extends QueryBase {
-        type: QueryType.Raw;
-        expectedReturn?: 'row' | 'rows';
-        strings: ReadonlyArray<string>;
-        params: Array<any>;
-    }
-    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
-    interface AlterTable extends QueryBase {
-        type: QueryType.AlterTable;
-        table: Schema;
-        alterColumn?: ColumnData;
-        addColumn?: ColumnData;
-        dropColumn?: string;
-    }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-}

package/dist/lib/Schema.d.ts

@@ -1,18 +0,0 @@
-import { ColumnData } from './Column';
-import { Formatter } from './Formatter';
-import { IndexData } from './Index';
-import { Query } from './Query';
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, IndexData>;
-}
-export interface SchemaInstructions {
-    columns: Record<string, string>;
-    indexes: Record<string, string>;
-}
-export declare namespace Schema {
-    function create(schema: Schema): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
-}

package/dist/lib/Selection.d.ts

@@ -1,20 +0,0 @@
-import type { Cursor } from './Cursor';
-import type { Expr } from './Expr';
-type SelectionBase = (() => any) | Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
-interface SelectionRecord extends Record<string, Selection> {
-}
-export type Selection = SelectionBase | SelectionRecord;
-export declare namespace Selection {
-    const __tableType: unique symbol;
-    const __cursorType: unique symbol;
-    type Infer<T> = T extends {
-        [__tableType](): infer K;
-    } ? K : T extends {
-        [__cursorType](): infer K;
-    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
-        [K in keyof T as T[K] extends () => any ? never : K]: Infer<T[K]>;
-    } : T extends () => any ? never : T;
-    type With<A, B> = Expr<Combine<A, B>>;
-    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
-}
-export {};

package/dist/lib/Table.d.ts

@@ -1,62 +0,0 @@
-import { Column, PrimaryKey } from './Column';
-import { Cursor } from './Cursor';
-import { EV, Expr } from './Expr';
-import { Fields } from './Fields';
-import { Index } from './Index';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Update } from './Update';
-export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
-    [Selection.__tableType](): Table.Normalize<T>;
-    constructor(schema: Schema);
-    fetch(id: EV<T extends {
-        id: Column.IsPrimary<infer V, any>;
-    } ? V : never>): Cursor.SelectSingle<Table.Normalize<T> | undefined>;
-    insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
-    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
-    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
-    delete(): Cursor.Delete;
-    createTable(): Cursor.CreateTable;
-    as(alias: string): this;
-    alias(): Record<string, this>;
-    get(name: string): Expr<any>;
-    toExpr(): Expr<Table.Normalize<T>>;
-    schema(): Schema;
-}
-export declare namespace Table {
-    type Intersection<A, B> = A & B extends infer U ? {
-        [P in keyof U]: EV<U[P]>;
-    } : never;
-    type OptionalKeys<T> = {
-        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
-    }[keyof T];
-    type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.IsPrimary<any, any> ? never : T[K] extends Column.IsOptional<any> ? never : K;
-    }[keyof T];
-    type Optionals<T> = {
-        [K in keyof T]?: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
-    };
-    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
-    export type Normalize<T> = {
-        [K in keyof T]: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
-    };
-    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
-    export {};
-}
-export type TableOptions<T, R> = {
-    name: string;
-    alias?: string;
-    columns: {
-        [K in keyof T]: Column<T[K]>;
-    };
-    indexes?: (this: Fields<T>) => Record<string, Index>;
-};
-export declare function table<T extends {}, R>(options: TableOptions<T, R>): Table<T> & Fields<T>;
-export declare namespace table {
-    export type infer<T> = Table.Infer<T>;
-    type Extensions<T> = {
-        [key: string]: (this: T, ...args: any[]) => any;
-    };
-    export function extend<T extends Table<any>, E extends Extensions<T>>(target: T, extensions: E): T & E;
-    export {};
-}

package/dist/lib/Target.d.ts

@@ -1,38 +0,0 @@
-import { ExprData } from './Expr';
-import { Query as QueryData } from './Query';
-import { Schema } from './Schema';
-export declare enum TargetType {
-    Expr = "Expr",
-    Query = "Query",
-    Table = "Table",
-    Join = "Join"
-}
-export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
-export declare namespace Target {
-    interface Expr {
-        type: TargetType.Expr;
-        expr: ExprData;
-        alias?: string;
-    }
-    function Expr(expr: ExprData, alias?: string): Expr;
-    interface Query {
-        type: TargetType.Query;
-        query: QueryData;
-        alias?: string;
-    }
-    function Query(query: QueryData, alias?: string): Query;
-    interface Table {
-        type: TargetType.Table;
-        table: Schema;
-    }
-    function Table(table: Schema): Table;
-    interface Join {
-        type: TargetType.Join;
-        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): Schema | undefined;
-}

package/dist/lib/Update.d.ts

@@ -1,4 +0,0 @@
-import type { EV } from './Expr';
-export type Update<Row> = Partial<{
-    [K in keyof Row]: EV<Row[K]>;
-}>;