@porulle/core 0.38.0 → 0.40.0

package/package.json

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

package/src/kernel/hooks/executor.ts

@@ -104,13 +104,13 @@ export async function runBeforeHooks<T>(
   return current;
 }
 
-export async function runAfterHooks<T>(
-  hooks: AfterHook<T>[],
-  originalData: T | null,
-  committedResult: T,
+export async function runAfterHooks<TResult, TData = TResult>(
+  hooks: AfterHook<TResult, TData>[],
+  originalData: TData | null,
+  committedResult: TResult,
   operation: HookOperation,
   context: HookContext,
-  runsInTransaction: (hook: AfterHook<T>) => boolean = () => false,
+  runsInTransaction: (hook: AfterHook<TResult, TData>) => boolean = () => false,
 ): Promise<HookReport> {
   const errors: HookError[] = [];
   for (const hook of hooks) {

package/src/kernel/hooks/types.ts

@@ -50,9 +50,18 @@ export type BeforeHook<TData> = (args: {
   context: HookContext;
 }) => Promise<TData> | TData;
 
-export type AfterHook<TData> = (args: {
+/**
+ * `data` is what went in, `result` is what was committed. For most operations
+ * those are the same shape, so `TData` defaults to `TResult` and a single type
+ * argument keeps its old meaning.
+ *
+ * They differ where the committed entity is not the input: a status change
+ * commits a hydrated order but its input is the transition itself, and a hook
+ * that cannot see which transition occurred cannot act on one.
+ */
+export type AfterHook<TResult, TData = TResult> = (args: {
   data: TData | null;
-  result: TData;
+  result: TResult;
   operation: HookOperation;
   context: HookContext;
 }) => Promise<void> | void;

package/src/modules/orders/service.ts

@@ -134,7 +134,14 @@ type StatusChangeHookInput = {
   reason?: string;
 };
 type BeforeStatusChangeHook = BeforeHook<StatusChangeHookInput>;
-type AfterStatusChangeHook = AfterHook<HydratedOrder>;
+/**
+ * `result` is the committed, hydrated order; `data` is the transition that
+ * produced it. A subscriber that must act on *which* transition occurred — the
+ * channel connector pushes an order to its merchant only when it leaves
+ * `pending_payment` — cannot read that from the order alone, because the order
+ * carries only the status it now has.
+ */
+type AfterStatusChangeHook = AfterHook<HydratedOrder, StatusChangeHookInput>;
 
 function context(
   actor: Actor | null,
@@ -1254,7 +1261,7 @@ export class OrderService {
     const hydrated = await this.hydrateOrder(cas, ctx);
     const report = await runAfterHooks(
       afterHooks,
-      null,
+      statusHookInput,
       hydrated,
       "statusChange",
       hookCtx,