@hamak/ui-store-impl 0.1.0

package/src/core/middleware-registry.test.ts

@@ -0,0 +1,247 @@
+/**
+ * MiddlewareRegistry Tests
+ */
+
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { MiddlewareRegistry } from './middleware-registry';
+import type { Middleware } from 'redux';
+import type { MiddlewareRegistration } from '@amk/ui-store-api';
+
+describe('MiddlewareRegistry', () => {
+  let registry: MiddlewareRegistry;
+
+  beforeEach(() => {
+    registry = new MiddlewareRegistry();
+  });
+
+  describe('register', () => {
+    test('should register middleware', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      const registration: MiddlewareRegistration = {
+        id: 'test-middleware',
+        middleware,
+      };
+
+      registry.register(registration);
+
+      expect(registry.has('test-middleware')).toBe(true);
+    });
+
+    test('should register middleware with default priority of 0', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      const registration: MiddlewareRegistration = {
+        id: 'test-middleware',
+        middleware,
+      };
+
+      registry.register(registration);
+      const info = registry.getInfo('test-middleware');
+
+      expect(info?.priority).toBe(0);
+    });
+
+    test('should register middleware with custom priority', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      const registration: MiddlewareRegistration = {
+        id: 'test-middleware',
+        middleware,
+        priority: 100,
+      };
+
+      registry.register(registration);
+      const info = registry.getInfo('test-middleware');
+
+      expect(info?.priority).toBe(100);
+    });
+
+    test('should throw error when registering after lock', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      const registration: MiddlewareRegistration = {
+        id: 'test-middleware',
+        middleware,
+      };
+
+      registry.lock();
+
+      expect(() => registry.register(registration)).toThrow(
+        /Cannot register middleware.*store already created/
+      );
+    });
+
+    test('should replace existing middleware with same id', () => {
+      const middleware1: Middleware = () => (next) => (action) => next(action);
+      const middleware2: Middleware = () => (next) => (action) => next(action);
+
+      registry.register({
+        id: 'test-middleware',
+        middleware: middleware1,
+        priority: 10,
+      });
+
+      registry.register({
+        id: 'test-middleware',
+        middleware: middleware2,
+        priority: 20,
+      });
+
+      const info = registry.getInfo('test-middleware');
+      expect(info?.priority).toBe(20);
+      expect(info?.middleware).toBe(middleware2);
+    });
+  });
+
+  describe('unregister', () => {
+    test('should unregister middleware', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      registry.register({
+        id: 'test-middleware',
+        middleware,
+      });
+
+      registry.unregister('test-middleware');
+
+      expect(registry.has('test-middleware')).toBe(false);
+    });
+
+    test('should not throw when unregistering non-existent middleware', () => {
+      expect(() => registry.unregister('non-existent')).not.toThrow();
+    });
+
+    test('should throw error when unregistering after lock', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      registry.register({
+        id: 'test-middleware',
+        middleware,
+      });
+
+      registry.lock();
+
+      expect(() => registry.unregister('test-middleware')).toThrow(
+        /Cannot unregister middleware after store creation/
+      );
+    });
+  });
+
+  describe('getAll', () => {
+    test('should return empty array when no middleware registered', () => {
+      expect(registry.getAll()).toEqual([]);
+    });
+
+    test('should return all middleware in priority order (highest first)', () => {
+      const middleware1: Middleware = () => (next) => (action) => next(action);
+      const middleware2: Middleware = () => (next) => (action) => next(action);
+      const middleware3: Middleware = () => (next) => (action) => next(action);
+
+      registry.register({ id: 'low', middleware: middleware1, priority: 10 });
+      registry.register({ id: 'high', middleware: middleware2, priority: 100 });
+      registry.register({ id: 'medium', middleware: middleware3, priority: 50 });
+
+      const all = registry.getAll();
+
+      expect(all).toEqual([middleware2, middleware3, middleware1]);
+    });
+
+    test('should handle middleware with same priority', () => {
+      const middleware1: Middleware = () => (next) => (action) => next(action);
+      const middleware2: Middleware = () => (next) => (action) => next(action);
+
+      registry.register({ id: 'first', middleware: middleware1, priority: 10 });
+      registry.register({ id: 'second', middleware: middleware2, priority: 10 });
+
+      const all = registry.getAll();
+
+      expect(all.length).toBe(2);
+      expect(all).toContain(middleware1);
+      expect(all).toContain(middleware2);
+    });
+  });
+
+  describe('has', () => {
+    test('should return false for non-existent middleware', () => {
+      expect(registry.has('non-existent')).toBe(false);
+    });
+
+    test('should return true for registered middleware', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      registry.register({ id: 'test', middleware });
+
+      expect(registry.has('test')).toBe(true);
+    });
+  });
+
+  describe('getInfo', () => {
+    test('should return undefined for non-existent middleware', () => {
+      expect(registry.getInfo('non-existent')).toBeUndefined();
+    });
+
+    test('should return registration info for existing middleware', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      const registration: MiddlewareRegistration = {
+        id: 'test',
+        middleware,
+        priority: 100,
+        plugin: 'test-plugin',
+        description: 'Test middleware',
+        optional: true,
+      };
+
+      registry.register(registration);
+      const info = registry.getInfo('test');
+
+      expect(info).toEqual(registration);
+    });
+  });
+
+  describe('getAllRegistrations', () => {
+    test('should return empty array when no middleware registered', () => {
+      expect(registry.getAllRegistrations()).toEqual([]);
+    });
+
+    test('should return all registrations', () => {
+      const middleware1: Middleware = () => (next) => (action) => next(action);
+      const middleware2: Middleware = () => (next) => (action) => next(action);
+
+      registry.register({ id: 'first', middleware: middleware1 });
+      registry.register({ id: 'second', middleware: middleware2 });
+
+      const registrations = registry.getAllRegistrations();
+
+      expect(registrations.length).toBe(2);
+      expect(registrations.map((r) => r.id)).toContain('first');
+      expect(registrations.map((r) => r.id)).toContain('second');
+    });
+  });
+
+  describe('lock', () => {
+    test('should prevent further registration', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+
+      registry.lock();
+
+      expect(() =>
+        registry.register({ id: 'test', middleware })
+      ).toThrow();
+    });
+
+    test('should prevent further unregistration', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      registry.register({ id: 'test', middleware });
+
+      registry.lock();
+
+      expect(() => registry.unregister('test')).toThrow();
+    });
+
+    test('should not affect read operations', () => {
+      const middleware: Middleware = () => (next) => (action) => next(action);
+      registry.register({ id: 'test', middleware });
+
+      registry.lock();
+
+      expect(registry.has('test')).toBe(true);
+      expect(registry.getInfo('test')).toBeDefined();
+      expect(registry.getAll().length).toBe(1);
+      expect(registry.getAllRegistrations().length).toBe(1);
+    });
+  });
+});

package/src/core/middleware-registry.ts

@@ -0,0 +1,64 @@
+/**
+ * Middleware Registry Implementation
+ */
+
+import type { Middleware } from 'redux';
+import type { IMiddlewareRegistry, MiddlewareRegistration } from '@amk/ui-store-api';
+
+export class MiddlewareRegistry implements IMiddlewareRegistry {
+  private registrations = new Map<string, MiddlewareRegistration>();
+  private locked = false;
+
+  register(registration: MiddlewareRegistration): void {
+    if (this.locked) {
+      throw new Error(
+        `Cannot register middleware "${registration.id}" - store already created. ` +
+        `Register middleware during plugin initialization phase.`
+      );
+    }
+
+    if (this.registrations.has(registration.id)) {
+      console.warn(`[MiddlewareRegistry] Middleware "${registration.id}" already registered, overwriting.`);
+    }
+
+    this.registrations.set(registration.id, {
+      priority: 0,
+      ...registration,
+    });
+  }
+
+  unregister(id: string): void {
+    if (this.locked) {
+      throw new Error(`Cannot unregister middleware after store creation`);
+    }
+    this.registrations.delete(id);
+  }
+
+  getAll(): Middleware[] {
+    const sorted = Array.from(this.registrations.values())
+      .sort((a, b) => (b.priority || 0) - (a.priority || 0));
+
+    return sorted.map(reg => reg.middleware);
+  }
+
+  has(id: string): boolean {
+    return this.registrations.has(id);
+  }
+
+  getInfo(id: string): MiddlewareRegistration | undefined {
+    return this.registrations.get(id);
+  }
+
+  getAllRegistrations(): MiddlewareRegistration[] {
+    return Array.from(this.registrations.values())
+      .sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  }
+
+  /**
+   * Lock the registry (called when store is created)
+   * @internal
+   */
+  lock(): void {
+    this.locked = true;
+  }
+}

package/src/core/reducer-registry.test.ts

@@ -0,0 +1,215 @@
+/**
+ * ReducerRegistry Tests
+ */
+
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { ReducerRegistry } from './reducer-registry';
+import type { Reducer } from 'redux';
+
+describe('ReducerRegistry', () => {
+  let registry: ReducerRegistry;
+  let onReducerChange: ReturnType<typeof mock>;
+
+  beforeEach(() => {
+    onReducerChange = mock(() => {});
+    registry = new ReducerRegistry(onReducerChange);
+  });
+
+  describe('register', () => {
+    test('should register a reducer', () => {
+      const reducer: Reducer = (state = {}) => state;
+
+      registry.register('test', reducer);
+
+      expect(registry.has('test')).toBe(true);
+    });
+
+    test('should call onReducerChange when reducer is registered', () => {
+      const reducer: Reducer = (state = {}) => state;
+
+      registry.register('test', reducer);
+
+      expect(onReducerChange).toHaveBeenCalled();
+    });
+
+    test('should replace existing reducer when replace flag is true', () => {
+      const reducer1: Reducer = (state = { value: 1 }) => state;
+      const reducer2: Reducer = (state = { value: 2 }) => state;
+
+      registry.register('test', reducer1);
+      registry.register('test', reducer2, true);
+
+      expect(registry.has('test')).toBe(true);
+      expect(onReducerChange).toHaveBeenCalledTimes(2);
+    });
+
+    test('should warn when replacing without replace flag', () => {
+      const reducer1: Reducer = (state = {}) => state;
+      const reducer2: Reducer = (state = {}) => state;
+
+      registry.register('test', reducer1);
+
+      // Should not replace - just warn
+      registry.register('test', reducer2, false);
+
+      // Reducer should still be the first one
+      const info = registry.getInfo('test');
+      expect(info?.reducer).toBe(reducer1);
+    });
+
+    test('should not call onReducerChange when no callback provided', () => {
+      const registryWithoutCallback = new ReducerRegistry();
+      const reducer: Reducer = (state = {}) => state;
+
+      expect(() => registryWithoutCallback.register('test', reducer)).not.toThrow();
+    });
+  });
+
+  describe('unregister', () => {
+    test('should unregister a reducer', () => {
+      const reducer: Reducer = (state = {}) => state;
+      registry.register('test', reducer);
+
+      registry.unregister('test');
+
+      expect(registry.has('test')).toBe(false);
+    });
+
+    test('should call onReducerChange when reducer is unregistered', () => {
+      const reducer: Reducer = (state = {}) => state;
+      registry.register('test', reducer);
+      onReducerChange.mockClear();
+
+      registry.unregister('test');
+
+      expect(onReducerChange).toHaveBeenCalled();
+    });
+
+    test('should not throw when unregistering non-existent reducer', () => {
+      expect(() => registry.unregister('non-existent')).not.toThrow();
+    });
+  });
+
+  describe('has', () => {
+    test('should return false for non-existent reducer', () => {
+      expect(registry.has('non-existent')).toBe(false);
+    });
+
+    test('should return true for registered reducer', () => {
+      const reducer: Reducer = (state = {}) => state;
+      registry.register('test', reducer);
+
+      expect(registry.has('test')).toBe(true);
+    });
+  });
+
+  describe('getInfo', () => {
+    test('should return undefined for non-existent reducer', () => {
+      expect(registry.getInfo('non-existent')).toBeUndefined();
+    });
+
+    test('should return registration info for existing key', () => {
+      const reducer: Reducer = (state = {}) => state;
+      registry.register('test', reducer);
+
+      const info = registry.getInfo('test');
+      expect(info?.reducer).toBe(reducer);
+      expect(info?.key).toBe('test');
+      expect(info?.registeredAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('getAll', () => {
+    test('should return empty object when no reducers registered', () => {
+      expect(registry.getAll()).toEqual({});
+    });
+
+    test('should return all reducers as an object', () => {
+      const reducer1: Reducer = (state = {}) => state;
+      const reducer2: Reducer = (state = {}) => state;
+
+      registry.register('first', reducer1);
+      registry.register('second', reducer2);
+
+      const all = registry.getAll();
+
+      expect(all).toEqual({
+        first: reducer1,
+        second: reducer2,
+      });
+    });
+  });
+
+  describe('getAllRegistrations', () => {
+    test('should return empty array when no reducers registered', () => {
+      expect(registry.getAllRegistrations()).toEqual([]);
+    });
+
+    test('should return all registrations with metadata', () => {
+      const reducer1: Reducer = (state = {}) => state;
+      const reducer2: Reducer = (state = {}) => state;
+
+      registry.register('first', reducer1);
+      registry.register('second', reducer2);
+
+      const registrations = registry.getAllRegistrations();
+
+      expect(registrations.length).toBe(2);
+      expect(registrations[0]).toHaveProperty('key');
+      expect(registrations[0]).toHaveProperty('reducer');
+      expect(registrations[0]).toHaveProperty('registeredAt');
+      expect(registrations[0].registeredAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('getCombinedReducer', () => {
+    test('should return identity reducer when no reducers registered', () => {
+      const combined = registry.getCombinedReducer();
+      const state = { test: 'value' };
+
+      expect(combined(state, { type: 'TEST' })).toEqual(state);
+    });
+
+    test('should combine multiple reducers', () => {
+      const counterReducer: Reducer = (state = 0, action: any) => {
+        if (action.type === 'INCREMENT') return state + 1;
+        return state;
+      };
+
+      const nameReducer: Reducer = (state = '', action: any) => {
+        if (action.type === 'SET_NAME') return action.payload;
+        return state;
+      };
+
+      registry.register('counter', counterReducer);
+      registry.register('name', nameReducer);
+
+      const combined = registry.getCombinedReducer();
+      let state = combined(undefined, { type: '@@INIT' });
+
+      expect(state).toEqual({ counter: 0, name: '' });
+
+      state = combined(state, { type: 'INCREMENT' });
+      expect(state).toEqual({ counter: 1, name: '' });
+
+      state = combined(state, { type: 'SET_NAME', payload: 'Test' });
+      expect(state).toEqual({ counter: 1, name: 'Test' });
+    });
+
+    test('should update combined reducer when new reducer is registered', () => {
+      const reducer1: Reducer = (state = 1) => state;
+      registry.register('first', reducer1);
+
+      const combined1 = registry.getCombinedReducer();
+      const state1 = combined1(undefined, { type: '@@INIT' });
+      expect(state1).toEqual({ first: 1 });
+
+      const reducer2: Reducer = (state = 2) => state;
+      registry.register('second', reducer2);
+
+      const combined2 = registry.getCombinedReducer();
+      const state2 = combined2(undefined, { type: '@@INIT' });
+      expect(state2).toEqual({ first: 1, second: 2 });
+    });
+  });
+});

package/src/core/reducer-registry.ts

@@ -0,0 +1,71 @@
+/**
+ * Reducer Registry Implementation
+ */
+
+import { combineReducers, type Reducer } from 'redux';
+import type { IReducerRegistry, ReducerMap, ReducerRegistration } from '@amk/ui-store-api';
+
+export class ReducerRegistry implements IReducerRegistry {
+  private reducers = new Map<string, ReducerRegistration>();
+  private onReducerChange?: (rootReducer: Reducer) => void;
+
+  constructor(onReducerChange?: (rootReducer: Reducer) => void) {
+    this.onReducerChange = onReducerChange;
+  }
+
+  register(key: string, reducer: Reducer, replace = false): void {
+    if (!replace && this.reducers.has(key)) {
+      console.warn(`[ReducerRegistry] Reducer "${key}" already registered. Use replace=true to override.`);
+      return;
+    }
+
+    this.reducers.set(key, {
+      key,
+      reducer,
+      registeredAt: new Date(),
+    });
+
+    // Notify about reducer change for hot replacement
+    if (this.onReducerChange) {
+      this.onReducerChange(this.getCombinedReducer());
+    }
+  }
+
+  unregister(key: string): void {
+    this.reducers.delete(key);
+
+    if (this.onReducerChange) {
+      this.onReducerChange(this.getCombinedReducer());
+    }
+  }
+
+  getAll(): ReducerMap {
+    const map: ReducerMap = {};
+    this.reducers.forEach((registration, key) => {
+      map[key] = registration.reducer;
+    });
+    return map;
+  }
+
+  getCombinedReducer(): Reducer {
+    const reducerMap = this.getAll();
+
+    if (Object.keys(reducerMap).length === 0) {
+      return (state = {}) => state;
+    }
+
+    return combineReducers(reducerMap);
+  }
+
+  has(key: string): boolean {
+    return this.reducers.has(key);
+  }
+
+  getInfo(key: string): ReducerRegistration | undefined {
+    return this.reducers.get(key);
+  }
+
+  getAllRegistrations(): ReducerRegistration[] {
+    return Array.from(this.reducers.values());
+  }
+}