@plyaz/types 1.22.5 → 1.22.7

package/dist/core/domain/types.d.ts

@@ -107,13 +107,19 @@ export type CoreValidatorClass<T extends CoreBaseValidatorInstance = CoreBaseVal
  * Injected services/dependencies for domain services.
  * These are created/managed by ServiceRegistry and injected into services.
  */
-export interface CoreInjectedServices {
+export interface CoreInjectedServices<TStores = unknown> {
     /** Cache manager instance */
     cache?: unknown;
     /** Database service instance */
     db?: unknown;
     /** API client instance */
     api?: unknown;
+    /**
+     * Store instances (from root store) keyed by store key.
+     * Type-safe: each key maps to its specific slice type.
+     * @example { example: ExampleStoreSlice, errors: ErrorStoreSlice }
+     */
+    stores?: TStores extends Record<string, unknown> ? Partial<TStores> : Record<string, TStores>;
 }
 /**
  * Base service configuration passed to constructor

package/dist/core/frontend/featureFlags.d.ts

@@ -53,15 +53,12 @@ export interface CoreFeatureFlagServiceInitConfig extends CoreBaseFrontendServic
 }
 /**
  * Base interface for frontend services with store integration
+ *
+ * Note: In the single root store architecture, stores are auto-injected
+ * by ServiceRegistry. Services no longer manually connect/disconnect stores.
  */
 export interface CoreBaseFrontendServiceInterface<TStore extends CoreBaseFrontendStore = CoreBaseFrontendStore> extends CoreBaseDomainServiceInterface {
-    /** Connect a store to receive updates */
-    connectStore(store: TStore): void;
-    /** Disconnect a store from receiving updates */
-    disconnectStore(store: TStore): void;
-    /** Disconnect all connected stores */
-    disconnectAllStores(): void;
-    /** Number of connected stores */
+    /** Number of connected stores (primary + read stores) */
     readonly connectedStoreCount: number;
     /** Whether any stores are connected */
     readonly hasConnectedStores: boolean;

package/dist/core/frontend/types.d.ts

@@ -7,6 +7,7 @@ import type { ReactNode } from 'react';
 import type { CoreBaseDomainServiceInterface } from '../domain';
 import type { CoreAppEnvironment, CoreAppContext } from '../modules';
 import type { FeatureFlagValue, FeatureFlagContext } from '../../features';
+import type { RootStoreSlice } from '../../store';
 import type { CoreBaseDomainServiceConfig } from '../domain';
 import type { CoreBaseServiceConfig, CoreBaseMapperInstance, CoreBaseValidatorInstance } from '../domain';
 import type { CoreDomainServiceInstance, CoreServiceEntry } from '../init';
@@ -40,36 +41,28 @@ import type { CoreDomainServiceInstance, CoreServiceEntry } from '../init';
  *   selectedId: string | null;
  * }
  *
+ * // Extend CoreBaseFrontendStore - all CRUD methods included in base
  * interface MyStore extends CoreBaseFrontendStore<MyStoreData> {
  *   items: MyEntity[];
  *   selectedId: string | null;
  *   isLoading: boolean;
- *
- *   // Required by CoreBaseFrontendStore
- *   setData: (data: MyStoreData) => void;
- *   updateData: (data: Partial<MyStoreData>) => void;
- *   setLoading: (isLoading: boolean) => void;
- *
- *   // Domain-specific methods
- *   addItem: (item: MyEntity) => void;
- *   updateItem: (id: string, item: MyEntity) => void;
- *   removeItem: (id: string) => void;
  * }
  *
- * export const useMyStore = create<MyStore>((set) => ({
+ * export const useMyStore = create<MyStore>((set, get) => ({
  *   items: [],
  *   selectedId: null,
  *   isLoading: false,
  *
+ *   // CoreBaseFrontendStore methods
+ *   getData: () => ({ items: get().items, selectedId: get().selectedId }),
  *   setData: (data) => set({ items: data.items, selectedId: data.selectedId }),
  *   updateData: (data) => set((state) => ({ ...state, ...data })),
  *   setLoading: (isLoading) => set({ isLoading }),
- *
- *   addItem: (item) => set((state) => ({ items: [...state.items, item] })),
- *   updateItem: (id, item) => set((state) => ({
- *     items: state.items.map((i) => (i.id === id ? item : i)),
+ *   addData: (item) => set((state) => ({ items: [...state.items, item] })),
+ *   updateDataById: (id, item) => set((state) => ({
+ *     items: state.items.map((i) => i.id === id ? { ...i, ...item } : i),
  *   })),
- *   removeItem: (id) => set((state) => ({
+ *   removeData: (id) => set((state) => ({
  *     items: state.items.filter((i) => i.id !== id),
  *   })),
  * }));
@@ -78,8 +71,9 @@ import type { CoreDomainServiceInstance, CoreServiceEntry } from '../init';
  * ## Service Integration
  * Services automatically call these methods after successful operations:
  * - After `fetchAll()` → calls `setData()` with full dataset
- * - After `create()` → service calls custom `addItem()` in `afterCreate` hook
- * - After `update()` → service calls custom `updateItem()` in `afterUpdate` hook
+ * - After `create()` → calls `addData()` to append new item
+ * - After `update()` → calls `updateDataById()` to update specific item
+ * - After `delete()` → calls `removeData()` to remove item
  * - Before any operation → calls `setLoading(true)`
  * - After operation completes → calls `setLoading(false)`
  *
@@ -89,6 +83,20 @@ import type { CoreDomainServiceInstance, CoreServiceEntry } from '../init';
  * @see {@link BaseFrontendDomainService} for service implementation
  */
 export interface CoreBaseFrontendStore<TData = Record<string, unknown>> {
+    /**
+     * Get current store data.
+     *
+     * Used by services to read current state for operations like delete
+     * (filter out item) or optimistic updates.
+     *
+     * @returns Current data object
+     *
+     * @example
+     * ```typescript
+     * getData: () => ({ items: get().items, selectedId: get().selectedId })
+     * ```
+     */
+    getData?(): TData;
     /**
      * Set/replace all data in the store (full replacement).
      *
@@ -132,6 +140,55 @@ export interface CoreBaseFrontendStore<TData = Record<string, unknown>> {
      * ```
      */
     setLoading?(isLoading: boolean): void;
+    /**
+     * Add data to store (append to array).
+     *
+     * Called by services after successful create operations.
+     * Store implementation handles appending to the items array.
+     *
+     * @param item - Item to add
+     *
+     * @example
+     * ```typescript
+     * addData: (item) => set((state) => ({
+     *   items: [...state.items, item]
+     * }))
+     * ```
+     */
+    addData?(item: unknown): void;
+    /**
+     * Update data in store by ID.
+     *
+     * Called by services after successful update operations.
+     * Store implementation handles finding and updating the specific item.
+     *
+     * @param id - Item ID to update
+     * @param item - Updated item data
+     *
+     * @example
+     * ```typescript
+     * updateDataById: (id, item) => set((state) => ({
+     *   items: state.items.map((i) => i.id === id ? { ...i, ...item } : i)
+     * }))
+     * ```
+     */
+    updateDataById?(id: string, item: unknown): void;
+    /**
+     * Remove data from store by ID.
+     *
+     * Called by services after successful delete operations.
+     * Store implementation handles filtering out the item.
+     *
+     * @param id - Item ID to remove
+     *
+     * @example
+     * ```typescript
+     * removeData: (id) => set((state) => ({
+     *   items: state.items.filter((item) => item.id !== id)
+     * }))
+     * ```
+     */
+    removeData?(id: string): void;
 }
 /**
  * Fetcher function type for API operations
@@ -525,6 +582,61 @@ export interface CoreStoreHandlers<TData = Record<string, unknown>, TStore exten
      * ```
      */
     setLoading?: (store: TStore, isLoading: boolean) => void;
+    /**
+     * Custom handler for adding data to store.
+     *
+     * Replaces the default `store.addData(item)` call.
+     * Called during create operations.
+     *
+     * @param store - Store instance
+     * @param item - Item to add
+     *
+     * @example
+     * ```typescript
+     * addData: (store, item) => {
+     *   store.appendItem(item);
+     *   store.setLastCreated(item.id);
+     * }
+     * ```
+     */
+    addData?: (store: TStore, item: unknown) => void;
+    /**
+     * Custom handler for updating data by ID.
+     *
+     * Replaces the default `store.updateDataById(id, item)` call.
+     * Called during update operations.
+     *
+     * @param store - Store instance
+     * @param id - Item ID to update
+     * @param item - Updated item data
+     *
+     * @example
+     * ```typescript
+     * updateDataById: (store, id, item) => {
+     *   store.updateItemById(id, item);
+     *   store.setLastUpdated(id);
+     * }
+     * ```
+     */
+    updateDataById?: (store: TStore, id: string, item: unknown) => void;
+    /**
+     * Custom handler for removing data by ID.
+     *
+     * Replaces the default `store.removeData(id)` call.
+     * Called during delete operations.
+     *
+     * @param store - Store instance
+     * @param id - Item ID to remove
+     *
+     * @example
+     * ```typescript
+     * removeData: (store, id) => {
+     *   store.removeItemById(id);
+     *   store.clearSelection();
+     * }
+     * ```
+     */
+    removeData?: (store: TStore, id: string) => void;
 }
 /**
  * Configuration for frontend domain services
@@ -533,19 +645,20 @@ export interface CoreBaseFrontendServiceConfig<TData = Record<string, unknown>,
     /**
      * Primary store key - the main store this service can mutate.
      * Service can call setData(), updateData(), setLoading() on this store.
-     * Must be a valid store key from the service's allowedStoreKeys.
+     * Type-safe: only valid store keys from RootStoreSlice allowed.
      *
-     * @example 'campaigns'
+     * @example 'example'
      */
-    store?: string;
+    store?: keyof RootStoreSlice;
     /**
      * Read-only store keys - stores this service can read from but not mutate.
      * Service can access state but should not call mutation methods.
      * Used for cross-domain data access (e.g., campaign service reading user data).
+     * Type-safe: only valid store keys from RootStoreSlice allowed.
      *
-     * @example ['users', 'error', 'featureFlags']
+     * @example ['errors', 'featureFlags']
      */
-    readStores?: string[];
+    readStores?: (keyof RootStoreSlice)[];
     /** API base path for endpoints (e.g., '/api/examples') */
     apiBasePath?: string;
     /** Fetcher functions for API operations (replaces direct apiClient usage) */

package/dist/core/init/types.d.ts

@@ -8,6 +8,7 @@ import type { ApiClientOptions } from '../../api';
 import type { FeatureFlagValue, FeatureFlagPollingConfig, CacheStrategyType } from '../../features';
 import type { PackageErrorLike, MessageCatalog } from '../../errors';
 import type { GlobalErrorHandlerConfig, ErrorHandlerLogger } from '../../errors/middleware';
+import type { RootStoreSlice } from '../../store';
 import type { CoreAppEnvironment, CoreAppContext, CoreRuntimeEnvironment, CoreServiceRuntime } from '../modules';
 import type { CoreDbServiceConfig } from '../services';
 import type { CoreInjectedServices } from '../domain';
@@ -36,23 +37,25 @@ export interface CoreServiceInitConfig {
     /**
      * Primary store key - the main store this service can mutate.
      * The service can call setData(), updateData(), setLoading() on this store.
+     * Type-safe: only valid store keys allowed.
      *
      * @example
      * ```typescript
      * { service: CampaignService, config: { store: 'campaigns' } }
      * ```
      */
-    store?: string;
+    store?: keyof RootStoreSlice;
     /**
      * Read-only store keys - stores this service can read from but not mutate.
      * Used for cross-domain data access (e.g., campaign service reading user data).
+     * Type-safe: only valid store keys allowed.
      *
      * @example
      * ```typescript
-     * { service: CampaignService, config: { store: 'campaigns', readStores: ['users', 'error'] } }
+     * { service: CampaignService, config: { store: 'campaigns', readStores: ['users', 'errors'] } }
      * ```
      */
-    readStores?: string[];
+    readStores?: (keyof RootStoreSlice)[];
     /**
      * When to initialize the service:
      * - 'immediate': Initialize during Core.initialize() (default)
@@ -386,13 +389,17 @@ export interface CoreServiceRegistryConfig {
     cache?: CoreCacheConfig;
     /**
      * Store registry interface for injecting stores into services.
-     * Provides type-safe store access via generics.
+     * Provides type-safe store access via store keys.
      *
-     * @see StoreTypeMap in @plyaz/types/store for available stores
+     * @see RootStoreSlice in @plyaz/types/store for available stores
      */
     stores?: {
-        /** Get a store by key with full type safety via generics */
-        getStore<T = unknown>(key: string): T | undefined;
+        /**
+         * Get a store slice by key with full type safety.
+         * @param key - Store key (e.g., 'example', 'errors', 'featureFlags')
+         * @returns Typed store slice or undefined
+         */
+        getStore<K extends keyof RootStoreSlice>(key: K): RootStoreSlice[K] | undefined;
     };
     /** Services to register and initialize */
     services: CoreServiceEntry[];

package/dist/examples/types.d.ts

@@ -123,17 +123,9 @@ export interface ExampleFrontendStoreState {
 }
 /**
  * Example frontend store actions.
- * Extends CoreBaseFrontendStore to ensure required methods are present.
+ * Extends CoreBaseFrontendStore which provides all CRUD methods.
  */
 export interface ExampleFrontendStoreActions extends CoreBaseFrontendStore<ExampleFrontendStoreData> {
-    /** Set items array */
-    setItems: (items: ExampleEntity[]) => void;
-    /** Add a single item */
-    addItem: (item: ExampleEntity) => void;
-    /** Update a single item */
-    updateItem: (id: string, updates: Partial<ExampleEntity>) => void;
-    /** Remove a single item */
-    removeItem: (id: string) => void;
     /** Select an item by ID */
     selectItem: (id: string | null) => void;
 }

package/dist/store/types.d.ts

@@ -56,35 +56,34 @@ export interface FeatureFlagStoreConfig {
 }
 /**
  * Combined root store state and actions.
- * Merges ALL slice types into a single store interface.
+ * Uses NAMESPACED structure for clear separation of slices.
  *
  * **Architecture:**
- * - Global slices: error, featureFlags (always included)
+ * - Global slices: errors, featureFlags (always included)
  * - Domain slices: example, campaigns, users, etc. (add as needed)
+ * - Each slice is namespaced under its key (e.g., store.example.items)
  *
- * **Benefits of single-store:**
+ * **Benefits of namespaced single-store:**
  * - ✅ One Zustand instance - can access without hooks
  * - ✅ Cross-slice subscriptions work automatically
  * - ✅ Single source of truth via store.getState()
- * - ✅ All slices can read/update each other
- */
-export type RootStoreSlice = ErrorStoreSlice & FeatureFlagStoreSlice & ExampleFrontendStoreSlice;
-/**
- * Type map of all available stores in the system.
- * Maps store keys to their corresponding store types.
+ * - ✅ Clear ownership - no property name conflicts
+ * - ✅ getStore(key) returns specific slice (not entire root)
  *
- * Add new stores here for type-safe store access:
  * @example
  * ```typescript
- * const exampleStore = getStore<'example'>('example'); // Fully typed!
+ * const rootStore = useRootStore();
+ * rootStore.example.items;          // Example slice
+ * rootStore.errors.errors;          // Error slice
+ * rootStore.featureFlags.flags;     // Feature flag slice
  * ```
  */
-export interface StoreTypeMap {
-    /** Error store - global error tracking (root store slice) */
-    error: ErrorStoreSlice;
-    /** Feature flags store - global feature flag state (root store slice) */
+export interface RootStoreSlice {
+    /** Error tracking slice (global) */
+    errors: ErrorStoreSlice;
+    /** Feature flags slice (global) */
     featureFlags: FeatureFlagStoreSlice;
-    /** Example store - example domain store (demonstrates pattern) */
+    /** Example domain slice */
     example: ExampleFrontendStoreSlice;
 }
 /**
@@ -93,11 +92,17 @@ export interface StoreTypeMap {
  */
 export interface StoreRegistry {
     /**
-     * Get a store by key with full type safety.
+     * Get a store slice by key with full type safety.
      * @param key - Store key from STORE_KEYS
-     * @returns Typed store instance or undefined
+     * @returns Typed store slice or undefined
+     *
+     * @example
+     * ```typescript
+     * const exampleSlice = getStore('example'); // Returns ExampleFrontendStoreSlice
+     * const errorSlice = getStore('errors');    // Returns ErrorStoreSlice
+     * ```
      */
-    getStore<K extends keyof StoreTypeMap>(key: K): StoreTypeMap[K] | undefined;
+    getStore<K extends keyof RootStoreSlice>(key: K): RootStoreSlice[K] | undefined;
 }
 /**
  * Configuration for creating the root store.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plyaz/types",
-  "version": "1.22.5",
+  "version": "1.22.7",
   "author": "Redeemer Pace",
   "license": "ISC",
   "description": "Provides shared TypeScript types and schema utilities for validation and parsing in the @playz ecosystem.",