or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

binary-resolution.md cli-utilities.md database-operations.md engine-commands.md error-handling.md generators.md index.md syntax-highlighting.md tracing.md utilities.md

tile.json

tessl/npm-prisma--internals

Comprehensive internal utility library for Prisma's CLI operations, schema management, generator handling, and engine interactions

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:npm/@prisma/internals@6.15.x

To install, run

npx @tessl/cli install tessl/npm-prisma--internals@6.15.0

@prisma/internals

The @prisma/internals package provides essential internal utilities and APIs for the Prisma ecosystem. This package serves as the foundational layer for Prisma CLI operations, offering comprehensive functionality for schema processing, code generation, database operations, and system integration.

Package Information

Name: @prisma/internals
Type: TypeScript/JavaScript library
Language: TypeScript
Installation: npm install @prisma/internals

Core Imports

// Common CLI utilities
import {
  loadSchemaContext,
  getSchemaWithPath,
  inferDirectoryConfig,
  type SchemaContext,
  type DirectoryConfig
} from '@prisma/internals'

// Engine operations
import {
  formatSchema,
  getConfig,
  getDMMF,
  validate,
  lintSchema
} from '@prisma/internals'

// Generator system
import {
  Generator,
  getGenerators,
  type GeneratorConfig,
  type GeneratorOptions
} from '@prisma/internals'

// Database operations
import {
  canConnectToDatabase,
  createDatabase,
  dropDatabase
} from '@prisma/internals'

// Utilities and helpers
import {
  resolveBinary,
  highlightDatamodel,
  logger,
  handlePanic
} from '@prisma/internals'

Basic Usage

Loading and Processing Schema

import { loadSchemaContext, getSchemaWithPath } from '@prisma/internals'

// Load schema context with all configuration
const context = await loadSchemaContext({
  cwd: process.cwd(),
  allowNull: false
})

// Get schema with specific path
const schemaResult = await getSchemaWithPath(
  './prisma/schema.prisma',
  undefined,
  { cwd: process.cwd() }
)

Engine Operations

import { formatSchema, getDMMF, validate } from '@prisma/internals'

// Format Prisma schema
const formattedSchemas = await formatSchema({
  schemas: schemaResult.schemas
})

// Generate DMMF (Data Model Meta Format)
const dmmf = await getDMMF({
  datamodel: schemaResult.schemas,
  previewFeatures: ['typedSql']
})

// Validate schema
validate({
  schemas: schemaResult.schemas,
  cwd: process.cwd()
})

Generator Management

import { getGenerators, Generator } from '@prisma/internals'

// Get all generators from schema
const generators = await getGenerators({
  schemaPath: './prisma/schema.prisma',
  cwd: process.cwd()
})

// Initialize and run generators
for (const generator of generators) {
  await generator.init()
  await generator.generate()
}

Architecture

The @prisma/internals package is organized into several functional domains:

Core Components

CLI Framework - Command-line interface utilities and argument parsing
Schema Engine - WASM-based schema operations (formatting, validation, DMMF generation)
Generator System - Code generator management and execution
Database Interface - Database connectivity and management operations
Binary Resolution - Engine binary path resolution and platform detection
File System Layer - Cross-platform file operations and utilities
Error Handling - Comprehensive error management including panic recovery
Tracing System - Distributed tracing and observability support

Data Flow

CLI Commands → Schema Loading → Engine Operations → Code Generation → Database Operations
     ↓              ↓                ↓                    ↓                ↓
File System ← Error Handling ← Binary Resolution ← Tracing ← Platform Utils

Capabilities

CLI Utilities and Command Framework

Comprehensive command-line interface utilities including argument parsing, schema loading, and configuration management. → CLI Utilities

// Load schema context with full configuration
const context = await loadSchemaContext(options?)
// Parse command arguments safely  
const result = arg(argv, spec, stopAtPositional?, permissive?)
// Get directory configuration for views, SQL, and migrations
const dirs = inferDirectoryConfig(schemaContext?, config?, cwd?)

Engine Commands and Schema Operations

Schema processing using WASM engines for formatting, validation, and DMMF generation. → Engine Commands

// Format Prisma schema files
const formatted = await formatSchema({ schemas }, formattingOptions?)
// Generate Data Model Meta Format
const dmmf = await getDMMF(options)
// Validate schema without generating DMMF
validate(options)
// Extract configuration from schema
const config = await getConfig(options)

Generator System and Management

Complete generator lifecycle management including initialization, execution, and cleanup. → Generators

// Get all generators from schema
const generators = await getGenerators(options)
// Get single generator (useful for testing)
const generator = await getGenerator(options)
// Abstract base class for generators
abstract class Generator {
  abstract init(): Promise<void>
  abstract generate(): Promise<void>
}

Database Operations

Database connectivity testing and management operations across different providers. → Database Operations

// Test database connectivity
const canConnect = await canConnectToDatabase(connectionString, cwd?, enginePath?)
// Create database if it doesn't exist
const created = await createDatabase(connectionString, cwd?, enginePath?)
// Drop/delete database
const dropped = await dropDatabase(connectionString, cwd?, enginePath?)

File System and Utility Functions

Cross-platform file system operations, environment handling, and general utilities. → Utilities

// Load environment variables from files
const env = loadEnvFile(path)
// Cross-platform path utilities
const posixPath = pathToPosix(path)
// Format milliseconds to human readable
const formatted = formatms(ms)
// Safe JavaScript identifier validation
const isValid = isValidJsIdentifier(name)

Binary Resolution and Platform Utilities

Engine binary path resolution and platform-specific operations. → Binary Resolution

// Resolve engine binary path
const binaryPath = await resolveBinary(name, proposedPath?)
// Get binary target for current platform
const target = getBinaryTargetForCurrentPlatform()
// Binary type enumeration
enum BinaryType { QueryEngine, SchemaEngine, ... }

Syntax Highlighting

Code syntax highlighting for Prisma schemas, SQL, and TypeScript. → Syntax Highlighting

// Highlight Prisma datamodel syntax
const highlighted = highlightDatamodel(str)
// Highlight SQL syntax
const sqlHighlighted = highlightSql(str) 
// Highlight TypeScript/JavaScript syntax
const tsHighlighted = highlightTS(str)

Tracing and Observability

Distributed tracing support with OpenTelemetry integration for monitoring and debugging. → Tracing

// Tracing helper interface
interface TracingHelper {
  isEnabled(): boolean
  getTraceParent(context?: Context): string
  runInChildSpan<R>(options: ExtendedSpanOptions, callback: SpanCallback<R>): R
}
// Engine tracing types
type EngineSpan = { id: string, name: string, startTime: HrTime, ... }

Error Handling and Panic Management

Comprehensive error handling including Rust panic recovery and error reporting. → Error Handling

// Custom Rust panic error class
class RustPanic extends Error {
  constructor(message: string, rustStack: string, request: any, area: ErrorArea)
}
// Type guards for error detection
const isRustPanic = (e: Error): e is RustPanic
const isWasmPanic = (error: Error): error is WasmPanic
// Panic reporting
const reportId = await sendPanic(options)

This package provides 173 public exports organized across 9 functional domains, serving as the foundational infrastructure for the entire Prisma ecosystem. Each domain offers specialized functionality while maintaining seamless integration with the broader Prisma toolchain.