akanjs 3.0.0-alpha.36 → 3.0.0-alpha.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.36",
+  "version": "3.0.0-alpha.37",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/store/action.ts

@@ -316,6 +316,11 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
                 : (value as object);
           (state[names.modelForm] as { [key: string]: any })[namesOfField.field] = setValue;
         });
+
+        const postSet = (this as unknown as { [key: string]: ((value: unknown) => unknown) | undefined })[
+          namesOfField.postSetField
+        ];
+        if (postSet) void postSet.call(this, value);
       },
       ...(field.isArray
         ? {

package/store/formSetterNames.ts

@@ -17,5 +17,14 @@ export const formSetterNames = (className: string, key: string) => {
     subFieldOnModel: `sub${classKeyName}On${className}`,
     addOrSubFieldOnModel: `addOrSub${classKeyName}On${className}`,
     uploadFieldOnModel: `upload${classKeyName}On${className}`,
+    /**
+     * The optional hook a store declares to run after this field is written.
+     *
+     * It carries no model suffix and a leading `_`, so it can never collide with a generated action name — which is
+     * the whole point: every generated action lives in a mapped type, and a mapped type produces *properties*, so a
+     * subclass method of the same name is a TS2425 error and there is no legal way to override one. A hook under a
+     * name the base type does not declare is the only shape TypeScript permits.
+     */
+    postSetField: `_postSet${classKeyName}`,
   };
 };

package/store/storeRegistry.ts

@@ -1,6 +1,7 @@
 import {
   ACTION_META,
   ACTION_OWNER_META,
+  FIELD_META,
   type MergeAllKeyOfObjects,
   type MergeAllKeyOfTypes,
   type MergeAllTypes,
@@ -9,7 +10,9 @@ import {
   STATE_META,
 } from "akanjs/base";
 import { applyMixins } from "akanjs/common";
+import { ConstantRegistry } from "akanjs/constant";
 import { attachAgentic } from "./agentic";
+import { formSetterNames } from "./formSetterNames";
 import type { RootStoreCls } from "./rootStore";
 import type { StoreCls } from "./store";
 import { StoreInstance } from "./storeInstance";
@@ -57,8 +60,28 @@ export class StoreRegistry {
     store[ACTION_META] = actions;
     store[ACTION_OWNER_META] = owners;
     StoreRegistry.#state.store.set(store.refName, store);
+    StoreRegistry.#warnUnknownPostSetHooks(store);
     return store;
   }
+
+  /**
+   * A `_postSet<Field>` hook cannot be typed — the generated setters live in a mapped type, so every name the base
+   * declares is a property a subclass method may not redeclare (TS2425), and the hook only compiles because the base
+   * declares nothing under it. A misspelled field would therefore never fire and never complain, so say so here.
+   */
+  static #warnUnknownPostSetHooks(store: StoreCls) {
+    const hooks = Object.keys(Object.getOwnPropertyDescriptors(store.prototype)).filter((key) =>
+      key.startsWith("_postSet"),
+    );
+    if (!hooks.length) return;
+    const model = ConstantRegistry.getDatabase(store.refName, { allowEmpty: true });
+    if (!model) return;
+    const known = new Set(
+      Object.keys(model.full[FIELD_META] as object).map((key) => formSetterNames("", key).postSetField),
+    );
+    for (const hook of hooks.filter((key) => !known.has(key)))
+      console.warn(`[${store.refName}Store] ${hook} matches no field of ${store.refName}, so it will never run.`);
+  }
   static get(refName: string) {
     return StoreRegistry.#state.store.get(refName);
   }

package/types/store/formSetterNames.d.ts

@@ -13,4 +13,13 @@ export declare const formSetterNames: (className: string, key: string) => {
     subFieldOnModel: string;
     addOrSubFieldOnModel: string;
     uploadFieldOnModel: string;
+    /**
+     * The optional hook a store declares to run after this field is written.
+     *
+     * It carries no model suffix and a leading `_`, so it can never collide with a generated action name — which is
+     * the whole point: every generated action lives in a mapped type, and a mapped type produces *properties*, so a
+     * subclass method of the same name is a TS2425 error and there is no legal way to override one. A hook under a
+     * name the base type does not declare is the only shape TypeScript permits.
+     */
+    postSetField: string;
 };