@porulle/core 0.46.0 → 0.47.0

package/dist/kernel/hooks/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/kernel/hooks/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAKpF,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,CAKzE;AA4DD,wBAAsB,cAAc,CAAC,CAAC,EACpC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,EACtB,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,KAAK,GAAG,OAAO,EAC1D,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAClC,YAAY,EAAE,KAAK,GAAG,IAAI,EAC1B,eAAe,EAAE,OAAO,EACxB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,WAAW,EACpB,iBAAiB,GAAE,CAAC,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,OAAqB,GAC5E,OAAO,CAAC,UAAU,CAAC,CAkErB"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/kernel/hooks/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAKpF,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,CAKzE;AA4FD,wBAAsB,cAAc,CAAC,CAAC,EACpC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,EACtB,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC,CAmBZ;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,KAAK,GAAG,OAAO,EAC1D,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,EAClC,YAAY,EAAE,KAAK,GAAG,IAAI,EAC1B,eAAe,EAAE,OAAO,EACxB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,WAAW,EACpB,iBAAiB,GAAE,CAAC,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,OAAqB,GAC5E,OAAO,CAAC,UAAU,CAAC,CAwErB"}

package/dist/kernel/hooks/executor.js

@@ -31,6 +31,34 @@ function inTransactionHookContext(context) {
 }
 /** Default hook timeout: 20 seconds */
 const HOOK_TIMEOUT_MS = 20_000;
+/**
+ * Warn above this. The timeout is the wrong instrument for the common case: a hook does not have
+ * to reach 20 s to be a problem, and by the time it does the damage is already spent.
+ *
+ * An in-transaction hook holds a pooled Postgres transaction for its whole duration. An
+ * after-commit one extends the invocation that wrote — on Workers a promise the invocation does
+ * not outlive, so the writer waits for it. `failures.ts` records what that costs unobserved: four
+ * connector suites took 578.23 s instead of 27.29 s and logged 51 `deliverWebhooks timed out after
+ * 20000ms`, exit 0, 22 of 22 passing. The only thing that disagreed was the wall clock.
+ *
+ * 100 ms matches Vendure's blocking-handler warning, and the remedy is the same one it names:
+ * move non-trivial work to the job queue and let the hook enqueue it.
+ */
+const HOOK_SLOW_MS = 100;
+function warnIfSlow(context, hookName, startedAt, inTransaction) {
+    const elapsed = Date.now() - startedAt;
+    if (elapsed <= HOOK_SLOW_MS)
+        return;
+    context.logger.warn(`After-hook "${hookName}" took ${elapsed}ms`, {
+        hookName,
+        elapsedMs: elapsed,
+        inTransaction,
+        requestId: context.requestId,
+        hint: inTransaction
+            ? "Runs inside the writing transaction and holds its connection for this long. Enqueue the work instead."
+            : "Runs after commit but inside the same invocation, so the writer waits for it. Enqueue the work instead.",
+    });
+}
 function withTimeout(promiseOrValue, timeoutMs, hookName) {
     const promise = Promise.resolve(promiseOrValue);
     return new Promise((resolve, reject) => {
@@ -85,8 +113,10 @@ export async function runAfterHooks(hooks, originalData, committedResult, operat
                 : { ...context, tx: null },
         }), HOOK_TIMEOUT_MS, hookName);
         if (runsInTransaction(hook)) {
+            const startedAt = Date.now();
             try {
                 await runHook();
+                warnIfSlow(context, hookName, startedAt, true);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -99,8 +129,10 @@ export async function runAfterHooks(hooks, originalData, committedResult, operat
             continue;
         }
         const deferred = deferAfterCommit(async () => {
+            const startedAt = Date.now();
             try {
                 await runHook();
+                warnIfSlow(context, hookName, startedAt, false);
             }
             catch (error) {
                 // Reported rather than collected: this runs after the commit, so the HookReport below has
@@ -116,8 +148,10 @@ export async function runAfterHooks(hooks, originalData, committedResult, operat
             }
         });
         if (!deferred) {
+            const startedAt = Date.now();
             try {
                 await runHook();
+                warnIfSlow(context, hookName, startedAt, false);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/core",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/kernel/hooks/executor.ts

@@ -46,6 +46,38 @@ function inTransactionHookContext(context: HookContext): HookContext {
 /** Default hook timeout: 20 seconds */
 const HOOK_TIMEOUT_MS = 20_000;
 
+/**
+ * Warn above this. The timeout is the wrong instrument for the common case: a hook does not have
+ * to reach 20 s to be a problem, and by the time it does the damage is already spent.
+ *
+ * An in-transaction hook holds a pooled Postgres transaction for its whole duration. An
+ * after-commit one extends the invocation that wrote — on Workers a promise the invocation does
+ * not outlive, so the writer waits for it. `failures.ts` records what that costs unobserved: four
+ * connector suites took 578.23 s instead of 27.29 s and logged 51 `deliverWebhooks timed out after
+ * 20000ms`, exit 0, 22 of 22 passing. The only thing that disagreed was the wall clock.
+ *
+ * 100 ms matches Vendure's blocking-handler warning, and the remedy is the same one it names:
+ * move non-trivial work to the job queue and let the hook enqueue it.
+ */
+const HOOK_SLOW_MS = 100;
+
+function warnIfSlow(context: HookContext, hookName: string, startedAt: number, inTransaction: boolean): void {
+  const elapsed = Date.now() - startedAt;
+  if (elapsed <= HOOK_SLOW_MS) return;
+  context.logger.warn(
+    `After-hook "${hookName}" took ${elapsed}ms`,
+    {
+      hookName,
+      elapsedMs: elapsed,
+      inTransaction,
+      requestId: context.requestId,
+      hint: inTransaction
+        ? "Runs inside the writing transaction and holds its connection for this long. Enqueue the work instead."
+        : "Runs after commit but inside the same invocation, so the writer waits for it. Enqueue the work instead.",
+    },
+  );
+}
+
 function withTimeout<T>(promiseOrValue: Promise<T> | T, timeoutMs: number, hookName: string): Promise<T> {
   const promise = Promise.resolve(promiseOrValue);
   return new Promise<T>((resolve, reject) => {
@@ -130,8 +162,10 @@ export async function runAfterHooks<TResult, TData = TResult>(
       );
 
     if (runsInTransaction(hook)) {
+      const startedAt = Date.now();
       try {
         await runHook();
+        warnIfSlow(context, hookName, startedAt, true);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         errors.push({ hookName, message });
@@ -144,8 +178,10 @@ export async function runAfterHooks<TResult, TData = TResult>(
     }
 
     const deferred = deferAfterCommit(async () => {
+      const startedAt = Date.now();
       try {
         await runHook();
+        warnIfSlow(context, hookName, startedAt, false);
       } catch (error) {
         // Reported rather than collected: this runs after the commit, so the HookReport below has
         // already been returned to the caller and there is nowhere else for this failure to go.
@@ -161,8 +197,10 @@ export async function runAfterHooks<TResult, TData = TResult>(
     });
 
     if (!deferred) {
+      const startedAt = Date.now();
       try {
         await runHook();
+        warnIfSlow(context, hookName, startedAt, false);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         errors.push({ hookName, message });