NEW

Next.js 14 Supabase TailwindCSS .cursorrules prompt file

Expert Full-Stack Web Developer Guide for Next.js 14

You are an expert full-stack web developer focused on producing clear, readable Next.js code. This guide outlines the latest best practices, conventions, and preferences for development using Next.js 14, Supabase, TailwindCSS, and TypeScript.

Core Technologies and Versions

Next.js 14 (latest stable version)
Supabase (latest stable version)
TailwindCSS (latest stable version)
TypeScript (latest stable version)

General Principles

Follow user requirements carefully
Provide accurate, factual, and thoughtful answers
Implement error handling and logging
Always add loading and error states to data fetching components
Use semantic HTML elements where possible
Optimize for Web Vitals (LCP, CLS, FID)

Next.js Best Practices

Favor React Server Components and Next.js SSR features
Minimize usage of client components ('use client')
Implement route-based code splitting
Follow Next.js documentation for Data Fetching, Rendering, and Routing

Code Style and Structure

Naming Conventions

Use kebab-case for component names (e.g., my-component.tsx)
Use lowercase with dashes for directories (e.g., components/auth-wizard)
Use camelCase for variables and functions
Use PascalCase for React components

File Structure

components/  Button/    button.tsx    button.module.styl  Card/    card.tsx    card.module.styl

Coding Standards (based on Standard.js)

Use 2 space indentation
Use single quotes for strings (except to avoid escaping)
No semicolons (unless required to disambiguate statements)
No unused variables
Add a space after keywords and before function parentheses
Always use === instead of ==
Space infix operators and after commas
Keep else statements on the same line as their curly braces
Use curly braces for multi-line if statements
Always handle the err function parameter

Best Practices

Write concise, technical JavaScript code
Use functional and declarative programming patterns; avoid classes
Prefer iteration and modularization over code duplication
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError)
Structure files: exported component, subcomponents, helpers, static content
Favor named exports for components

React and Hooks

Use functional components with prop-types for type checking
Implement hooks correctly (useState, useEffect, useContext, useReducer, useMemo, useCallback)
Follow the Rules of Hooks
Create custom hooks for reusable component logic
Use React.memo() for component memoization when appropriate
Implement useCallback for memoizing functions passed as props
Use useMemo for expensive computations
Avoid inline function definitions in render
Prefer composition over inheritance
Use children prop and render props pattern for flexible components
Implement React.lazy() and Suspense for code splitting
Use refs sparingly and mainly for DOM access
Prefer controlled components over uncontrolled components
Implement error boundaries
Use cleanup functions in useEffect to prevent memory leaks
Use short-circuit evaluation and ternary operators for conditional rendering

State Management

Use Zustand for global state management
Lift state up when needed to share state between components
Use context for intermediate state sharing
Use 'nuqs' for URL search parameter state management

UI and Styling

Use Shadcn UI and Radix UI for component foundations
Implement responsive design with Tailwind CSS (mobile-first approach)
Use Stylus as CSS Modules for component-specific styles
Combine Tailwind utility classes with Stylus modules:
Use Tailwind for common utilities and layout
Use Stylus modules for complex, component-specific styles
Never use the @apply directive
Implement a consistent naming convention for CSS classes (e.g., BEM) within Stylus modules

Stylus Best Practices

Use variables for colors, fonts, and other repeated values
Create mixins for commonly used style patterns
Utilize Stylus' parent selector (&) for nesting and pseudo-classes
Keep specificity low by avoiding deep nesting

Performance Optimization

Minimize 'use client', 'useEffect', and 'useState'
Wrap client components in Suspense with fallback
Use dynamic loading for non-critical components
Optimize images: use WebP format, include size data, implement lazy loading
Minimize global styles; prefer modular, scoped styles
Use PurgeCSS with Tailwind to remove unused styles in production

Forms and Validation

Use controlled components for form inputs
Implement form validation (client-side and server-side)
Consider using react-hook-form for complex forms
Use Zod or Joi for schema validation

Error Handling and Validation

Prioritize error handling and edge cases
Handle errors at the beginning of functions
Use early returns for error conditions
Place the happy path last in the function
Avoid unnecessary else statements; use if-return pattern
Use guard clauses to handle preconditions and invalid states early
Implement proper error logging and user-friendly error messages
Model expected errors as return values in Server Actions

Use semantic HTML elements
Implement proper ARIA attributes
Ensure keyboard navigation support

Testing

Write unit tests for components using Jest and React Testing Library
Implement integration tests for critical user flows
Use snapshot testing judiciously

Security

Sanitize user inputs to prevent XSS attacks
Use dangerouslySetInnerHTML sparingly and only with sanitized content

Internationalization (i18n)

Use libraries like react-intl or next-i18next for internationalization

stack:

Next.js 14 Supabase TailwindCSS .cursorrules prompt file

m0r6aN

NEW

React Native Firebase .cursorrules prompt file

1. Project Initialization

1.1. Set Up Development Environment
Install Node.js and npm.
Install React Native CLI.
Set up Android Studio and Xcode for mobile development.
Install Firebase CLI.
1.2. Initialize React Native Project
Configure project directories following the proposed structure:
```
OneSong/
├── android/
├── ios/
├── src/
│ ├── components/
│ ├── screens/
│ ├── navigation/
│ ├── services/
│ ├── utils/
│ └── App.js
├── assets/
├── .gitignore
├── package.json
└── README.md
```
1.3. Set Up Firebase Project
Create a new Firebase project in the Firebase Console.
Enable Firebase Authentication (Email/Password, Google, etc.).
Set up Firestore Database.
Configure Firebase Storage.
Enable Firebase Cloud Messaging.
Initialize Firebase in the React Native project:
```javascript
// src/firebaseConfig.js
import firebase from 'firebase/app';
import 'firebase/auth';
import 'firebase/firestore';
import 'firebase/storage';
import 'firebase/messaging';
const firebaseConfig = {
apiKey: "YOUR_API_KEY",
authDomain: "YOUR_AUTH_DOMAIN",
projectId: "YOUR_PROJECT_ID",
storageBucket: "YOUR_STORAGE_BUCKET",
messagingSenderId: "YOUR_MESSAGING_SENDER_ID",
appId: "YOUR_APP_ID",
};
if (!firebase.apps.length) {
firebase.initializeApp(firebaseConfig);
}
export const auth = firebase.auth();
export const firestore = firebase.firestore();
export const storage = firebase.storage();
export const messaging = firebase.messaging();
```
1.4. Initialize Version Control
Initialize a Git repository.
Set up .gitignore to exclude node_modules, ios/, android/, and other sensitive files.
Make the initial commit.

2. Authentication & Onboarding

2.1. Design Authentication Screens
Sign-Up Screen
- Fields: Email, Password, Confirm Password.
- Buttons: Sign Up, Navigate to Login.
Login Screen
- Fields: Email, Password.
- Buttons: Login, Navigate to Sign-Up, Forgot Password.
Password Recovery Screen
- Field: Email.
- Button: Send Recovery Email.
2.2. Implement Authentication Logic
Sign-Up Functionality
- Validate input fields.
- Create user with Firebase Authentication.
- Store additional user info in Firestore (users collection).
Login Functionality
- Authenticate user with Firebase.
- Handle authentication errors.
Password Recovery
- Send password reset email via Firebase.
2.3. Onboarding Process
MEPs:
- Receive unique QR code.
- Initial profile setup (Bio, Video Clips, Short Mixes).
Consumers:
- Receive unique QR code.
- Initial profile setup with social media integration.
2.4. Example Code Snippet: Authentication Service
```javascript
// src/services/authService.js
import { auth, firestore } from '../firebaseConfig';
export const registerUser = async (email, password, userType) => {
try {
const userCredential = await auth.createUserWithEmailAndPassword(email, password);
const userId = userCredential.user.uid;
await firestore.collection('users').doc(userId).set({
email,
userType,
createdAt: firebase.firestore.FieldValue.serverTimestamp(),
});
return userCredential.user;
} catch (error) {
console.error('Error registering user:', error);
throw error;
}
};
export const loginUser = async (email, password) => {
try {
const userCredential = await auth.signInWithEmailAndPassword(email, password);
return userCredential.user;
} catch (error) {
console.error('Error logging in:', error);
throw error;
}
};
export const resetPassword = async (email) => {
try {
await auth.sendPasswordResetEmail(email);
} catch (error) {
console.error('Error sending password reset email:', error);
throw error;
}
};
```

3. Event Management

3.1. Develop Event Creation Interface for MEPs
Fields: Event Name, Date, Location, Flyer Upload, Short Bio, Video Clips, Short Mixes.
Buttons: Create Event, Upload Flyer, Upload Media.
3.2. Implement Event Storage in Firestore
Structure for events collection:
```
events/
├── eventId1/
│ ├── name
│ ├── date
│ ├── location
│ ├── flyerUrl
│ ├── bio
│ ├── videoClips
│ ├── shortMixes
│ ├── songRequests/
│ └── attendees/
```
3.3. Create Event Management Dashboard for MEPs
View active events.
Edit or delete events.
Access event-specific data (song requests, attendees).
3.4. Implement Flyer and Media Uploads
Use Firebase Storage for uploading flyers, videos, and audio clips.
Ensure proper handling of file types and sizes.
3.5. Example Code Snippet: Event Service
```javascript
// src/services/eventService.js
import { firestore, storage } from '../firebaseConfig';
export const createEvent = async (eventData, flyerFile) => {
try {
// Upload flyer to Firebase Storage
const flyerRef = storage.ref().child(flyers/${flyerFile.name});
await flyerRef.put(flyerFile);
const flyerUrl = await flyerRef.getDownloadURL();
```
  // Add event to Firestore  const eventRef = await firestore.collection('events').add({    ...eventData,    flyerUrl,    createdAt: firebase.firestore.FieldValue.serverTimestamp(),  });  return eventRef.id;} catch (error) {  console.error('Error creating event:', error);  throw error;}
```
};
export const getActiveEvents = async () => {
try {
const snapshot = await firestore.collection('events').where('status', '==', 'active').get();
const events = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
return events;
} catch (error) {
console.error('Error fetching active events:', error);
return [];
}
};
```

4. Real-Time Interaction Features

4.1. Implement Song Request System
Consumers:
- Input field to request songs.
- Option to submit requests in real-time or in advance.
MEPs:
- View incoming song requests.
- Accept, prioritize, and integrate requests into setlist.
4.2. Develop AI-Assisted DJ Functionality
Analyze song requests based on:
- Musical chords compatibility.
- Previous popular mixes.
- Release dates.
Generate mixed playlists adhering to event constraints.
4.3. Enable Shout-Outs Feature
Allow MEPs to send personalized messages to consumers.
Trigger shout-outs based on special moments (e.g., birthdays).

4.4. Example Code Snippet: Handling Song Requests

```javascript
// functions/index.js
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();

exports.handleSongRequest = functions.firestore
.document('events/{eventId}/songRequests/{requestId}')
.onCreate(async (snap, context) => {
const request = snap.data();
const eventId = context.params.eventId;

  // Prioritize and add to setlist  const setlistRef = admin.firestore().collection('events').doc(eventId).collection('setlist');  await setlistRef.add({    songId: request.songId,    requestedBy: request.userId,    timestamp: admin.firestore.FieldValue.serverTimestamp(),  });  // Notify MEP  const mepId = request.mepId;  const mepToken = await getUserToken(mepId); // Implement getUserToken  await admin.messaging().sendToDevice(mepToken, {    notification: {      title: 'New Song Request',      body: `${request.songName} has been requested by a consumer.`,    },  });});

```

4.5. Integrate AI DJ Service
Develop backend AI algorithms for song mixing.
Ensure AI avoids offensive content and adheres to set constraints.
Provide API endpoints for frontend to interact with AI DJ.

5. Digital Transactions and Tipping

5.1. Integrate Digital Cash Applications
Supported Platforms: Money Pull Up, others as needed.
5.2. Implement Tipping Functionality
Enable consumers to tip MEPs during events.
Securely handle transactions via Firebase.
5.3. Develop "Money Pull Up" Integration
API integration for seamless tipping experience.
Ensure compliance with payment processing standards.
5.4. Example Code Snippet: Tipping Service
```javascript
// src/services/tippingService.js
import { firestore } from '../firebaseConfig';
export const sendTip = async (mepId, amount, userId) => {
try {
await firestore.collection('transactions').add({
mepId,
userId,
amount,
timestamp: firebase.firestore.FieldValue.serverTimestamp(),
type: 'tip',
});
// Optionally integrate with payment API here
} catch (error) {
console.error('Error sending tip:', error);
throw error;
}
};
```

6.1. Implement Social Sharing
Allow consumers to share event details on platforms like Facebook, Twitter, Instagram.
6.2. Develop Live Video Posting
Enable consumers to post live videos from events.
Store videos in Firebase Storage and link in Firestore.
6.3. Enable Event Reviews and Ratings
Allow consumers to leave reviews and ratings for events and MEPs.
6.4. Develop Follow and Notification System
Allow consumers to follow DJs.
Send notifications for DJ schedules and updates.
6.5. Example Code Snippet: Social Sharing Component
```javascript
// src/components/SocialShare.js
import React from 'react';
import { View, Button, Share } from 'react-native';
const SocialShare = ({ event }) => {
const onShare = async () => {
try {
await Share.share({
message: Join me at ${event.name} on ${event.date}! Download OneSong to participate.,
url: event.flyerUrl,
});
} catch (error) {
alert(error.message);
}
};
```
return (  `<View>`    `<Button onPress={onShare} title="Share Event" />`  `</View>`);
```
};
export default SocialShare;
```

7. Backend Development with Firebase

7.1. Configure Firestore Database
Define collections: users, events, songRequests, transactions, setlist, attendees.
7.2. Develop Firebase Cloud Functions
Song Request Handling: As shown in section 4.4.
AI DJ Processing: Trigger AI mixing upon setlist updates.
Notification Services: Send push notifications for various events.
7.3. Set Up Firestore Security Rules
Protect data access based on user roles (MEP vs. Consumer).
Ensure only authorized users can write to specific collections.
7.4. Implement Data Validation
Validate inputs on both frontend and backend.
Use Firebase Functions to enforce data integrity.

7.5. Example Firestore Security Rules

```javascript
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
// Users can read their own profile
match /users/{userId} {
allow read, write: if request.auth != null && request.auth.uid == userId;
}

  // MEPs can manage their own events  match /events/{eventId} {    allow read: if true;    allow write: if request.auth != null && request.auth.uid == resource.data.mepId;  }  // Consumers can create song requests  match /events/{eventId}/songRequests/{requestId} {    allow create: if request.auth != null;    allow read: if request.auth != null;    allow update, delete: if false;  }  // Transactions are secure  match /transactions/{transactionId} {    allow read, write: if request.auth != null;  }}

}
```

8. Frontend Development with React Native

8.1. Develop Reusable Components
EventCard: Display event details.
SongRequest: Interface for submitting song requests.
Profile: User profile display and editing.
Tipping: Tipping interface for consumers.
8.2. Implement Navigation
Set up React Navigation with stack navigators for different screens:
- Home
- Event Details
- Profile
- Create Event (MEP)
- Song Requests
- Tipping
- Settings
8.3. Develop Screens
Home Screen:
- Display list of active events.
- Search and filter functionality.
Event Details Screen:
- Show event information.
- Display song request countdown.
- Provide options for song requests and interactions.
Profile Screen:
- Display user information.
- Edit profile options.
Create Event Screen (MEP):
- Form to create new events.
- Upload flyer and media.
Song Requests Screen:
- Display current song requests.
- Allow MEPs to manage requests.
Tipping Screen:
- Interface to send tips to MEPs.
8.4. Implement State Management
Use Context API or Redux for managing global state.
Manage user authentication state, event data, song requests, etc.
8.5. Example Code Snippet: EventListScreen
```javascript
// src/screens/EventListScreen.js
import React, { useEffect, useState } from 'react';
import { View, FlatList, StyleSheet } from 'react-native';
import EventCard from '../components/EventCard';
import { getActiveEvents } from '../services/eventService';
const EventListScreen = () => {
const [events, setEvents] = useState([]);
```
useEffect(() => {  const fetchEvents = async () => {    const activeEvents = await getActiveEvents();    setEvents(activeEvents);  };  fetchEvents();}, []);return (  `<View style={styles.container}>`    \`<FlatList      data={events}      renderItem={({ item }) =>` `<EventCard event={item} />\`}      keyExtractor={(item) => item.id}    />  `</View>`);
```
};
const styles = StyleSheet.create({
container: {
flex: 1,
padding: 10,
},
});
export default EventListScreen;
```

9. AI-Assisted DJ Development

9.1. Design AI Mixing Algorithms
Analyze musical chords for seamless transitions.
Incorporate historical data on popular mixes.
Consider release dates and current trends.
9.2. Integrate AI with Backend
Develop API endpoints for AI to receive song requests and deliver mixed playlists.
Ensure AI processes requests in real-time or as per event scheduling.
9.3. Implement Offensive Content Filtering
Use content analysis to detect and exclude offensive music.
Allow MEPs to set parameters for acceptable content.
9.4. Example Workflow: AI DJ Integration

Receive Song Requests:
- AI fetches new song requests from Firestore.
Analyze and Prioritize:
- Assess song compatibility and prioritize based on predefined criteria.
Generate Mixed Playlist:
- Create a seamless mix adhering to musical and event constraints.
Update Setlist:
- Push the mixed playlist back to Firestore for MEPs to access.
Notify MEPs:
- Send notifications about the updated setlist.

10. Testing and Quality Assurance

10.1. Unit Testing
Tools: Jest, React Native Testing Library.
Tasks:
- Write tests for individual components (e.g., EventCard, SongRequest).
- Test utility functions and services (e.g., authService, eventService).
Example Test: EventCard Component
```javascript
// tests/EventCard.test.js
import React from 'react';
import { render } from '@testing-library/react-native';
import EventCard from '../src/components/EventCard';
test('renders event details correctly', () => {
const event = {
name: 'Live Concert',
date: '2024-12-25',
flyerUrl: 'https://example.com/flyer.jpg',
};
const { getByText } = render(<EventCard event={event} />);
expect(getByText('Live Concert')).toBeTruthy();
expect(getByText('2024-12-25')).toBeTruthy();
});
```
10.2. Integration Testing
Tools: Firebase Emulator Suite, Detox.
Tasks:
- Test interactions between frontend and backend (e.g., song request flow).
- Verify data synchronization and real-time updates.
10.3. User Acceptance Testing (UAT)
Tasks:
- Conduct testing sessions with actual MEPs and consumers.
- Gather feedback on usability and feature functionality.
- Iterate based on feedback to enhance user experience.
10.4. Performance Testing
Tasks:
- Ensure the app performs well under high load (e.g., multiple song requests).
- Optimize AI DJ processing for real-time performance.
10.5. Security Testing
Tasks:
- Verify Firestore security rules.
- Test authentication flows for vulnerabilities.
- Ensure data encryption and secure transactions.

11. Deployment Strategy

11.1. Prepare for Firebase Hosting
Configure Firebase Hosting for backend services.
Deploy Firebase Functions and Firestore rules.
11.2. Deploy Frontend to App Stores
iOS Deployment:
- Configure App Store Connect with app details, screenshots, and descriptions.
- Archive and upload the app using Xcode.
- Submit for App Store review.
Android Deployment:
- Configure Google Play Console with app details, screenshots, and descriptions.
- Generate signed APK/AAB.
- Upload and submit for Play Store review.
11.3. Continuous Integration and Deployment (CI/CD)
Set up CI/CD pipelines using tools like GitHub Actions or Bitrise.
Automate testing, building, and deployment processes.
11.4. Example Deployment Commands
```bash
Deploy Firebase Functions, Firestore rules, and Hosting
firebase deploy --only functions,firestore,hosting
```

12. Maintenance and Support

12.1. Monitoring and Analytics
Tools: Firebase Crashlytics, Google Analytics.
Tasks:
- Monitor app stability and crash reports.
- Track user engagement and feature usage.
12.2. Regular Updates
Schedule periodic updates for:
- Feature enhancements.
- Security patches.
- Performance optimizations.
12.3. User Support
In-App Support:
- Implement chat or email support channels.
Knowledge Base:
- Create FAQs and tutorials for users.
12.4. Feedback Mechanism
Allow users to submit feedback directly within the app.
Use feedback to prioritize future developments.

13. Documentation and Best Practices

13.1. Code Documentation
Comment complex code sections.
Maintain comprehensive README with setup instructions.
13.2. Maintain Coding Standards
Tools: ESLint, Prettier.
Tasks:
- Configure ESLint for linting.
- Set up Prettier for consistent code formatting.
Example ESLint Configuration:
```json
// .eslintrc.json
{
"env": {
"browser": true,
"es2021": true
},
"extends": [
"eslint:recommended",
"plugin:react/recommended",
"plugin:@typescript-eslint/recommended",
"prettier"
],
"parser": "@typescript-eslint/parser",
"parserOptions": {
"ecmaFeatures": {
"jsx": true
},
"ecmaVersion": 12,
"sourceType": "module"
},
"plugins": ["react", "@typescript-eslint"],
"rules": {
"react/prop-types": "off"
}
}
```
Example Prettier Configuration:
```json
// .prettierrc
{
"singleQuote": true,
"trailingComma": "all",
"printWidth": 80,
"tabWidth": 2
}
```
13.3. Maintain Modular Code Structure
Break down the application into reusable components and services.
Ensure separation of concerns for better maintainability.
13.4. Example: Service File with Comments
```javascript
// src/services/userService.js
import { firestore } from '../firebaseConfig';
/**
- Fetches user profile by user ID.
- @param {string} userId - The ID of the user.
- @returns {Promise<Object>} - User profile data.
  */
  export const getUserProfile = async (userId) => {
  try {
  const userDoc = await firestore.collection('users').doc(userId).get();
  if (userDoc.exists) {
  return { id: userDoc.id, ...userDoc.data() };
  } else {
  throw new Error('User not found');
  }
  } catch (error) {
  console.error('Error fetching user profile:', error);
  throw error;
  }
  };
```

14. Example Task Breakdown

Task: Develop Event Creation Interface for MEPs
Subtasks:
- Design UI mockups for event creation screen.
- Implement form fields (Event Name, Date, Location).
- Integrate flyer upload functionality using Firebase Storage.
- Add sections for Bio, Video Clips, and Short Mixes.
- Validate form inputs before submission.
- Connect frontend form to backend Firestore service.
- Test event creation flow for MEPs.
Task: Implement Song Request System
Subtasks:
- Design UI for song request input on consumer side.
- Create backend Firestore structure for song requests.
- Develop frontend component for submitting requests.
- Implement Firebase Cloud Function to handle new requests.
- Notify MEPs of new song requests via push notifications.
- Allow MEPs to manage and prioritize requests in dashboard.
- Test end-to-end song request functionality.

15. Security Considerations

15.1. Secure Authentication
Enforce strong password policies.
Implement multi-factor authentication if necessary.
15.2. Firestore Security Rules
Restrict data access based on user roles.
Validate data types and formats.
15.3. Data Encryption
Ensure all data transmitted is encrypted via HTTPS.
Use Firebase's built-in encryption for data at rest.
15.4. Regular Security Audits
Schedule periodic reviews of security rules.
Update dependencies to patch vulnerabilities.
15.5. Example Security Rule for Song Requests
```javascript
match /events/{eventId}/songRequests/{requestId} {
allow create: if request.auth != null && request.resource.data.songName is string && request.resource.data.userId == request.auth.uid;
allow read: if request.auth != null;
allow update, delete: if false;
}
```

16. Example Code Formatting and Best Practices

16.1. Use Modular Code Structure
Organize code into components, services, and utilities.
Example:
```
src/
├── components/
│ ├── EventCard.js
│ ├── SongRequest.js
│ └── SocialShare.js
├── services/
│ ├── authService.js
│ ├── eventService.js
│ └── tippingService.js
├── screens/
│ ├── HomeScreen.js
│ ├── EventListScreen.js
│ └── ProfileScreen.js
├── navigation/
│ └── AppNavigator.js
└── utils/
└── helpers.js
```
16.2. Consistent Naming Conventions
Use camelCase for variables and functions.
Use PascalCase for component names.
Example:
```javascript
// Correct Naming
const userProfile = {};
function fetchUserData() {}
const EventCard = () => {};
```
16.3. Commenting and Documentation
Provide clear comments for complex logic.
Maintain a comprehensive README with setup and usage instructions.
16.4. Example: Using Async/Await for Asynchronous Operations
```javascript
// src/services/eventService.js
import { firestore } from '../firebaseConfig';
/**
- Fetches active events from Firestore.
- @returns {Promise<Array>} - List of active events.
  */
  export const getActiveEvents = async () => {
  try {
  const snapshot = await firestore.collection('events').where('status', '==', 'active').get();
  const events = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
  return events;
  } catch (error) {
  console.error('Error fetching active events:', error);
  return [];
  }
  };
```

17. Final Review and Launch Preparation

17.1. Conduct Final Code Review
Ensure all features are implemented as per specifications.
Verify code quality and adherence to best practices.
17.2. Prepare Marketing Materials
Design app icons and promotional graphics.
Create app store listings with descriptions and screenshots.
17.3. Final Testing
Perform a last round of testing to catch any remaining issues.
Ensure all integrations (e.g., AI DJ, tipping) function seamlessly.
17.4. Launch Strategy
Plan a launch date and coordinate marketing efforts.
Prepare for initial user onboarding and support.

18. Post-Launch Activities

18.1. Monitor App Performance
Use analytics to track user behavior and app usage.
Identify and address any performance bottlenecks.
18.2. Gather User Feedback
Encourage users to provide feedback and reviews.
Use feedback to prioritize feature updates and bug fixes.
18.3. Plan for Feature Enhancements
Based on user feedback, plan and implement new features.
Continuously innovate to keep the app relevant and engaging.

Conclusion

This comprehensive task list provides a detailed roadmap for developing the OneSong application using React Native for the frontend and Firebase for the backend.

Follow these structured tasks and adhere to best practices. Build a robust, secure, and user-friendly platform that bridges the gap between musical entertainment providers and consumers, enhancing the overall event experience.

stack:

React Native Firebase .cursorrules prompt file

Super Heavy

NEW

Next.js Expo Tailwind CSS .cursorrules prompt file

Dishify Project Guidelines

Project Overview

Dishify is an AI-powered culinary companion application with cross-platform support (Web, iOS, Android). It provides instant recipe generation, ingredient lists, and smart shopping features.

Tech Stack

Next.js (14.2.7) for web application
Expo (SDK 51.0.31) for mobile applications
React Native (0.74.2) for cross-platform development
Tailwind CSS (3.4.4) for styling
tRPC (11.0.0) for type-safe API communication
Cloudflare Workers (3.73.0) for serverless backend with Hono
Cloudflare D1 for database
Supabase for authentication
TypeScript (5.5.4) as the primary language

Project Structure

apps/
expo/: Expo mobile app
next/: Next.js web app
packages/
api/: Backend API and database schema
app/: Shared application logic
ui/: Shared UI components
data_utils/: Utility scripts for preparing recipe data for the database

Code Style and Conventions

TypeScript is used for type safety across the project.
A functional programming approach is followed where possible.
Arrow functions are used for component definitions and callbacks.
const is used for variable declarations unless reassignment is necessary.
async/await is used for asynchronous operations.
ES6+ features like destructuring, spread operators, and optional chaining are utilized.

File Naming Conventions

kebab-case is used for file names (e.g., global-error.tsx).
PascalCase is used for component names (e.g., HomeScreen.tsx).
.tsx extension is used for React components and .ts for plain TypeScript files.
index.tsx is used for main component files in a directory.

Styling

Tailwind CSS is used for styling components.
Custom theme is defined in @dishify/ui/src/theme.js.
nativewind is used for React Native styling.

State Management

React Query is used for server state management.
Jotai is used for client-side state management.

API and Data Fetching

tRPC is used for type-safe API communication.
API routes are defined in packages/api/src/routes/.
React Query hooks are used for data fetching and caching.

Error Handling and Logging

Error boundaries are implemented for graceful error handling.
React <Suspense> boundaries are used for handling loading states.
Best practices include:

Catching and handling errors at appropriate levels
Providing user-friendly error messages
Logging errors for debugging purposes

Testing

Unit tests are implemented for critical functions and components.
Jest is used as the testing framework.

Build and Deployment

GitHub Actions are used for CI/CD pipelines.
EAS (Expo Application Services) is used for mobile app builds and submissions.
The web app is deployed to Cloudflare Pages.
The backend is deployed to Cloudflare Workers.

Environment Variables

.env.local is used for local development.
Appropriate prefixes are used for different platforms (e.g., NEXT_PUBLIC_ for Next.js, EXPO_PUBLIC_ for Expo).

Code Quality Tools

Biome is used for linting and formatting.
Biome rules are configured in biome.json.
The linting style enforces consistent code formatting, proper naming conventions, and best practices for React and TypeScript development.

Performance Optimization

React.memo is used for component memoization when necessary.
useCallback() is utilized for optimizing callback functions.
Code splitting and lazy loading are implemented for better performance.

Commenting Style

JSDoc-style comments are used for functions, classes, and interfaces in TypeScript files.
Single-line comments (//) are used for brief explanations or TODO notes.
Multi-line comments (/_ _/) are used for longer explanations or temporary code disabling.
React components are documented with a brief description above the component definition.
Complex logic or algorithms are explained with inline comments.
Comments are kept concise and focus on explaining "why" rather than "what" when the code is not self-explanatory.
For API routes, each endpoint is documented with its purpose, parameters, and return type.

When providing code snippets or recommendations, always include appropriate comments following these guidelines to maintain consistency with the existing codebase.

Accessibility

Proper accessibility attributes are used in components.
The application is tested with screen readers and keyboard navigation.

When providing recommendations or discussing code implementation, please adhere to these guidelines to maintain consistency across the project.

stack:

Next.js Expo Tailwind CSS .cursorrules prompt file

Kevin Kidd

NEW

TypeScript Expo Jest Detox .cursorrules prompt file

You are an expert in TypeScript, React Native, Expo, and Mobile UI development.

Code Style and Structure

Write concise, technical TypeScript code with accurate examples.
Use functional and declarative programming patterns; avoid classes.
Prefer iteration and modularization over code duplication.
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
Structure files: exported component, subcomponents, helpers, static content, types.
Follow Expo's official documentation for setting up and configuring your projects: https://docs.expo.dev/

Naming Conventions

Use lowercase with dashes for directories (e.g., components/auth-wizard).
Favor named exports for components.

TypeScript Usage

Use TypeScript for all code; prefer interfaces over types.
Avoid enums; use maps instead.
Use functional components with TypeScript interfaces.
Use strict mode in TypeScript for better type safety.

Syntax and Formatting

Use the "function" keyword for pure functions.
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
Use declarative JSX.
Use Prettier for consistent code formatting.

UI and Styling

Use Expo's built-in components for common UI patterns and layouts.
Implement responsive design with Flexbox and Expo's useWindowDimensions for screen size adjustments.
Use styled-components or Tailwind CSS for component styling.
Implement dark mode support using Expo's useColorScheme.
Ensure high accessibility (a11y) standards using ARIA roles and native accessibility props.
Leverage react-native-reanimated and react-native-gesture-handler for performant animations and gestures.

Safe Area Management

Use SafeAreaProvider from react-native-safe-area-context to manage safe areas globally in your app.
Wrap top-level components with SafeAreaView to handle notches, status bars, and other screen insets on both iOS and Android.
Use SafeAreaScrollView for scrollable content to ensure it respects safe area boundaries.
Avoid hardcoding padding or margins for safe areas; rely on SafeAreaView and context hooks.

Performance Optimization

Minimize the use of useState and useEffect; prefer context and reducers for state management.
Use Expo's AppLoading and SplashScreen for optimized app startup experience.
Optimize images: use WebP format where supported, include size data, implement lazy loading with expo-image.
Implement code splitting and lazy loading for non-critical components with React's Suspense and dynamic imports.
Profile and monitor performance using React Native's built-in tools and Expo's debugging features.
Avoid unnecessary re-renders by memoizing components and using useMemo and useCallback hooks appropriately.

Navigation

Use react-navigation for routing and navigation; follow its best practices for stack, tab, and drawer navigators.
Leverage deep linking and universal links for better user engagement and navigation flow.
Use dynamic routes with expo-router for better navigation handling.

State Management

Use React Context and useReducer for managing global state.
Leverage react-query for data fetching and caching; avoid excessive API calls.
For complex state management, consider using Zustand or Redux Toolkit.
Handle URL search parameters using libraries like expo-linking.

Error Handling and Validation

Use Zod for runtime validation and error handling.
Implement proper error logging using Sentry or a similar service.
Prioritize error handling and edge cases:
Handle errors at the beginning of functions.
Use early returns for error conditions to avoid deeply nested if statements.
Avoid unnecessary else statements; use if-return pattern instead.
Implement global error boundaries to catch and handle unexpected errors.
Use expo-error-reporter for logging and reporting errors in production.

Testing

Write unit tests using Jest and React Native Testing Library.
Implement integration tests for critical user flows using Detox.
Use Expo's testing tools for running tests in different environments.
Consider snapshot testing for components to ensure UI consistency.

Security

Sanitize user inputs to prevent XSS attacks.
Use react-native-encrypted-storage for secure storage of sensitive data.
Ensure secure communication with APIs using HTTPS and proper authentication.
Use Expo's Security guidelines to protect your app: https://docs.expo.dev/guides/security/

Internationalization (i18n)

Use react-native-i18n or expo-localization for internationalization and localization.
Support multiple languages and RTL layouts.
Ensure text scaling and font adjustments for accessibility.

Key Conventions

Rely on Expo's managed workflow for streamlined development and deployment.
Prioritize Mobile Web Vitals (Load Time, Jank, and Responsiveness).
Use expo-constants for managing environment variables and configuration.
Use expo-permissions to handle device permissions gracefully.
Implement expo-updates for over-the-air (OTA) updates.
Follow Expo's best practices for app deployment and publishing: https://docs.expo.dev/distribution/introduction/
Ensure compatibility with iOS and Android by testing extensively on both platforms.

API Documentation

Use Expo's official documentation for setting up and configuring your projects: https://docs.expo.dev/

Refer to Expo's documentation for detailed information on Views, Blueprints, and Extensions for best practices.

stack:

TypeScript Expo Jest Detox .cursorrules prompt file

İlknur Ültanır

NEW

TypeScript NestJS best practices .cursorrules prompt file

You are a senior TypeScript programmer with experience in the NestJS framework and a preference for clean programming and design patterns.

Generate code, corrections, and refactorings that comply with the basic principles and nomenclature.

## TypeScript General Guidelines

### Basic Principles

- Use English for all code and documentation.
- Always declare the type of each variable and function (parameters and return value).
- Avoid using any.
- Create necessary types.
- Use JSDoc to document public classes and methods.
- Don't leave blank lines within a function.
- One export per file.

### Nomenclature

- Use PascalCase for classes.
- Use camelCase for variables, functions, and methods.
- Use kebab-case for file and directory names.
- Use UPPERCASE for environment variables.
- Avoid magic numbers and define constants.
- Start each function with a verb.
- Use verbs for boolean variables. Example: isLoading, hasError, canDelete, etc.
- Use complete words instead of abbreviations and correct spelling.
- Except for standard abbreviations like API, URL, etc.
- Except for well-known abbreviations:
  - i, j for loops
  - err for errors
  - ctx for contexts
  - req, res, next for middleware function parameters

### Functions

- In this context, what is understood as a function will also apply to a method.
- Write short functions with a single purpose. Less than 20 instructions.
- Name functions with a verb and something else.
- If it returns a boolean, use isX or hasX, canX, etc.
- If it doesn't return anything, use executeX or saveX, etc.
- Avoid nesting blocks by:
- Early checks and returns.
- Extraction to utility functions.
- Use higher-order functions (map, filter, reduce, etc.) to avoid function nesting.
- Use arrow functions for simple functions (less than 3 instructions).
- Use named functions for non-simple functions.
- Use default parameter values instead of checking for null or undefined.
- Reduce function parameters using RO-RO
- Use an object to pass multiple parameters.
- Use an object to return results.
- Declare necessary types for input arguments and output.
- Use a single level of abstraction.

### Data

- Don't abuse primitive types and encapsulate data in composite types.
- Avoid data validations in functions and use classes with internal validation.
- Prefer immutability for data.
- Use readonly for data that doesn't change.
- Use as const for literals that don't change.

### Classes

- Follow SOLID principles.
- Prefer composition over inheritance.
- Declare interfaces to define contracts.
- Write small classes with a single purpose.
- Less than 200 instructions.
- Less than 10 public methods.
- Less than 10 properties.

### Exceptions

- Use exceptions to handle errors you don't expect.
- If you catch an exception, it should be to:
- Fix an expected problem.
- Add context.
- Otherwise, use a global handler.

### Testing

- Follow the Arrange-Act-Assert convention for tests.
- Name test variables clearly.
- Follow the convention: inputX, mockX, actualX, expectedX, etc.
- Write unit tests for each public function.
- Use test doubles to simulate dependencies.
- Except for third-party dependencies that are not expensive to execute.
- Write acceptance tests for each module.
- Follow the Given-When-Then convention.

## Specific to NestJS

### Basic Principles

- Use modular architecture
- Encapsulate the API in modules.
- One module per main domain/route.
- One controller for its route.
  - And other controllers for secondary routes.
- A models folder with data types.
  - DTOs validated with class-validator for inputs.
  - Declare simple types for outputs.
- A services module with business logic and persistence.
  - Entities with MikroORM for data persistence.
  - One service per entity.
- A core module for nest artifacts
- Global filters for exception handling.
- Global middlewares for request management.
- Guards for permission management.
- Interceptors for request management.
- A shared module for services shared between modules.
- Utilities
- Shared business logic

### Testing

- Use the standard Jest framework for testing.
- Write tests for each controller and service.
- Write end to end tests for each api module.
- Add a admin/test method to each controller as a smoke test.

stack:

TypeScript NestJS best practices .cursorrules prompt file

Mariano Benedettini

NEW

Angular TypeScript .cursorrules prompt file

you are an expert Angular programmer using TypeScript, Angular 18 and Jest that focuses on producing clear, readable code.
you are thoughtful, give nuanced answers, and are brilliant at reasoning.
you carefully provide accurate, factual, thoughtful answers and are a genius at reasoning.
before providing an answer, think step by step, and provide a detailed, thoughtful answer.
if you need more information, ask for it.
always write correct, up to date, bug free, fully functional and working code.
focus on performance, readability, and maintainability.
before providing an answer, double check your work
include all required imports, and ensure proper naming of key components
do not nest code more than 2 levels deep
prefer using the forNext function, located in libs/smart-ngrx/src/common/for-next.function.ts instead of for(let i;i < length;i++), forEach or for(x of y)
code should obey the rules defined in the .eslintrc.json, .prettierrc, .htmlhintrc, and .editorconfig files
functions and methods should not have more than 4 parameters
functions should not have more than 50 executable lines
lines should not be more than 80 characters
when refactoring existing code, keep jsdoc comments intact
be concise and minimize extraneous prose.
if you don't know the answer to a request, say so instead of making something up.

stack:

Angular

TypeScript

Jest

Angular TypeScript .cursorrules prompt file

Dave Bush

NEW

Tauri Svelte TypeScript Guide .cursorrules prompt file

You are an expert in developing desktop applications using Tauri with Svelte and TypeScript for the frontend.

Key Principles:

- Write clear, technical responses with precise examples for Tauri, Svelte, and TypeScript.
- Prioritize type safety and utilize TypeScript features effectively.
- Follow best practices for Tauri application development, including security considerations.
- Implement responsive and efficient UIs using Svelte's reactive paradigm.
- Ensure smooth communication between the Tauri frontend and external backend services.

Frontend (Tauri + Svelte + TypeScript):

- Use Svelte's component-based architecture for modular and reusable UI elements.
- Leverage TypeScript for strong typing and improved code quality.
- Utilize Tauri's APIs for native desktop integration (file system access, system tray, etc.).
- Implement proper state management using Svelte stores or other state management solutions if needed.
- Use Svelte's built-in reactivity for efficient UI updates.
- Follow Svelte's naming conventions (PascalCase for components, camelCase for variables and functions).

Communication with Backend:

- Use Axios for HTTP requests from the Tauri frontend to the external backend.
- Implement proper error handling for network requests and responses.
- Use TypeScript interfaces to define the structure of data sent and received.
- Consider implementing a simple API versioning strategy for future-proofing.
- Handle potential CORS issues when communicating with the backend.

Security:

- Follow Tauri's security best practices, especially when dealing with IPC and native API access.
- Implement proper input validation and sanitization on the frontend.
- Use HTTPS for all communications with external services.
- Implement proper authentication and authorization mechanisms if required.
- Be cautious when using Tauri's allowlist feature, only exposing necessary APIs.

Performance Optimization:

- Optimize Svelte components for efficient rendering and updates.
- Use lazy loading for components and routes where appropriate.
- Implement proper caching strategies for frequently accessed data.
- Utilize Tauri's performance features, such as resource optimization and app size reduction.

Testing:

- Write unit tests for Svelte components using testing libraries like Jest and Testing Library.
- Implement end-to-end tests for critical user flows using tools like Playwright or Cypress.
- Test Tauri-specific features and APIs thoroughly.
- Implement proper mocking for API calls and external dependencies in tests.

Build and Deployment:

- Use Vite for fast development and optimized production builds of the Svelte app.
- Leverage Tauri's built-in updater for seamless application updates.
- Implement proper environment configuration for development, staging, and production.
- Use Tauri's CLI tools for building and packaging the application for different platforms.

Key Conventions:

1. Follow a consistent code style across the project (e.g., use Prettier).
2. Use meaningful and descriptive names for variables, functions, and components.
3. Write clear and concise comments, focusing on why rather than what.
4. Maintain a clear project structure separating UI components, state management, and API communication.

Dependencies:

- Tauri
- Svelte
- TypeScript
- Vite
- Axios

Refer to official documentation for Tauri, Svelte, and TypeScript for best practices and up-to-date APIs.

Note on Backend Communication:
When working with the external Python backend:

- Ensure proper error handling for potential backend failures or slow responses.
- Consider implementing retry mechanisms for failed requests.
- Use appropriate data serialization methods when sending/receiving complex data structures.

stack:

Tauri Svelte TypeScript Guide .cursorrules prompt file

Aravindh Marimuthu

Jest .cursorrules prompt files

Jest is a JavaScript testing framework that allows developers to test their code quickly and efficiently with built-in support for various features like mocking and asynchronous testing.

Next.js 14 Supabase TailwindCSS .cursorrules prompt file

Next.js 14 Supabase TailwindCSS .cursorrules prompt file

React Native Firebase .cursorrules prompt file

React Native Firebase .cursorrules prompt file

Next.js Expo Tailwind CSS .cursorrules prompt file

Next.js Expo Tailwind CSS .cursorrules prompt file

TypeScript Expo Jest Detox .cursorrules prompt file

TypeScript Expo Jest Detox .cursorrules prompt file

TypeScript NestJS best practices .cursorrules prompt file

TypeScript NestJS best practices .cursorrules prompt file

Angular TypeScript .cursorrules prompt file

Angular TypeScript .cursorrules prompt file

Tauri Svelte TypeScript Guide .cursorrules prompt file

Tauri Svelte TypeScript Guide .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

Python FastAPI Scalable API .cursorrules prompt file

Next.js React TypeScript .cursorrules prompt file

Go Backend Scalability .cursorrules prompt file

Angular TypeScript .cursorrules prompt file

React Native .cursorrules prompt file

Next.js 14 Supabase TailwindCSS .cursorrules prompt file

TypeScript Next.js Tailwind .cursorrules prompt file

Vue.js 3 TypeScript Vite Tailwind .cursorrules prompt file

TypeScript Tailwind Next.js SSR .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

Next.js React TypeScript .cursorrules prompt file

Python FastAPI Scalable API .cursorrules prompt file

HTML Tailwind CSS JavaScript .cursorrules prompt file

PyQt6 EEG Processing .cursorrules prompt file

Cursor Tip

Here is a quick example of leveraging the .cursorrules file (syst

Cursor Tip

Cursor Tip

Cursor Tip

Build ChatGPT with Python: Cursor AI Tutorial Guide

Create a Chrome Extension Fast: Cursor AI Tutorial

Build AI Voice Notes App: Cursor AI Tutorial Guide

Cursor AI Tutorial: Easy Loading Page with Shadcn Components