Prisma Roadmap
55 sections • 564 topics
- 1. Installing Prisma CLI
- 2. Initializing Prisma Project
- 3. Configuring Database Connection
- Example: schema.prisma datasource
- 4. Setting Up Client Generator
- 5. Configuring Environment Variables
- 6. Setting Custom Output Directory
- 7. Enabling Preview Features
- 8. Configuring Binary Targets
- 9. Setting Engine Type
- 10. Configuring Logging Levels
- 1. Defining Datasource Block
- 2. Configuring Generator Block
- 3. Creating Model Definitions
- Example: Minimal model
- 4. Defining Enum Types
- 5. Using Comments and Documentation
- 6. Understanding Schema Syntax Rules
- 7. Organizing Multi-File Schemas
- 8. Validating Schema Syntax
- 9. Formatting Schema Files
- 10. Using Schema Extensions
- 1. Defining One-to-One Relation
- 2. Setting Foreign Key Field
- 3. Configuring Referenced Field
- 4. Using Optional One-to-One Relations
- 5. Creating Required One-to-One Relations
- 6. Setting Relation Name
- 7. Using Referential Actions
- 8. Querying One-to-One Relations
- 9. Creating Related Records
- 10. Updating One-to-One Relations
- 1. Using Implicit Many-to-Many
- 2. Defining Explicit Join Table
- 3. Configuring Join Table Fields
- 4. Adding Extra Fields to Join Table
- 5. Querying Many-to-Many Relations
- 6. Connecting Existing Records
- 7. Disconnecting Related Records
- 8. Setting Multiple Relations
- 9. Filtering by Related Records
- 10. Managing Relation Ordering
- 1. Defining Self-Referencing Model
- 2. Creating One-to-One Self-Relation
- 3. Creating One-to-Many Self-Relation
- 4. Creating Many-to-Many Self-Relation
- 5. Setting Relation Names
- 6. Querying Self-Related Records
- 7. Creating Hierarchical Structures
- 8. Implementing Parent-Child Patterns
- 9. Handling Recursive Queries
- 10. Managing Circular References
- 1. Running Client Generation
- 2. Understanding Generated Types
- 3. Configuring Custom Output Path
- 4. Using Multiple Generators
- 5. Enabling Preview Features
- 6. Regenerating After Schema Changes
- Regeneration Workflow
- 7. Understanding Client API Structure
- 8. Using Auto-Generated Model Types
- 9. Accessing Enums from Client
- 10. Configuring Engine Options
- 1. Creating PrismaClient Instance
- 2. Configuring Client Options
- 3. Using Singleton Pattern
- Example: Next.js / Node singleton
- 4. Managing Development Hot Reload
- 5. Setting Error Formatting
- 6. Configuring Data Sources
- 7. Using Multiple Client Instances
- 8. Implementing Lazy Loading
- 9. Handling Client Initialization Errors
- 10. Using Global Prisma Instance
- 1. Deleting Single Record
- 2. Deleting Multiple Records
- 3. Using Where Clause Filters
- 4. Handling Cascade Deletes
- 5. Implementing Soft Delete Pattern
- 6. Understanding Hard vs Soft Delete
- Hard Delete
- Soft Delete
- 7. Deleting Related Records
- 8. Handling Delete Errors
- 9. Validating Before Delete
- 10. Restoring Soft Deleted Records
- 1. Using Skip Offset
- 2. Limiting Results
- 3. Implementing Cursor Pagination
- 4. Combining Skip and Take
- 5. Using Distinct Pagination
- 6. Creating Infinite Scroll Pattern
- Example: Infinite scroll endpoint
- 7. Calculating Total Pages
- 8. Handling Pagination Edge Cases
- 9. Optimizing Large Dataset Pagination
- 10. Using Relay-Style Pagination
- 1. Using Interactive Transactions
- 2. Creating Sequential Transactions
- 3. Implementing Nested Writes
- 4. Using Transaction Isolation Levels
- 5. Handling Transaction Rollbacks
- 6. Setting Transaction Timeout
- 7. Using Idempotent Operations
- 8. Implementing Optimistic Concurrency
- 9. Avoiding Long-Running Transactions
- 10. Handling Transaction Errors
- 1. Executing Raw SELECT
- 2. Using Parameterized Queries
- 3. Executing Raw Write Operations
- 4. Using Unsafe Raw Queries
- 5. Typing Raw Query Results
- 6. Using Tagged Template Literals
- 7. Escaping Values Safely
- 8. Executing Multiple Statements
- 9. Using Database-Specific Functions
- 10. Combining Raw and Type-Safe Queries
- 1. Creating Query Middleware
- 2. Understanding Middleware Params
- 3. Modifying Query Parameters
- 4. Transforming Query Results
- 5. Implementing Soft Delete Middleware
- 6. Adding Timestamps Automatically
- 7. Logging Query Performance
- 8. Chaining Multiple Middleware
- 9. Using Async Middleware
- 10. Debugging Middleware Execution
- 1. Creating Client Extensions
- 2. Adding Custom Model Methods
- 3. Implementing Query Extensions
- 4. Using Result Extensions
- 5. Creating Reusable Extensions
- 6. Composing Multiple Extensions
- 7. Using Community Extensions
- 8. Testing Custom Extensions
- 9. Publishing Extension Packages
- 10. Managing Extension Lifecycle
- 1. Creating Single Field Unique
- 2. Defining Composite Unique
- 3. Using Unique in findUnique
- 4. Handling Unique Violations
- 5. Creating Conditional Unique Constraints
- 6. Using Case-Insensitive Unique
- 7. Implementing Partial Unique Indexes
- 8. Updating Unique Fields
- 9. Deleting by Unique Fields
- 10. Validating Uniqueness at Runtime
- 1. Adding deletedAt Field
- 2. Using Middleware for Soft Delete
- 3. Filtering Deleted Records
- 4. Implementing Restore Functionality
- 5. Performing Hard Deletes
- 6. Using Global Soft Delete Scope
- 7. Handling Relation Cascades
- 8. Archiving Deleted Records
- 9. Implementing Paranoid Mode
- 10. Querying Including Deleted Records
- 1. Configuring Multiple Datasources
- 2. Using Database Schemas
- 3. Switching Between Schemas
- 4. Managing Cross-Schema Queries
- 5. Implementing Multi-Tenancy Pattern
- Single DB / shared schema
- DB-per-tenant
- 6. Using Database-Specific Schema Features
- 7. Handling Per-Schema Migrations
- 8. Synchronizing Multiple Schemas
- 9. Configuring Per-Schema Connection Pools
- 10. Testing with Multiple Schemas
- 1. Catching PrismaClientKnownRequestError
- 2. Handling Unique Constraint Errors
- 3. Handling Foreign Key Errors
- 4. Handling Record Not Found Errors
- 5. Handling Validation Errors
- 6. Implementing Error Logging
- 7. Using Error Codes
- 8. Implementing Custom Error Classes
- 9. Handling Transaction Errors
- 10. Implementing Error Recovery Strategies
- 1. Preventing SQL Injection
- 2. Sanitizing User Input
- 3. Implementing Field-Level Security
- 4. Managing Database Credentials
- 5. Using Environment Variables
- 6. Implementing Row-Level Security
- 7. Encrypting Sensitive Data
- 8. Implementing Audit Logging
- 9. Managing Database Permissions
- 10. Implementing Rate Limiting
- 1. Implementing Repository Pattern
- 2. Using Unit of Work Pattern
- 3. Implementing Service Layer
- 4. Using Singleton Pattern
- 5. Implementing Factory Pattern
- 6. Using Builder Pattern for Queries
- 7. Implementing Observer Pattern
- 8. Using Strategy Pattern
- 9. Implementing CQRS Pattern
- Commands
- Queries
- 10. Using Domain-Driven Design
- 1. Deploying to Vercel
- 2. Deploying to AWS Lambda
- 3. Deploying with Docker
- 4. Configuring Production Database
- 5. Running Migrations in Production
- 6. Implementing CI/CD Pipeline
- 7. Managing Multiple Environments
- 8. Implementing Zero-Downtime Migrations
- 9. Using Database Backups
- 10. Implementing Rollback Strategy