@plyaz/types 1.9.1 → 1.9.3

package/dist/api/index.d.ts

@@ -38,6 +38,7 @@ export type * from './config/types';
 export type * from './utils/types';
 export type * from './pubsub/types';
 export type * from './hooks/types';
+export type * from './services/types';
 export type * from './endpoints/types';
 export type * from './endpoints/health/types';
 export type * from './endpoints/campaigns/types';

package/dist/api/services/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Service Layer Types
+ * Core types for service functions and configuration
+ */
+import type { ApiClientWithEvents, UpdateConfigOptions } from '../client/types';
+import type { ApiConfig } from '../config';
+/**
+ * Options for service functions
+ * Allows overriding the API client instance, temporary config updates, and update strategy
+ *
+ * By default, services use a shared client instance with all available endpoints.
+ * This interface allows customization of the client behavior per-request or permanently.
+ *
+ * @template TEndpoints - The endpoints type for the API client
+ *
+ * @example
+ * ```typescript
+ * // Use default client (has access to all endpoints internally)
+ * const campaign = await fetchCampaign('123');
+ *
+ * // Override timeout temporarily (uses temporary config mode by default)
+ * const campaign = await fetchCampaign('123', {
+ *   apiConfig: { timeout: 5000 }
+ * });
+ *
+ * // Override with different update strategy
+ * const campaign = await fetchCampaign('123', {
+ *   apiConfig: { timeout: 5000 },
+ *   updateConfigOptions: { strategy: 'merge', scope: 'client' }
+ * });
+ *
+ * // Use custom client instance (rare - usually for testing)
+ * const customClient = await createApiClient({ baseURL: 'https://staging.api.com' });
+ * const campaign = await fetchCampaign('123', {
+ *   apiClient: customClient,
+ *   apiConfig: { retry: { attempts: 5 } }
+ * });
+ * ```
+ */
+export interface ServiceOptions<TEndpoints = unknown, TEventManager = unknown> {
+    /**
+     * Optional API client instance override
+     * Use this when you need a different client configuration
+     * The client should have all required endpoints for the service
+     */
+    apiClient?: ApiClientWithEvents<TEventManager, TEndpoints>;
+    /**
+     * Optional API configuration updates
+     * By default applied with { strategy: 'temporary' } mode (affects only this request)
+     * Can be overridden via updateConfigOptions
+     */
+    apiConfig?: Partial<ApiConfig>;
+    /**
+     * Optional update config options
+     * Controls how apiConfig is applied to the client
+     *
+     * Defaults to: { strategy: 'temporary' }
+     * - 'temporary': Only affects this request (highest priority)
+     * - 'merge': Merges with client config (persists)
+     * - 'replace': Replaces client config (persists)
+     */
+    updateConfigOptions?: UpdateConfigOptions;
+}

package/dist/logger/types.d.ts

@@ -1,3 +1,4 @@
+import type pino from 'pino';
 export interface LoggerInterface {
     debug(message: string, ...supportingDetials: unknown[]): void;
     info(message: string, ...supportingDetials: unknown[]): void;
@@ -7,3 +8,48 @@ export interface LoggerInterface {
 }
 export type LoggerMethodTypes = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 export type LoggerEnvironment = 'development' | 'production';
+/**
+ * Infers the parameter types for a specific logger method from the `pino.Logger` interface.
+ *
+ * @template T - The logger method name (e.g., `'info'`, `'error'`, `'warn'`, `'debug'`, `'fatal'`, `'trace'`).
+ *
+ * @description
+ * This utility type extracts the argument list of a given logger method dynamically.
+ * For example, if `T` is `'info'`, it will return the tuple type of parameters accepted by `pino.info()`.
+ *
+ * - It leverages TypeScript’s `infer` keyword to capture parameter types.
+ * - It returns a tuple type representing those arguments.
+ * - It never falls back to `any` or `unknown` — ensuring strict typing.
+ *
+ * @example
+ * ```ts
+ * type InfoArgs = LoggerFnArgs<'info'>;
+ * // => same as Parameters<pino.Logger['info']>
+ * ```
+ */
+export type LoggerFnArgs<T extends LoggerMethodTypes> = pino.Logger<'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'trace', boolean>[T] extends (...args: infer A) => void ? A : never;
+/**
+ * Defines the structure of the Logger React Context.
+ *
+ * @description
+ * Provides a generic, strongly-typed logging function that mirrors `pino`’s
+ * available log methods (`debug`, `info`, `warn`, `error`, `fatal`, `trace`).
+ *
+ * This ensures that:
+ * - Each log method infers the correct argument types.
+ * - No `any` or `unknown` is used anywhere in the type definitions.
+ *
+ * @template T - The specific log level method name.
+ *
+ * @example
+ * ```ts
+ * const context: LoggerContextType = {
+ *   log: (level, ...args) => {
+ *     // example usage: log('info', 'User created', { id: 123 });
+ *   },
+ * };
+ * ```
+ */
+export type LoggerContextType = {
+    log: <T extends LoggerMethodTypes>(level: T, ...args: LoggerFnArgs<T>) => void;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plyaz/types",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "author": "Redeemer Pace",
   "license": "ISC",
   "description": "Provides shared TypeScript types and schema utilities for validation and parsing in the @playz ecosystem.",
@@ -172,6 +172,7 @@
   "keywords": [],
   "packageManager": "pnpm@10.11.0",
   "dependencies": {
+    "pino": "^10.0.0",
     "type-fest": "^4.41.0"
   },
   "devDependencies": {