@hamak/ui-store-impl 0.4.6 → 0.4.16

package/src/middleware/event-bridge-middleware.test.ts

@@ -1,131 +0,0 @@
-/**
- * Event Bridge Middleware Tests
- */
-
-import { describe, test, expect, vi } from 'vitest';
-import { createEventBridgeMiddleware } from './event-bridge-middleware';
-import { createStore, applyMiddleware } from 'redux';
-
-describe('createEventBridgeMiddleware', () => {
-  test('should create middleware', () => {
-    const hooks = { emit: vi.fn(() => {}) };
-    const middleware = createEventBridgeMiddleware(hooks);
-
-    expect(middleware).toBeDefined();
-    expect(typeof middleware).toBe('function');
-  });
-
-  test('should emit before and after action events', () => {
-    const hooks = { emit: vi.fn(() => {}) };
-    const middleware = createEventBridgeMiddleware(hooks);
-
-    const reducer = (state = {}) => state;
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    const action = { type: 'TEST_ACTION', payload: 'test' };
-    store.dispatch(action);
-
-    expect(hooks.emit).toHaveBeenCalledWith('redux:action:before', expect.objectContaining({
-      action,
-      state: expect.any(Object),
-    }));
-
-    expect(hooks.emit).toHaveBeenCalledWith('redux:action:after', expect.objectContaining({
-      action,
-      state: expect.any(Object),
-    }));
-  });
-
-  test('should emit specific action type event', () => {
-    const hooks = { emit: vi.fn(() => {}) };
-    const middleware = createEventBridgeMiddleware(hooks);
-
-    const reducer = (state = {}) => state;
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    const action = { type: 'USER_LOGIN', payload: { userId: 123 } };
-    store.dispatch(action);
-
-    expect(hooks.emit).toHaveBeenCalledWith('redux:action:USER_LOGIN', action);
-  });
-
-  test('should handle actions without type gracefully', () => {
-    // Skip this test - Redux v5 validates that actions must have a type property
-    // This is proper Redux behavior that we don't need to work around
-  });
-
-  test('should work when hooks is undefined', () => {
-    const middleware = createEventBridgeMiddleware(undefined);
-
-    const reducer = (state = {}) => state;
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    expect(() => store.dispatch({ type: 'TEST' })).not.toThrow();
-  });
-
-  test('should pass action through middleware chain', () => {
-    const hooks = { emit: vi.fn(() => {}) };
-    const middleware = createEventBridgeMiddleware(hooks);
-
-    const reducer = vi.fn((state = { count: 0 }, action: any) => {
-      if (action.type === 'INCREMENT') {
-        return { count: state.count + 1 };
-      }
-      return state;
-    });
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    store.dispatch({ type: 'INCREMENT' });
-
-    expect(reducer).toHaveBeenCalled();
-    expect(store.getState()).toEqual({ count: 1 });
-  });
-
-  test('should emit events in correct order', () => {
-    const eventOrder: string[] = [];
-    const hooks = {
-      emit: vi.fn((event: string) => {
-        eventOrder.push(event);
-      }),
-    };
-
-    const middleware = createEventBridgeMiddleware(hooks);
-    const reducer = (state = {}) => state;
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    store.dispatch({ type: 'TEST_ACTION' });
-
-    expect(eventOrder).toEqual([
-      'redux:action:before',
-      'redux:action:after',
-      'redux:action:TEST_ACTION',
-    ]);
-  });
-
-  test('should include state in before/after events', () => {
-    const hooks = { emit: vi.fn(() => {}) };
-    const middleware = createEventBridgeMiddleware(hooks);
-
-    const reducer = (state = { value: 0 }, action: any) => {
-      if (action.type === 'SET_VALUE') {
-        return { value: action.payload };
-      }
-      return state;
-    };
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    store.dispatch({ type: 'SET_VALUE', payload: 42 });
-
-    // Check before event has initial state
-    expect(hooks.emit).toHaveBeenCalledWith('redux:action:before', expect.objectContaining({
-      state: { value: 0 },
-    }));
-
-    // Check after event has updated state
-    expect(hooks.emit).toHaveBeenCalledWith('redux:action:after', expect.objectContaining({
-      state: { value: 42 },
-    }));
-  });
-});

package/src/middleware/event-bridge-middleware.ts

@@ -1,26 +0,0 @@
-/**
- * Event Bridge Middleware
- * Bridges Redux actions to microkernel event bus
- */
-
-import type { Middleware } from 'redux';
-
-export function createEventBridgeMiddleware(hooks: any): Middleware {
-  return (store) => (next) => (action: any) => {
-    // Emit before action
-    hooks?.emit('redux:action:before', { action, state: store.getState() });
-
-    // Execute action
-    const result = next(action);
-
-    // Emit after action
-    hooks?.emit('redux:action:after', { action, state: store.getState() });
-
-    // Emit specific action type event
-    if (action?.type) {
-      hooks?.emit(`redux:action:${action.type}`, action);
-    }
-
-    return result;
-  };
-}

package/src/middleware/index.ts

@@ -1,6 +0,0 @@
-/**
- * Middleware Export
- */
-
-export * from './event-bridge-middleware';
-export * from './logger-middleware';

package/src/middleware/logger-middleware.test.ts

@@ -1,129 +0,0 @@
-/**
- * Logger Middleware Tests
- */
-
-import { describe, test, expect, vi } from 'vitest';
-import { createLoggerMiddleware } from './logger-middleware';
-import { createStore, applyMiddleware } from 'redux';
-
-describe('createLoggerMiddleware', () => {
-  test('should create middleware', () => {
-    const middleware = createLoggerMiddleware();
-
-    expect(middleware).toBeDefined();
-    expect(typeof middleware).toBe('function');
-  });
-
-  test('should log actions with type', () => {
-    const consoleGroupSpy = vi.spyOn(console, 'group');
-    const consoleLogSpy = vi.spyOn(console, 'log');
-    const consoleGroupEndSpy = vi.spyOn(console, 'groupEnd');
-
-    const middleware = createLoggerMiddleware();
-    const reducer = (state = { count: 0 }, action: any) => {
-      if (action.type === 'INCREMENT') {
-        return { count: state.count + 1 };
-      }
-      return state;
-    };
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-    store.dispatch({ type: 'INCREMENT' });
-
-    expect(consoleGroupSpy).toHaveBeenCalledWith('[Redux] INCREMENT');
-    expect(consoleLogSpy).toHaveBeenCalledWith('Prev State:', { count: 0 });
-    expect(consoleLogSpy).toHaveBeenCalledWith('Action:', { type: 'INCREMENT' });
-    expect(consoleLogSpy).toHaveBeenCalledWith('Next State:', { count: 1 });
-    expect(consoleGroupEndSpy).toHaveBeenCalled();
-
-    consoleGroupSpy.mockRestore();
-    consoleLogSpy.mockRestore();
-    consoleGroupEndSpy.mockRestore();
-  });
-
-  test('should not log actions without string type', () => {
-    const consoleGroupSpy = vi.spyOn(console, 'group');
-    const middleware = createLoggerMiddleware();
-
-    const reducer = (state = {}) => state;
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    // Redux requires actions to have a type, so we'll test with a non-string type
-    // This would normally be caught by Redux, but our middleware should handle it gracefully
-    // We'll skip this test as Redux v5 validates this strictly
-    consoleGroupSpy.mockRestore();
-  });
-
-  test('should pass action through middleware chain', () => {
-    const middleware = createLoggerMiddleware();
-    const reducer = vi.fn((state = {}) => state);
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-    store.dispatch({ type: 'TEST' });
-
-    expect(reducer).toHaveBeenCalled();
-  });
-
-  test('should return action result', () => {
-    const middleware = createLoggerMiddleware();
-    const reducer = (state = {}) => state;
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-    const action = { type: 'TEST', payload: 123 };
-    const result = store.dispatch(action);
-
-    expect(result).toEqual(action);
-  });
-
-  test('should handle actions with numeric type', () => {
-    // Skip this test - Redux v5 validates action types strictly and will throw
-    // if type is not a string. This is good behavior that we don't need to test against.
-  });
-
-  test('should log state before and after action', () => {
-    const consoleLogSpy = vi.spyOn(console, 'log');
-    const middleware = createLoggerMiddleware();
-
-    const reducer = (state = { value: 0 }, action: any) => {
-      if (action.type === 'SET_VALUE') {
-        return { value: action.payload };
-      }
-      return state;
-    };
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-    store.dispatch({ type: 'SET_VALUE', payload: 42 });
-
-    expect(consoleLogSpy).toHaveBeenCalledWith('Prev State:', { value: 0 });
-    expect(consoleLogSpy).toHaveBeenCalledWith('Next State:', { value: 42 });
-
-    consoleLogSpy.mockRestore();
-  });
-
-  test('should work with multiple actions', () => {
-    const consoleGroupSpy = vi.spyOn(console, 'group');
-    const middleware = createLoggerMiddleware();
-
-    const reducer = (state = { count: 0 }, action: any) => {
-      if (action.type === 'INCREMENT') return { count: state.count + 1 };
-      if (action.type === 'DECREMENT') return { count: state.count - 1 };
-      return state;
-    };
-
-    const store = createStore(reducer, applyMiddleware(middleware));
-
-    // Clear any initialization calls
-    consoleGroupSpy.mockClear();
-
-    store.dispatch({ type: 'INCREMENT' });
-    store.dispatch({ type: 'INCREMENT' });
-    store.dispatch({ type: 'DECREMENT' });
-
-    expect(consoleGroupSpy).toHaveBeenCalledTimes(3);
-    expect(consoleGroupSpy).toHaveBeenNthCalledWith(1, '[Redux] INCREMENT');
-    expect(consoleGroupSpy).toHaveBeenNthCalledWith(2, '[Redux] INCREMENT');
-    expect(consoleGroupSpy).toHaveBeenNthCalledWith(3, '[Redux] DECREMENT');
-
-    consoleGroupSpy.mockRestore();
-  });
-});

package/src/middleware/logger-middleware.ts

@@ -1,25 +0,0 @@
-/**
- * Logger Middleware
- * Development logger for Redux actions
- */
-
-import type { Middleware } from 'redux';
-
-export function createLoggerMiddleware(): Middleware {
-  return (store) => (next) => (action: any) => {
-    if (typeof action?.type === 'string') {
-      console.group(`[Redux] ${action.type}`);
-      console.log('Prev State:', store.getState());
-      console.log('Action:', action);
-
-      const result = next(action);
-
-      console.log('Next State:', store.getState());
-      console.groupEnd();
-
-      return result;
-    }
-
-    return next(action);
-  };
-}

package/src/plugin/index.ts

@@ -1,5 +0,0 @@
-/**
- * Plugin Export
- */
-
-export * from './store-plugin-factory';

package/src/plugin/store-plugin-factory.ts

@@ -1,142 +0,0 @@
-/**
- * Store Plugin Factory
- * Creates a microkernel plugin for Redux store management
- */
-
-import type { PluginModule } from '@hamak/microkernel-spi';
-import {
-  STORE_MANAGER_TOKEN,
-  MIDDLEWARE_REGISTRY_TOKEN,
-  REDUCER_REGISTRY_TOKEN,
-  STORE_EXTENSIONS_TOKEN,
-  type StoreMiddlewareExtension,
-  type StorePluginExtensions,
-} from '@hamak/ui-store-api';
-import { StoreManager } from '../core/store-manager';
-import {
-  createEventBridgeMiddleware,
-  createLoggerMiddleware,
-} from '../middleware';
-import {
-  applyStoreExtensions,
-  createStoreExtensionsCollector,
-} from '../extensions/store-extensions';
-
-export interface StorePluginConfig extends StorePluginExtensions {
-  /** Enable Redux DevTools integration */
-  devTools?: boolean;
-
-  /** Enable logger middleware in development */
-  logger?: boolean;
-}
-
-export function createStorePlugin(
-  config: StorePluginConfig = {}
-): PluginModule {
-  const storeManager = new StoreManager();
-  const middlewareRegistry = storeManager.getMiddlewareRegistry();
-  const reducerRegistry = storeManager.getReducerRegistry();
-  const extensionsCollector = createStoreExtensionsCollector();
-
-  const registerDefaultMiddleware = (hooks: any) => {
-    extensionsCollector.register('ui-store:event-bridge', {
-      middleware: [
-        {
-          id: 'event-bridge',
-          middleware: createEventBridgeMiddleware(hooks),
-          priority: 1000,
-          plugin: 'ui-store',
-          description: 'Bridges Redux actions to microkernel events',
-        },
-      ],
-    });
-
-    if (
-      config.logger !== false &&
-      process.env.NODE_ENV === 'development'
-    ) {
-      extensionsCollector.register('ui-store:logger', {
-        middleware: [
-          {
-            id: 'logger',
-            middleware: createLoggerMiddleware(),
-            priority: -1000,
-            plugin: 'ui-store',
-            description: 'Development logger',
-          },
-        ],
-      });
-    }
-  };
-
-  const registerConfigExtensions = () => {
-    if (config.middleware?.length) {
-      const middleware: StoreMiddlewareExtension[] = config.middleware.map((mw) => ({
-        ...mw,
-        plugin: mw.plugin ?? 'ui-store-config',
-      }));
-
-      extensionsCollector.register('ui-store-config:middleware', {
-        middleware,
-      });
-    }
-
-    if (config.reducers && Object.keys(config.reducers).length) {
-      extensionsCollector.register('ui-store-config:reducers', {
-        reducers: config.reducers,
-      });
-    }
-  };
-
-  return {
-    async initialize(ctx) {
-      // Register services via DI
-      ctx.provide({ provide: STORE_MANAGER_TOKEN, useValue: storeManager });
-      ctx.provide({
-        provide: MIDDLEWARE_REGISTRY_TOKEN,
-        useValue: middlewareRegistry,
-      });
-      ctx.provide({
-        provide: REDUCER_REGISTRY_TOKEN,
-        useValue: reducerRegistry,
-      });
-      ctx.provide({
-        provide: STORE_EXTENSIONS_TOKEN,
-        useValue: extensionsCollector,
-      });
-
-      registerDefaultMiddleware(ctx.hooks);
-      registerConfigExtensions();
-
-      console.log('[ui-store] Plugin initialized');
-    },
-
-    async activate(ctx) {
-      applyStoreExtensions(
-        extensionsCollector,
-        middlewareRegistry,
-        reducerRegistry
-      );
-
-      // Initialize the store after all plugins have registered middleware/reducers
-      const store = storeManager.initialize({
-        devTools: config.devTools,
-      });
-
-      // Bridge Redux state changes to microkernel events
-      store.subscribe(() => {
-        ctx.hooks.emit('redux:state-changed', store.getState());
-      });
-
-      // Emit ready event
-      ctx.hooks.emit('ui-store:ready', { store });
-
-      console.log('[ui-store] Plugin activated');
-    },
-
-    async deactivate() {
-      storeManager.destroy();
-      console.log('[ui-store] Plugin deactivated');
-    },
-  };
-}

package/tsconfig.es2015.json

@@ -1,24 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "target": "ES2015",
-    "lib": [
-      "ES2015",
-      "DOM"
-    ],
-    "outDir": "./dist/es2015",
-    "declaration": false,
-    "declarationMap": false,
-    "sourceMap": false,
-    "downlevelIteration": true,
-    "composite": false
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts"
-  ]
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020", "DOM"],
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "allowImportingTsExtensions": false
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}