@rawan-temo/prisma-zod-generator 3.3.1-config-coercion.0

package/src/utils/dosProtection.ts

@@ -0,0 +1,29 @@
+/**
+ * Resource exhaustion error.
+ *
+ * This file was a 480-line DoS protection toolkit: a `DoSProtection` class with iteration,
+ * recursion, memory, execution-time, regex, string, JSON and file-size guards, a rate
+ * limiter, a `dosProtection` singleton, a `@dosProtect` decorator, and safeMap/safeFilter/
+ * safeForEach/safeChunker wrappers.
+ *
+ * None of it was reachable. The singleton had no caller anywhere; the class was instantiated
+ * only to create that singleton; the decorator and the safe* wrappers had no callers either.
+ * The one live export was this error class, thrown by the Pro data-factories pack when a
+ * schema exceeds its model limit — a check the pack performs itself. 36 of the file's 38
+ * functions were uncovered, which is what made it worth looking at.
+ *
+ * Deleting the class also orphaned `utils/concurrency.ts`, whose surviving `RateLimiter` had
+ * been kept solely for it; that file is gone too. So the guards described above are not
+ * "temporarily untested" — they were never wired in, and nothing was protecting the
+ * generator. If limits are wanted, they need enforcing at the points that consume schema
+ * input, not reinstating here.
+ */
+export class ResourceExhaustionError extends Error {
+  constructor(
+    message: string,
+    public readonly resourceType: string,
+  ) {
+    super(message);
+    this.name = 'ResourceExhaustionError';
+  }
+}

package/src/utils/errorHandling.ts

@@ -0,0 +1,85 @@
+/**
+ * Standardized error handling utilities for PZG Pro
+ */
+
+export class PZGProError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly feature: string,
+    public readonly context?: Record<string, unknown>,
+  ) {
+    super(message);
+    this.name = 'PZGProError';
+  }
+}
+
+export class LicenseError extends PZGProError {
+  constructor(message: string, context?: Record<string, unknown>) {
+    super(message, 'LICENSE_ERROR', 'license', context);
+    this.name = 'LicenseError';
+  }
+}
+
+export class FileSystemError extends PZGProError {
+  constructor(message: string, feature: string, context?: Record<string, unknown>) {
+    super(message, 'FILESYSTEM_ERROR', feature, context);
+    this.name = 'FileSystemError';
+  }
+}
+
+/**
+ * Safe file operation wrapper
+ */
+export async function safeFileOperation<T>(
+  operation: () => Promise<T> | T,
+  filePath: string,
+  feature: string,
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'File operation failed';
+    throw new FileSystemError(
+      `Failed to perform file operation on ${filePath}: ${message}`,
+      feature,
+      { filePath, originalError: error },
+    );
+  }
+}
+
+/**
+ * Production-safe logger that doesn't expose sensitive information
+ */
+export function logError(error: PZGProError): void {
+  // Only log safe information in production
+  const safeContext = {
+    code: error.code,
+    feature: error.feature,
+    message: error.message,
+    timestamp: new Date().toISOString(),
+  };
+
+  // stdout, not stderr, for the reason spelled out on `logger.warn`: Prisma runs generators as
+  // child processes over JSON-RPC and does not surface their stderr. Every caller of this
+  // rethrows, so the failure itself does reach the user via Prisma — but the detail here, the
+  // error code and which Pro feature was refused, is the part that makes it actionable, and on
+  // stderr none of it arrived.
+  if (process.env.NODE_ENV === 'development') {
+    console.log('[PZG Pro Error]', safeContext, error.context);
+  } else {
+    console.log('[PZG Pro Error]', safeContext);
+  }
+}
+
+/*
+ * Seven exports were removed here as unreachable: the safeAsync, safeSync and withRetry
+ * wrappers, the assertDefined and assertNonEmpty guards, and the ValidationError and
+ * SecurityError classes. src/license.ts is this module's only consumer, and it imports exactly
+ * LicenseError, logError and safeFileOperation — 23 of the file's 24 functions were uncovered,
+ * which is what prompted the look.
+ *
+ * ValidationError went with the two assert helpers, which were the only things that threw it.
+ * FileSystemError stays because safeFileOperation throws it, and PZGProError stays as the base
+ * the remaining classes extend.
+ */

package/src/utils/formatFile.ts

@@ -0,0 +1,77 @@
+import path from 'path';
+import prettier from 'prettier';
+import type { BuiltInParserName } from 'prettier';
+
+const PARSER_BY_EXTENSION: Record<string, BuiltInParserName> = {
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.mts': 'typescript',
+  '.cts': 'typescript',
+  '.js': 'babel',
+  '.jsx': 'babel',
+  '.mjs': 'babel',
+  '.cjs': 'babel',
+  '.json': 'json',
+  '.md': 'markdown',
+  '.mdx': 'mdx',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.html': 'html',
+  '.graphql': 'graphql',
+};
+
+/**
+ * Pick a Prettier parser from the target file name.
+ *
+ * Returns `undefined` for formats Prettier has no parser for (`.sql`, `.py`,
+ * `.txt`, …). Callers must treat that as "write this content verbatim" — it is
+ * not an error. Historically every write was parsed as TypeScript, so any
+ * non-TS artefact threw and was dropped by writeFileSafely's catch.
+ */
+export function parserForFile(filePath: string): BuiltInParserName | undefined {
+  const match = /\.[^.\\/]+$/.exec(filePath);
+  return match ? PARSER_BY_EXTENSION[match[0].toLowerCase()] : undefined;
+}
+
+/**
+ * Format `content` with Prettier.
+ *
+ * `filePath` selects the parser and locates the user's Prettier config. When it is
+ * omitted the content is parsed as TypeScript, preserving the original behaviour for
+ * the core schema writers. Content that Prettier cannot parse is returned unchanged
+ * rather than throwing, so a formatting problem can never cost the caller its file.
+ */
+export const formatFile = async (content: string, filePath?: string): Promise<string> => {
+  const parser = filePath === undefined ? 'typescript' : parserForFile(filePath);
+  if (!parser) {
+    return content;
+  }
+
+  // `resolveConfig` takes the path of the *file being formatted* and searches upward
+  // from its directory. It used to be handed `process.cwd()`, which Prettier treats as
+  // a file name and so searches from the parent of - meaning the project's own
+  // `.prettierrc` was skipped and only an ancestor's config could ever be found.
+  //
+  // Since `prisma generate` runs at the project root, that was every project: the
+  // user's config was silently ignored and the defaults below applied instead. It also
+  // made output depend on where the project sat on disk, because a repo nested under a
+  // directory that happened to hold a `.prettierrc` picked that one up.
+  //
+  // Passing the target file also lets a per-directory config over the output folder
+  // apply, which is what Prettier itself would do for that file.
+  const configTarget = filePath ?? path.join(process.cwd(), 'index.ts');
+  const resolved = await prettier.resolveConfig(configTarget);
+  const formatOptions = resolved ?? {
+    trailingComma: 'all' as const,
+    tabWidth: 2,
+    printWidth: 80,
+    bracketSpacing: true,
+    semi: true,
+    singleQuote: true,
+    useTabs: false,
+  };
+
+  return prettier.format(content, { ...formatOptions, parser });
+};

package/src/utils/logger.ts

@@ -0,0 +1,35 @@
+/**
+ * Simple logger that hides debug logs unless explicitly enabled.
+ *
+ * Enable with one of:
+ * - DEBUG_PRISMA_ZOD=1|true
+ * - DEBUG=1|true
+ * - DEBUG including the substring "prisma-zod" (e.g. DEBUG=prisma-zod)
+ */
+const rawDebug = (process.env.DEBUG_PRISMA_ZOD ?? process.env.DEBUG ?? '').toLowerCase();
+
+function parseEnabled(val: string): boolean {
+  if (!val) return false;
+  if (val === '1' || val === 'true') return true;
+  // Support namespaces like DEBUG=prisma-zod,prisma:* etc.
+  return /(^|[,\s:*])(prisma[-_]?zod)([,\s:*]|$)/.test(val);
+}
+
+const enabled = parseEnabled(rawDebug);
+
+export const logger = {
+  debug: (...args: unknown[]) => {
+    if (enabled) console.log(...args);
+  },
+  info: (...args: unknown[]) => console.info(...args),
+  // Warnings go to stdout, not stderr: Prisma runs generators as child
+  // processes over JSON-RPC and does not surface their stderr, so a
+  // console.warn is invisible to the person running `prisma generate` —
+  // which would silently defeat every diagnostic we emit (skipped @zod
+  // annotations, unknown config keys, unsupported Prisma versions, ...).
+  warn: (...args: unknown[]) => console.log(...args),
+  error: (...args: unknown[]) => console.error(...args),
+  isDebugEnabled: () => enabled,
+};
+
+export default logger;

package/src/utils/naming-resolver.ts

@@ -0,0 +1,294 @@
+import { GeneratorConfig } from '../config/parser';
+
+export interface PureModelNamingResolved {
+  filePattern: string;
+  schemaSuffix: string; // may be ''
+  typeSuffix: string; // may be ''
+  exportNamePattern: string;
+  legacyAliases: boolean;
+  preset?: string;
+}
+
+const PRESET_MAP: Record<string, PureModelNamingResolved> = {
+  'zod-prisma': {
+    filePattern: '{Model}.schema.ts',
+    schemaSuffix: 'Schema',
+    typeSuffix: 'Type',
+    exportNamePattern: '{Model}Schema',
+    legacyAliases: true,
+    preset: 'zod-prisma',
+  },
+  'zod-prisma-types': {
+    filePattern: '{Model}.schema.ts',
+    schemaSuffix: '',
+    typeSuffix: '',
+    exportNamePattern: '{Model}',
+    legacyAliases: true,
+    preset: 'zod-prisma-types',
+  },
+  'legacy-model-suffix': {
+    filePattern: '{Model}.model.ts',
+    schemaSuffix: 'Model',
+    typeSuffix: 'ModelType',
+    exportNamePattern: '{Model}Model',
+    legacyAliases: false,
+    preset: 'legacy-model-suffix',
+  },
+};
+
+type NamingSection = NonNullable<GeneratorConfig['naming']>;
+type PureModelNamingOverrides = NonNullable<NamingSection['pureModel']>;
+
+function safeGetNaming(config: GeneratorConfig | null | undefined): NamingSection | undefined {
+  return config && typeof config === 'object' ? (config as GeneratorConfig).naming : undefined;
+}
+
+export function resolvePureModelNaming(
+  config: GeneratorConfig | null | undefined,
+): PureModelNamingResolved {
+  const naming = safeGetNaming(config);
+  const presetName = naming?.preset;
+  const lookupKey = presetName ? presetName.trim().toLowerCase() : presetName;
+  let base: PureModelNamingResolved =
+    lookupKey && PRESET_MAP[lookupKey]
+      ? { ...PRESET_MAP[lookupKey] }
+      : {
+          filePattern: '{Model}.schema.ts',
+          schemaSuffix: 'Schema',
+          typeSuffix: 'Type',
+          exportNamePattern: '{Model}{SchemaSuffix}',
+          legacyAliases: false,
+          preset: 'default',
+        };
+  // Defensive: explicitly handle legacy-model-suffix in case map lookup fails due to unexpected input normalization
+  if (lookupKey === 'legacy-model-suffix' && (!base || base.preset !== 'legacy-model-suffix')) {
+    base = { ...PRESET_MAP['legacy-model-suffix'] };
+  }
+  const overrides: Partial<PureModelNamingOverrides> = naming?.pureModel || {};
+  const resolved = {
+    ...base,
+    ...overrides,
+    filePattern: overrides.filePattern || base.filePattern,
+    schemaSuffix: overrides.schemaSuffix === '' ? '' : overrides.schemaSuffix || base.schemaSuffix,
+    typeSuffix: overrides.typeSuffix === '' ? '' : overrides.typeSuffix || base.typeSuffix,
+    exportNamePattern: overrides.exportNamePattern || base.exportNamePattern,
+    legacyAliases:
+      overrides.legacyAliases !== undefined ? !!overrides.legacyAliases : base.legacyAliases,
+  };
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- logger loaded lazily to avoid circular deps in tests
+    const { logger } = require('./logger');
+    logger.debug(
+      `[namingResolver] preset=${presetName || 'none'} filePattern=${resolved.filePattern}`,
+    );
+  } catch {}
+  return resolved;
+}
+
+export function applyPattern(
+  pattern: string,
+  modelName: string,
+  schemaSuffix: string,
+  typeSuffix: string,
+): string {
+  const tokens: Record<string, string> = {
+    '{Model}': modelName,
+    '{model}': modelName.charAt(0).toLowerCase() + modelName.slice(1),
+    '{camel}': modelName.charAt(0).toLowerCase() + modelName.slice(1),
+    '{kebab}': modelName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase(),
+    '{SchemaSuffix}': schemaSuffix,
+    '{TypeSuffix}': typeSuffix,
+  };
+  return applyUniversalPattern(pattern, tokens);
+}
+
+// Enhanced pattern application for all types
+export function applyUniversalPattern(pattern: string, tokens: Record<string, string>): string {
+  return Object.keys(tokens).reduce(
+    (acc, token) => acc.replace(new RegExp(token.replace(/[{}]/g, '\\$&'), 'g'), tokens[token]),
+    pattern,
+  );
+}
+
+// Enum naming resolution
+export interface EnumNamingResolved {
+  filePattern: string;
+  exportNamePattern: string;
+}
+
+export function resolveEnumNaming(config: GeneratorConfig | null | undefined): EnumNamingResolved {
+  const naming = safeGetNaming(config);
+  const enumConfig = naming?.enum;
+
+  return {
+    filePattern: enumConfig?.filePattern || '{Enum}.schema.ts',
+    exportNamePattern: enumConfig?.exportNamePattern || '{Enum}Schema',
+  };
+}
+
+// Input naming resolution
+export interface InputNamingResolved {
+  filePattern: string;
+  exportNamePattern: string;
+}
+
+export function resolveInputNaming(
+  config: GeneratorConfig | null | undefined,
+): InputNamingResolved {
+  const naming = safeGetNaming(config);
+  const inputConfig = naming?.input;
+
+  return {
+    filePattern: inputConfig?.filePattern || '{InputType}.schema.ts',
+    exportNamePattern: inputConfig?.exportNamePattern || '{Model}{InputType}ObjectSchema',
+  };
+}
+
+// Schema naming resolution
+export interface SchemaNamingResolved {
+  filePattern: string;
+  exportNamePattern: string;
+}
+
+export function resolveSchemaNaming(
+  config: GeneratorConfig | null | undefined,
+): SchemaNamingResolved {
+  const naming = safeGetNaming(config);
+  const schemaConfig = naming?.schema;
+
+  return {
+    filePattern: schemaConfig?.filePattern || '{operation}{Model}.schema.ts',
+    exportNamePattern: schemaConfig?.exportNamePattern || '{Model}{Operation}Schema',
+  };
+}
+
+// Unified pattern application function
+export function generateFileName(
+  pattern: string,
+  modelName: string,
+  operation?: string,
+  inputType?: string,
+  enumName?: string,
+): string {
+  // If pattern contains a model token ({Model} or {model}) and {InputType}, and inputType starts with modelName,
+  // strip the model name from inputType to avoid duplicate prefixes in filenames
+  let processedInputType = inputType || '';
+  if (
+    pattern.includes('{InputType}') &&
+    (pattern.includes('{Model}') || pattern.includes('{model}')) &&
+    inputType &&
+    modelName
+  ) {
+    if (inputType.startsWith(modelName)) {
+      processedInputType = inputType.substring(modelName.length);
+    }
+  }
+
+  const tokens: Record<string, string> = {
+    '{Model}': modelName,
+    '{model}': modelName.charAt(0).toLowerCase() + modelName.slice(1),
+    '{camel}': modelName.charAt(0).toLowerCase() + modelName.slice(1),
+    '{kebab}': modelName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase(),
+    // Normalize operation tokens to mirror generateExportName semantics
+    '{Operation}': operation ? operation.charAt(0).toUpperCase() + operation.slice(1) : '',
+    '{operation}': operation ? operation.charAt(0).toLowerCase() + operation.slice(1) : '',
+    '{InputType}': processedInputType,
+    '{Enum}': enumName || '',
+    '{enum}': enumName ? enumName.charAt(0).toLowerCase() + enumName.slice(1) : '',
+  };
+
+  return applyUniversalPattern(pattern, tokens);
+}
+
+export function generateExportName(
+  pattern: string,
+  modelName: string,
+  operation?: string,
+  inputType?: string,
+  enumName?: string,
+): string {
+  // If pattern contains a model token ({Model} or {model}) and {InputType}, and inputType starts with modelName,
+  // strip the model name from inputType to avoid duplication
+  let processedInputType = inputType || '';
+  if (
+    pattern.includes('{InputType}') &&
+    (pattern.includes('{Model}') || pattern.includes('{model}')) &&
+    inputType &&
+    modelName
+  ) {
+    if (inputType.startsWith(modelName)) {
+      processedInputType = inputType.substring(modelName.length);
+    }
+  }
+
+  const tokens: Record<string, string> = {
+    '{Model}': modelName,
+    '{model}': modelName.charAt(0).toLowerCase() + modelName.slice(1),
+    '{kebab}': modelName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase(),
+    '{Operation}': operation ? operation.charAt(0).toUpperCase() + operation.slice(1) : '',
+    '{operation}': operation ? operation.charAt(0).toLowerCase() + operation.slice(1) : '',
+    '{InputType}': processedInputType,
+    '{Enum}': enumName || '',
+    '{enum}': enumName ? enumName.charAt(0).toLowerCase() + enumName.slice(1) : '',
+  };
+
+  return applyUniversalPattern(pattern, tokens);
+}
+
+/**
+ * Reverse-derive a PascalCase model name from an export symbol and pattern.
+ *
+ * Supports patterns containing one of {Model}, {model}, {camel}, or {kebab} and
+ * accounts for dynamic suffix tokens {SchemaSuffix}/{TypeSuffix} when computing
+ * the static prefix/suffix surrounding the model token. Falls back to stripping
+ * configured suffixes when a direct match is not possible.
+ */
+export function parseExportSymbol(
+  symbol: string,
+  pattern: string,
+  schemaSuffix: string = '',
+  typeSuffix: string = '',
+): string {
+  const replaceSuffixTokens = (segment: string): string =>
+    segment.replace(/\{SchemaSuffix\}/g, schemaSuffix).replace(/\{TypeSuffix\}/g, typeSuffix);
+
+  const tryExtract = (token: '{Model}' | '{model}' | '{camel}' | '{kebab}') => {
+    if (!pattern.includes(token)) return null;
+    const [preRaw, postRaw] = pattern.split(token);
+    const pre = replaceSuffixTokens(preRaw || '');
+    const post = replaceSuffixTokens(postRaw || '');
+    if (symbol.startsWith(pre) && symbol.endsWith(post)) {
+      const core = symbol.substring(pre.length, symbol.length - post.length);
+      switch (token) {
+        case '{Model}':
+          return core; // Already PascalCase
+        case '{model}':
+        case '{camel}':
+          return core ? core.charAt(0).toUpperCase() + core.slice(1) : core;
+        case '{kebab}':
+          return core
+            .split('-')
+            .map((seg) => (seg ? seg[0].toUpperCase() + seg.slice(1) : ''))
+            .join('');
+      }
+    }
+    return null;
+  };
+
+  // Prefer explicit {Model} first, then lowercase/camel, then kebab
+  const viaModel =
+    tryExtract('{Model}') ||
+    tryExtract('{model}') ||
+    tryExtract('{camel}') ||
+    tryExtract('{kebab}');
+  if (viaModel !== null) return viaModel;
+
+  // Heuristics: if the symbol ends with known suffixes, strip them
+  if (schemaSuffix && symbol.endsWith(schemaSuffix)) {
+    return symbol.slice(0, -schemaSuffix.length);
+  }
+  if (typeSuffix && symbol.endsWith(typeSuffix)) {
+    return symbol.slice(0, -typeSuffix.length);
+  }
+  return symbol;
+}

package/src/utils/prismaImport.ts

@@ -0,0 +1,7 @@
+import path from 'path';
+import Transformer from '../transformer';
+
+export function getPrismaImportSpecifier(targetDir: string): string {
+  const resolvedDir = path.resolve(targetDir);
+  return Transformer.resolvePrismaImportPath(resolvedDir);
+}