@alinea/store

export enum BinOp

{

Add

And

Concat

Div

Equals

Glob

Greater

GreaterOrEqual

Less

LessOrEqual

Match

Mod

Mult

NotEquals

NotIn

Subt

}

export const Collection: CollectionConstructor

export interface CollectionConstructor

{

constructor<Row>(

options: CollectionOptions

): Collection<Row>

extend:

{}

}

export class CollectionImpl<Row extends {} = any> extends CursorImpl<Row>

{

constructor<Row extends {} = any>(

options: CollectionOptions

): CollectionImpl<Row>

cursor: CursorData

get fields(): Selection<Row>

get id(): Expr<string>

as<T = Row>(

): Collection<T>

first(): CursorSingleRow<Row>

get<K extends string | number | symbol>(

): Expr<Row[K]>

get(

): Expr<any>

groupBy(

groupBy: Array<Expr<any>>

): Cursor<Row>

groupBy(

pick: {}

): Cursor<Row>

having(

having: Expr<boolean>

): Cursor<Row>

include(

selection: I

): Cursor<Omit<Row, keyof TypeOf> & TypeOf>

innerJoin<T>(

that: Collection<T>,

on: Expr<boolean>

): Cursor<Row>

leftJoin<T>(

that: Collection<T>,

on: Expr<boolean>

): Cursor<Row>

orderBy(

orderBy: Array<OrderBy>

): Cursor<Row>

orderBy(

pick: {}

): Cursor<Row>

pick<Props extends Array<keyof Row>>(

properties: Props

): Selection<>

select<X extends SelectionInput | {}>(

selection: X

): Cursor<TypeOf<X>>

skip(

offset: undefined | number

): Cursor<Row>

take(

limit: undefined | number

): Cursor<Row>

toExpr(): Expr<unknown>

toJSON(): CursorData

union(

that: Cursor<Row>

): Cursor<Row>

where(

where: EV<boolean> | {}

): Cursor<Row>

with<X extends SelectionInput>(

that: X

): With<Row, X>

extend<Row, F extends Record<string, Expr<any>>>(

collection: Collection<Row>,

createFields: {}

): Collection<Row & TypeOf<F>>

}

export type CollectionOptions

{

alias: string

columns: Array<string>

flat: boolean

where: Expr<boolean>

computed(

collection: unknown

): Record<string, Expr<any>>

}

export const Cursor: CursorConstructor

export interface CursorConstructor

{

constructor<Row>(

cursor: CursorData

): Cursor<Row>

}

export type CursorData

{

from: From

groupBy: Array<ExprData>

having: ExprData

limit: number

offset: number

orderBy: Array<OrderBy>

selection: ExprData

singleResult: boolean

union: CursorData

where: ExprData

}

export class CursorImpl<Row>

{

constructor<Row>(

cursor: CursorData

): CursorImpl<Row>

cursor: CursorData

get fields(): Selection<Row>

first(): CursorSingleRow<Row>

get<K extends string | number | symbol>(

): Expr<Row[K]>

get(

): Expr<any>

groupBy(

groupBy: Array<Expr<any>>

): Cursor<Row>

groupBy(

pick: {}

): Cursor<Row>

having(

having: Expr<boolean>

): Cursor<Row>

include(

selection: I

): Cursor<Omit<Row, keyof TypeOf> & TypeOf>

innerJoin<T>(

that: Collection<T>,

on: Expr<boolean>

): Cursor<Row>

leftJoin<T>(

that: Collection<T>,

on: Expr<boolean>

): Cursor<Row>

orderBy(

orderBy: Array<OrderBy>

): Cursor<Row>

orderBy(

pick: {}

): Cursor<Row>

select<X extends SelectionInput | {}>(

selection: X

): Cursor<TypeOf<X>>

skip(

offset: undefined | number

): Cursor<Row>

take(

limit: undefined | number

): Cursor<Row>

toExpr(): Expr<unknown>

toJSON(): CursorData

union(

that: Cursor<Row>

): Cursor<Row>

where(

where: EV<boolean> | {}

): Cursor<Row>

with<S extends SelectionInput>(

selection: S

): With<Row, S>

}

export class CursorSingleRow<Row> extends CursorImpl<Row>

{

constructor<Row>(

cursor: CursorData

): CursorSingleRow<Row>

cursor: CursorData

get fields(): Selection<Row>

first(): CursorSingleRow<Row>

get<K extends string | number | symbol>(

): Expr<Row[K]>

get(

): Expr<any>

groupBy(

groupBy: Array<Expr<any>>

): Cursor<Row>

groupBy(

pick: {}

): Cursor<Row>

having(

having: Expr<boolean>

): Cursor<Row>

include(

selection: I

): Cursor<Omit<Row, keyof TypeOf> & TypeOf>

innerJoin<T>(

that: Collection<T>,

on: Expr<boolean>

): Cursor<Row>

leftJoin<T>(

that: Collection<T>,

on: Expr<boolean>

): Cursor<Row>

orderBy(

orderBy: Array<OrderBy>

): Cursor<Row>

orderBy(

pick: {}

): Cursor<Row>

select<X extends SelectionInput | {}>(

selection: X

): Cursor<TypeOf<X>>

skip(

offset: undefined | number

): Cursor<Row>

take(

limit: undefined | number

): Cursor<Row>

toExpr(): Expr<unknown>

toJSON(): CursorData

union(

that: Cursor<Row>

): Cursor<Row>

where(

where: EV<boolean> | {}

): Cursor<Row>

with<S extends SelectionInput>(

selection: S

): With<Row, S>

}

export type Document

{

id: string

}

export namespace Driver {

export type Options

{

fileMustExist: boolean

readonly: boolean

}

export type PreparedStatement

{

all<T>(

params: Array<any>

): Array<T>

get<T>(

params: Array<any>

): T

run(

params: Array<any>

): {changes: number}

}

export interface Driver

{

exec(

sql: String

): void

export(): Uint8Array

prepare(

sql: String

): PreparedStatement

transaction<T>(

run: {}

): T

}

/**

Expression or value of type T */

export type EV<T>

| Expr<T>

| T

export class Expr<T>

{

constructor<T>(

expr: ExprData

): Expr<T>

expr: ExprData

NULL: ExprData

uniqueId: number

__id(): string

add(

this: Expr<number>,

that: EV<number>

): Expr<number>

and(

this: Expr<boolean>,

that: EV<boolean>

): Expr<boolean>

asc(): OrderBy

at(

this: Expr<Array<T>>,

index: number

): Expr<null | T>

case<T extends string | number, C extends , DC extends SelectionInput>(

this: Expr<T>,

cases: C,

defaultCase: DC

): Expr<TypeOf<C[keyof C]> | TypeOf<DC>>

concat(

this: Expr<string>,

that: EV<string>

): Expr<string>

desc(): OrderBy

divide(

this: Expr<number>,

that: EV<number>

): Expr<number>

each<T>(

this: Expr<Array<T>>

): Cursor<T>

get<K extends string | number | symbol>(

): Expr<T[K]>

glob(

this: Expr<string>,

that: EV<string>

): Expr<boolean>

greater(

that: any

): Expr<boolean>

greaterOrEqual(

that: any

): Expr<boolean>

is(

that: EV<T> | CursorSingleRow<T>

): Expr<boolean>

isIn<T>(

this: Expr<T>,

that: EV<Array<T>> | Cursor<T>

): Expr<boolean>

isNot(

that: EV<T>

): Expr<boolean>

isNotIn<T>(

this: Expr<T>,

that: EV<Array<T>> | Cursor<T>

): Expr<boolean>

isNotNull(): Expr<boolean>

isNull(): Expr<boolean>

less(

that: any

): Expr<boolean>

lessOrEqual(

that: any

): Expr<boolean>

like(

this: Expr<string>,

that: EV<string>

): Expr<boolean>

map<T, X extends SelectionInput>(

this: Expr<Array<T>>,

fn: {}

): Selection<Array<TypeOf<X>>>

match(

this: Expr<string>,

that: EV<string>

): Expr<boolean>

multiply(

this: Expr<number>,

that: EV<number>

): Expr<number>

not(): Expr<boolean>

or(

this: Expr<boolean>,

that: EV<boolean>

): Expr<boolean>

remainder(

this: Expr<number>,

that: EV<number>

): Expr<number>

substract(

this: Expr<number>,

that: EV<number>

): Expr<number>

sure(): Expr<NonNullable<T>>

with<Row extends {}, X extends SelectionInput>(

this: Expr<Row>,

that: X

): With<Row, X>

create<T>(

input: EV<T>

): Expr<T>

value<T>(

value: T

): Expr<T>

}

export type ExprData

| {expr: ExprData, op: UnOp, type: ExprType.UnOp}

| {a: ExprData, b: ExprData, op: BinOp, type: ExprType.BinOp}

| {expr: ExprData, field: string, type: ExprType.Field}

| {param: ParamData, type: ExprType.Param}

| {method: string, params: Array<ExprData>, type: ExprType.Call}

| {cursor: CursorData, type: ExprType.Query}

| {fields: Record<string, ExprData>, type: ExprType.Record}

| {a: ExprData, b: ExprData, type: ExprType.Merge}

| {from: From, type: ExprType.Row}

| {cases: Record<string, ExprData>, defaultCase: ExprData, expr: ExprData, type: ExprType.Case}

export const ExprData:

{

BinOp(

op: BinOp,

a: ExprData,

b: ExprData

): ExprData

Call(

method: string,

params: Array<ExprData>

): ExprData

Case(

expr: ExprData,

cases: Record<string, ExprData>,

defaultCase: ExprData

): ExprData

Field(

expr: ExprData,

field: string

): ExprData

Merge(

a: ExprData,

b: ExprData

): ExprData

Param(

param: ParamData

): ExprData

Query(

cursor: CursorData

): ExprData

Record(

fields: Record<string, ExprData>

): ExprData

Row(

from: From

): ExprData

UnOp(

op: UnOp,

expr: ExprData

): ExprData

create(

input: any

): ExprData

}

export enum ExprType

{

BinOp

Call

Case

Field

Merge

Param

Query

Record

Row

UnOp

}

export namespace Fields {

export function create(

from: ExprData

): {}

}

export type Fields<T>

= IsStrictlyAny<T> extends true

? unknown

: FieldsOf<UnionToIntersection<RequiredKeepUndefined<T>>>

export type FormatCursorOptions

{

formatAsJson: boolean

formatInline: boolean

includeSelection: boolean

formatSubject(

selection: Statement

): Statement

}

export type FormatExprOptions

= FormatCursorOptions &

{

formatShallow: boolean

}

export class Formatter

{

constructor(): Formatter

escape(

value: any

): string

escapeId(

id: string

): string

format(

value: any,

asJson: undefined | boolean

): Statement

formatAccess(

asJson: undefined | boolean,

on: Statement,

field: string

): Statement

formatCursor(

cursor: CursorData,

options: FormatCursorOptions

): Statement

formatDelete(

cursor: CursorData,

options: FormatCursorOptions

): Statement

formatExpr(

expr: ExprData,

options: FormatExprOptions

): Statement

formatField(

expr: ExprData,

field: string,

options: FormatExprOptions

): Statement

formatFrom(

from: From,

options: FormatExprOptions

): Statement

formatGroupBy(

groupBy: undefined | Array<ExprData>,

options: FormatExprOptions

): Statement

formatHaving(

having: undefined | ExprData,

options: FormatExprOptions

): Statement

formatId(

id: string

): Statement

formatJsonAccess(

on: Statement,

field: string

): Statement

formatOrderBy(

orderBy: undefined | Array<OrderBy>,

options: FormatExprOptions

): Statement

formatSelect(

cursor: CursorData,

options: FormatCursorOptions

): Statement

formatString(

input: string

): Statement

formatUnwrapArray(

sql: Statement

): Statement

formatUpdate(

cursor: CursorData,

update: Record<string, any>,

options: FormatCursorOptions

): Statement

formatUpdateColumn(

update: Record<string, any>,

options: FormatExprOptions

): Statement

formatUpdateTable(

columns: Array<string>,

update: Record<string, any>,

options: FormatExprOptions

): Statement

formatValueAccess(

on: Statement,

field: string

): Statement

formatWhere(

where: undefined | ExprData,

options: FormatExprOptions

): Statement

tryDirectFieldOf(

expr: ExprData,

field: string,

options: FormatExprOptions

): undefined | Statement

}

export namespace From {

export function Column(

of: From,

column: string

): From

export function Each(

expr: ExprData,

alias: string

): From

export function Join(

left: From,

right: From,

join: "left" | "inner",

on: ExprData

): From

export function Table(

columns: Array<string>,

alias: string

): From

export function path(

from: From

): Array<string>

export function source(

from: From

): string

}

export type From

| {alias: string, expr: ExprData, type: FromType.Each}

| {alias: string, columns: Array<string>, name: string, type: FromType.Table}

| {column: string, of: From, type: FromType.Column}

| {join: "left" | "inner", left: From, on: ExprData, right: From, type: FromType.Join}

export enum FromType

{

Column

Each

Join

Table

}

/**

These will have to be supported in every driver */

export type Functions

{

arrayLength(

x: EV<Array<any>>

): Expr<number>

count(

x: Expr<any>

): Expr<number>

iif<T>(

x: EV<boolean>,

y: EV<T>,

z: EV<T>

): Expr<T>

}

export const Functions: Functions

export type IdLess<Row>

= Omit<Row, "id"> &

{

id: string

}

export type OrderBy

{

expr: ExprData

order: OrderDirection

}

export enum OrderDirection

{

Asc

Desc

}

export class Param

{

constructor(

param: ParamData

): Param

param: ParamData

value(

value: any

): Param

}

export type ParamData

| {type: ParamType.Value, value: any}

| {name: string, type: ParamType.Named}

export const ParamData:

{

Named(

): ParamData

Value(

value: any

): ParamData

}

export enum ParamType

{

Named

Value

}

export type QueryOptions

{

debug: boolean

}

export namespace Selection {

export type With<A, B>

= Selection<Omit<A, keyof Store.TypeOf> & Store.TypeOf>

}

export class Selection<T>

{

constructor<T>(

expr: ExprData

): Selection<T>

expr: ExprData

with<X extends SelectionInput>(

that: X

): With<T, X>

create(

input: any

): ExprData

}

export type SelectionInput

| SelectionInputBase

| SelectionInputRecord

export function sql(

strings: TemplateStringsArray,

inserts: Array<undefined | Statement | Param>

): Statement

export class Statement

{

constructor(

sql: string,

params: Array<ParamData>

): Statement

params: Array<ParamData>

sql: string

EMPTY: Statement

getParams(

input: Record<string, any>

): Array<any>

join(

statements: Array<undefined | Statement>,

separator: string

): Statement

raw(

sql: string

): Statement

}

export namespace Store {

export type TypeOf<T>

= T extends CursorSingleRow<infer K>

? K

: T extends Cursor<infer K>

? Array<K>

: T extends Expr<infer K>

? K

: T extends Selection<infer K>

? K

: T extends Record<string, SelectionInput | Cursor<any>>

: T extends {}

? TypeOf<K>

: T extends Promise<infer K>

? K

: T

}

export interface Store

{

all<Row>(

cursor: Cursor<Row>,

options: QueryOptions

): Array<Row>

count<Row>(

cursor: Cursor<Row>,

options: QueryOptions

): number

createIndex<Row extends Document>(

collection: Collection<Row>,

on: Array<Expr<any>>

): void

delete<Row>(

cursor: Cursor<Row>,

options: QueryOptions

): {changes: number}

first<Row>(

cursor: Cursor<Row>,

options: QueryOptions

): null | Row

insert<Row extends Document>(

collection: Collection<Row>,

object: IdLess<Row>,

options: QueryOptions

): Row

insertAll<Row extends Document>(

collection: Collection<Row>,

objects: Array<IdLess<Row>>,

options: QueryOptions

): Array<Row>

transaction<T>(

run: {}

): T

update<Row>(

cursor: Cursor<Row>,

update: Partial<>,

options: QueryOptions

): {changes: number}

}

export enum UnOp

{

IsNull

Not

}

export type Update<Row>

= Partial<>