Some work on typing rethinkdbdash

rethindbdash.js.flow

// @flow

declare module "rethinkdbdash" {
  declare type Runnable<T> = {
    run: () => Promise<T>,
  }

  declare type OrderedField = {}

  declare type IndexOpts = { index: string }
  declare type GroupOpts = { multi: bool } & IndexOpts
  declare type BoundOpts = { leftBound?: ?( "open" | "closed" ), rightBound?: ?( "open" | "closed" ) }
  declare type FilterOpts = { default: boolean | RethinkDBError }
  declare type BetweenOpts = { index?: string } & BoundOpts
  declare type ScalarLiteral = string | string[] | number | number[] | bool | bool[] | {}
  declare type OrderByOpts = string | OrderedField | { index: string | OrderedField }

  declare type Sequence = Table | Selection | Stream | Collection

  declare type Row = ( field: string ) => Scalar

  declare type RethinkDBError = { __isRethinkdbError: true, message: string }
  declare type PredicateJoin = ( row1: Row, row2: Row ) => AnyScalar
  declare type ScalarOperator<T> = ( value: T ) => T
  declare type ScalarOperators<T> = {
    add: ScalarOperator<T>,
    sub: ScalarOperator<T>,
    mul: ScalarOperator<T>,
    div: ScalarOperator<T>,
    mod: ScalarOperator<T>,
    lt: ScalarOperator<T>,
    gt: ScalarOperator<T>,
    le: ScalarOperator<T>,
    ge: ScalarOperator<T>,
    ne: ScalarOperator<T>,
    eq: ScalarOperator<T>,
  }

  declare type Scalar = {
    coerceTo: ( type: "binary" ) => Scalar,
    default: ( defaultValue: AnyScalar ) => Scalar,
    typeOf: () => Scalar,
    info: () => Scalar,
    toJSON: () => Scalar,
    toJsonString: () => Scalar,
  }

  declare type ScalarBoolean = Scalar & {
    branch: ( ifTrue: AnyValue, ifFalse: AnyValue ) => any,
    not: ScalarOperator<ScalarBoolean>,
    or: ScalarOperator<ScalarBoolean>,
  }

  declare type ScalarNumber = Scalar & ScalarOperators<ScalarNumber> & {

  }

  declare type ScalarString = Scalar & ScalarOperators<ScalarString> & {
    upcase: () => ScalarString,
    downcase: () => ScalarString,
    coerceTo: ( type: "number" ) => ScalarNumber,
    count: () => ScalarNumber,
    split: ( separator: string, maxSplits: number ) => Collection,
    match: ( regexp: RegExp ) => Scalar,
  }

  declare type ScalarObject<T: {}> = Scalar & {
    coerceTo: ( type: "array" ) => Collection,
    coerceTo: ( type: "string" ) => ScalarString,
    keys: () => Collection,
    values: () => Collection,
    hasFields: ( ...fields: string[] ) => ScalarBoolean,
    count: () => ScalarNumber,
  }

  declare type ScalarTime = Scalar & ScalarOperators<ScalarTime> & {
    inTimezone: ( timezone: string ) => ScalarTime,
    timezone: () => ScalarTime,
    date: () => ScalarTime,
    timeOfDay: () => ScalarTime,
    year: () => ScalarTime,
    month: () => ScalarTime,
    day: () => ScalarTime,
    dayOfWeek: () => ScalarTime,
    dayOfYear: () => ScalarTime,
    hours: () => ScalarTime,
    minutes: () => ScalarTime,
    seconds: () => ScalarTime,
    toISO8601: () => ScalarTime,
    toEpochTime: () => ScalarTime,
    during: ( startTime: ScalarTime, endTime: ScalarTime, opts?: ?BoundOpts ) => ScalarTime,
  }

  declare type AnyScalar = ScalarTime | ScalarNumber | ScalarString | ScalarObject | ScalarBoolean | ScalarLiteral
  declare type AnyValue = AnyScalar | Sequence | SingleRowSelection

  declare type PredicateBuiltinMutation = ( value: AnyScalar ) => PredicateBuiltin
  declare type PredicateObject = { [key: string]: ScalarLiteral }
  declare type PredicateFunction = ( row: Row ) => AnyScalar
  declare type PredicateBuiltin = ( ( fieldName: string ) => PredicateBuiltin ) & {
    lt: PredicateBuiltinMutation,
    gt: PredicateBuiltinMutation,
  }
  declare type Predicate = PredicateObject | PredicateFunction | PredicateBuiltin

  /* Handlers */

  declare type MapHandler = ( row: Row ) => any
  declare type ReduceHandler = ( left: Row | Scalar, right: Row | Scalar ) => any
  declare type FoldHandler = ( left: AnyScalar, row: Row | Scalar ) => AnyScalar
  declare type SumHandler = ( value: Scalar | Row, row: Row | Scalar ) => Scalar
  declare type AvgHandler = SumHandler
  declare type MinHandler = SumHandler
  declare type MaxHandler = SumHandler
  declare type EmitHandler = ( accumulator: Scalar, row: Row | Scalar ) => ( AnyScalar )[]
  declare type MergeHandler = ( row: Row | Scalar ) => { [key: string]: SingleRowSelection | Collection }

  /* -- Handlers -- */

  declare type Fold<T> = ( base: ScalarLiteral, handler: FoldHandler ) => T
  declare type FoldEmit<T> = (
    base: ScalarLiteral, handler: FoldHandler, opts: { emit: EmitHandler, finalEmit?: EmitHandler }
  ) => T
  declare type EqJoin<T> = ( by: string | Predicate, table: Table ) => T
  declare type Pluck<T> = ( ...fields: string[] ) => T
  declare type Without<T> = ( ...fields: string[] ) => T
  declare type Merge<T> = ( ...what: ( SingleRowSelection | MergeHandler )[] ) => T

  declare type Document = any
  declare type DocumentUpdate = {
    new_val: ?Document,
    old_val: ?Document,
  }
  declare type CursorEachHandler = ( error: ?Error, documentUpdate: DocumentUpdate ) => any
  declare type Cursor = { each: ( handler: CursorEachHandler ) => any }

  /* Sequence types */

  declare type SingleRowSelectionFuncs<SingleRowSelectionT> = {
    pluck: Pluck<SingleRowSelectionFuncs<SingleRowSelectionT>>,
    without: Without<SingleRowSelectionFuncs<SingleRowSelectionT>>,
    merge: Merge<SingleRowSelectionFuncs<SingleRowSelectionT>>,
    getField: ( field: string ) => SingleRowSelectionFuncs<SingleRowSelectionT>,
    keys: () => Collection,
    values: () => Collection,
  }

  declare type SingleRowSelection = SingleRowSelectionFuncs<SingleRowSelection> & Runnable<Document>
  declare type LiveSingleRowSelection = SingleRowSelectionFuncs<LiveSingleRowSelection> & Runnable<Cursor>

  declare type CollectionFuncs<CollectionT> = {
      filter: ( predicate: Predicate ) => CollectionT,
      orderBy: ( opts: OrderByOpts ) => CollectionT,
      innerJoin: ( sequence: Sequence, handler: PredicateJoin ) => CollectionT,
      outerJoin: ( sequence: Sequence, handler: PredicateJoin ) => CollectionT,
      eqJoin: EqJoin<CollectionT>,
      zip: () => CollectionT,
      map: ( handler: MapHandler ) => CollectionT,
      withFields: ( ...fields: string[] ) => CollectionT,
      skip: ( amount: number ) => CollectionT,
      limit: ( amount: number ) => CollectionT,
      nth: ( index: number ) => CollectionT,
      slice: ( start: number, end?: number, opts?: BoundOpts ) => CollectionT,
      reduce: ( handler: ReduceHandler ) => CollectionT,
      fold: Fold<CollectionT>,
      sum: ( by: string | SumHandler ) => Scalar,
      avg: ( by: string | AvgHandler ) => Scalar,
      min: ( by: string | MinHandler | IndexOpts ) => Scalar,
      max: ( by: string | MaxHandler | IndexOpts ) => Scalar,
      distinct: () => CollectionT,
      contains: ( value: AnyScalar | Predicate ) => Scalar,
      union: ( sequence: Sequence ) => CollectionT,
      sample: ( amount: number ) => CollectionT,
      pluck: Pluck<CollectionT>,
      without: Without<CollectionT>,
      merge: Merge<CollectionT>,
      append: ( value: AnyScalar ) => CollectionT,
      prepend: ( value: AnyScalar ) => CollectionT,
      difference: ( otherCollection: ScalarLiteral[] | CollectionT ) => CollectionT,
      setUnion: ( value: ScalarLiteral[] | CollectionT ) => CollectionT,
      setIntersection: ( value: ScalarLiteral[] | CollectionT ) => CollectionT,
      setDifference: ( value: ScalarLiteral[] | CollectionT ) => CollectionT,
      setInsert: ( value: ScalarLiteral[] ) => CollectionT,
      getField: ( field: string ) => CollectionT,
      hasFields: ( ...fields: string[] ) => CollectionT,
      insertAt: ( offset: number, value: AnyScalar ) => CollectionT,
      spliceAt: ( offset: number, value: AnyScalar ) => CollectionT,
      deleteAt: ( offset: number, endOffset?: number ) => CollectionT,
      changeAt: ( offset: number, value: AnyScalar ) => CollectionT,
      forEach: ( handler: ( row: Row ) => any ) => Scalar,
      typeOf: () => Scalar,
      info: () => Scalar,
    }

  declare type Collection = CollectionFuncs<Collection> & Runnable<Document[]>
  declare type LiveCollection = CollectionFuncs<LiveCollection> & Runnable<Cursor>

  declare type StreamFuncs<StreamT> = {
    filter: ( predicate: Predicate ) => StreamT,
    orderBy: ( opts: OrderByOpts ) => StreamT,
    innerJoin: ( sequence: Sequence, handler: PredicateJoin ) => StreamT,
    outerJoin: ( sequence: Sequence, handler: PredicateJoin ) => StreamT,
    eqJoin: EqJoin<StreamT>,
    zip: () => StreamT,
    map: ( handler: MapHandler ) => StreamT,
    withFields: ( ...fields: string[] ) => StreamT,
    skip: ( amount: number ) => StreamT,
    limit: ( amount: number ) => StreamT,
    nth: ( index: number ) => StreamT,
    slice: ( start: number, end?: number, opts?: BoundOpts ) => StreamT,
    group: ( by: string | Predicate, opts?: GroupOpts ) => StreamT,
    ungroup: () => Collection,
    fold: Fold<StreamT>,
    union: ( sequence: Sequence ) => StreamT,
    sample: ( amount: number ) => Selection,
    pluck: Pluck<StreamT>,
    without: Without<StreamT>,
    merge: Merge<StreamT>,
    getField: ( field: string ) => StreamT,
    hasFields: ( ...fields: string[] ) => StreamT,
    coerceTo: ( type: "array" ) => Collection,
    coerceTo: ( type: "object" ) => Scalar,
  }

  declare type Stream = StreamFuncs<Stream> & Collection
  declare type LiveStream = StreamFuncs<LiveStream> & LiveCollection

  declare type SelectionFuncs<SelectionT> = {
    orderBy: ( opts: OrderByOpts ) => SelectionT,
    filter: ( predicate: Predicate ) => SelectionT,
    eqJoin: EqJoin<SelectionT>,
    fold: Fold<SelectionT>,
    pluck: Pluck<SelectionT>,
    without: Without<SelectionT>,
    merge: Merge<SelectionT>,
    getField: ( field: string ) => SelectionT,
  }

  declare type Selection =
    SelectionFuncs<Selection> &
    Stream &
    { changes: () => LiveSelection }

  declare type LiveSelection = SelectionFuncs<LiveSelection> & LiveStream

  declare type Table = {
    get: ( id: string | number ) => SingleRowSelection,
    getAll: ( key: ScalarLiteral, opts?: IndexOpts ) => Selection,
    between: ( lowerKey: ScalarLiteral, upperKey: ScalarLiteral, opts?: BetweenOpts ) => Selection,
    fold: Fold<Table>,
    eqJoin: EqJoin<Selection>,
    distinct: ( opts?: IndexOpts ) => Stream,
  } & Selection

  /* -- Sequence types -- */

  declare type Connection = {
    db: (dbName: string) => Connection,
    dbCreate: (dbName: string) => Runnable<Document>,
    tableCreate: (tableName: string) => Runnable<Document>,
    table: ( tableName: string ) => Table,
    desc: ( fieldName: string ) => OrderedField,
    asc: ( fieldName: string ) => OrderedField,
    row: ( fieldName: string ) => PredicateBuiltin,
    literal: ( literal?: ScalarLiteral ) => ScalarLiteral,
    object: ( ...values: ( string | number )[] ) => Scalar,
    random: () => Scalar,
    round: ( number: Scalar ) => Scalar,
    ceil: ( number: Scalar ) => Scalar,
    floor: ( number: Scalar ) => Scalar,
    now: () => Scalar,
    time: (
      year: AnyScalar,
      month: AnyScalar,
      day: AnyScalar,
      hour?: AnyScalar,
      minute?: AnyScalar,
      second?: AnyScalar,
      timezone: string
    ) => Scalar,
    epochTime: ( time: Scalar ) => Scalar,
    ISO8601: ( string: AnyScalar, opts?: { defaultTimeZone: string } ) => Scalar,
    args: ( args: string[] ) => any,
    binary: ( data: Buffer ) => Scalar,
    do: ( args: any, handler: any ) => any,
    branch: ( test: AnyScalar, ifTrue: AnyValue, ifFalse: AnyValue ) => any,
    range: ( startValue?: number, endValue: ?number ) => Stream,
    error: ( message?: string ) => RethinkDBError,
    expr: ( value: ScalarLiteral | Buffer ) => Scalar,
    json: ( jsonString: string ) => Scalar,
    js: ( jsCode: string ) => any,
    http: ( url: string ) => Scalar,
    uuid: ( fromString?: string ) => Scalar,
    getPoolMaster: () => {
      on: ( eventName: "log", handler: ( log: string ) => any ) => any,
      on: ( eventName: "error", handler: ( error: Error ) => any ) => any,
    },
  }

  declare var exports: ( opts?: {
    db?: ?string,
    user?: ?string,
    password?: ?string,
    discovery?: ?boolean,
    pool?: ?boolean,
    buffer?: ?number,
    max?: ?number,
    timeout?: ?number,
    pingInterval?: ?number,
    timeoutError?: ?number,
    timeoutGb?: ?number,
    maxExponent?: ?number,
    silent?: ?boolean,
    host: ?string,
    port?: ?number,
    servers?: ?{host: string, port?: ?number},
    optionalRun?: ?boolean,
  } ) => Connection
}