Browse

Prisma .cursorrules prompt files

Prisma is a modern database toolkit for TypeScript and Node.js, offering type-safe database interactions which improve developer productivity and reduce runtime errors.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

Shadcn UI

JavaScript

Python

Radix UI

Next.js

Vite

JSX

WebP

Zod

Docker

Next.js App Router

Supabase

CSS

PostgreSQL

Redis

FastAPI

HTML

Pydantic

pytest

Git

Jest

react-hook-form

Solidity

Vercel

SQLAlchemy

Tailwind Aria

Suspense

SvelteKit

Vue.js

GitHub Actions

Celery

ESLint

PHP

TailwindCSS

Pinia

PEP 8

asyncpg

TypeScript

SQL

Playwright

Svelte

Prettier

Radix

DaisyUI

Vitest

JSDoc

JSON

ARIA

Drizzle ORM

Vue Router

VueUse

Astro

Svelte 5

tRPC

Expo

CORS

aiomysql

GitLab CI

Django

Typescript

scikit-learn

pandas

GitHub

RabbitMQ

Java

WebP.

tanStackQuery

Phoenix LiveView

Ecto

File System Watcher

Plug

Finch

Gettext

Phoenix

Elixir

Jason

Phoenix LiveDashboard

Sobelow

ExCoveralls

DNS Cluster

ExUnit

Release Please

Swoosh

Credo

LeftHook

ES6

npm

Laravel

styled-components

RESTful API

Shadcn

Markdown

OpenZeppelin

Slither

Hardhat

Mythril

Clear

Automation Testing

Testing Best Practices

Web Testing

Commit Message Conventions

Code Writing Guidelines

Development Best Practices

Dependencies Management

Python Conventions

Database Modeling

Authentication Security

Python Full-Stack Development.

Framework Development

Asynchronous Processing

Svelte

Overview

Scalable Architecture

Development Environment

Deployment Strategy

Digital Transactions

React Native

Event Management

AI Algorithms

Documentation and Best Practices

Real-Time Features

Maintenance and Support

Firebase Integration

Security Considerations

Project Setup

Social Features

Internal Linking

Blogging

External Linking

Page Speed

Schema Markup

Core Web Vitals

Mobile Optimization

User Engagement

Content Optimization

URL Structure

Real-time Graphics

Visual Experience Tools

Full-Stack Development

Error Handling and Validation

Code Style and Structure

Front-End Development

Web Development Strategies

Server Side Rendering

Server-side Logic

Code Patterns

Turborepo

Tailwind CSS

Radix UI

Server-side Development

PostgreSQL

Prisma

Shadcn UI

Forms and Validation

Next.js Best Practices

Web Development Guide

Type Checking

Component Modularity

JavaScript Best Practices

Mobile App Development

Show

5

rules

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

TypeScript Next.js Tailwind .cursorrules prompt file

You are an expert in TypeScript, Node.js, Next.js App Router, React, Prisma, PostgreSQL, Turborepo, Shadcn UI, Radix UI and Tailwind.

Write concise, technical TypeScript code with accurate examples.
Use functional and declarative programming patterns; avoid classes.
Prefer iteration and modularization over code duplication. But if you don't have a proper abstraction then writing similar code twice is fine.
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
Structure files: exported component, subcomponents, helpers, static content, types.
Use kebab case for route directories (e.g., api/hello-world/route). Use PascalCase for components (eg. components/Button.tsx)
Shadcn components are in components/ui. All other components are in components/.
Colocate files in the folder they're used. Unless the component can be used in many places across the app. Then it can be placed in the components folder.
We use Turborepo with pnpm workspaces.
We have one app called web in apps/web.
We have packages in the packages folder.
We have Next.js server actions in the apps/web/utils/actions folder. Eg. apps/web/utils/actions/cold-email has actions related to cold email management.
Favor named exports for components.
Use TypeScript for all code.
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
Use Shadcn UI and Tailwind for components and styling.
Implement responsive design with Tailwind CSS; use a mobile-first approach.
Use next/image package for images.
For API get requests to server use the swr package. Example:
```typescript
const searchParams = useSearchParams();
const page = searchParams.get("page") || "1";
const { data, isLoading, error } = useSWR<PlanHistoryResponse>(
/api/user/planned/history?page=${page}
);
```
Use the Loading component. Example:
```tsx
<Card>
<LoadingContent loading={isLoading} error={error}>
{data && <MyComponent data={data} />}
</LoadingContent>
</Card>
```
If we're in a server file, you can fetch the data inline.
For mutating data, use Next.js server actions.
Use isActionError with toastError and toastSuccess. Success toast is optional. Example:
```typescript
import { toastError, toastSuccess } from "@/components/Toast";
const onSubmit: SubmitHandler<TestRulesInputs> = useCallback(async (data) => {
const result = await testAiCustomContentAction({ content: data.message });
if (isActionError(result)) {
toastError({
title: "Error testing email",
description: result.error,
});
} else {
toastSuccess({ description: "Saved!" });
}
}, []);
```
Implement type-safe server actions with proper validation.
Define input schemas using Zod for robust type checking and validation.
Handle errors gracefully and return appropriate responses.
Ensure all server actions return the Promise`` type
Use React Hook Form with Zod for validation. The same validation should be done in the server action too. Example:
```tsx
export const ProcessHistory = () => {
const {
register,
handleSubmit,
formState: { errors, isSubmitting },
} = useForm<ProcessHistoryOptions>({
resolver: zodResolver(processHistorySchema),
});
const onSubmit: SubmitHandler<ProcessHistoryOptions> = useCallback(
async (data) => {
const result = await processHistoryAction(data.email);
handleActionResult(result, Processed history for ${data.email});
},
[]
);
return (
<form className="max-w-sm space-y-4" onSubmit={handleSubmit(onSubmit)}>
`<Input
type="email"
name="email"
label="Email"
registerProps={register("email", { required: true })}
error={errors.email}
/>`
<Button type="submit" loading={isSubmitting}>
Process History
</Button>
</form>
);
};
```
This is how you do a text area. Example:
```tsx
`<Input
type="text"
as="textarea"
rows={3}
name="message"
placeholder="Paste in email content"
registerProps={register("message", { required: true })}
error={errors.message}
/>`
```
This is the format of a server action. Example:
```typescript
export async function processHistoryAction(
unsafeData: ProcessHistoryOptions
): Promise<ServerActionResponse> {
const session = await auth();
const userId = session?.user.id;
if (!userId) return { error: "Not logged in" };
const data = processHistorySchema.safeParse(unsafeData);
if (!data.success) return { error: "Invalid data" };
// perform action
await processHistory();
revalidatePath("/history");
}
```

stack:

TypeScript Next.js Tailwind .cursorrules prompt file

Elie Steinbock

3

NEW

Solidity TypeScript .cursorrules prompt file

You are an expert in Solidity, TypeScript, Node.js, postgres, Sqlite3, and Prisma.

Key Principles

Write concise, technical responses with accurate TypeScript examples.
Use functional, declarative programming. Avoid classes.
Prefer iteration and modularization over duplication.
Use descriptive variable names with auxiliary verbs (e.g., isLoading).
Use lowercase with dashes for directories (e.g., components/auth-wizard).
Favor named exports for components.
Use the Receive an Object, Return an Object (RORO) pattern.

JavaScript/TypeScript
Use "function" keyword for pure functions. Omit semicolons.
Use TypeScript for all code. Prefer interfaces over types. Avoid enums, use maps.
File structure: Exported component, subcomponents, helpers, static content, types.
Avoid unnecessary curly braces in conditional statements.
For single-line statements in conditionals, omit curly braces.
Use concise, one-line syntax for simple conditional statements (e.g., if (condition) doSomething()).

Error Handling and Validation
Prioritize error handling and edge cases:
Handle errors and edge cases at the beginning of functions.
Use early returns for error conditions to avoid deeply nested if statements.
Place the happy path last in the function for improved readability.
Avoid unnecessary else statements; use if-return pattern instead.
Use guard clauses to handle preconditions and invalid states early.
Implement proper error logging and user-friendly error messages.
Consider using custom error types or error factories for consistent error handling.