@praxisjs/store 1.2.3 → 1.3.1

package/src/apply-plugins.ts

@@ -0,0 +1,77 @@
+import type { StorePlugin } from "./plugin-types.js";
+
+export function applyPluginsToStore<T extends object>(
+  instance: T,
+  storeName: string,
+  plugins: StorePlugin[],
+): T {
+  if (plugins.length === 0) return instance;
+
+  const extensions: Record<string, unknown> = {};
+
+  const proxy: T = new Proxy(instance, {
+    get(target, prop: string | symbol): unknown {
+      if (typeof prop === "symbol") return Reflect.get(target, prop) as unknown;
+
+      if (prop in extensions) {
+        const ext = extensions[prop];
+        return typeof ext === "function"
+          ? (ext as (...a: unknown[]) => unknown).bind(proxy)
+          : ext;
+      }
+
+      const val = Reflect.get(target, prop, proxy) as unknown;
+
+      if (typeof val === "function" && !prop.startsWith("$")) {
+        return (...args: unknown[]): unknown => {
+          for (const p of plugins) p.onAction?.({ name: prop, args, storeName });
+          const result = (val as (...a: unknown[]) => unknown).apply(proxy, args);
+          if (result instanceof Promise) {
+            return result
+              .then((resolved: unknown) => {
+                for (const p of plugins)
+                  p.onActionDone?.({ name: prop, args, storeName, result: resolved });
+                return resolved;
+              })
+              .catch((err: unknown) => {
+                for (const p of plugins)
+                  p.onActionDone?.({ name: prop, args, storeName, result: undefined, error: err });
+                throw err;
+              });
+          }
+          for (const p of plugins)
+            p.onActionDone?.({ name: prop, args, storeName, result });
+          return result;
+        };
+      }
+
+      return val;
+    },
+
+    set(target, prop: string | symbol, value: unknown): boolean {
+      if (typeof prop === "symbol") {
+        (target as Record<symbol, unknown>)[prop] = value;
+        return true;
+      }
+      const prevValue = Reflect.get(target, prop, proxy) as unknown;
+      const ok: boolean = Reflect.set(target, prop, value, proxy);
+      if (ok) {
+        for (const p of plugins)
+          p.onMutation?.({ key: prop, value, prevValue, storeName });
+      }
+      return ok;
+    },
+  });
+
+  for (const plugin of plugins) {
+    plugin.onInit?.({
+      store: proxy as unknown as Record<string, unknown>,
+      storeName,
+      extend(props) {
+        Object.assign(extensions, props);
+      },
+    });
+  }
+
+  return proxy;
+}

package/src/create-store.ts

@@ -1,8 +1,19 @@
 import { signal, effect } from "@praxisjs/core/internal";
 
+import { getGlobalPlugins } from "./plugin-registry.js";
+
+import type { StorePlugin } from "./plugin-types.js";
+
+export interface CreateStoreOptions {
+  name?: string;
+  plugins?: StorePlugin[];
+}
+
 export function createStore<T extends Record<string, unknown>>(
   definition: T & ThisType<T>,
+  options: CreateStoreOptions = {},
 ) {
+  const storeName = options.name ?? "anonymous";
   const initialState: Record<string, unknown> = {};
   const methods: Record<string, (...args: unknown[]) => unknown> = {};
 
@@ -17,12 +28,40 @@ export function createStore<T extends Record<string, unknown>>(
     signals[key] = signal(value);
   }
 
+  const activePlugins = [...getGlobalPlugins(), ...(options.plugins ?? [])];
+  const extensions: Record<string, unknown> = {};
+
   const store = new Proxy({} as T, {
     get(_t, key: string | symbol) {
       if (typeof key !== "string") return undefined;
-      if (key in methods)
-        return (...args: unknown[]): unknown =>
-          methods[key].call(store, ...args);
+      if (key in extensions) {
+        const ext = extensions[key];
+        return typeof ext === "function"
+          ? (ext as (...a: unknown[]) => unknown).bind(store)
+          : ext;
+      }
+      if (key in methods) {
+        return (...args: unknown[]): unknown => {
+          for (const p of activePlugins) p.onAction?.({ name: key, args, storeName });
+          const result = methods[key].call(store, ...args);
+          if (result instanceof Promise) {
+            return result
+              .then((resolved: unknown) => {
+                for (const p of activePlugins)
+                  p.onActionDone?.({ name: key, args, storeName, result: resolved });
+                return resolved;
+              })
+              .catch((err: unknown) => {
+                for (const p of activePlugins)
+                  p.onActionDone?.({ name: key, args, storeName, result: undefined, error: err });
+                throw err;
+              });
+          }
+          for (const p of activePlugins)
+            p.onActionDone?.({ name: key, args, storeName, result });
+          return result;
+        };
+      }
       if (key === "$subscribe") return subscribe;
       if (key === "$reset") return reset;
       if (key === "$patch") return patch;
@@ -35,13 +74,26 @@ export function createStore<T extends Record<string, unknown>>(
     set(_t, key: string | symbol, value: unknown) {
       if (typeof key !== "string") return true;
       if (key in signals) {
+        const prevValue = signals[key]();
         signals[key].set(value);
+        for (const p of activePlugins)
+          p.onMutation?.({ key, value, prevValue, storeName });
         return true;
       }
       return false;
     },
   });
 
+  for (const plugin of activePlugins) {
+    plugin.onInit?.({
+      store: store as unknown as Record<string, unknown>,
+      storeName,
+      extend(props) {
+        Object.assign(extensions, props);
+      },
+    });
+  }
+
   function getState(): Record<string, unknown> {
     const s: Record<string, unknown> = {};
     for (const k of Object.keys(signals)) s[k] = signals[k]();
@@ -61,7 +113,7 @@ export function createStore<T extends Record<string, unknown>>(
   function patch(partial: Partial<Record<string, unknown>>): void {
     for (const [k, v] of Object.entries(partial)) {
       if (v === undefined) continue;
-      if (k in signals) signals[k].set(v);
+      if (k in signals) Reflect.set(store as object, k, v);
     }
   }
 

package/src/decorators.ts

@@ -4,25 +4,46 @@ import {
   type ReactiveHost,
 } from "@praxisjs/decorators";
 
+import { applyPluginsToStore } from "./apply-plugins.js";
+import { getGlobalPlugins } from "./plugin-registry.js";
+
+import type { StorePlugin } from "./plugin-types.js";
+
 const storeRegistry = new Map<new (...args: unknown[]) => unknown, unknown>();
+const storePluginsMap = new WeakMap<
+  new (...args: unknown[]) => ReactiveStore,
+  StorePlugin[]
+>();
 
 /** Base class for store classes. Extend this to enable `@State` and `@DeepState` on store fields. */
 export class ReactiveStore implements ReactiveHost {
   _stateDirty = false;
 }
 
-export function Storable() {
+export interface StorableOptions {
+  plugins?: StorePlugin[];
+}
+
+export function Storable(options: StorableOptions = {}) {
   return function (
     constructor: new (...args: unknown[]) => ReactiveStore,
     _context: ClassDecoratorContext,
   ): void {
     storeRegistry.set(constructor, null);
+    if (options.plugins?.length) {
+      storePluginsMap.set(constructor, options.plugins);
+    }
   };
 }
 
 export function store<T extends ReactiveStore>(StoreClass: new () => T): T {
   if (!storeRegistry.has(StoreClass) || storeRegistry.get(StoreClass) === null) {
-    storeRegistry.set(StoreClass, new StoreClass());
+    const instance = new StoreClass();
+    const perStore =
+      storePluginsMap.get(StoreClass as new (...args: unknown[]) => ReactiveStore) ?? [];
+    const plugins = [...getGlobalPlugins(), ...perStore];
+    const wrapped = applyPluginsToStore(instance, StoreClass.name, plugins);
+    storeRegistry.set(StoreClass, wrapped);
   }
   return storeRegistry.get(StoreClass) as T;
 }

package/src/index.ts

@@ -1 +1,10 @@
-export { Storable, Store, store, ReactiveStore } from "./decorators";
+export { Storable, Store, store, ReactiveStore } from "./decorators.js";
+export type { StorableOptions } from "./decorators.js";
+export { useStorePlugin, clearPlugins } from "./plugin-registry.js";
+export type {
+  StorePlugin,
+  StoreMutation,
+  StoreActionContext,
+  StoreActionResult,
+  StoreInitContext,
+} from "./plugin-types.js";

package/src/plugin-registry.ts

@@ -0,0 +1,15 @@
+import type { StorePlugin } from "./plugin-types.js";
+
+const globalRegistry: StorePlugin[] = [];
+
+export function useStorePlugin(plugin: StorePlugin): void {
+  globalRegistry.push(plugin);
+}
+
+export function getGlobalPlugins(): StorePlugin[] {
+  return globalRegistry.slice();
+}
+
+export function clearPlugins(): void {
+  globalRegistry.length = 0;
+}

package/src/plugin-types.ts

@@ -0,0 +1,31 @@
+export interface StoreMutation {
+  key: string;
+  value: unknown;
+  prevValue: unknown;
+  storeName: string;
+}
+
+export interface StoreActionContext {
+  name: string;
+  args: unknown[];
+  storeName: string;
+}
+
+export interface StoreActionResult extends StoreActionContext {
+  result: unknown;
+  error?: unknown;
+}
+
+export interface StoreInitContext {
+  store: Record<string, unknown>;
+  storeName: string;
+  extend(props: Record<string, unknown>): void;
+}
+
+export interface StorePlugin {
+  name: string;
+  onInit?(context: StoreInitContext): void;
+  onMutation?(mutation: StoreMutation): void;
+  onAction?(context: StoreActionContext): void;
+  onActionDone?(result: StoreActionResult): void;
+}