### Memory Operations - In-Memory Key-Value Storage with TTL

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Provides in-memory caching with Time-To-Live (TTL) support, suitable for session data, counters, and temporary storage. This example demonstrates setting, getting, incrementing, and deleting data from memory. It takes 'Data' as input and returns the modified 'Data' object.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function memoryExample(data: Data): Promise<Data> {
    const { userId } = data.context

    try {
        await rdk.setMemory({
            key: `user-session-${userId}`,
            value: { loginTime: Date.now(), preferences: { theme: 'dark' } },
            expireAt: Date.now() + (24 * 60 * 60 * 1000)
        })

        const sessionData = await rdk.getMemory({
            key: `user-session-${userId}`
        })

        await rdk.incrementMemory({
            key: `page-views`,
            value: 1
        })

        await rdk.incrementMemory({
            key: `analytics`,
            path: 'dailyVisits',
            value: 1
        })

        await rdk.deleteMemory({
            key: `temp-data-${userId}`
        })

        data.response.body = { sessionData }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Execute Multiple RDK Operations in a Batch Pipeline

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

This example shows how to execute multiple RDK operations, such as memory set/increment, database writes, and method calls, in a single atomic batch using the RDK pipeline. It enhances performance and ensures transactional integrity. The output includes the results of each operation and the count of executed operations.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function pipelineExample(data: Data): Promise<Data> {
    const { userId, instanceId } = data.context

    try {
        const results = await rdk.pipeline()
            .setMemory({
                key: `user-activity-${userId}`,
                value: { lastActive: Date.now() }
            })
            .writeToDatabase({
                partKey: `USER#${userId}`,
                sortKey: `ACTIVITY#${Date.now()}`,
                data: { action: 'login', instanceId }
            })
            .incrementMemory({
                key: `global-counters`,
                path: 'totalLogins',
                value: 1
            })
            .methodCall({
                classId: 'NotificationService',
                lookupKey: { name: 'service', value: 'main' },
                methodName: 'sendWelcomeMessage',
                body: { userId }
            })
            .send()

        data.response.body = {
            batchResults: results,
            operationsExecuted: Object.keys(results).length
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Instance Management - Create, Call, State, List, and Delete Instances

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Manage the lifecycle of class instances in the cloud. Supports creating instances with lookup keys, calling methods, retrieving state, listing instances, and deleting them. Requires RDK and Data types.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function instanceExample(data: Data): Promise<Data> {
    const { userId } = data.context

    try {
        const instance = await rdk.getInstance({
            classId: 'UserProfile',
            lookupKey: {
                name: 'userId',
                value: userId
            }
        })

        const newInstance = await rdk.getInstance({
            classId: 'OrderProcessor',
            body: { userId, orderType: 'express' }
        })

        const methodResult = await rdk.methodCall({
            classId: 'OrderProcessor',
            instanceId: newInstance.body.instanceId,
            methodName: 'processPayment',
            body: { amount: 100, currency: 'USD' },
            retryConfig: {
                delay: 1000,
                count: 3,
                rate: 2
            }
        })

        const instanceState = await rdk.getState({
            classId: 'UserProfile',
            instanceId: instance.body.instanceId
        })

        const allInstances = await rdk.listInstanceIds({
            classId: 'UserProfile',
            instanceIdPrefix: 'user_',
            nextToken: data.request.queryStringParams?.nextToken
        })

        await rdk.deleteInstance({
            classId: 'TempProcessor',
            instanceId: 'temp_12345'
        })

        data.response.body = {
            instance: instance.body,
            methodResult: methodResult.body,
            instanceState: instanceState.body,
            allInstances
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### File Operations - Upload, Download, List, and Generate Signed URLs

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Interact with S3-compatible object storage for file management. Supports uploading, downloading, listing files with prefixes, and generating pre-signed URLs for temporary access. Requires RDK and Data types.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function fileExample(data: Data): Promise<Data> {
    const { userId } = data.context
    const { fileContent, fileName } = data.request.body

    try {
        await rdk.setFile({
            filename: `users/${userId}/documents/${fileName}`,
            body: fileContent
        })

        const userFiles = await rdk.listFiles({
            prefix: `users/${userId}/`,
            nextToken: data.request.queryStringParams?.nextToken
        })

        const documentContent = await rdk.getFile({
            filename: `users/${userId}/documents/profile.json`
        })

        const signedUrl = await rdk.getFile({
            filename: `users/${userId}/documents/large-file.pdf`,
            returnSignedURL: true
        })

        await rdk.deleteFile({
            filename: `users/${userId}/temp/upload.tmp`
        })

        data.response.body = {
            userFiles,
            documentContent: documentContent?.data,
            signedUrl: signedUrl?.extraData?.url
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Manage System Deployments, Cache, and Imports with RDK

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

This function demonstrates system-level operations using RDK, including deploying projects, invalidating cache entries for specific methods or entire classes, and performing bulk imports. It's essential for system administration and maintaining application state.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function systemExample(data: Data): Promise<Data> {
    const { classId, instanceId } = data.context

    try {
        const deployResult = await rdk.deployProject({
            force: false
        })

        const cacheInvalidation = await rdk.invalidateCache({
            classId: classId,
            methodName: 'getUserData',
            instanceId: instanceId
        })

        await rdk.invalidateCache({
            classId: 'UserProfile'
        })

        const bulkImportResult = await rdk.bulkImport({
            getInstance: [
                {
                    classId: 'BulkProcessor',
                    lookupKey: { name: 'batch', value: 'batch_001' }
                }
            ],
            methodCall: [
                {
                    classId: 'BulkProcessor',
                    lookupKey: { name: 'batch', value: 'batch_001' },
                    methodName: 'processBatch',
                    body: { batchSize: 1000 }
                }
            ]
        })

        data.response.body = {
            deployResult,
            cacheInvalidation,
            bulkImportResult
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Init Delegate - Initialize New Instance State with TypeScript

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

The Init delegate handles new instance creation by initializing state structure and default values. It is called after the getInstanceId delegate when rdk.getInstance() is invoked with a body parameter. Dependencies include '@retter/rdk'. It takes 'data: Data' as input and returns the modified 'data' object.

```typescript
import { Data } from "@retter/rdk";

export async function init(data: Data): Promise<Data> {
    try {
        const { instanceId } = data.context
        const { email } = data.request.body

        if (!email) {
            throw new Error('Email required')
        }

        data.state.private = {
            email,
            code: Math.floor(100000 + Math.random() * 900000).toString(),
            attempts: 0,
            expiresAt: Date.now() + (5 * 60 * 1000)
        }

        data.state.public = {
            status: 'pending',
            lastUpdatedAt: Date.now()
        }

        data.tasks.push({
            method: 'sendVerificationEmail',
            classId: 'EmailService',
            instanceId: 'main',
            after: 10,
            payload: { email, code: data.state.private.code }
        })

        data.response = {
            statusCode: 200,
            body: {
                message: `${instanceId} is created successfully`,
                instanceId
            }
        }

    } catch (error: any) {
        data.response = {
            statusCode: 400,
            body: { error: error.message }
        }
    }

    return data
}
```

--------------------------------

### Write Method - Synchronous State Mutation with Persistence

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Implements critical business logic with exclusive instance locking, ensuring state changes are persisted only upon successful execution (HTTP 200-299). It handles deposits to a wallet, updates states, and writes to the database. It takes a specific 'WalletData' type as input and returns the modified 'WalletData'.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

interface WalletPublicState {
    walletId: string;
    displayBalance: number;
    lastActivity: number;
}

interface WalletPrivateState {
    actualBalance: number;
    transactions: Array<{ 
        id: string;
        type: 'deposit' | 'spend';
        amount: number;
        timestamp: number;
    }>;
}

interface WalletData extends Data<any, any, WalletPublicState, WalletPrivateState> {}

export async function deposit(data: WalletData): Promise<WalletData> {
    try {
        const { instanceId } = data.context
        const { amount } = data.request.body

        if (amount <= 0) {
            throw new Error('Amount must be positive')
        }

        data.state.private!.actualBalance += amount
        data.state.private!.transactions.push({
            id: `tx_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
            type: 'deposit',
            amount,
            timestamp: Date.now()
        })

        data.state.public!.displayBalance = data.state.private!.actualBalance
        data.state.public!.lastActivity = Date.now()

        const dbResult = await rdk.writeToDatabase({
            partKey: `WALLET#${instanceId}`,
            sortKey: `TX#${Date.now()}`,
            data: { amount, type: 'deposit' }
        })

        if (!dbResult?.success) {
            throw new Error('Database write failed')
        }

        data.response = {
            statusCode: 200,
            body: {
                message: 'Deposit successful',
                newBalance: data.state.private!.actualBalance
            }
        }

    } catch (error: any) {
        data.response = {
            statusCode: 400,
            body: { error: error.message }
        }
    }

    return data
}
```

--------------------------------

### Database Operations - Write, Read, Query, Increment, and Remove Data

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Perform partition-key/sort-key based storage operations using the RDK. Supports writing, reading, querying, atomic increments, and removing data with optional expiration. Requires RDK and Data types.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function databaseExample(data: Data): Promise<Data> {
    const { userId } = data.context
    const { userData, productId } = data.request.body

    try {
        await rdk.writeToDatabase({
            partKey: `USER#${userId}`,
            sortKey: `PROFILE#${Date.now()}`,
            data: userData,
            expireAt: Date.now() + (365 * 24 * 60 * 60 * 1000)
        })

        const userProfile = await rdk.readDatabase({
            partKey: `USER#${userId}`,
            sortKey: `PROFILE#CURRENT`,
            memory: true
        })

        const userOrders = await rdk.queryDatabase({
            partKey: `USER#${userId}`,
            beginsWith: 'ORDER#',
            reverse: true,
            limit: 10
        })

        await rdk.incrementDatabase({
            partKey: `PRODUCT#${productId}`,
            sortKey: 'STATS',
            path: 'viewCount',
            value: 1
        })

        await rdk.removeFromDatabase({
            partKey: `USER#${userId}`,
            sortKey: `TEMP#data`
        })

        data.response.body = { userProfile, userOrders }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Lookup Key Operations - Custom Instance Discovery (TypeScript)

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Maps custom keys (like email or username) to instances for flexible routing. It uses RDK's setLookUpKey, getLookUpKey, and deleteLookUpKey methods. Inputs are data from the request body, and outputs are mapped instances or an error. It handles setting, retrieving, and deleting lookup keys.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function lookupExample(data: Data): Promise<Data> {
    const { email, username } = data.request.body

    try {
        await rdk.setLookUpKey({
            key: {
                name: 'email',
                value: email
            }
        })

        await rdk.setLookUpKey({
            key: {
                name: 'username',
                value: username
            }
        })

        const instanceByEmail = await rdk.getLookUpKey({
            key: {
                name: 'email',
                value: email
            },
            classId: 'UserProfile'
        })

        const instanceByUsername = await rdk.getLookUpKey({
            key: {
                name: 'username',
                value: username
            }
        })

        await rdk.deleteLookUpKey({
            key: {
                name: 'temp-lookup',
                value: 'temp_value'
            }
        })

        data.response.body = {
            emailMapping: instanceByEmail,
            usernameMapping: instanceByUsername
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### SQL Database Integration (TypeScript)

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Executes SQL queries on external databases with support for parameterized statements and transactions. It uses RDK's sql method. Inputs are database credentials, the SQL query, query type, and parameters. Outputs are the query results or an error. Supports various SQL query types and parameter binding.

```typescript
import RDK, { Data, SqlQueryTypes } from "@retter/rdk";

const rdk = new RDK();

export async function sqlExample(data: Data): Promise<Data> {
    const { sqlQuery } = data.request.body

    try {
        const sqlResult = await rdk.sql({
            username: 'db_user',
            password: 'db_password',
            database: 'production_db',
            query: sqlQuery || 'SELECT * FROM users WHERE active = ?',
            queryType: SqlQueryTypes.SELECT,
            queryOptions: { parameters: [true] }
        })

        data.response.body = {
            sqlResult: sqlResult?.data
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Perform MongoDB Operations with RDK

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

This snippet demonstrates how to interact with MongoDB using the RDK, including find, insert, update, and delete operations. It requires a MongoDB connection URI, database name, and collection name. The 'find' operation supports filtering, sorting, limiting, and projection.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function mongoExample(data: Data): Promise<Data> {
    const { userId } = data.context

    try {
        const mongoResult = await rdk.mongodb({
            uri: 'mongodb://username:password@host:port',
            database: 'app_database',
            collection: 'users',
            find: {
                filter: { status: 'active' },
                sort: { createdAt: -1 },
                limit: 10,
                project: { password: 0 }
            }
        })

        await rdk.mongodb({
            uri: 'mongodb://username:password@host:port',
            database: 'app_database',
            collection: 'activity_logs',
            insertOne: {
                document: {
                    userId,
                    action: 'api_call',
                    timestamp: new Date(),
                    metadata: { source: 'rio-method' }
                }
            }
        })

        data.response.body = {
            mongoResult: mongoResult?.data
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Authorizer Delegate - Implement Access Control with TypeScript

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

The Authorizer delegate implements method-level access control. It's called before each method execution to validate user permissions based on identity, claims, and method name. Dependencies include '@retter/rdk'. It takes 'data: Data' as input and returns a 'Response' object indicating access status.

```typescript
import { Data, Response } from "@retter/rdk";

export async function authorizer(data: Data): Promise<Response> {
    const { methodName, identity, claims } = data.context

    switch (methodName) {
        case 'GET':
        case 'INIT':
            return { statusCode: 200 }

        case 'validateEmailCode':
            return { statusCode: 200 }

        case 'adminMethod':
            if (identity === 'admin' || claims?.role === 'admin') {
                return { statusCode: 200 }
            }
            return { statusCode: 403, body: { message: 'Admin required' } }

        case 'STATE':
        case 'LIST':
            if (identity === 'authenticated-user') {
                return { statusCode: 200 }
            }
            return { statusCode: 401, body: { message: 'Authentication required' } }

        case 'DESTROY':
            return { statusCode: 403, body: { message: 'Destruction not allowed' } }

        default:
            break
    }

    return { statusCode: 403, body: { message: 'Access denied' } }
}
```

--------------------------------

### Destroy Delegate - Handle Instance Cleanup

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Executes cleanup operations before an instance is deleted. This delegate can prevent destruction or perform final tasks like closing connections and notifying external systems. It takes 'Data' as input and returns a 'Response' object.

```typescript
import { Data, Response } from "@retter/rdk";

export async function destroy(data: Data): Promise<Response> {
    const { instanceId, identity } = data.context

    if (identity !== 'admin') {
        return {
            statusCode: 403,
            body: { message: 'Destruction not allowed' }
        }
    }

    // Perform cleanup operations here
    // Close connections, notify external systems, etc.

    return {
        statusCode: 200,
        body: { message: 'Instance destroyed', instanceId }
    }
}
```

--------------------------------

### HTTP Requests - External API Integration (TypeScript)

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Makes HTTP requests to external services using a static IP and supports asynchronous responses via callbacks. It employs RDK's httpRequest method. Inputs include the API URL, method, headers, and data payload. Outputs are the external API's response or an error. Supports custom headers, data, timeouts, and synchronous/asynchronous modes.

```typescript
import RDK, { Data, StaticIPHttpMethod } from "@retter/rdk";

const rdk = new RDK();

export async function httpExample(data: Data): Promise<Data> {
    const { instanceId } = data.context
    const { apiUrl } = data.request.body

    try {
        const httpResponse = await rdk.httpRequest({
            url: apiUrl || 'https://api.example.com/data',
            method: StaticIPHttpMethod.POST,
            headers: {
                'Content-Type': 'application/json',
                'Authorization': 'Bearer token'
            },
            data: {
                requestData: { query: 'user-data' },
                returnEndpoint: {
                    projectId: 'your-project',
                    classId: 'ResponseHandler',
                    instanceId: instanceId,
                    methodName: 'handleResponse'
                }
            },
            timeout: 30000,
            sync: true
        })

        data.response.body = {
            httpResponse: httpResponse?.data
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### Authentication Operations - Token and Session Management (TypeScript)

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Generates custom JWT tokens with specified claims and terminates user sessions. It utilizes RDK's generateCustomToken and terminateSession methods. Inputs include user IDs and custom claims, with outputs being a custom token and status indicators. Handles token generation and session termination.

```typescript
import RDK, { Data } from "@retter/rdk";

const rdk = new RDK();

export async function authExample(data: Data): Promise<Data> {
    const { userId } = data.context
    const { targetUserId, customClaims } = data.request.body

    try {
        const customToken = await rdk.generateCustomToken({
            userId: targetUserId || userId,
            identity: 'authenticated-user',
            claims: {
                role: 'premium',
                permissions: ['read', 'write'],
                ...customClaims
            },
            accessTokenTTL: 3600,
            refreshTokenTTL: 86400
        })

        await rdk.terminateSession({
            userId: targetUserId,
            identity: 'authenticated-user'
        })

        await rdk.terminateSession({
            userId: targetUserId
        })

        data.response.body = {
            customToken: customToken?.data?.customToken,
            tokenGenerated: true,
            sessionsTerminated: true
        }

    } catch (error: any) {
        data.response = { statusCode: 500, body: { error: error.message } }
    }

    return data
}
```

--------------------------------

### GetInstanceId Delegate - Resolve Instance Identifier

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

Determines the instance ID for new instances using custom logic. Supports singleton patterns, user-based isolation, and dynamic ID generation. It takes 'Data' as input and returns a string or undefined.

```typescript
import { Data } from "@retter/rdk";

export async function getInstanceId(data: Data): Promise<string | undefined> {
    const { email } = data.request.body

    // User-based instance: one instance per email
    if (email) {
        return email.toLowerCase().trim()
    }

    // Random instance: generate unique ID
    const timestamp = Date.now()
    const random = Math.random().toString(36).substring(2, 8)
    return `${timestamp}-${random}`

    // Singleton pattern: return fixed string for single instance
    // return "default"
}
```

--------------------------------

### GetState Delegate - Custom State Retrieval with TypeScript

Source: https://context7.com/rettersoft/rio-ai-docs/llms.txt

The GetState delegate applies custom transformations, filtering, or computed values to state before returning it to clients. It enables role-based data visibility and dynamic field computation. Dependencies include '@retter/rdk'. It takes 'data: Data' as input and returns a 'Response' object.

```typescript
import { Data, Response } from "@retter/rdk";

export async function getState(data: Data): Promise<Response> {
    const { identity } = data.context

    const response: any = {
        public: data.state.public,
        private: data.state.private,
        retrievedAt: Date.now()
    }

    if (identity !== 'admin') {
        response.private.code = "********"
    }

    return { statusCode: 200, body: response }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.