memory-orm/lib/type.d.ts

client side ORM + map reduce

import { ListIteratee, ListIterator, Many, NotVoid, ObjectIteratee, ObjectIterator } from 'lodash'
import { Metadata, Rule } from './mem'
import { Model } from './model'
import { Struct } from './struct'
import { Query } from './query'
import { Datum } from './datum'
import { List } from './list'
import { Set } from './set'
declare type NAVI_LEAF = number
export declare type DATA<O> =
  | Partial<O>[]
  | {
      [id: string]: Partial<O>
    }
export declare type DATUM<O> = Partial<O>
export declare type DIC<T> = {
  [key: string]: T
}
export declare type HASH<K extends string, T> = {
  [key in K]: T
}
export declare type SET<A extends DEFAULT_RULE_TYPE> = Set<A>
export declare type LIST<A extends DEFAULT_RULE_TYPE> = List<A>
export declare type QUERY<A extends DEFAULT_RULE_TYPE> = Query<A>
export declare type QUERY_WITH_SCOPE<A extends DEFAULT_RULE_TYPE> = Query<A> & A[2]
export declare type ID = string | number
export declare type PATH = string | (string | number)[]
export declare type LeafEmitter = Emitter<LeafCmd>
export declare type OrderEmitter = Emitter<OrderCmd>
export declare type MODEL = Model | Struct
export interface MODEL_DATA {
  idx?: string
  _id?: string
  id: string
}
export declare type NAVI = {
  [key: string]: NAVI | NAVI_LEAF
}
export declare type DEPLOY<O> = {
  (
    this: O,
    cmd: {
      o: O
      model: CLASS<O>
      reduce: LeafEmitter
      order: OrderEmitter
    }
  ): void
}
export declare type SCHEMA<A extends DEFAULT_RULE_TYPE> = {
  (this: Rule<A>): void
}
export declare type SCOPE<A extends DEFAULT_RULE_TYPE> = {
  (all: QUERY_WITH_SCOPE<A>): Partial<A[2]>
}
export declare type DEFAULT_RULE_TYPE = [MODEL_DATA, DIC<any>, DIC<any>]
export declare type Emitter<T> = {
  (keys: PATH, cmd: T): void
}
export declare type NameBase = {
  base: string
  list: string
  id: string
  ids: string
  relations: string[]
  deploys: DEPLOY<any>[]
  depends: (() => void)[]
}
export declare type Cache = {
  $format: {
    [path: string]: ReduceLeaf
  }
  $memory: Memory
  $sort: {
    [path: string]: OrderCmd
  }
}
export declare type Filter = {
  (item: any, meta: Metadata): boolean
}
export declare type PathCmd = {
  key: string
}
export declare type RelationCmd = Partial<{
  key: string
  target: string
  miss: string
  cost: number
  directed: boolean
  reverse: boolean
}>
export declare type SortIterationCmd = Many<
  | ListIterator<any, NotVoid>
  | ListIteratee<any>
  | ObjectIterator<any, NotVoid>
  | ObjectIteratee<any>
>
export declare type SortCmd =
  | [SortIterationCmd]
  | [SortIterationCmd, Many<boolean | 'asc' | 'desc'>]
export declare type OrderCmd = Partial<{
  belongs_to: string
  pluck: string
  index: string
  cover: string[]
  diff: string[]
  quantile: number
  mode: boolean
  page: boolean
  sort: SortCmd
}>
export declare type ReduceOrderPage<A extends DEFAULT_RULE_TYPE> = ReduceOrder<A>[] & {
  query: Query<A>
  from: ReduceLeaf
  all: number
  page_idx(this: Reduce[][], item: Object): number | null
}
export declare type ReduceOrder<A extends DEFAULT_RULE_TYPE> = List<A> &
  Partial<{
    query: Query<A>
    from: ReduceLeaf
    id: string
    all: number
    remain: string[]
    cover: string[]
    quantile: ReduceOrder<A>
  }>
export declare type LeafCmd = Partial<{
  id: ID
  list: boolean
  navi: string[]
  set: string | number
  max: string | number
  min: string | number
  count: number
  all: number
  pow: number
}>
export declare type ReduceLeaf = Partial<{
  id: ID
  list: (Model | Struct)[]
  hash: {
    [key: string]: Model | Struct
  }
  navi: NAVI
  set: string[]
  max_is: any
  min_is: any
  max: string | number
  min: string | number
  variance_data: number[]
  variance: number
  count: number
  all: number
  pow: number
  avg: number
  sd: number
  standard(this: ReduceLeaf, data: number): number
  range: number
  density: number
}>
export declare type Reduce =
  | {
      [key: string]: Reduce
    }
  | ReduceLeaf
export declare type ReduceDefault<A extends DEFAULT_RULE_TYPE> = {
  list: LIST<A>
  hash: HASH<string, A>
}
export interface Memory {
  [key: string]: Datum
}
export interface SetContext<A extends DEFAULT_RULE_TYPE> {
  model: typeof Model | typeof Struct
  all: Query<A>
  base: Cache
  journal: Cache
  meta: Metadata
  deploys: DEPLOY<any>[]
  from: DATA<A[0]>
  parent: Object | undefined
}
export declare type CLASS<O> = {
  $name: NameBase
  bless(data: any, query?: any): asserts data is O
  new (): O
  new (rule: any): O
}
export declare type QUERY_ARGS = {
  [path: string]: (string | number)[] | RegExp | string | number | boolean | null
}
export {}