Database

Database is a built-in NoSQL data storage with in-memory acceleration layer that you can interact via RDK.

• You cannot write more than 25 records in parallel.
• You cannot increase paths in parallel.
• You cannot get more than 100 records in parallel.
• You cannot remove more than 25 records in parallel.
• You cannot run more than 10 queries in parallel.

interface WriteToDatabase {
    partKey: string
    sortKey: string
    memory?: boolean
    data: Record<string, any>
}


interface IncrementDatabase {
    partKey: string
    sortKey: string
    path?: string
    value: number
    memory?: boolean
    expireAt?: number,
}


interface ReadDatabase {
    partKey: string
    sortKey: string
    memory?: boolean
}


interface QueryDatabase {
    partKey: string
    beginsWith?: string
    greaterOrEqual?: string
    lessOrEqual?: string
    reverse?: boolean
    nextToken?: string
    limit?: number
}


interface RemovePartitionFromDatabase {
    partKey: string
}


interface RemoveFromDatabase extends RemovePartitionFromDatabase {
    sortKey: string
}


interface OperationResponse {
    success: boolean
    data?: any
    error?: string
}


export interface ReadDatabaseResponse extends OperationResponse {
    data?: { part: string, sort: string, data?: any }
}


export type DatabaseOutput = { partKey: string, sortKey: string, data?: any }
export interface QueryDatabaseResponse extends OperationResponse {
    data?: { items?: DatabaseOutput[], nextToken?: string }
}


async function writeToDatabase(input: WriteToDatabase): Promise<OperationResponse | undefined> {
    // ...
}
async function incrementDatabase(input: IncrementDatabase): Promise<OperationResponse | undefined> {
    // ...
}
async function readDatabase(input: ReadDatabase): Promise<ReadDatabaseResponse | undefined> {
    // ...
}
async function queryDatabase(input: QueryDatabase): Promise<QueryDatabaseResponse | undefined> {
    // ...
}
async function removeFromDatabase(input: RemoveFromDatabase): Promise<OperationResponse | undefined> {
    // ...
}
async function removePartitionFromDatabase(input: RemovePartitionFromDatabase): Promise<OperationResponse | undefined> {
    // ...
}

Usage

import RDK from '@retter/rdk'


const rdk = new RDK()


await rdk.writeToDatabase({ partKey: 'my-part', sortKey: 'my-sort', memory: true, data: { key: 'value' } })
await rdk.readDatabase({ partKey: 'my-part', sortKey: 'my-sort', memory: true })
await rdk.queryDatabase({ partKey: 'my-part', beginsWith: 'my', limit: 10 })
await rdk.removeFromDatabase({ partKey: 'my-part', sortKey: 'my-sort' })


await rdk.pipeline()
    .writeToDatabase({ partKey: 'my-part', sortKey: 'my-sort', memory: true, data: { key: 'value' } })
    .writeToDatabase({ partKey: 'my-part', sortKey: 'my-other-sort', memory: true, data: { key: 'value2' } })
    .readDatabase({ partKey: 'my-part', sortKey: 'my-sort', memory: true })
    .queryDatabase({ partKey: 'my-part', beginsWith: 'my', limit: 10 })
    .removeFromDatabase({ partKey: 'my-part', sortKey: 'my-sort' })
    .removePartitionFromDatabase({ partKey: 'my-part' })
    .send()

API Reference

Write To Database Input

Increment Database Input

Read Database Input

Remove From Database Input

Remove Partition From Database Input

Query Database Input

Operation Output

Read Database Response

Remove Partition From Database Response

Query Database Response