chore: simplify plugin contract to improve tsc performance

Author: ymc9

.vscode/launch.json

@@ -10,11 +10,7 @@
             "request": "launch",
             "skipFiles": ["<node_internals>/**"],
             "type": "node",
-            "args": [
-                "generate",
-                "--schema",
-                "${workspaceFolder}/samples/blog/zenstack/schema.zmodel"
-            ]
+            "args": ["generate", "--schema", "${workspaceFolder}/samples/blog/zenstack/schema.zmodel"]
         },
         {
             "name": "Debug with TSX",
@@ -44,15 +40,14 @@
 
                 // Ignore all dependencies (optional)
                 "${workspaceFolder}/node_modules/**"
-            ]
+            ],
+            "cwd": "${fileDirname}"
         },
         {
             "name": "Run Extension",
             "type": "extensionHost",
             "request": "launch",
-            "args": [
-                "--extensionDevelopmentPath=${workspaceFolder}/packages/ide/vscode"
-            ],
+            "args": ["--extensionDevelopmentPath=${workspaceFolder}/packages/ide/vscode"],
             "sourceMaps": true,
             "outFiles": ["${workspaceFolder}/packages/ide/vscode/dist/**/*.js"]
         },

README.md

@@ -289,15 +289,11 @@ ORM query interception allows you to intercept the high-level ORM API calls. The
 ```ts
 db.$use({
     id: 'cost-logger',
-    onQuery: {
-        $allModels: {
-            $allOperations: async ({ model, operation, args, query }) => {
-                const start = Date.now();
-                const result = await query(args);
-                console.log(`[cost] ${model} ${operation} took ${Date.now() - start}ms`);
-                return result;
-            },
-        },
+    onQuery: async ({ model, operation, args, query }) => {
+        const start = Date.now();
+        const result = await query(args);
+        console.log(`[cost] ${model} ${operation} took ${Date.now() - start}ms`);
+        return result;
     },
 });
 ```
@@ -333,11 +329,14 @@ Another popular interception use case is, instead of intercepting calls, "listen
 ```ts
 db.$use({
     id: 'mutation-hook-plugin',
-    beforeEntityMutation({ model, action }) {
-        console.log(`Before ${model} ${action}`);
-    },
-    afterEntityMutation({ model, action }) {
-        console.log(`After ${model} ${action}`);
+    onEntityMutation: {
+        beforeEntityMutation({ model, action }) {
+            console.log(`Before ${model} ${action}`);
+        },
+
+        afterEntityMutation({ model, action }) {
+            console.log(`After ${model} ${action}`);
+        },
     },
 });
 ```
@@ -347,20 +346,24 @@ You can provide an extra `mutationInterceptionFilter` to control what to interce
 ```ts
 db.$use({
     id: 'mutation-hook-plugin',
-    mutationInterceptionFilter: ({ model }) => {
-        return {
-            intercept: model === 'User',
-            // load entities affected before the mutation (defaults to false)
-            loadBeforeMutationEntities: true,
-            // load entities affected after the mutation (defaults to false)
-            loadAfterMutationEntities: true,
-        };
-    },
-    beforeEntityMutation({ model, action, entities }) {
-        console.log(`Before ${model} ${action}: ${entities}`);
-    },
-    afterEntityMutation({ model, action, afterMutationEntities }) {
-        console.log(`After ${model} ${action}: ${afterMutationEntities}`);
+    onEntityMutation: {
+        mutationInterceptionFilter: ({ model }) => {
+            return {
+                intercept: model === 'User',
+                // load entities affected before the mutation (defaults to false)
+                loadBeforeMutationEntities: true,
+                // load entities affected after the mutation (defaults to false)
+                loadAfterMutationEntities: true,
+            };
+        },
+
+        beforeEntityMutation({ model, action, entities }) {
+            console.log(`Before ${model} ${action}: ${entities}`);
+        },
+
+        afterEntityMutation({ model, action, afterMutationEntities }) {
+            console.log(`After ${model} ${action}: ${afterMutationEntities}`);
+        },
     },
 });
 ```

TODO.md

@@ -99,6 +99,7 @@
     - [ ] Short-circuit pre-create check for scalar-field only policies
     - [ ] Inject "replace into"
     - [ ] Inject "on conflict do update"
+    - [ ] Inject "insert into select from"
 - [x] Migration
 - [ ] Databases
     - [x] SQLite

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

@@ -1,4 +1,4 @@
-import { invariant, lowerCaseFirst } from '@zenstackhq/common-helpers';
+import { invariant } from '@zenstackhq/common-helpers';
 import type { QueryExecutor } from 'kysely';
 import {
     CompiledQuery,
@@ -376,30 +376,10 @@ function createModelCrudHandler<Schema extends SchemaDef, Model extends GetModel
             // apply plugins
             const plugins = [...(client.$options.plugins ?? [])];
             for (const plugin of plugins) {
-                if (plugin.onQuery && typeof plugin.onQuery === 'object') {
-                    // for each model key or "$allModels"
-                    for (const [_model, modelHooks] of Object.entries<any>(plugin.onQuery)) {
-                        if (_model === lowerCaseFirst(model) || _model === '$allModels') {
-                            if (modelHooks && typeof modelHooks === 'object') {
-                                // for each operation key or "$allOperations"
-                                for (const [op, opHooks] of Object.entries(modelHooks)) {
-                                    if (op === operation || op === '$allOperations') {
-                                        if (typeof opHooks === 'function') {
-                                            const _proceed = proceed;
-                                            proceed = () =>
-                                                opHooks({
-                                                    client,
-                                                    model,
-                                                    operation,
-                                                    args,
-                                                    query: _proceed,
-                                                }) as Promise<unknown>;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
+                const onQuery = plugin.onQuery;
+                if (onQuery) {
+                    const _proceed = proceed;
+                    proceed = () => onQuery({ client, model, operation, args, query: _proceed }) as Promise<unknown>;
                 }
             }