prisma2ts

A CLI tool that converts Prisma schema files into TypeScript interface/type declarations with inline JSDoc comments.

Installation

npm install -g prisma2ts

Or run directly with npx:

npx prisma2ts --input schema.prisma

Usage

prisma2ts [options]

Options

• -i, --input <path> - Input Prisma schema file or directory (default: schema.prisma)
• -o, --output <path> - Output TypeScript file or directory (prints to stdout if not specified)
• -r, --recursive - Recursively process all .prisma files in input directory
• -c, --config <file> - Path to configuration file
• --init-config - Create a sample configuration file
• --no-docs - Disable JSDoc comment generation
• --table - Print summary table of parsed models and enums
• --json - Output JSON representation instead of TypeScript
• -V, --version - Display version number
• -h, --help - Display help information

Examples

Basic usage:

prisma2ts --input schema.prisma --output types.ts

Generate without JSDoc comments:

prisma2ts --input schema.prisma --no-docs

Show summary table:

prisma2ts --input schema.prisma --table

Output as JSON:

prisma2ts --input schema.prisma --json

Recursive directory processing:

# Process all .prisma files in a directory
prisma2ts --recursive --input ./schemas --output ./types

# Process with table summary
prisma2ts -r --input ./schemas --output ./types --table

Configuration file usage:

# Create a sample configuration file
prisma2ts --init-config

# Use configuration file for custom mappings
prisma2ts --config prisma2ts.config.json

# Use custom config file path
prisma2ts --config ./configs/my-config.json

Features

• Single File Conversion: Convert individual Prisma schema files
• Recursive Directory Processing: Process entire directories of .prisma files at once
• Configuration File Support: Define custom input/output mappings with prisma2ts.config.json
• Custom File Mappings: Map specific schema files to custom output locations and names
• Enum Conversion: Converts Prisma enums to TypeScript union types
• Model Conversion: Converts Prisma models to TypeScript interfaces
• JSDoc Generation: Preserves // comments as JSDoc annotations
• Type Mapping: Maps Prisma types to appropriate TypeScript types
• JSON Support: Includes JsonValue type alias when needed
• Clean Output: Strips generator/datasource blocks and block comments
• Directory Structure Preservation: Maintains nested folder structure in output

Configuration File

For complex projects with multiple schema files, you can use a configuration file to define custom input/output mappings.

Creating a Configuration File

prisma2ts --init-config

This creates a prisma2ts.config.json file with the following structure:

{
  "mappings": [
    {
      "input": "schemas/user.prisma",
      "output": "types/UserTypes.ts",
      "options": {
        "docs": true
      }
    },
    {
      "input": "schemas/product.prisma", 
      "output": "types/ProductTypes.ts"
    },
    {
      "input": "schemas/**/*.prisma",
      "output": "types/generated/{{name}}.ts"
    }
  ],
  "options": {
    "docs": true,
    "json": false
  }
}

Configuration Options

• mappings: Array of input/output file mappings

  • input: Path to input .prisma file (supports basic glob patterns)
  • output: Path to output file (supports template variables like {{name}})
  • options: Per-mapping options (overrides global options)

• options: Global options for all mappings

  • docs: Enable/disable JSDoc generation (default: true)
  • json: Output JSON instead of TypeScript (default: false)

Template Variables

You can use template variables in output paths:

• {{name}}: Base filename without extension
• {{dir}}: Directory name containing the input file
• {{path}}: Relative path from current directory

Type Mappings

| Prisma Type | TypeScript Type | | ----------- | --------------- | | String | string | | Int | number | | Float | number | | Boolean | boolean | | DateTime | Date | | Json | JsonValue | | BigInt | bigint | | Bytes | string |

Example

Input (schema.prisma):

enum Role {
  USER     // Standard user
  ADMIN    // Administrator
}

model User {
  id    String @id
  email String @unique
  name  String? // Display name
  role  Role    @default(USER)
}

Output (TypeScript):

export type Role =
  /** Standard user */
  | "USER"
  /** Administrator */
  | "ADMIN";

export interface User {
  id: string;
  email: string;
  /** Display name */
  name?: string | null;
  role: Role;
}

License

MIT