Class Async<Value, Indexes>

constructor

• new Async<Value, Indexes>(): Async<Value, Indexes>

• Type Parameters

  • Value extends string | object | any[]

  • Indexes extends string = "There is no index available"

  Returns Async<Value, Indexes>

identifier

last_modified

page_sz

clear

• clear(): Promise<void>

• Returns Promise<void>

close

• close(): void

• Returns void

consume

• consume(key): Promise<undefined | Value>

• Parameters

  • key: Key

  Returns Promise<undefined | Value>

debug

• debug(): Promise<void>

• Returns Promise<void>

delete

• delete(): Promise<void>

• Returns Promise<void>

export

• export(): Promise<Map<Key, Async_Entry<Value>>>

• Returns Promise<Map<Key, Async_Entry<Value>>>

get

• get(key): Promise<undefined | Value>

• Parameters

  • key: Key

  Returns Promise<undefined | Value>

get_some

• get_some(keys): Promise<Value[]>

• Parameters

  • keys: Key[]

  Returns Promise<Value[]>

has

• has(key): Promise<boolean>

• Parameters

  • key: Key

  Returns Promise<boolean>

import

• import(set, merge?): Promise<void>

• Parameters

  • set: Map<Key, Async_Entry<Value>>

  • Optional merge: boolean

  Returns Promise<void>

index

• index(name): Promise<Key_Value_Pair<Value>[]>

• Parameters

  • name: Indexes

  Returns Promise<Key_Value_Pair<Value>[]>

• index(name, options): Promise<Key_Value_Pair<Value>[]>

• Parameters

  • name: Indexes

  • options: {
        reverse: boolean;
    }

    • reverse: boolean

  Returns Promise<Key_Value_Pair<Value>[]>

• index(name, options): Promise<Key_Value_Pair<Value>[]>

• Parameters

  • name: Indexes

  • options: {
        mode: "only";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "above";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "below";
        value: any;
    } | {
        lower_inclusive?: boolean;
        lower_value: any;
        mode: "range";
        upper_inclusive?: boolean;
        upper_value: any;
    }

  Returns Promise<Key_Value_Pair<Value>[]>

• index(name, options): Promise<Key_Value_Pair<Value>[]>

• Parameters

  • name: Indexes

  • options: {
        reverse: boolean;
    } & ({
        mode: "only";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "above";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "below";
        value: any;
    } | {
        lower_inclusive?: boolean;
        lower_value: any;
        mode: "range";
        upper_inclusive?: boolean;
        upper_value: any;
    })

  Returns Promise<Key_Value_Pair<Value>[]>

• index(name, options): Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

• Parameters

  • name: Indexes

  • options: {
        offset?: number;
        page: number;
        page_sz?: number;
    } & ({
        mode: "only";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "above";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "below";
        value: any;
    } | {
        lower_inclusive?: boolean;
        lower_value: any;
        mode: "range";
        upper_inclusive?: boolean;
        upper_value: any;
    })

  Returns Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>
• index(name, options): Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

• Parameters

  • name: Indexes

  • options: {
        offset?: number;
        page: number;
        page_sz?: number;
        reverse: boolean;
    } & ({
        mode: "only";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "above";
        value: any;
    } | {
        inclusive?: boolean;
        mode: "below";
        value: any;
    } | {
        lower_inclusive?: boolean;
        lower_value: any;
        mode: "range";
        upper_inclusive?: boolean;
        upper_value: any;
    })

  Returns Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>
• index(name, options): Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

• Parameters

  • name: Indexes

  • options: {
        offset?: number;
        page: number;
        page_sz?: number;
    }

    • Optional offset?: number

    • page: number

    • Optional page_sz?: number

  Returns Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>
• index(name, options): Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

• Parameters

  • name: Indexes

  • options: {
        offset?: number;
        page: number;
        page_sz?: number;
        reverse: boolean;
    }

    • Optional offset?: number

    • page: number

    • Optional page_sz?: number

    • reverse: boolean

  Returns Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

indexes

• indexes(): Indexes[]

• Returns Indexes[]

init

• init(identifier, options?): Promise<void>

• Parameters

  • identifier: string

  • Optional options: {
        autoincrement?: boolean;
        consume_default?: Value;
        indexes?: Index<Indexes>[];
        keypath?: Value extends object
            ? Key
            : undefined;
        middlewares?: Middlewares<Value, Indexes>;
        migrate?: ((data) => Promise<void>);
        page_sz?: number;
        version?: number;
    }

    • Optional autoincrement?: boolean

    • Optional consume_default?: Value

    • Optional indexes?: Index<Indexes>[]

    • Optional keypath?: Value extends object
          ? Key
          : undefined

    • Optional middlewares?: Middlewares<Value, Indexes>

    • Optional migrate?: ((data) => Promise<void>)

      • • (data): Promise<void>

        • Parameters

          • data: {
                old_version: number;
                remove_index: ((name) => void);
            }

            • old_version: number

            • remove_index: ((name) => void)

              • • (name): void

                • Parameters

                  • name: string

                  Returns void

          Returns Promise<void>

    • Optional page_sz?: number

    • Optional version?: number

  Returns Promise<void>

length

• length(): Promise<number>

• Returns Promise<number>

page

• page(number, options?): Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

• Parameters

  • number: number

    Starts from 1

  • Optional options: {
        offset?: number;
        reverse?: boolean;
        sz?: number;
    }

    • Optional offset?: number

    • Optional reverse?: boolean

    • Optional sz?: number

  Returns Promise<{
      has_next: boolean;
      results: Key_Value_Pair<Value>[];
  }>

rm

• rm(key): Promise<void>

• Parameters

  • key: Key

  Returns Promise<void>

set

• set(value, key?, options?): Promise<Key>

• Parameters

  • value: Value

    If keypath was set but autoincrement was not, make sure value has the prop keypath is pointing to

  • Optional key: Key

    If keypath was set, it must be undefined. If both autoincrement and keypath were not set, it must be Key

  • options: Partial<Options> = {}

  Returns Promise<Key>

update

• update(key, data): Promise<void>

• Parameters

  • key: Key

  • data: ((old) => Promise<{
        options?: Options | {
            expiry?: number;
        };
        value?: Value | EveryOpt<Value>;
    }>)

    • • (old): Promise<{
            options?: Options | {
                expiry?: number;
            };
            value?: Value | EveryOpt<Value>;
        }>

      • Parameters

        • old: Async_Entry<Value>

        Returns Promise<{
            options?: Options | {
                expiry?: number;
            };
            value?: Value | EveryOpt<Value>;
        }>

  Returns Promise<void>

• update(key, data): Promise<void>

• Parameters

  • key: Key

  • data: {
        options?: Options | {
            expiry?: number;
        };
        value?: Value | EveryOpt<Value>;
    }

    • Optional options?: Options | {
          expiry?: number;
      }

    • Optional value?: Value | EveryOpt<Value>

  Returns Promise<void>

values

• values(reverse?): Promise<Key_Value_Pair<Value>[]>

• Parameters

  • Optional reverse: boolean

  Returns Promise<Key_Value_Pair<Value>[]>