fix(client): Allow to use Metric as a model name

Problem: even though built-in `Metric` type is placed in
a different namespace, type conflict still occurs: `Delegate` classes
are in the same namespace and can't refer to non-namespaced name.

Implements a tiny part of [namespace overhaul proposal](https://www.notion.so/prismaio/Fix-type-name-clashes-in-TS-Client-9e9bbdee13f94a818ece060e55465267): introduces `$Models` namespace.

Ref #12469

packages/client/src/generation/TSClient/Generatable.ts

@@ -3,6 +3,7 @@ export interface Generatable {
   toTS(edge?: boolean): string | Promise<string>
   toBrowserJS?(): string | Promise<string>
   toTSWithoutNamespace?(): string | Promise<string>
+  toTSInModelNamespace?(): string | Promise<string>
 }
 
 export function JS(gen: Generatable, edge = false): string | Promise<string> {

packages/client/src/generation/TSClient/Model.ts

@@ -270,7 +270,7 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
     : GetScalarType<T[P], ${aggregateName}[P]>
 }`
   }
-  public toTSWithoutNamespace(): string {
+  public toTSInModelNamespace(): string {
     const { model } = this
     const docLines = model.documentation ?? ''
     const modelLine = `Model ${model.name}\n`
@@ -315,6 +315,16 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
 
     return `${ts.stringify(payloadExport)}\n\n${ts.stringify(modelTypeExport)}`
   }
+
+  toTSWithoutNamespace() {
+    return ts.stringify(
+      ts.moduleExport(ts.typeDeclaration(this.model.name, ts.namedType(`$Model.${this.model.name}`))),
+      {
+        indentLevel: 1,
+      },
+    )
+  }
+
   public toTS(): string {
     const { model } = this
     const isComposite = this.dmmf.typeMap[model.name]
@@ -344,9 +354,9 @@ ${ts.stringify(buildScalarSelectType({ modelName: this.model.name, fields: this.
 })}
 ${includeType}
 
-type ${model.name}GetPayload<S extends boolean | null | undefined | ${getArgName(model.name)}> = $Types.GetResult<${
-      model.name
-    }Payload, S>
+type ${model.name}GetPayload<S extends boolean | null | undefined | ${getArgName(
+      model.name,
+    )}> = $Types.GetResult<$Model.${model.name}Payload, S>
 
 ${isComposite ? '' : new ModelDelegate(this.outputType, this.dmmf, this.generator).toTS()}
 

packages/client/src/generation/TSClient/PrismaClient.ts

@@ -31,7 +31,7 @@ function clientExtensionsResultDefinition(this: PrismaClientClass) {
     return `${lowerCase(modelName)}?: {
         [K in keyof R_${modelName}_Needs]: {
           needs: R_${modelName}_Needs[K]
-          compute: (data: $Types.GetResult<${modelName}Payload<ExtArgs>, { select: R_${modelName}_Needs[K] }, 'findUniqueOrThrow'>) => unknown
+          compute: (data: $Types.GetResult<$Model.${modelName}Payload<ExtArgs>, { select: R_${modelName}_Needs[K] }, 'findUniqueOrThrow'>) => unknown
         }
       }`
   }
@@ -86,8 +86,8 @@ function clientTypeMapModelsDefinition(this: PrismaClientClass) {
         return `${acc}
       ${action}: {
         args: Prisma.${getModelArgName(modelName, action)}<ExtArgs>,
-        result: $Utils.OptionalFlat<${modelName}>
-        payload: ${modelName}Payload<ExtArgs>
+        result: $Utils.OptionalFlat<$Model.${modelName}>
+        payload: $Model.${modelName}Payload<ExtArgs>
       }`
       }, '')}
     }`

packages/client/src/generation/TSClient/TSClient.ts

@@ -188,6 +188,10 @@ ${buildNFTAnnotations(dataProxy, engineType, platforms, relativeOutdir)}
 
 ${commonCode.tsWithoutNamespace()}
 
+declare namespace $Model {
+  ${modelAndTypes.map((m) => m.toTSInModelNamespace()).join('\n')}
+}
+
 ${modelAndTypes.map((m) => m.toTSWithoutNamespace()).join('\n')}
 ${
   modelEnums && modelEnums.length > 0

packages/client/src/generation/utils.ts

@@ -247,34 +247,34 @@ export function getReturnType({
     const promiseOpen = renderPromise ? 'Prisma.PrismaPromise<' : ''
     const promiseClose = renderPromise ? '>' : ''
 
-    return `${promiseOpen}$Types.GetResult<${name}Payload<ExtArgs>, T, '${actionName}', never>${
+    return `${promiseOpen}$Types.GetResult<$Model.${name}Payload<ExtArgs>, T, '${actionName}', never>${
       isChaining ? '| Null' : ''
     }${promiseClose}`
   }
 
   if (actionName === 'findFirstOrThrow' || actionName === 'findUniqueOrThrow') {
     return `Prisma__${name}Client<${getType(
-      `$Types.GetResult<${name}Payload<ExtArgs>, T, '${actionName}', never>`,
+      `$Types.GetResult<$Model.${name}Payload<ExtArgs>, T, '${actionName}', never>`,
       isList,
     )}, never, ExtArgs>`
   }
   if (actionName === 'findFirst' || actionName === 'findUnique') {
     if (isField) {
       return `Prisma__${name}Client<${getType(
-        `$Types.GetResult<${name}Payload<ExtArgs>, T, '${actionName}', never>`,
+        `$Types.GetResult<$Model.${name}Payload<ExtArgs>, T, '${actionName}', never>`,
         isList,
       )} | Null, never, ExtArgs>`
     }
     return `HasReject<GlobalRejectSettings, LocalRejectSettings, '${actionName}', '${name}'> extends True ? Prisma__${name}Client<${getType(
-      `$Types.GetResult<${name}Payload<ExtArgs>, T, '${actionName}', never>`,
+      `$Types.GetResult<$Model.${name}Payload<ExtArgs>, T, '${actionName}', never>`,
       isList,
     )}, never, ExtArgs> : Prisma__${name}Client<${getType(
-      `$Types.GetResult<${name}Payload<ExtArgs>, T, '${actionName}', never>`,
+      `$Types.GetResult<$Model.${name}Payload<ExtArgs>, T, '${actionName}', never>`,
       isList,
     )} | null, null, ExtArgs>`
   }
   return `Prisma__${name}Client<${getType(
-    `$Types.GetResult<${name}Payload<ExtArgs>, T, '${actionName}', never>`,
+    `$Types.GetResult<$Model.${name}Payload<ExtArgs>, T, '${actionName}', never>`,
     isList,
   )}, never, ExtArgs>`
 }

packages/client/tests/functional/naming-conflict/metric/_matrix.ts

@@ -0,0 +1,24 @@
+import { defineMatrix } from '../../_utils/defineMatrix'
+
+export default defineMatrix(() => [
+  [
+    {
+      provider: 'sqlite',
+    },
+    {
+      provider: 'postgresql',
+    },
+    {
+      provider: 'mysql',
+    },
+    {
+      provider: 'mongodb',
+    },
+    {
+      provider: 'cockroachdb',
+    },
+    {
+      provider: 'sqlserver',
+    },
+  ],
+])

packages/client/tests/functional/naming-conflict/metric/prisma/_schema.ts

@@ -0,0 +1,21 @@
+import { idForProvider } from '../../../_utils/idForProvider'
+import testMatrix from '../_matrix'
+
+export default testMatrix.setupSchema(({ provider }) => {
+  return /* Prisma */ `
+  generator client {
+    provider = "prisma-client-js"
+  }
+  
+  datasource db {
+    provider = "${provider}"
+    url      = env("DATABASE_URI_${provider}")
+  }
+  
+  model Metric {
+    id ${idForProvider(provider)}
+    name String
+    value Int
+  }
+  `
+})

packages/client/tests/functional/naming-conflict/metric/tests.ts

@@ -0,0 +1,24 @@
+import testMatrix from './_matrix'
+// @ts-ignore
+import type { PrismaClient } from './node_modules/@prisma/client'
+
+declare let prisma: PrismaClient
+
+testMatrix.setupTestSuite(() => {
+  test('allows to use Metric name for a model', async () => {
+    await prisma.metric.create({
+      data: {
+        name: 'signups',
+        value: 9000,
+      },
+    })
+
+    const metric = await prisma.metric.findFirst()
+
+    expect(metric).toEqual({
+      id: expect.any(String),
+      name: 'signups',
+      value: 9000,
+    })
+  })
+})