@plyaz/api 1.0.1 → 1.1.0

package/dist/api/network/connection.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Network connection detection utilities
+ */
+import type { NetworkInfo, ConnectionType, EffectiveConnectionType } from '@plyaz/types/api';
+export declare function getNetworkInfo(headers?: HeadersInit | Record<string, string | string[]>): NetworkInfo;
+/**
+ * Get connection type
+ *
+ * @returns Connection type (wifi, cellular, etc.)
+ */
+export declare function getConnectionType(): ConnectionType;
+/**
+ * Get effective connection type (quality)
+ *
+ * @returns Effective type (4g, 3g, 2g, etc.)
+ */
+export declare function getEffectiveConnectionType(): EffectiveConnectionType;
+/**
+ * Check if on cellular connection
+ *
+ * @returns True if using cellular data
+ */
+export declare function isCellularConnection(): boolean;
+/**
+ * Check if on wifi connection
+ *
+ * @returns True if using wifi
+ */
+export declare function isWifiConnection(): boolean;
+/**
+ * Check if data saver is enabled
+ *
+ * @returns True if data saver mode is on
+ */
+export declare function isDataSaverEnabled(): boolean;
+/**
+ * Get network round-trip time (latency)
+ *
+ * @returns RTT in milliseconds or null
+ */
+export declare function getNetworkRTT(): number | null;
+/**
+ * Get network downlink speed
+ *
+ * @returns Speed in Mbps or null
+ */
+export declare function getNetworkSpeed(): number | null;
+/**
+ * Check if currently online
+ *
+ * @returns True if online
+ */
+export declare function isOnline(): boolean;
+/**
+ * Check if currently offline
+ *
+ * @returns True if offline
+ */
+export declare function isOffline(): boolean;
+//# sourceMappingURL=connection.d.ts.map

package/dist/api/network/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../src/api/network/connection.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,uBAAuB,EAExB,MAAM,kBAAkB,CAAC;AAyI1B,wBAAgB,cAAc,CAC5B,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,GACxD,WAAW,CAQb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAGlD;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,uBAAuB,CAGpE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAG5C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAG7C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAG/C;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAEnC"}

package/dist/api/network/core.d.ts

@@ -0,0 +1,26 @@
+import type { NetworkInformation } from '@plyaz/types/api';
+/**
+ * Re-export fetchff's slow connection detection
+ * Checks if user is on a slow network (2G/3G)
+ *
+ * @returns True if connection is slow
+ *
+ * @example
+ * if (isSlowConnection()) {
+ *   console.log('User on slow connection');
+ * }
+ */
+export declare const isSlowConnection: () => boolean;
+/**
+ * Check if Network Information API is supported
+ *
+ * @returns True if Network API is available
+ */
+export declare function isNetworkAPISupported(): boolean;
+/**
+ * Get network connection object
+ *
+ * @returns Network connection or null
+ */
+export declare function getConnection(): NetworkInformation | null;
+//# sourceMappingURL=core.d.ts.map

package/dist/api/network/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/api/network/core.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAA2B,MAAM,kBAAkB,CAAC;AAGpF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,eAA0B,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAK/C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,kBAAkB,GAAG,IAAI,CAWzD"}

package/dist/api/network/events.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Network Events System
+ * Event system for monitoring and responding to network changes
+ */
+import type { NetworkEventStats } from '@plyaz/types/api';
+/**
+ * Start monitoring network events
+ */
+export declare function startNetworkEventMonitoring(): () => void;
+/**
+ * Network event statistics
+ */
+/**
+ * Get network event statistics for monitoring
+ * Returns statistics from the shared event system
+ */
+export declare function getNetworkEventStats(): NetworkEventStats;
+//# sourceMappingURL=events.d.ts.map

package/dist/api/network/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/api/network/events.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,iBAAiB,EAIlB,MAAM,kBAAkB,CAAC;AAqG1B;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAgExD;AAsDD;;GAEG;AACH;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CAwBxD"}

package/dist/api/network/frameworks/express.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Express middleware for network detection and enriched headers
+ */
+import type { Request, Response, RequestHandler } from 'express';
+import type { NetworkInfo, ApiHeaders, ExpressRequestWithNetwork, EnrichedHeadersMiddlewareOptions, ExpressRequestWithEnrichedHeaders, NetworkDetectionOptions } from '@plyaz/types/api';
+/**
+ * Express middleware for network detection
+ * Adds network information to the request object and requests Client Hints from browser
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { networkDetectionMiddleware } from '@plyaz/api/utils/network/frameworks/express';
+ *
+ * const app = express();
+ *
+ * // Apply to all routes
+ * app.use(networkDetectionMiddleware);
+ *
+ * app.get('/api/data', (req: ExpressRequestWithNetwork, res) => {
+ *   const { networkInfo } = req;
+ *
+ *   if (networkInfo?.effectiveType === '4g') {
+ *     res.json({ quality: 'high', data: getHighQualityData() });
+ *   } else {
+ *     res.json({ quality: 'standard', data: getStandardData() });
+ *   }
+ * });
+ * ```
+ */
+export declare const networkDetectionMiddleware: RequestHandler;
+export declare function createNetworkDetectionMiddleware(options?: NetworkDetectionOptions): RequestHandler;
+/**
+ * Type guard to check if request has network info
+ *
+ * @param req - Request to check
+ * @returns True if request has network info
+ */
+export declare function hasNetworkInfo(req: Request | ExpressRequestWithNetwork): req is ExpressRequestWithNetwork;
+/**
+ * Express route handler wrapper that provides network info
+ *
+ * @param handler - Route handler that receives network info
+ * @returns Express route handler
+ *
+ * @example
+ * ```typescript
+ * app.get('/api/data', withNetworkInfo((req, res, networkInfo) => {
+ *   if (networkInfo?.saveData) {
+ *     return res.json({ mode: 'data-saver' });
+ *   }
+ *   return res.json({ mode: 'normal' });
+ * }));
+ * ```
+ */
+export declare function withNetworkInfo(handler: (req: Request, res: Response, networkInfo: NetworkInfo) => void | Promise<void>): RequestHandler;
+/**
+ * Express middleware for enriched context headers
+ * Collects device, network, platform, and compliance headers and sets them in AsyncLocalStorage context
+ *
+ * @param options - Middleware configuration options
+ * @returns Express middleware
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { enrichedHeadersMiddleware } from '@plyaz/api/network/frameworks/express';
+ *
+ * const app = express();
+ *
+ * // Apply enriched headers middleware
+ * app.use(enrichedHeadersMiddleware({
+ *   preset: 'standard',
+ *   includePerformance: true,
+ *   storeInLocals: true
+ * }));
+ *
+ * // Service functions will automatically have enriched headers
+ * app.get('/api/users', async (req, res) => {
+ *   const users = await fetchUsers({ page: 1 }); // Headers auto-included
+ *   res.json(users);
+ * });
+ * ```
+ */
+export declare function enrichedHeadersMiddleware(options?: EnrichedHeadersMiddlewareOptions): RequestHandler;
+/**
+ * Express route handler wrapper that provides enriched headers
+ *
+ * @param handler - Route handler that receives enriched headers
+ * @returns Express route handler
+ *
+ * @example
+ * ```typescript
+ * app.get('/api/data', withEnrichedHeaders(async (req, res, headers) => {
+ *   if (headers['x-user-region'] === 'eu') {
+ *     return res.json({ compliance: 'GDPR' });
+ *   }
+ *   return res.json({ compliance: 'standard' });
+ * }));
+ * ```
+ */
+export declare function withEnrichedHeaders(handler: (req: Request, res: Response, headers: ApiHeaders) => void | Promise<void>): RequestHandler;
+/**
+ * Type guard to check if request has enriched headers
+ *
+ * @param req - Request to check
+ * @returns True if request has enriched headers
+ */
+export declare function hasEnrichedHeaders(req: Request | ExpressRequestWithEnrichedHeaders): req is ExpressRequestWithEnrichedHeaders;
+//# sourceMappingURL=express.d.ts.map

package/dist/api/network/frameworks/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../../src/api/network/frameworks/express.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAgB,cAAc,EAAE,MAAM,SAAS,CAAC;AAI/E,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,yBAAyB,EACzB,gCAAgC,EAChC,iCAAiC,EACjC,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAK1B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,0BAA0B,EAAE,cA6BxC,CAAC;AAEF,wBAAgB,gCAAgC,CAC9C,OAAO,GAAE,uBAA4B,GACpC,cAAc,CAyChB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,OAAO,GAAG,yBAAyB,GACvC,GAAG,IAAI,yBAAyB,CAElC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACvF,cAAc,CAkBhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,cAAc,CAoGhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAClF,cAAc,CAiDhB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,GAAG,iCAAiC,GAC/C,GAAG,IAAI,iCAAiC,CAE1C"}

package/dist/api/network/frameworks/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Framework-specific middleware for network detection
+ *
+ * Provides middleware and utilities for:
+ * - Next.js (API Routes and Edge Runtime)
+ * - Express
+ * - NestJS
+ */
+export { createAdaptiveResponse, shouldServeHighQuality, getAdaptiveCacheDuration, shouldUseAggressiveCaching, getFrameworkAdaptiveTimeout, getFrameworkAdaptiveBatchSize, } from './shared';
+export { withNetworkDetection, getNetworkInfoFromRequest, addClientHintsToResponse, hasNetworkInfo as hasNetworkInfoNextjs, } from './nextjs';
+export { networkDetectionMiddleware, createNetworkDetectionMiddleware, hasNetworkInfo as hasNetworkInfoExpress, withNetworkInfo, } from './express';
+export { NetworkDetectionMiddleware, NetworkInfoParam, NetworkProperty, NetworkGuard, ClientHintsInterceptor, NoDataSaverGuard, MinimumConnectionGuard, type NestRequestWithNetwork, } from './nestjs/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/network/frameworks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/network/frameworks/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,6BAA6B,GAC9B,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,EACxB,cAAc,IAAI,oBAAoB,GACvC,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,0BAA0B,EAC1B,gCAAgC,EAChC,cAAc,IAAI,qBAAqB,EACvC,eAAe,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,sBAAsB,EACtB,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,gBAAgB,CAAC"}

package/dist/api/network/frameworks/nestjs/clientHintsInterceptor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * NestJS interceptor to add Client Hints headers to response
+ */
+import { ExecutionContext, CallHandler } from '@nestjs/common';
+import type { Observable } from 'rxjs';
+/**
+ * NestJS interceptor to add Client Hints headers to response
+ *
+ * @example
+ * ```typescript
+ * import { Module } from '@nestjs/common';
+ * import { APP_INTERCEPTOR } from '@nestjs/core';
+ * import { ClientHintsInterceptor } from '@plyaz/api/network/frameworks/nestjs';
+ *
+ * @Module({
+ *   providers: [
+ *     {
+ *       provide: APP_INTERCEPTOR,
+ *       useClass: ClientHintsInterceptor,
+ *     },
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare class ClientHintsInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}
+//# sourceMappingURL=clientHintsInterceptor.d.ts.map

package/dist/api/network/frameworks/nestjs/clientHintsInterceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientHintsInterceptor.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/clientHintsInterceptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAc,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAIvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBACa,sBAAsB;IACjC,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC;CAW7E"}

package/dist/api/network/frameworks/nestjs/decorators.d.ts

@@ -0,0 +1,48 @@
+import type { NetworkInfo } from '@plyaz/types/api';
+/**
+ * NestJS decorator to inject network info into controller methods
+ *
+ * @example
+ * ```typescript
+ * import { Controller, Get } from '@nestjs/common';
+ * import { NetworkInfoParam } from '@plyaz/api/network/frameworks/nestjs';
+ * import type { NetworkInfo } from '@plyaz/api/network';
+ *
+ * @Controller('api')
+ * export class DataController {
+ *   @Get('data')
+ *   getData(@NetworkInfoParam() networkInfo: NetworkInfo) {
+ *     if (networkInfo?.saveData) {
+ *       return { mode: 'data-saver', data: this.getMinimalData() };
+ *     }
+ *     return { mode: 'normal', data: this.getFullData() };
+ *   }
+ * }
+ * ```
+ */
+export declare const NetworkInfoParam: (...dataOrPipes: unknown[]) => ParameterDecorator;
+/**
+ * NestJS decorator to get specific network property
+ *
+ * @example
+ * ```typescript
+ * @Controller('api')
+ * export class DataController {
+ *   @Get('data')
+ *   getData(
+ *     @NetworkProperty('effectiveType') effectiveType: string,
+ *     @NetworkProperty('saveData') saveData: boolean
+ *   ) {
+ *     if (saveData) {
+ *       return { mode: 'data-saver' };
+ *     }
+ *     if (effectiveType === '4g') {
+ *       return { mode: 'high-quality' };
+ *     }
+ *     return { mode: 'standard' };
+ *   }
+ * }
+ * ```
+ */
+export declare const NetworkProperty: (...dataOrPipes: (keyof NetworkInfo | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/api/network/frameworks/nestjs/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/decorators.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAA0B,MAAM,kBAAkB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,mDAuB5B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,oMA0B3B,CAAC"}

package/dist/api/network/frameworks/nestjs/enrichedHeadersGuard.d.ts

@@ -0,0 +1,80 @@
+/**
+ * NestJS Guard for Enriched Context Headers
+ * Sets up enriched headers context before route handlers execute
+ */
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import type { EnrichedHeadersGuardOptions } from '@plyaz/types/api';
+/**
+ * NestJS guard that collects enriched context headers
+ * Sets up AsyncLocalStorage context for service functions
+ *
+ * @example
+ * ```typescript
+ * import { Controller, Get, UseGuards } from '@nestjs/common';
+ * import { EnrichedHeadersGuard } from '@plyaz/api/network/frameworks/nestjs';
+ * import { fetchUsers } from '@plyaz/api/services';
+ *
+ * @Controller('users')
+ * @UseGuards(new EnrichedHeadersGuard({
+ *   preset: 'standard',
+ *   requiredCompliance: ['GDPR']
+ * }))
+ * export class UsersController {
+ *   @Get()
+ *   async getUsers() {
+ *     // Service function automatically has enriched headers
+ *     return await fetchUsers({ page: 1 });
+ *   }
+ * }
+ * ```
+ */
+export declare class EnrichedHeadersGuard implements CanActivate {
+    private readonly options;
+    /**
+     * Check if all required headers are present
+     */
+    private checkRequiredHeaders;
+    /**
+     * Check if required compliance is met
+     */
+    private checkRequiredCompliance;
+    /**
+     * Build enriched headers for request
+     */
+    private buildHeadersForRequest;
+    /**
+     * Perform validation checks on headers
+     */
+    private validateHeaders;
+    /**
+     * Handle successful header processing
+     */
+    private handleSuccess;
+    /**
+     * Handle error during header building
+     */
+    private handleBuildError;
+    constructor(options?: EnrichedHeadersGuardOptions);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}
+/**
+ * Create enriched headers guard with specific options
+ *
+ * @param options - Guard configuration
+ * @returns Configured guard instance
+ *
+ * @example
+ * ```typescript
+ * @UseGuards(createEnrichedHeadersGuard({
+ *   preset: 'compliance-strict',
+ *   requiredCompliance: ['GDPR'],
+ *   debug: true
+ * }))
+ * export class EuComplianceController {
+ *   // All methods require GDPR compliance
+ * }
+ * ```
+ */
+export declare function createEnrichedHeadersGuard(options?: EnrichedHeadersGuardOptions): EnrichedHeadersGuard;
+export declare function RequireEnrichedHeaders(options?: EnrichedHeadersGuardOptions): (target: object, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
+//# sourceMappingURL=enrichedHeadersGuard.d.ts.map

package/dist/api/network/frameworks/nestjs/enrichedHeadersGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrichedHeadersGuard.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/enrichedHeadersGuard.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAc,WAAW,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAI3E,OAAO,KAAK,EAAc,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAKhF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,oBAAqB,YAAW,WAAW;IAsL1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IArLpC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAkC/B;;OAEG;YACW,sBAAsB;IAoCpC;;OAEG;IACH,OAAO,CAAC,eAAe;IAmBvB;;OAEG;YACW,aAAa;IAkB3B;;OAEG;YACW,gBAAgB;gBAoCD,OAAO,GAAE,2BAAgC;IAEhE,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;CA2B/D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,2BAAgC,GACxC,oBAAoB,CAEtB;AAuCD,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,2BAAgC,GACxC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,kBAAkB,KAAK,IAAI,CAejF"}

package/dist/api/network/frameworks/nestjs/enrichedHeadersInterceptor.d.ts

@@ -0,0 +1,83 @@
+/**
+ * NestJS Interceptor for Enriched Context Headers
+ * Automatically collects enriched headers and sets AsyncLocalStorage context for service functions
+ */
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import type { EnrichedHeadersInterceptorOptions } from '@plyaz/types/api';
+/**
+ * NestJS interceptor that collects enriched context headers
+ * Automatically runs service functions with enriched headers in AsyncLocalStorage context
+ *
+ * @example
+ * ```typescript
+ * import { Controller, Get, UseInterceptors } from '@nestjs/common';
+ * import { EnrichedHeadersInterceptor } from '@plyaz/api/network/frameworks/nestjs';
+ * import { fetchUsers } from '@plyaz/api/services';
+ *
+ * @Controller('users')
+ * @UseInterceptors(new EnrichedHeadersInterceptor({
+ *   preset: 'standard',
+ *   includePerformance: true
+ * }))
+ * export class UsersController {
+ *   @Get()
+ *   async getUsers() {
+ *     // Service function automatically has enriched headers
+ *     return await fetchUsers({ page: 1 });
+ *   }
+ * }
+ * ```
+ */
+export declare class EnrichedHeadersInterceptor implements NestInterceptor {
+    private readonly options;
+    constructor(options?: EnrichedHeadersInterceptorOptions);
+    /**
+     * Build enriched headers for the request
+     */
+    private buildHeaders;
+    /**
+     * Add enriched headers to response
+     */
+    private addHeadersToResponse;
+    /**
+     * Create observable with context
+     */
+    private createContextObservable;
+    /**
+     * Handle context setup error
+     */
+    private handleContextError;
+    /**
+     * Handle error during header building
+     */
+    private handleBuildError;
+    /**
+     * Create fallback observable when headers fail
+     */
+    private createFallbackObservable;
+    /**
+     * Handle fallback error
+     */
+    private handleFallbackError;
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<unknown>>;
+}
+/**
+ * Create enriched headers interceptor with specific options
+ *
+ * @param options - Interceptor configuration
+ * @returns Configured interceptor instance
+ *
+ * @example
+ * ```typescript
+ * @UseInterceptors(createEnrichedHeadersInterceptor({
+ *   preset: 'compliance-strict',
+ *   debug: true
+ * }))
+ * export class ComplianceController {
+ *   // All methods automatically have enriched headers
+ * }
+ * ```
+ */
+export declare function createEnrichedHeadersInterceptor(options?: EnrichedHeadersInterceptorOptions): EnrichedHeadersInterceptor;
+//# sourceMappingURL=enrichedHeadersInterceptor.d.ts.map

package/dist/api/network/frameworks/nestjs/enrichedHeadersInterceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrichedHeadersInterceptor.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/enrichedHeadersInterceptor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAc,eAAe,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAIlC,OAAO,KAAK,EAAc,iCAAiC,EAAE,MAAM,kBAAkB,CAAC;AAKtF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBACa,0BAA2B,YAAW,eAAe;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,GAAE,iCAAsC;IAE5E;;OAEG;YACW,YAAY;IAgB1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqB/B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwB1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgCxB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAoBhC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAwBrB,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;CAqC5F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gCAAgC,CAC9C,OAAO,GAAE,iCAAsC,GAC9C,0BAA0B,CAE5B"}

package/dist/api/network/frameworks/nestjs/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * NestJS middleware and decorators for network detection
+ */
+export type { NestRequestWithNetwork } from '@plyaz/types/api';
+export { NetworkDetectionMiddleware } from './networkDetectionMiddleware';
+export { NetworkGuard } from './networkGuard';
+export { ClientHintsInterceptor } from './clientHintsInterceptor';
+export { NoDataSaverGuard } from './noDataSaverGuard';
+export { MinimumConnectionGuard } from './minimumConnectionGuard';
+export { EnrichedHeadersGuard } from './enrichedHeadersGuard';
+export { EnrichedHeadersInterceptor } from './enrichedHeadersInterceptor';
+export { NetworkInfoParam, NetworkProperty } from './decorators';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/network/frameworks/nestjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAG/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAG1E,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/api/network/frameworks/nestjs/minimumConnectionGuard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pre-built guard for minimum connection quality
+ */
+import { ExecutionContext } from '@nestjs/common';
+import { NetworkGuard } from './networkGuard';
+/**
+ * Pre-built guard for minimum connection quality
+ *
+ * @example
+ * ```typescript
+ * @Controller('api')
+ * export class StreamingController {
+ *   @Get('video-stream')
+ *   @UseGuards(new MinimumConnectionGuard('3g'))
+ *   streamVideo() {
+ *     // This route requires at least 3G connection
+ *     return this.videoStreamService.stream();
+ *   }
+ * }
+ * ```
+ */
+export declare class MinimumConnectionGuard extends NetworkGuard {
+    private readonly minimumType;
+    constructor(minimumType?: '4g' | '3g' | '2g');
+    canActivate(context: ExecutionContext): boolean;
+}
+//# sourceMappingURL=minimumConnectionGuard.d.ts.map

package/dist/api/network/frameworks/nestjs/minimumConnectionGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimumConnectionGuard.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/minimumConnectionGuard.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAc,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;GAeG;AACH,qBACa,sBAAuB,SAAQ,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,GAAE,IAAI,GAAG,IAAI,GAAG,IAAW;IAInE,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO;CAShD"}

package/dist/api/network/frameworks/nestjs/networkDetectionMiddleware.d.ts

@@ -0,0 +1,31 @@
+/**
+ * NestJS middleware class for network detection
+ */
+import { NestMiddleware } from '@nestjs/common';
+import type { Response, NextFunction } from 'express';
+import type { NestRequestWithNetwork } from '@plyaz/types/api';
+/**
+ * NestJS middleware class for network detection
+ *
+ * @example
+ * ```typescript
+ * // app.module.ts
+ * import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
+ * import { NetworkDetectionMiddleware } from '@plyaz/api/network/frameworks/nestjs';
+ *
+ * @Module({
+ *   // ... module configuration
+ * })
+ * export class AppModule implements NestModule {
+ *   configure(consumer: MiddlewareConsumer) {
+ *     consumer
+ *       .apply(NetworkDetectionMiddleware)
+ *       .forRoutes('*'); // Apply to all routes
+ *   }
+ * }
+ * ```
+ */
+export declare class NetworkDetectionMiddleware implements NestMiddleware {
+    use(req: NestRequestWithNetwork, res: Response, next: NextFunction): void;
+}
+//# sourceMappingURL=networkDetectionMiddleware.d.ts.map

package/dist/api/network/frameworks/nestjs/networkDetectionMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkDetectionMiddleware.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/networkDetectionMiddleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAc,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,KAAK,EAAe,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBACa,0BAA2B,YAAW,cAAc;IAC/D,GAAG,CAAC,GAAG,EAAE,sBAAsB,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;CA0B1E"}

package/dist/api/network/frameworks/nestjs/networkGuard.d.ts

@@ -0,0 +1,33 @@
+/**
+ * NestJS guard base class for network conditions
+ */
+import { ExecutionContext } from '@nestjs/common';
+import type { NetworkInfo } from '@plyaz/types/api';
+/**
+ * NestJS guard to check network conditions
+ *
+ * @example
+ * ```typescript
+ * import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+ * import { NetworkGuard } from '@plyaz/api/network/frameworks/nestjs';
+ *
+ * @Injectable()
+ * export class HighQualityOnlyGuard extends NetworkGuard {
+ *   canActivate(context: ExecutionContext): boolean {
+ *     const networkInfo = this.getNetworkInfo(context);
+ *     return networkInfo.effectiveType === '4g' && !networkInfo.saveData;
+ *   }
+ * }
+ *
+ * @Controller('api')
+ * @UseGuards(HighQualityOnlyGuard)
+ * export class HighQualityController {
+ *   // Routes here only accessible on 4G without data saver
+ * }
+ * ```
+ */
+export declare abstract class NetworkGuard {
+    protected getNetworkInfo(context: ExecutionContext): NetworkInfo;
+    abstract canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}
+//# sourceMappingURL=networkGuard.d.ts.map

package/dist/api/network/frameworks/nestjs/networkGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkGuard.d.ts","sourceRoot":"","sources":["../../../../../src/api/network/frameworks/nestjs/networkGuard.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAc,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAA0B,MAAM,kBAAkB,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8BACsB,YAAY;IAChC,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,WAAW;IAuBhE,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;CAC5E"}

package/dist/api/network/frameworks/nestjs/noDataSaverGuard.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pre-built guard for data saver mode
+ */
+import { ExecutionContext } from '@nestjs/common';
+import { NetworkGuard } from './networkGuard';
+/**
+ * Pre-built guard for data saver mode
+ *
+ * @example
+ * ```typescript
+ * @Controller('api')
+ * export class DataController {
+ *   @Get('full-data')
+ *   @UseGuards(NoDataSaverGuard)
+ *   getFullData() {
+ *     // This route is not accessible when data saver is enabled
+ *     return { data: this.getLargeDataset() };
+ *   }
+ * }
+ * ```
+ */
+export declare class NoDataSaverGuard extends NetworkGuard {
+    canActivate(context: ExecutionContext): boolean;
+}
+//# sourceMappingURL=noDataSaverGuard.d.ts.map