more plugin tests

Author: ymc9

packages/runtime/src/client/plugin.ts

@@ -12,7 +12,7 @@ import type { MaybePromise } from '../utils/type-utils';
 import type { QueryContext } from './query-executor';
 
 /**
- * The result of the lifecycle interception filter.
+ * The result of the hooks interception filter.
  */
 export type MutationInterceptionFilterResult = {
     /**
@@ -36,7 +36,7 @@ export type MutationInterceptionFilterResult = {
     loadAfterMutationEntity?: boolean;
 };
 
-type MutationLifecycleEventArgs<Schema extends SchemaDef> = {
+type MutationHooksArgs<Schema extends SchemaDef> = {
     /**
      * The model that is being mutated.
      */
@@ -71,12 +71,12 @@ export type PluginTransformKyselyResultArgs<Schema extends SchemaDef> = {
 };
 
 export type PluginBeforeEntityMutationArgs<Schema extends SchemaDef> =
-    MutationLifecycleEventArgs<Schema> & {
+    MutationHooksArgs<Schema> & {
         entities?: Record<string, unknown>[];
     };
 
 export type PluginAfterEntityMutationArgs<Schema extends SchemaDef> =
-    MutationLifecycleEventArgs<Schema> & {
+    MutationHooksArgs<Schema> & {
         beforeMutationEntities?: Record<string, unknown>[];
         afterMutationEntities?: Record<string, unknown>[];
     };
@@ -100,20 +100,6 @@ export interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
      */
     description?: string;
 
-    /**
-     * Kysely query transformation. See {@link KyselyPlugin.transformQuery}.
-     */
-    transformKyselyQuery?: (
-        args: PluginTransformKyselyQueryArgs<Schema>
-    ) => RootOperationNode;
-
-    /**
-     * Kysely query result transformation. See {@link KyselyPlugin.transformResult}.
-     */
-    transformKyselyResult?: (
-        args: PluginTransformKyselyResultArgs<Schema>
-    ) => Promise<QueryResult<UnknownRow>>;
-
     /**
      * Called before an ORM query is executed.
      */
@@ -129,12 +115,26 @@ export interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
         } & PluginContext<Schema>
     ) => MaybePromise<void>;
 
+    /**
+     * Kysely query transformation. See {@link KyselyPlugin.transformQuery}.
+     */
+    transformKyselyQuery?: (
+        args: PluginTransformKyselyQueryArgs<Schema>
+    ) => RootOperationNode;
+
+    /**
+     * Kysely query result transformation. See {@link KyselyPlugin.transformResult}.
+     */
+    transformKyselyResult?: (
+        args: PluginTransformKyselyResultArgs<Schema>
+    ) => Promise<QueryResult<UnknownRow>>;
+
     /**
      * This callback determines whether a mutation should be intercepted, and if so,
      * what data should be loaded before and after the mutation.
      */
     mutationInterceptionFilter?: (
-        args: MutationLifecycleEventArgs<Schema>
+        args: MutationHooksArgs<Schema>
     ) => MaybePromise<MutationInterceptionFilterResult>;
 
     /**

packages/runtime/test/plugin/kysely-transformer.test.ts

@@ -0,0 +1,91 @@
+import {
+    AndNode,
+    BinaryOperationNode,
+    ColumnNode,
+    OperatorNode,
+    ReferenceNode,
+    SelectQueryNode,
+    TableNode,
+    ValueNode,
+    WhereNode,
+} from 'kysely';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ZenStackClient, type ClientContract } from '../../src';
+import { schema } from '../test-schema';
+
+describe('Entity lifecycle tests', () => {
+    let _client: ClientContract<typeof schema>;
+
+    beforeEach(async () => {
+        _client = await new ZenStackClient(schema);
+        await _client.$pushSchema();
+    });
+
+    it('supports transforming kysely queries', async () => {
+        const client = _client.$use({
+            id: 'test-plugin',
+            transformKyselyQuery(args) {
+                if (SelectQueryNode.is(args.node)) {
+                    // inject filter: email = '[email protected]'
+                    const additionalFilter = BinaryOperationNode.create(
+                        ReferenceNode.create(
+                            ColumnNode.create('email'),
+                            TableNode.create('User')
+                        ),
+                        OperatorNode.create('='),
+                        ValueNode.create('[email protected]')
+                    );
+                    args.node = {
+                        ...args.node,
+                        where: WhereNode.create(
+                            args.node.where
+                                ? AndNode.create(
+                                      args.node.where.where,
+                                      additionalFilter
+                                  )
+                                : additionalFilter
+                        ),
+                    };
+                }
+                return args.node;
+            },
+        });
+
+        const user = await client.user.create({
+            data: { email: '[email protected]' },
+        });
+
+        await expect(
+            client.user.findFirst({
+                where: { id: user.id },
+            })
+        ).toResolveNull();
+
+        await client.user.update({
+            where: { id: user.id },
+            data: { email: '[email protected]' },
+        });
+        await expect(
+            client.user.findFirst({
+                where: { id: user.id },
+            })
+        ).resolves.toMatchObject({ id: user.id });
+    });
+
+    it('supports transforming kysely results', async () => {
+        const client = _client.$use({
+            id: 'test-plugin',
+            async transformKyselyResult(args) {
+                args.result.rows.forEach((row) => {
+                    (row as any).happy = true;
+                });
+                return args.result;
+            },
+        });
+        await expect(
+            client.user.create({
+                data: { email: '[email protected]' },
+            })
+        ).resolves.toMatchObject({ email: '[email protected]', happy: true });
+    });
+});