perf: improve tsc performance for runtime project (#97)

Author: ymc9

packages/runtime/src/client/client-impl.ts

@@ -411,100 +411,156 @@ function createModelCrudHandler<Schema extends SchemaDef, Model extends GetModel
         });
     };
 
+    // type parameters to operation handlers are explicitly specified to improve tsc performance
     return {
         findUnique: (args: unknown) => {
-            return createPromise('findUnique', args, new FindOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'findUnique',
+                args,
+                new FindOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         findUniqueOrThrow: (args: unknown) => {
             return createPromise(
                 'findUnique',
                 args,
-                new FindOperationHandler(client, model, inputValidator),
+                new FindOperationHandler<Schema>(client, model, inputValidator),
                 true,
                 true,
             );
         },
 
         findFirst: (args: unknown) => {
-            return createPromise('findFirst', args, new FindOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'findFirst',
+                args,
+                new FindOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         findFirstOrThrow: (args: unknown) => {
             return createPromise(
                 'findFirst',
                 args,
-                new FindOperationHandler(client, model, inputValidator),
+                new FindOperationHandler<Schema>(client, model, inputValidator),
                 true,
                 true,
             );
         },
 
         findMany: (args: unknown) => {
-            return createPromise('findMany', args, new FindOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'findMany',
+                args,
+                new FindOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         create: (args: unknown) => {
-            return createPromise('create', args, new CreateOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'create',
+                args,
+                new CreateOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         createMany: (args: unknown) => {
-            return createPromise('createMany', args, new CreateOperationHandler(client, model, inputValidator), false);
+            return createPromise(
+                'createMany',
+                args,
+                new CreateOperationHandler<Schema>(client, model, inputValidator),
+                false,
+            );
         },
 
         createManyAndReturn: (args: unknown) => {
             return createPromise(
                 'createManyAndReturn',
                 args,
-                new CreateOperationHandler(client, model, inputValidator),
+                new CreateOperationHandler<Schema>(client, model, inputValidator),
                 true,
             );
         },
 
         update: (args: unknown) => {
-            return createPromise('update', args, new UpdateOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'update',
+                args,
+                new UpdateOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         updateMany: (args: unknown) => {
-            return createPromise('updateMany', args, new UpdateOperationHandler(client, model, inputValidator), false);
+            return createPromise(
+                'updateMany',
+                args,
+                new UpdateOperationHandler<Schema>(client, model, inputValidator),
+                false,
+            );
         },
 
         updateManyAndReturn: (args: unknown) => {
             return createPromise(
                 'updateManyAndReturn',
                 args,
-                new UpdateOperationHandler(client, model, inputValidator),
+                new UpdateOperationHandler<Schema>(client, model, inputValidator),
                 true,
             );
         },
 
         upsert: (args: unknown) => {
-            return createPromise('upsert', args, new UpdateOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'upsert',
+                args,
+                new UpdateOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         delete: (args: unknown) => {
-            return createPromise('delete', args, new DeleteOperationHandler(client, model, inputValidator), true);
+            return createPromise(
+                'delete',
+                args,
+                new DeleteOperationHandler<Schema>(client, model, inputValidator),
+                true,
+            );
         },
 
         deleteMany: (args: unknown) => {
-            return createPromise('deleteMany', args, new DeleteOperationHandler(client, model, inputValidator), false);
+            return createPromise(
+                'deleteMany',
+                args,
+                new DeleteOperationHandler<Schema>(client, model, inputValidator),
+                false,
+            );
         },
 
         count: (args: unknown) => {
-            return createPromise('count', args, new CountOperationHandler(client, model, inputValidator), false);
+            return createPromise(
+                'count',
+                args,
+                new CountOperationHandler<Schema>(client, model, inputValidator),
+                false,
+            );
         },
 
         aggregate: (args: unknown) => {
             return createPromise(
                 'aggregate',
                 args,
-                new AggregateOperationHandler(client, model, inputValidator),
+                new AggregateOperationHandler<Schema>(client, model, inputValidator),
                 false,
             );
         },
 
         groupBy: (args: unknown) => {
-            return createPromise('groupBy', args, new GroupByOperationHandler(client, model, inputValidator));
+            return createPromise('groupBy', args, new GroupByOperationHandler<Schema>(client, model, inputValidator));
         },
     } as ModelOperations<Schema, Model>;
 }

packages/runtime/src/utils/type-utils.ts

@@ -22,23 +22,19 @@ export type WrapType<T, Optional = false, Array = false> = Optional extends true
       ? T[]
       : T;
 
-export type MapBaseType<T> = T extends 'String'
-    ? string
-    : T extends 'Boolean'
-      ? boolean
-      : T extends 'Int' | 'Float'
-        ? number
-        : T extends 'BigInt'
-          ? bigint
-          : T extends 'Decimal'
-            ? Decimal
-            : T extends 'DateTime'
-              ? Date
-              : T extends 'Bytes'
-                ? Uint8Array
-                : T extends 'Json'
-                  ? JsonValue
-                  : unknown;
+type TypeMap = {
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    BigInt: bigint;
+    Decimal: Decimal;
+    DateTime: Date;
+    Bytes: Uint8Array;
+    Json: JsonValue;
+};
+
+export type MapBaseType<T extends string> = T extends keyof TypeMap ? TypeMap[T] : unknown;
 
 export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
 

packages/runtime/test/client-api/computed-fields.test.ts

@@ -14,7 +14,7 @@ model User {
             {
                 computedFields: {
                     User: {
-                        upperName: (eb) => eb.fn('upper', ['name']),
+                        upperName: (eb: any) => eb.fn('upper', ['name']),
                     },
                 },
             } as any,
@@ -90,7 +90,7 @@ model User {
             {
                 computedFields: {
                     User: {
-                        upperName: (eb) => eb.lit(null),
+                        upperName: (eb: any) => eb.lit(null),
                     },
                 },
             } as any,