@plyaz/types 1.22.4 → 1.22.5

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

@@ -4,7 +4,6 @@
  * Type definitions for frontend domain services with store integration.
  */
 import type { ReactNode } from 'react';
-import type { StoreKey } from '../../store';
 import type { CoreBaseDomainServiceInterface } from '../domain';
 import type { CoreAppEnvironment, CoreAppContext } from '../modules';
 import type { FeatureFlagValue, FeatureFlagContext } from '../../features';
@@ -531,16 +530,22 @@ export interface CoreStoreHandlers<TData = Record<string, unknown>, TStore exten
  * Configuration for frontend domain services
  */
 export interface CoreBaseFrontendServiceConfig<TData = Record<string, unknown>, TStore extends CoreBaseFrontendStore<TData> = CoreBaseFrontendStore<TData>> extends CoreBaseDomainServiceConfig {
-    /** Single store to connect on initialization */
-    store?: TStore;
-    /** Multiple stores to connect on initialization */
-    stores?: TStore[];
     /**
-     * Store keys this service should connect to.
-     * Must be a subset of the service's `allowedStoreKeys`.
-     * If not specified, no stores are connected (warning logged).
+     * 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.
+     *
+     * @example 'campaigns'
+     */
+    store?: string;
+    /**
+     * 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).
+     *
+     * @example ['users', 'error', 'featureFlags']
      */
-    storeKeys?: StoreKey[];
+    readStores?: string[];
     /** 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

@@ -5,7 +5,6 @@
  * Services must implement these interfaces to be auto-initialized.
  */
 import type { ApiClientOptions } from '../../api';
-import type { StoreKey } from '../../store';
 import type { FeatureFlagValue, FeatureFlagPollingConfig, CacheStrategyType } from '../../features';
 import type { PackageErrorLike, MessageCatalog } from '../../errors';
 import type { GlobalErrorHandlerConfig, ErrorHandlerLogger } from '../../errors/middleware';
@@ -35,22 +34,25 @@ export interface CoreServiceInitConfig {
     /** Whether the service is enabled (default: true) */
     enabled?: boolean;
     /**
-     * Store keys this service should connect to.
-     *
-     * Each frontend service can specify which stores it needs access to.
-     * The service's `allowedStoreKeys` static property defines valid options.
-     * If not specified, no stores will be connected (warning logged).
+     * Primary store key - the main store this service can mutate.
+     * The service can call setData(), updateData(), setLoading() on this store.
      *
      * @example
      * ```typescript
-     * // Service that uses error and featureFlags stores
-     * { service: MyService, config: { storeKeys: ['error', 'featureFlags'] } }
+     * { service: CampaignService, config: { store: 'campaigns' } }
+     * ```
+     */
+    store?: string;
+    /**
+     * 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).
      *
-     * // Service that only uses error store
-     * { service: AnotherService, config: { storeKeys: ['error'] } }
+     * @example
+     * ```typescript
+     * { service: CampaignService, config: { store: 'campaigns', readStores: ['users', 'error'] } }
      * ```
      */
-    storeKeys?: StoreKey[];
+    readStores?: string[];
     /**
      * When to initialize the service:
      * - 'immediate': Initialize during Core.initialize() (default)
@@ -303,11 +305,6 @@ export interface CoreServiceCreateOptions<TConfig = unknown, TMapper = unknown,
     loggerPrefix?: string;
     /** Whether this is a singleton instance */
     isSingleton?: boolean;
-    /**
-     * Store keys this service should connect to.
-     * Passed from the service config to the create method.
-     */
-    storeKeys?: StoreKey[];
     /**
      * Injected service instances (cache, db, api).
      * Services built by ServiceRegistry will receive these automatically.
@@ -387,6 +384,16 @@ export interface CoreServiceRegistryConfig {
     db?: Partial<CoreDbServiceConfig>;
     /** Global cache config (shared by all services unless overridden) */
     cache?: CoreCacheConfig;
+    /**
+     * Store registry interface for injecting stores into services.
+     * Provides type-safe store access via generics.
+     *
+     * @see StoreTypeMap 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;
+    };
     /** Services to register and initialize */
     services: CoreServiceEntry[];
 }

package/dist/examples/index.d.ts

@@ -14,4 +14,4 @@
  * ```
  */
 export { CreateExampleSchema, UpdateExampleSchema, PatchExampleSchema, QueryExampleSchema, DeleteExampleSchema, ExampleResponseSchema, ExampleListResponseSchema, } from './schemas';
-export type { CreateExampleDTO, UpdateExampleDTO, PatchExampleDTO, QueryExampleDTO, DeleteExampleDTO, ExampleResponseDTO, ExampleListResponseDTO, ExampleEntity, ExampleStoreItem, ExampleStoreState, ExampleCreatedPayload, ExampleUpdatedPayload, ExampleDeletedPayload, ExampleValidationFailedPayload, ExampleFrontendStoreData, ExampleFrontendStore, ExampleFrontendServiceConfig, ExampleFrontendEventType, ExampleUser, ExampleDomainServiceConfig, } from './types';
+export type { CreateExampleDTO, UpdateExampleDTO, PatchExampleDTO, QueryExampleDTO, DeleteExampleDTO, ExampleResponseDTO, ExampleListResponseDTO, ExampleEntity, ExampleStoreItem, ExampleStoreState, ExampleCreatedPayload, ExampleUpdatedPayload, ExampleDeletedPayload, ExampleValidationFailedPayload, ExampleFrontendStoreData, ExampleFrontendStoreState, ExampleFrontendStoreActions, ExampleFrontendStoreSlice, ExampleFrontendServiceConfig, ExampleFrontendEventType, ExampleUser, ExampleDomainServiceConfig, } from './types';

package/dist/examples/types.d.ts

@@ -111,25 +111,41 @@ export interface ExampleFrontendStoreData {
     selectedId: string | null;
 }
 /**
- * Example frontend store interface (Zustand-compatible)
+ * Example frontend store state shape.
  */
-export interface ExampleFrontendStore extends CoreBaseFrontendStore<ExampleFrontendStoreData> {
+export interface ExampleFrontendStoreState {
+    /** Array of example items */
     items: ExampleEntity[];
+    /** Currently selected item ID */
     selectedId: string | null;
+    /** Loading state */
     isLoading: boolean;
-    setData(data: ExampleFrontendStoreData): void;
-    updateData?(data: Partial<ExampleFrontendStoreData>): void;
-    setLoading(isLoading: boolean): void;
-    setItems(items: ExampleEntity[]): void;
-    addItem(item: ExampleEntity): void;
-    updateItem(id: string, updates: Partial<ExampleEntity>): void;
-    removeItem(id: string): void;
-    selectItem(id: string | null): void;
+}
+/**
+ * Example frontend store actions.
+ * Extends CoreBaseFrontendStore to ensure required methods are present.
+ */
+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;
+}
+/**
+ * Complete example frontend store slice (state + actions).
+ */
+export interface ExampleFrontendStoreSlice extends ExampleFrontendStoreState, ExampleFrontendStoreActions {
 }
 /**
  * Example Frontend Service Configuration
  */
-export interface ExampleFrontendServiceConfig extends CoreBaseFrontendServiceConfig<ExampleFrontendStoreData, ExampleFrontendStore>, CoreServiceInitConfig {
+export interface ExampleFrontendServiceConfig extends CoreBaseFrontendServiceConfig<ExampleFrontendStoreData, ExampleFrontendStoreSlice>, CoreServiceInitConfig {
     /** API base path for example endpoints */
     apiBasePath?: string;
     /** Auto-fetch on initialization */

package/dist/store/types.d.ts

@@ -8,6 +8,7 @@
  */
 import type { SerializedError, ErrorStoreActions, ErrorStoreSlice } from '../errors/store';
 import type { FeatureFlagStoreState, FeatureFlagStoreSlice } from '../features/feature-flag/store.types';
+import type { ExampleFrontendStoreSlice } from '../examples';
 /**
  * Configuration for creating an error store.
  */
@@ -55,9 +56,49 @@ export interface FeatureFlagStoreConfig {
 }
 /**
  * Combined root store state and actions.
- * Merges all slice types into a single store interface.
+ * Merges ALL slice types into a single store interface.
+ *
+ * **Architecture:**
+ * - Global slices: error, featureFlags (always included)
+ * - Domain slices: example, campaigns, users, etc. (add as needed)
+ *
+ * **Benefits of 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.
+ *
+ * Add new stores here for type-safe store access:
+ * @example
+ * ```typescript
+ * const exampleStore = getStore<'example'>('example'); // Fully typed!
+ * ```
  */
-export type RootStoreSlice = ErrorStoreSlice & FeatureFlagStoreSlice;
+export interface StoreTypeMap {
+    /** Error store - global error tracking (root store slice) */
+    error: ErrorStoreSlice;
+    /** Feature flags store - global feature flag state (root store slice) */
+    featureFlags: FeatureFlagStoreSlice;
+    /** Example store - example domain store (demonstrates pattern) */
+    example: ExampleFrontendStoreSlice;
+}
+/**
+ * Type-safe store registry interface.
+ * Use this for dependency injection of stores.
+ */
+export interface StoreRegistry {
+    /**
+     * Get a store by key with full type safety.
+     * @param key - Store key from STORE_KEYS
+     * @returns Typed store instance or undefined
+     */
+    getStore<K extends keyof StoreTypeMap>(key: K): StoreTypeMap[K] | undefined;
+}
 /**
  * Configuration for creating the root store.
  */

package/package.json

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