refactor: generate enhance API and avoid dynamic require in runtime

.github/workflows/build-test.yml

@@ -9,7 +9,7 @@ env:
 
 on:
     pull_request:
-        branches: ['dev', 'main']
+        branches: ['dev', 'main', 'v2']
 
 jobs:
     build-test:
@@ -32,18 +32,11 @@ jobs:
         strategy:
             matrix:
                 node-version: [18.x]
-                prisma-version: [v4, v5]
 
         steps:
             - name: Checkout
               uses: actions/checkout@v3
 
-            - name: Set Prisma Version
-              if: ${{ matrix.prisma-version == 'v5' }}
-              shell: bash
-              run: |
-                  bash ./script/test-prisma-v5.sh
-
             - name: Install pnpm
               uses: pnpm/action-setup@v2
               with:

packages/plugins/tanstack-query/tsconfig.json

@@ -6,5 +6,5 @@
         "jsx": "react"
     },
     "include": ["src/**/*.ts"],
-    "exclude": ["src/runtime"]
+    "exclude": ["src/runtime", "src/runtime-v5"]
 }

packages/runtime/package.json

@@ -53,11 +53,9 @@
         "linkDirectory": true
     },
     "dependencies": {
-        "@types/bcryptjs": "^2.4.2",
         "bcryptjs": "^2.4.3",
         "buffer": "^6.0.3",
         "change-case": "^4.1.2",
-        "colors": "1.4.0",
         "decimal.js": "^10.4.2",
         "deepcopy": "^2.1.0",
         "lower-case-first": "^2.0.2",

packages/runtime/res/enhance.d.ts

@@ -0,0 +1 @@
+export { enhance } from '.zenstack/enhance';

packages/runtime/res/enhance.js

@@ -0,0 +1,10 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+
+try {
+    exports.enhance = require('.zenstack/enhance').enhance;
+} catch {
+    exports.enhance = function () {
+        throw new Error('Generated "enhance" function not found. Please run `zenstack generate` first.');
+    };
+}

packages/runtime/src/constants.ts

@@ -66,7 +66,7 @@ export const PRISMA_PROXY_ENHANCER = '$__zenstack_enhancer';
 /**
  * Minimum Prisma version supported
  */
-export const PRISMA_MINIMUM_VERSION = '4.8.0';
+export const PRISMA_MINIMUM_VERSION = '5.0.0';
 
 /**
  * Selector function name for fetching pre-update entity values.

packages/runtime/src/enhance.d.ts

@@ -0,0 +1,2 @@
+// @ts-expect-error stub for re-exporting generated code
+export { enhance } from '.zenstack/enhance';

packages/runtime/src/enhancements/enhance.ts

@@ -1,4 +1,3 @@
-import { getDefaultModelMeta } from '../loader';
 import { withOmit, WithOmitOptions } from './omit';
 import { withPassword, WithPasswordOptions } from './password';
 import { withPolicy, WithPolicyContext, WithPolicyOptions } from './policy';
@@ -21,16 +20,15 @@ let hasOmit: boolean | undefined = undefined;
  * @param context The context to for evaluating access policies.
  * @param options Options.
  */
-export function enhance<DbClient extends object>(
+export function createEnhancement<DbClient extends object>(
     prisma: DbClient,
-    context?: WithPolicyContext,
-    options?: EnhancementOptions
+    options: EnhancementOptions,
+    context?: WithPolicyContext
 ) {
     let result = prisma;
 
     if (hasPassword === undefined || hasOmit === undefined) {
-        const modelMeta = options?.modelMeta ?? getDefaultModelMeta(options?.loadPath);
-        const allFields = Object.values(modelMeta.fields).flatMap((modelInfo) => Object.values(modelInfo));
+        const allFields = Object.values(options.modelMeta.fields).flatMap((modelInfo) => Object.values(modelInfo));
         hasPassword = allFields.some((field) => field.attributes?.some((attr) => attr.name === '@password'));
         hasOmit = allFields.some((field) => field.attributes?.some((attr) => attr.name === '@omit'));
     }
@@ -46,7 +44,7 @@ export function enhance<DbClient extends object>(
     }
 
     // policy proxy
-    result = withPolicy(result, context, options);
+    result = withPolicy(result, options, context);
 
     return result;
 }

packages/runtime/src/enhancements/index.ts

@@ -3,7 +3,6 @@ export * from './enhance';
 export * from './omit';
 export * from './password';
 export * from './policy';
-export * from './preset';
 export * from './types';
 export * from './utils';
 export * from './where-visitor';

packages/runtime/src/enhancements/omit.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { enumerate, getModelFields, resolveField, type ModelMeta } from '../cross';
-import { getDefaultModelMeta } from '../loader';
 import { DbClientContract } from '../types';
 import { DefaultPrismaProxyHandler, makeProxy } from './proxy';
 import { CommonEnhancementOptions } from './types';
@@ -14,18 +13,17 @@ export interface WithOmitOptions extends CommonEnhancementOptions {
     /**
      * Model metadata
      */
-    modelMeta?: ModelMeta;
+    modelMeta: ModelMeta;
 }
 
 /**
  * Gets an enhanced Prisma client that supports @omit attribute.
  */
-export function withOmit<DbClient extends object>(prisma: DbClient, options?: WithOmitOptions): DbClient {
-    const _modelMeta = options?.modelMeta ?? getDefaultModelMeta(options?.loadPath);
+export function withOmit<DbClient extends object>(prisma: DbClient, options: WithOmitOptions): DbClient {
     return makeProxy(
         prisma,
-        _modelMeta,
-        (_prisma, model) => new OmitHandler(_prisma as DbClientContract, model, _modelMeta),
+        options.modelMeta,
+        (_prisma, model) => new OmitHandler(_prisma as DbClientContract, model, options.modelMeta),
         'omit'
     );
 }

packages/runtime/src/enhancements/password.ts

@@ -4,7 +4,6 @@
 import { hash } from 'bcryptjs';
 import { DEFAULT_PASSWORD_SALT_LENGTH } from '../constants';
 import { NestedWriteVisitor, type ModelMeta, type PrismaWriteActionType } from '../cross';
-import { getDefaultModelMeta } from '../loader';
 import { DbClientContract } from '../types';
 import { DefaultPrismaProxyHandler, PrismaProxyActions, makeProxy } from './proxy';
 import { CommonEnhancementOptions } from './types';
@@ -16,18 +15,17 @@ export interface WithPasswordOptions extends CommonEnhancementOptions {
     /**
      * Model metadata
      */
-    modelMeta?: ModelMeta;
+    modelMeta: ModelMeta;
 }
 
 /**
  * Gets an enhanced Prisma client that supports @password attribute.
  */
-export function withPassword<DbClient extends object = any>(prisma: DbClient, options?: WithPasswordOptions): DbClient {
-    const _modelMeta = options?.modelMeta ?? getDefaultModelMeta(options?.loadPath);
+export function withPassword<DbClient extends object = any>(prisma: DbClient, options: WithPasswordOptions): DbClient {
     return makeProxy(
         prisma,
-        _modelMeta,
-        (_prisma, model) => new PasswordHandler(_prisma as DbClientContract, model, _modelMeta),
+        options.modelMeta,
+        (_prisma, model) => new PasswordHandler(_prisma as DbClientContract, model, options.modelMeta),
         'password'
     );
 }

packages/runtime/src/enhancements/policy/handler.ts

@@ -47,6 +47,7 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
         private readonly policy: PolicyDef,
         private readonly modelMeta: ModelMeta,
         private readonly zodSchemas: ZodSchemas | undefined,
+        private readonly prismaModule: any,
         model: string,
         private readonly user?: AuthUser,
         private readonly logPrismaQuery?: boolean
@@ -57,6 +58,7 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
             this.modelMeta,
             this.policy,
             this.zodSchemas,
+            this.prismaModule,
             this.user,
             this.shouldLogQuery
         );
@@ -73,20 +75,28 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     findUnique(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.where) {
-            throw prismaClientValidationError(this.prisma, 'where field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'where field is required in query argument'
+            );
         }
         return this.findWithFluentCallStubs(args, 'findUnique', false, () => null);
     }
 
     findUniqueOrThrow(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.where) {
-            throw prismaClientValidationError(this.prisma, 'where field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'where field is required in query argument'
+            );
         }
         return this.findWithFluentCallStubs(args, 'findUniqueOrThrow', true, () => {
             throw this.utils.notFound(this.model);
@@ -216,10 +226,14 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async create(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.data) {
-            throw prismaClientValidationError(this.prisma, 'data field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'data field is required in query argument'
+            );
         }
 
         this.utils.tryReject(this.prisma, this.model, 'create');
@@ -469,10 +483,14 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async createMany(args: { data: any; skipDuplicates?: boolean }) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.data) {
-            throw prismaClientValidationError(this.prisma, 'data field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'data field is required in query argument'
+            );
         }
 
         this.utils.tryReject(this.prisma, this.model, 'create');
@@ -576,13 +594,21 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async update(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.where) {
-            throw prismaClientValidationError(this.prisma, 'where field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'where field is required in query argument'
+            );
         }
         if (!args.data) {
-            throw prismaClientValidationError(this.prisma, 'data field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'data field is required in query argument'
+            );
         }
 
         args = this.utils.clone(args);
@@ -967,10 +993,14 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async updateMany(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.data) {
-            throw prismaClientValidationError(this.prisma, 'data field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'data field is required in query argument'
+            );
         }
 
         this.utils.tryReject(this.prisma, this.model, 'update');
@@ -1024,16 +1054,28 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async upsert(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.where) {
-            throw prismaClientValidationError(this.prisma, 'where field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'where field is required in query argument'
+            );
         }
         if (!args.create) {
-            throw prismaClientValidationError(this.prisma, 'create field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'create field is required in query argument'
+            );
         }
         if (!args.update) {
-            throw prismaClientValidationError(this.prisma, 'update field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'update field is required in query argument'
+            );
         }
 
         this.utils.tryReject(this.prisma, this.model, 'create');
@@ -1077,10 +1119,14 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async delete(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
         if (!args.where) {
-            throw prismaClientValidationError(this.prisma, 'where field is required in query argument');
+            throw prismaClientValidationError(
+                this.prisma,
+                this.prismaModule,
+                'where field is required in query argument'
+            );
         }
 
         this.utils.tryReject(this.prisma, this.model, 'delete');
@@ -1133,7 +1179,7 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async aggregate(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
 
         args = this.utils.clone(args);
@@ -1149,7 +1195,7 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
 
     async groupBy(args: any) {
         if (!args) {
-            throw prismaClientValidationError(this.prisma, 'query argument is required');
+            throw prismaClientValidationError(this.prisma, this.prismaModule, 'query argument is required');
         }
 
         args = this.utils.clone(args);
@@ -1193,7 +1239,7 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
             args = { create: {}, update: {}, delete: {} };
         } else {
             if (typeof args !== 'object') {
-                throw prismaClientValidationError(this.prisma, 'argument must be an object');
+                throw prismaClientValidationError(this.prisma, this.prismaModule, 'argument must be an object');
             }
             if (Object.keys(args).length === 0) {
                 // include all
@@ -1254,6 +1300,7 @@ export class PolicyProxyHandler<DbClient extends DbClientContract> implements Pr
             this.policy,
             this.modelMeta,
             this.zodSchemas,
+            this.prismaModule,
             model,
             this.user,
             this.logPrismaQuery