OpenPanel is an open-source web and product analytics platform, an open-source alternative to Mixpanel with optional self-hosting.
import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
interface JsonFieldMapping {
model: string;
field: string;
type: string;
}
function parseSchemaForJsonTypes(schemaPath: string): JsonFieldMapping[] {
const schemaContent = readFileSync(schemaPath, 'utf-8');
const lines = schemaContent.split('\n');
const mappings: JsonFieldMapping[] = [];
let currentModel = '';
for (let i = 0; i < lines.length; i++) {
const line = lines[i]?.trim() || '';
// Track current model
if (line.startsWith('model ')) {
const parts = line.split(' ');
currentModel = parts[1] || '';
continue;
}
// Look for Json fields with type comments
if (line.includes('Json') && i > 0) {
const prevLine = lines[i - 1]?.trim() || '';
const typeMatch = prevLine.match(/\/\/\/ \[([^\]]+)\]/);
if (typeMatch) {
const fieldMatch = line.match(/(\w+)\s+Json/);
if (fieldMatch?.[1] && typeMatch[1]) {
mappings.push({
model: currentModel,
field: fieldMatch[1],
type: typeMatch[1],
});
}
}
}
}
return mappings;
}
function processGeneratedFiles(
generatedDir: string,
mappings: JsonFieldMapping[]
): void {
// Process the main files in the generated directory
const mainFiles = [
'client.ts',
'commonInputTypes.ts',
'enums.ts',
'models.ts',
];
for (const fileName of mainFiles) {
const filePath = join(generatedDir, fileName);
try {
replaceJsonValueInFileForModel(filePath, mappings);
} catch (error) {
console.log(`Skipping ${filePath}: ${error}`);
}
}
// Process files in the models subdirectory - each file corresponds to one model
const modelsDir = join(generatedDir, 'models');
try {
const modelFiles = readdirSync(modelsDir);
for (const fileName of modelFiles) {
if (fileName.endsWith('.ts')) {
const filePath = join(modelsDir, fileName);
try {
// Extract model name from filename (e.g., "Notification.ts" -> "Notification")
const modelName = fileName.replace('.ts', '');
// Only process mappings for this specific model
const modelMappings = mappings.filter((m) => m.model === modelName);
if (modelMappings.length > 0) {
replaceJsonValueInFileForModel(filePath, modelMappings);
}
} catch (error) {
console.log(`Skipping ${filePath}: ${error}`);
}
}
}
} catch (error) {
console.log(`Could not read models directory: ${error}`);
}
}
function replaceJsonValueInFileForModel(
filePath: string,
mappings: JsonFieldMapping[]
): void {
let content = readFileSync(filePath, 'utf-8');
let modified = false;
for (const mapping of mappings) {
// Pattern 1: Simple runtime.JsonValue replacement (for select/return types)
const simpleJsonValueRegex = new RegExp(
`\\b${mapping.field}:\\s*runtime\\.JsonValue\\b`,
'g'
);
if (simpleJsonValueRegex.test(content)) {
content = content.replace(
simpleJsonValueRegex,
`${mapping.field}: PrismaJson.${mapping.type}`
);
modified = true;
}
// Pattern 2: runtime.InputJsonValue with optional JsonNullValueInput (for create/update inputs)
const inputJsonValueRegex = new RegExp(
`\\b${mapping.field}:\\s*(?:Prisma\\.JsonNullValueInput\\s*\\|\\s*)?runtime\\.InputJsonValue\\b`,
'g'
);
if (inputJsonValueRegex.test(content)) {
content = content.replace(
inputJsonValueRegex,
`${mapping.field}: PrismaJson.${mapping.type}`
);
modified = true;
}
// Pattern 3: Optional runtime.InputJsonValue with optional JsonNullValueInput
const optionalInputJsonValueRegex = new RegExp(
`\\b${mapping.field}\\?:\\s*(?:Prisma\\.JsonNullValueInput\\s*\\|\\s*)?runtime\\.InputJsonValue\\b`,
'g'
);
if (optionalInputJsonValueRegex.test(content)) {
content = content.replace(
optionalInputJsonValueRegex,
`${mapping.field}?: PrismaJson.${mapping.type}`
);
modified = true;
}
// Pattern 4: `field: Prisma.(Nullable)JsonNullValueInput | runtime.InputJsonValue`
// (create/update inputs). Scoped to the field so a model with two Json
// columns does not get the first column's type stamped on the second.
const unionJsonValueRegex = new RegExp(
`\\b${mapping.field}(\\??):\\s*(Prisma\\.(?:Nullable)?JsonNullValueInput\\s*\\|\\s*)runtime\\.InputJsonValue\\b`,
'g'
);
if (unionJsonValueRegex.test(content)) {
content = content.replace(
unionJsonValueRegex,
`${mapping.field}$1: $2PrismaJson.${mapping.type}`
);
modified = true;
}
// Pattern 5: `field: X | runtime.InputJsonValue` for any other union shape.
const simpleInputJsonValueRegex = new RegExp(
`(\\b${mapping.field}\\??:[^\\n]*?)\\|\\s*runtime\\.InputJsonValue\\b`,
'g'
);
if (simpleInputJsonValueRegex.test(content)) {
content = content.replace(
simpleInputJsonValueRegex,
`$1| PrismaJson.${mapping.type}`
);
modified = true;
}
// Pattern 6: Optional union types with JsonNullValueInput | runtime.InputJsonValue
const optionalUnionJsonValueRegex = new RegExp(
`\\b${mapping.field}\\?:\\s*(?:Prisma\\.JsonNullValueInput\\s*\\|\\s*)?runtime\\.InputJsonValue\\b`,
'g'
);
if (optionalUnionJsonValueRegex.test(content)) {
content = content.replace(
optionalUnionJsonValueRegex,
`${mapping.field}?: PrismaJson.${mapping.type}`
);
modified = true;
}
}
if (modified) {
writeFileSync(filePath, content, 'utf-8');
console.log(`Updated ${filePath}`);
}
}
function main() {
const schemaPath = join(__dirname, '../prisma/schema.prisma');
const generatedDir = join(__dirname, '../src/generated/prisma');
console.log('Parsing schema for Json type mappings...');
const mappings = parseSchemaForJsonTypes(schemaPath);
console.log('Found Json type mappings:');
for (const mapping of mappings) {
console.log(` ${mapping.model}.${mapping.field} -> ${mapping.type}`);
}
if (mappings.length === 0) {
console.log('No mappings found!');
return;
}
console.log('Processing generated files...');
processGeneratedFiles(generatedDir, mappings);
console.log('Post-codegen script completed!');
}
main();