Complete Phase 1.2 implementation with comprehensive testing and documentation

Co-authored-by: southseact-3d <217551146+southseact-3d@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot]
2026-02-09 19:39:04 +00:00
parent fd6d2d641b
commit fd41d95f72
5 changed files with 407 additions and 182 deletions

401
chat/TESTING_GUIDE.md Normal file
View File

@@ -0,0 +1,401 @@
# Testing Guide: Secure Database Implementation
This guide walks you through testing the secure database implementation locally and in a container.
## Prerequisites
- Node.js 20+ installed
- Docker installed (for container testing)
- OpenSSL (for generating keys)
## Local Testing
### 1. Install Dependencies
```bash
cd chat
npm install
```
### 2. Generate Encryption Keys
```bash
export DATABASE_ENCRYPTION_KEY=$(openssl rand -hex 32)
export JWT_SECRET=$(openssl rand -hex 32)
echo "Save these keys for future use:"
echo "DATABASE_ENCRYPTION_KEY=$DATABASE_ENCRYPTION_KEY"
echo "JWT_SECRET=$JWT_SECRET"
```
### 3. Setup Database
```bash
node scripts/setup-database.js
```
Expected output:
```
✅ Database connected
✅ Database schema created
✅ Database tables created: users, sessions, refresh_tokens, etc.
```
### 4. Test Encryption
```bash
cat > test-encryption.js << 'EOF'
const { initEncryption, encrypt, decrypt } = require('./src/utils/encryption');
const crypto = require('crypto');
const key = crypto.randomBytes(32).toString('hex');
initEncryption(key);
const plaintext = 'sensitive@email.com';
const encrypted = encrypt(plaintext);
const decrypted = decrypt(encrypted);
console.log('✅ Encryption test:', plaintext === decrypted ? 'PASSED' : 'FAILED');
EOF
node test-encryption.js
rm test-encryption.js
```
### 5. Test Repositories
```bash
cat > test-repos.js << 'EOF'
const { initDatabase, closeDatabase } = require('./src/database/connection');
const { initEncryption } = require('./src/utils/encryption');
const userRepo = require('./src/repositories/userRepository');
const crypto = require('crypto');
initEncryption(process.env.DATABASE_ENCRYPTION_KEY);
initDatabase('./.data/shopify_ai.db');
const user = userRepo.createUser({
id: 'test123',
email: 'test@example.com',
passwordHash: '$2b$12$test',
emailVerified: true
});
console.log('✅ User created:', user.email);
const found = userRepo.getUserById('test123');
console.log('✅ User retrieved:', found.email);
userRepo.deleteUser('test123');
console.log('✅ User deleted');
closeDatabase();
EOF
node test-repos.js
rm test-repos.js
```
### 6. Test Migration
Create sample JSON data:
```bash
mkdir -p .data
cat > .data/users.json << 'EOF'
[
{
"id": "user1",
"email": "test@example.com",
"passwordHash": "$2b$12$test",
"emailVerified": true,
"plan": "professional"
}
]
EOF
cat > .data/user-sessions.json << 'EOF'
{
"token123": {
"id": "session1",
"userId": "user1",
"expiresAt": 9999999999999
}
}
EOF
```
Run migration:
```bash
# Remove existing database
rm -f .data/shopify_ai.db*
# Setup fresh database
node scripts/setup-database.js
# Run migration
node scripts/migrate-to-database.js
```
Expected output:
```
✅ Migration complete!
Users: ✓ Success: 1
Sessions: ✓ Success: 1
```
### 7. Test JSON Compatibility Mode
```bash
# Switch to JSON mode
export USE_JSON_DATABASE=1
# Your app should now use JSON files instead of database
# (Integration with server.js needed)
```
## Container Testing
### 1. Build Container
```bash
cd /home/runner/work/shopify-ai-backup/shopify-ai-backup
docker build -t shopify-ai-builder:test .
```
### 2. Run Container with Environment Variables
```bash
docker run -d \
--name shopify-ai-test \
-p 4500:4500 \
-e DATABASE_ENCRYPTION_KEY=$(openssl rand -hex 32) \
-e JWT_SECRET=$(openssl rand -hex 32) \
-v shopify-data:/home/web/data \
shopify-ai-builder:test
```
### 3. Check Logs
```bash
docker logs shopify-ai-test
```
Expected in logs:
```
🔍 Checking database status...
🔧 Database not found, setting up new database...
⚠️ Generated new encryption key (save this!)
✅ Database setup complete!
```
### 4. Verify Database Created
```bash
docker exec shopify-ai-test ls -lh /home/web/data/.data/
```
Expected output:
```
shopify_ai.db
shopify_ai.db-wal
shopify_ai.db-shm
.encryption_key
.jwt_secret
```
### 5. Test Auto-Initialization on Restart
```bash
# Restart container
docker restart shopify-ai-test
# Check logs
docker logs shopify-ai-test | tail -20
```
Expected:
```
✅ Database already exists
```
### 6. Test Migration in Container
```bash
# Copy sample JSON files
docker exec shopify-ai-test sh -c 'cat > /home/web/data/.data/users.json << EOF
[{"id":"user1","email":"test@example.com","passwordHash":"test"}]
EOF'
# Run migration
docker exec shopify-ai-test node /opt/webchat/scripts/migrate-to-database.js
```
### 7. Verify Tables
```bash
docker exec shopify-ai-test sqlite3 /home/web/data/.data/shopify_ai.db ".tables"
```
Expected output:
```
affiliates payment_sessions token_blacklist
audit_log refresh_tokens users
contact_messages sessions withdrawals
feature_requests
```
### 8. Check Encryption Keys Persisted
```bash
docker exec shopify-ai-test cat /home/web/data/.data/.encryption_key
docker exec shopify-ai-test cat /home/web/data/.data/.jwt_secret
```
Save these keys to your environment configuration!
### 9. Test JSON Fallback Mode
```bash
# Stop container
docker stop shopify-ai-test
docker rm shopify-ai-test
# Start with JSON mode
docker run -d \
--name shopify-ai-test \
-p 4500:4500 \
-e USE_JSON_DATABASE=1 \
-v shopify-data:/home/web/data \
shopify-ai-builder:test
# Check logs
docker logs shopify-ai-test | grep "JSON"
```
Expected:
```
📁 Running in JSON compatibility mode
```
### 10. Cleanup
```bash
docker stop shopify-ai-test
docker rm shopify-ai-test
docker volume rm shopify-data
```
## Production Deployment
### Environment Variables Required
```bash
# Required
DATABASE_ENCRYPTION_KEY=<64-char-hex> # Generate: openssl rand -hex 32
JWT_SECRET=<64-char-hex> # Generate: openssl rand -hex 32
# Optional
DATABASE_PATH=./.data/shopify_ai.db
DATABASE_BACKUP_ENABLED=1
DATABASE_WAL_MODE=1
USE_JSON_DATABASE=0 # Set to 1 for JSON mode
JWT_ACCESS_TOKEN_TTL=900 # 15 minutes
JWT_REFRESH_TOKEN_TTL=604800 # 7 days
```
### First Deployment
1. **Generate keys** and save them securely
2. **Deploy container** with environment variables
3. **Verify logs** show database initialization
4. **Save generated keys** from logs if not pre-set
5. **Test authentication** (once integrated)
### Subsequent Deployments
1. **Use same keys** from first deployment
2. **Database persists** via volume
3. **No migration needed** unless upgrading from JSON
### Rollback to JSON
If issues occur:
1. Set `USE_JSON_DATABASE=1`
2. Restart container
3. System uses JSON files
4. Original JSON backups preserved
## Troubleshooting
### Database Not Found
```bash
# Check data directory
ls -la /home/web/data/.data/
# Re-run initialization
node scripts/init-database.js
```
### Encryption Error
```bash
# Verify key is 64 characters (hex)
echo $DATABASE_ENCRYPTION_KEY | wc -c # Should be 65 (64 + newline)
# Regenerate if needed
export DATABASE_ENCRYPTION_KEY=$(openssl rand -hex 32)
```
### Migration Failed
```bash
# Check JSON files exist
ls -la .data/*.json
# Check database exists
ls -la .data/shopify_ai.db
# View backup
ls -la .data/migration_backup_*/
```
### Permission Issues
```bash
# In container
chown -R root:root /home/web/data
chmod -R 755 /home/web/data
```
## Security Checklist
- [ ] Encryption keys generated securely
- [ ] Keys stored in secure environment (not in code)
- [ ] Database file permissions restricted (600/700)
- [ ] Backup encryption keys offline
- [ ] Test rollback procedure
- [ ] Verify audit logging works
- [ ] Test session revocation
- [ ] Test token refresh
## Next Steps
1. ✅ Database implementation complete
2. ✅ Encryption working
3. ✅ Migration tested
4. ⏳ Integrate with server.js authentication
5. ⏳ Add auth API endpoints
6. ⏳ End-to-end testing
7. ⏳ Production deployment
## Support
For issues:
1. Check logs: `docker logs <container>`
2. Verify environment variables
3. Test locally first
4. Review DATABASE_IMPLEMENTATION.md