feat(generator): support custom default casing for client properties

src/prisma/generator/models.py

@@ -33,7 +33,7 @@
 from pydantic.fields import PrivateAttr
 
 from .. import config
-from .utils import Faker, Sampler, clean_multiline
+from .utils import Faker, Sampler, clean_multiline, to_camel_case, to_pascal_case, to_snake_case
 from ..utils import DEBUG_GENERATOR, assert_never
 from ..errors import UnsupportedListTypeError
 from .._compat import (
@@ -248,6 +248,14 @@ def __str__(self) -> str:
         return self.value
 
 
+class ClientCasing(str, enum.Enum):
+    snake_case = 'snake_case'
+    camel_case = 'camel_case'
+    lower_case = 'lower_case'
+    upper_case = 'upper_case'
+    pascal_case = 'pascal_case'
+
+
 class Module(BaseModel):
     if TYPE_CHECKING:
         spec: machinery.ModuleSpec
@@ -496,6 +504,7 @@ class Config(BaseSettings):
         env='PRISMA_PY_CONFIG_RECURSIVE_TYPE_DEPTH',
     )
     engine_type: EngineType = FieldInfo(default=EngineType.binary, env='PRISMA_PY_CONFIG_ENGINE_TYPE')
+    client_casing: ClientCasing = FieldInfo(default=ClientCasing.lower_case)
 
     # this should be a list of experimental features
     # https://github.com/prisma/prisma/issues/12442
@@ -684,7 +693,8 @@ def name_validator(cls, name: str) -> str:
                 f'use a different model name with \'@@map("{name}")\'.'
             )
 
-        if iskeyword(name.lower()):
+        config = get_config()
+        if isinstance(config, Config) and config.client_casing == ClientCasing.lower_case and iskeyword(name.lower()):
             raise ValueError(
                 f'Model name "{name}" results in a client property that shadows a Python keyword; '
                 f'use a different model name with \'@@map("{name}")\'.'
@@ -748,6 +758,13 @@ def instance_name(self) -> str:
 
         `User` -> `Prisma().user`
         """
+        config = get_config()
+        if isinstance(config, Config) and config.client_casing == ClientCasing.camel_case:
+            return to_camel_case(self.name)
+        elif isinstance(config, Config) and config.client_casing == ClientCasing.pascal_case:
+            return to_pascal_case(self.name)
+        elif isinstance(config, Config) and config.client_casing == ClientCasing.snake_case:
+            return to_snake_case(self.name)
         return self.name.lower()
 
     @property

src/prisma/generator/utils.py

@@ -1,4 +1,5 @@
 import os
+import re
 import shutil
 from typing import TYPE_CHECKING, Any, Dict, List, Union, TypeVar, Iterator
 from pathlib import Path
@@ -122,3 +123,29 @@ def clean_multiline(string: str) -> str:
     assert string, 'Expected non-empty string'
     lines = string.splitlines()
     return '\n'.join([dedent(lines[0]), *lines[1:]])
+
+
+ACRONYM_RE = re.compile(r'([A-Z\d]+)(?=[A-Z\d]|$)')
+PASCAL_RE = re.compile(r'([^\-_]+)')
+SPLIT_RE = re.compile(r'([\-_]*[A-Z][^A-Z]*[\-_]*)')
+UNDERSCORE_RE = re.compile(r'(?<=[^\-_])[\-_]+[^\-_]')
+
+
+def to_snake_case(input_str: str) -> str:
+    input_str = ACRONYM_RE.sub(lambda m: m.group(0).title(), input_str)
+    input_str = '_'.join(s for s in SPLIT_RE.split(input_str) if s)
+    return input_str.lower()
+
+
+def to_camel_case(input_str: str) -> str:
+    if len(input_str) != 0 and not input_str[:2].isupper():
+        input_str = input_str[0].lower() + input_str[1:]
+    return UNDERSCORE_RE.sub(lambda m: m.group(0)[-1].upper(), input_str)
+
+
+def to_pascal_case(input_str: str) -> str:
+    def _replace_fn(match: re.Match[str]) -> str:
+        return match.group(1)[0].upper() + match.group(1)[1:]
+
+    input_str = to_camel_case(PASCAL_RE.sub(_replace_fn, input_str))
+    return input_str[0].upper() + input_str[1:] if len(input_str) != 0 else input_str