@natiwo/database

Database clients for Prisma, DynamoDB, and Redis

Installation

pnpm add @natiwo/database

# Install peer dependencies as needed
pnpm add @prisma/client      # For Prisma
pnpm add @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb  # For DynamoDB
pnpm add ioredis             # For Redis

Features

• 🗄️ Prisma Client - Singleton instance with connection pooling
• ☁️ DynamoDB - Type-safe repository pattern
• ⚡ Redis - Caching with decorators
• 🔄 Auto-reconnect - Handles connection failures
• 📊 TypeScript - Full type safety

Quick Start

Prisma

import { getPrismaClient } from '@natiwo/database';

const prisma = getPrismaClient();

const users = await prisma.user.findMany();
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'John Doe',
  },
});

DynamoDB

import { DynamoRepository } from '@natiwo/database';

interface User {
  id: string;
  email: string;
  name: string;
}

const userRepo = new DynamoRepository<User>('users-table');

// Get item
const user = await userRepo.get({ id: '123' });

// Put item
await userRepo.put({
  id: '123',
  email: '[email protected]',
  name: 'John Doe',
});

// Query
const users = await userRepo.query({
  keyCondition: 'email = :email',
  values: { ':email': '[email protected]' },
});

// Scan
const allUsers = await userRepo.scan();

// Update
await userRepo.update({
  key: { id: '123' },
  updates: { name: 'Jane Doe' },
});

// Delete
await userRepo.delete({ id: '123' });

Redis

import { getRedisClient, Cache } from '@natiwo/database';

const redis = getRedisClient();

// Basic operations
await redis.set('key', 'value');
const value = await redis.get('key');
await redis.del('key');

// With expiration
await redis.setex('key', 3600, 'value'); // Expires in 1 hour

// Cache decorator
class UserService {
  @Cache(600) // Cache for 10 minutes
  async getUser(id: string) {
    return await prisma.user.findUnique({ where: { id } });
  }
}

Configuration

Prisma

Uses DATABASE_URL environment variable:

DATABASE_URL="postgresql://user:password@localhost:5432/mydb"

DynamoDB

Configure AWS credentials:

AWS_REGION=us-east-1
AWS_ACCESS_KEY_ID=your-key
AWS_SECRET_ACCESS_KEY=your-secret

Or use custom config:

import { getDynamoClient } from '@natiwo/database';

const dynamo = getDynamoClient({
  region: 'us-east-1',
  endpoint: 'http://localhost:8000', // For local DynamoDB
});

Redis

REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=your-password
REDIS_DB=0

Or programmatic:

import { getRedisClient } from '@natiwo/database';

const redis = getRedisClient({
  host: 'localhost',
  port: 6379,
  password: 'secret',
});

Advanced Usage

Prisma Transaction

const result = await prisma.$transaction([
  prisma.user.create({ data: userData }),
  prisma.profile.create({ data: profileData }),
]);

DynamoDB Batch Operations

const userRepo = new DynamoRepository<User>('users');

// Batch write
await Promise.all([
  userRepo.put(user1),
  userRepo.put(user2),
  userRepo.put(user3),
]);

Redis Caching Pattern

async function getCachedUser(id: string) {
  const cached = await redis.get(`user:${id}`);
  
  if (cached) {
    return JSON.parse(cached);
  }
  
  const user = await prisma.user.findUnique({ where: { id } });
  await redis.setex(`user:${id}`, 3600, JSON.stringify(user));
  
  return user;
}

Best Practices

1. Reuse client instances

   // ✅ Good - single instance
   const prisma = getPrismaClient();
      
   // ❌ Bad - creates new connections
   const prisma1 = new PrismaClient();
   const prisma2 = new PrismaClient();

2. Handle errors gracefully

   try {
     await prisma.user.create({ data });
   } catch (error) {
     if (error.code === 'P2002') {
       // Unique constraint violation
     }
   }

3. Use transactions for related operations

   await prisma.$transaction([
     prisma.account.update({ ... }),
     prisma.transaction.create({ ... }),
   ]);

4. Close connections on shutdown

   process.on('SIGTERM', async () => {
     await prisma.$disconnect();
     await redis.quit();
     process.exit(0);
   });

License

MIT © NATIWO Sistemas