@flusys/nestjs-shared 0.1.0-beta.3 → 1.0.0-rc

package/README.md

@@ -32,8 +32,8 @@ This comprehensive guide covers the shared package - the shared NestJS infrastru
 - **Generic CRUD** - Standardized API controller and service patterns
 - **Permission System** - Role and permission-based access control
 - **Caching** - In-memory + Redis hybrid caching
-- **Request Correlation** - AsyncLocalStorage-based request tracking (NEW)
-- **Middleware** - Logging, correlation, and performance monitoring (NEW)
+- **Request Correlation** - AsyncLocalStorage-based request tracking
+- **Middleware** - Logging, correlation, and performance monitoring
 - **Interceptors** - Response metadata, idempotency, auto field setting
 - **Multi-Tenancy** - Dynamic database connection management
 - **Error Handling** - Centralized error handling utilities
@@ -121,7 +121,6 @@ nestjs-shared/
 │   │
 │   ├── interfaces/           # TypeScript interfaces
 │   │   ├── api.interface.ts
-│   │   ├── base-query.interface.ts
 │   │   ├── identity.interface.ts
 │   │   ├── logged-user-info.interface.ts
 │   │   ├── logger.interface.ts
@@ -298,7 +297,7 @@ override async getExtraManipulateQuery(
 
 ## ApiController - Generic CRUD Controller
 
-The `createApiController` factory creates standardized REST API controllers.
+The `createApiController` factory creates standardized POST-only RPC controllers.
 
 ### Basic Usage
 
@@ -462,23 +461,52 @@ export class ReportsController {
 }
 ```
 
-### @RequireAllPermissions
+### @RequirePermissionCondition
 
-Require all listed permissions:
+Build complex permission conditions with nested AND/OR logic:
 
 ```typescript
-import { RequireAllPermissions } from '@flusys/nestjs-shared/decorators';
+import { RequirePermissionCondition } from '@flusys/nestjs-shared/decorators';
 
 @Controller('sensitive')
 export class SensitiveController {
-  @RequireAllPermissions('admin.access', 'security.clearance')
-  @Get()
-  getSensitiveData() {
-    // Requires BOTH permissions
-  }
+  // Simple: User needs 'admin' OR 'manager'
+  @RequirePermissionCondition({
+    operator: 'or',
+    permissions: ['admin', 'manager'],
+  })
+  @Get('simple')
+  getSimpleData() {}
+
+  // Complex: User needs 'users.read' AND ('admin' OR 'manager')
+  @RequirePermissionCondition({
+    operator: 'and',
+    permissions: ['users.read'],
+    children: [
+      { operator: 'or', permissions: ['admin', 'manager'] }
+    ]
+  })
+  @Get('complex')
+  getComplexData() {}
+
+  // Very complex: (A AND B) OR (C AND D)
+  @RequirePermissionCondition({
+    operator: 'or',
+    children: [
+      { operator: 'and', permissions: ['finance.read', 'finance.write'] },
+      { operator: 'and', permissions: ['admin.full', 'reports.access'] }
+    ]
+  })
+  @Get('very-complex')
+  getVeryComplexData() {}
 }
 ```
 
+**Note:** For simple "require ALL permissions" use case, use `@RequirePermission` which defaults to AND logic:
+```typescript
+@RequirePermission('admin.access', 'security.clearance')  // User needs BOTH
+```
+
 ---
 
 ## Guards
@@ -487,106 +515,62 @@ The shared package provides two guards for authentication and authorization:
 
 ### JwtAuthGuard
 
-**Location:** `@flusys/nestjs-shared/guards/jwt-auth.guard.ts`
-
-The `JwtAuthGuard` validates JWT tokens for protected routes. It extends Passport's `AuthGuard('jwt')` and respects the `@Public()` decorator.
-
-**Why in shared module:**
-- All feature modules (auth, iam, storage) need JWT authentication
-- Keeps feature modules independent (no cross-dependencies)
-- JwtStrategy registration remains in auth module
-- This guard just validates tokens using the registered strategy
-
-**Usage:**
+Validates JWT tokens for protected routes. Extends Passport's `AuthGuard('jwt')` and respects `@Public()` decorator.
 
 ```typescript
 import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
-import { UseGuards } from '@nestjs/common';
 
-// Protect entire controller
+// Apply globally
+@Module({
+  providers: [{ provide: APP_GUARD, useClass: JwtAuthGuard }],
+})
+export class AppModule {}
+
+// Or per controller
 @Controller('users')
 @UseGuards(JwtAuthGuard)
 export class UserController {
-  // All routes protected
-
   @Post('login')
-  @Public()  // Skip JWT check for this route
+  @Public()  // Skip JWT check
   async login() { }
 }
-
-// Or apply globally
-@Module({
-  providers: [
-    {
-      provide: APP_GUARD,
-      useClass: JwtAuthGuard,
-    },
-  ],
-})
-export class AppModule {}
 ```
 
-**Features:**
-- Validates JWT tokens from `Authorization: Bearer <token>` header
-- Respects `@Public()` decorator to skip authentication
-- Throws `UnauthorizedException` for invalid/expired tokens
-- Works with JwtStrategy registered in auth module
-
-**Note:** The JwtStrategy (which registers the JWT validation logic with Passport) is still in the auth module at `@flusys/nestjs-auth/strategies/jwt.strategy.ts`. This guard uses that registered strategy.
-
 ### PermissionGuard
 
-**Location:** `@flusys/nestjs-shared/guards/permission.guard.ts`
-
-The `PermissionGuard` handles permission-based access control.
+Checks user permissions from cache with AND/OR/nested logic support.
 
 ```typescript
-import { Module } from '@nestjs/common';
-import { APP_GUARD } from '@nestjs/core';
 import { PermissionGuard } from '@flusys/nestjs-shared/guards';
 
+// Apply globally
 @Module({
-  providers: [
-    {
-      provide: APP_GUARD,
-      useClass: PermissionGuard,
-    },
-  ],
+  providers: [{ provide: APP_GUARD, useClass: PermissionGuard }],
 })
 export class AppModule {}
 ```
 
-### Permission Cache Key Format
+**Cache Key Formats:**
 
 ```typescript
 // Without company feature
 `permissions:user:{userId}`
 
-// With company feature (includes branchId for DIRECT permissions)
+// With company feature
 `permissions:company:{companyId}:branch:{branchId}:user:{userId}`
 ```
 
-### Permission Guard Configuration
-
-```typescript
-// Configure via PermissionModule options
-PermissionModule.forRoot({
-  // Cache TTL in seconds
-  cacheTtl: 3600,
-
-  // Permission check mode
-  mode: 'RBAC' | 'DIRECT' | 'FULL',
-
-  // Custom permission resolver
-  resolver: CustomPermissionResolver,
-});
-```
+**Features:**
+- Supports AND/OR operators via `@RequirePermission` and `@RequireAnyPermission`
+- Nested conditions via `@RequirePermissionCondition`
+- Wildcard support (`*` and `*.suffix`)
+- Company/branch scoped permissions
 
 ---
 
 ## Middleware
 
-### LoggerMiddleware (NEW - 2026-01-12, Enhanced - 2026-01-14)
+### LoggerMiddleware
 
 **Location:** `@flusys/nestjs-shared/middlewares/logger.middleware.ts`
 
@@ -877,7 +861,7 @@ export class PostController {
 
 ### Slug Interceptor
 
-Auto-generate slugs from name field:
+Auto-generate slugs from name field using UtilsService (injected via DI):
 
 ```typescript
 import { Slug } from '@flusys/nestjs-shared/interceptors';
@@ -893,6 +877,8 @@ export class ProductController {
 }
 ```
 
+**Note:** Requires `UtilsModule` to be imported in your module for dependency injection.
+
 ---
 
 ## Caching System
@@ -976,7 +962,7 @@ export class AppModule {}
 
 ## Multi-Tenant DataSource
 
-Dynamic database connection management for multi-tenant applications.
+Dynamic database connection management with connection pooling and request-scoped tenant resolution.
 
 ### Setup
 
@@ -986,7 +972,7 @@ import { DataSourceModule } from '@flusys/nestjs-shared/modules';
 @Module({
   imports: [
     DataSourceModule.forRoot({
-      // Default database config (used as template)
+      bootstrapAppConfig: { databaseMode: 'multi-tenant' },
       defaultDatabaseConfig: {
         type: 'mysql',
         host: 'localhost',
@@ -994,11 +980,9 @@ import { DataSourceModule } from '@flusys/nestjs-shared/modules';
         username: 'root',
         password: 'password',
       },
-
-      // Tenant configurations
       tenants: [
-        { id: 'tenant1', database: 'tenant1_db', isActive: true },
-        { id: 'tenant2', database: 'tenant2_db', isActive: true },
+        { id: 'tenant1', database: 'tenant1_db' },
+        { id: 'tenant2', database: 'tenant2_db' },
       ],
     }),
   ],
@@ -1006,41 +990,35 @@ import { DataSourceModule } from '@flusys/nestjs-shared/modules';
 export class AppModule {}
 ```
 
-### Usage with Tenant Header
+### Key Methods
 
-```typescript
-// Client sends X-Tenant-ID header
-// DataSource automatically switches to tenant's database
+| Method | Description |
+|--------|-------------|
+| `getDataSource()` | Get DataSource for current tenant (from header) |
+| `getDataSourceForTenant(id)` | Get DataSource for specific tenant |
+| `getRepository(entity)` | Get repository for current tenant |
+| `withTenant(id, callback)` | Execute callback with specific tenant DataSource |
+| `forAllTenants(callback)` | Execute callback for all active tenants |
+| `registerTenant(config)` | Register new tenant at runtime |
+| `removeTenant(id)` | Remove tenant and close connection |
+
+### Usage
 
+```typescript
 @Injectable()
 export class TenantService {
-  constructor(
-    @Inject('DATASOURCE_PROVIDER')
-    private dataSourceProvider: MultiTenantDataSourceService,
-  ) {}
+  constructor(private dataSource: MultiTenantDataSourceService) {}
 
-  async getConnection(tenantId: string) {
-    return this.dataSourceProvider.getConnection(tenantId);
+  async getUsers() {
+    // Auto-resolves tenant from X-Tenant-ID header
+    const repo = await this.dataSource.getRepository(User);
+    return repo.find();
   }
-}
-```
 
-### Tenant Resolution
-
-```typescript
-// Default: Resolved from X-Tenant-ID header
-@Controller('users')
-export class UserController {
-  // Automatically uses tenant-specific database
-}
-
-// Manual tenant specification
-@Injectable()
-export class CrossTenantService {
-  async copyData(fromTenant: string, toTenant: string) {
-    const fromConn = await this.dataSourceProvider.getConnection(fromTenant);
-    const toConn = await this.dataSourceProvider.getConnection(toTenant);
-    // ...
+  async crossTenantCopy(fromId: string, toId: string) {
+    const fromDs = await this.dataSource.getDataSourceForTenant(fromId);
+    const toDs = await this.dataSource.getDataSourceForTenant(toId);
+    // Copy data between tenants
   }
 }
 ```
@@ -1063,18 +1041,15 @@ import { FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
     "category": "electronics"
   },
   "pagination": {
-    "page": 1,
-    "limit": 10
+    "currentPage": 0,
+    "pageSize": 10
   },
   "sort": {
-    "field": "createdAt",
-    "order": "DESC"
-  },
-  "search": {
-    "fields": ["name", "description"],
-    "value": "laptop"
+    "createdAt": "DESC",
+    "name": "ASC"
   },
-  "select": ["id", "name", "price"]
+  "select": ["id", "name", "price"],
+  "withDeleted": false
 }
 ```
 
@@ -1235,11 +1210,12 @@ import {
   Public,
   RequirePermission,
   RequireAnyPermission,
-  RequireAllPermissions,
+  RequirePermissionCondition,
 } from '@flusys/nestjs-shared/decorators';
 
 // Guards
 import {
+  JwtAuthGuard,
   PermissionGuard,
 } from '@flusys/nestjs-shared/guards';
 
@@ -1375,25 +1351,17 @@ async getPermissions(userId: string) {
 
 The `@flusys/nestjs-shared` package provides:
 
-✅ **Generic CRUD** - Consistent API patterns
-✅ **Permission System** - Flexible access control
-✅ **Caching** - High-performance data access
-✅ **Multi-Tenancy** - Database isolation
-✅ **Request Correlation** - AsyncLocalStorage-based tracking (NEW)
-✅ **Middleware** - Logging and performance monitoring (NEW)
-✅ **Interceptors** - Request/response processing
-✅ **Error Handling** - Centralized error management
+- **Generic CRUD** - Consistent API patterns
+- **Permission System** - Flexible access control
+- **Caching** - High-performance data access
+- **Multi-Tenancy** - Database isolation
+- **Request Correlation** - AsyncLocalStorage-based tracking
+- **Middleware** - Logging and performance monitoring
+- **Interceptors** - Request/response processing
+- **Error Handling** - Centralized error management
 
 This is the shared infrastructure layer used by all other Flusys packages.
 
 ---
 
-**Last Updated:** 2026-02-07
-**Recent Improvements:**
-- 2026-02-07: Documentation cleanup - removed outdated JWT configuration section, updated package architecture to match actual structure
-- 2026-01-14: Enhanced `LoggerMiddleware` with complete request/response details (URL, path, query, headers, user context)
-- 2026-01-14: Added multiple response hooks (send, json, end) for reliable response capture
-- 2026-01-14: Improved error logging with stack traces
-- 2026-01-12: Added `LoggerMiddleware` for request correlation and structured logging
-- 2026-01-12: Added AsyncLocalStorage-based request context (requestId, tenantId, userId, companyId)
-- 2026-01-13: Removed JWT config/constants (moved to auth-specific packages)
+**Last Updated:** 2026-02-18

package/cjs/classes/api-controller.class.js

@@ -8,10 +8,10 @@ Object.defineProperty(exports, "createApiController", {
         return createApiController;
     }
 });
-const _decorators = require("@flusys/nestjs-shared/decorators");
-const _dtos = require("@flusys/nestjs-shared/dtos");
-const _guards = require("@flusys/nestjs-shared/guards");
-const _interceptors = require("@flusys/nestjs-shared/interceptors");
+const _decorators = require("../decorators");
+const _dtos = require("../dtos");
+const _guards = require("../guards");
+const _interceptors = require("../interceptors");
 const _common = require("@nestjs/common");
 const _swagger = require("@nestjs/swagger");
 const _classtransformer = require("class-transformer");
@@ -104,8 +104,10 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
     // 2. It's an object with 'level' property but no endpoint keys
     const isGlobalSecurity = typeof securityConfig === 'string' || securityConfig && typeof securityConfig === 'object' && 'level' in securityConfig && !endpointKeys.some((key)=>key in securityConfig);
     // Normalize security config for each endpoint
+    // IMPORTANT: When per-endpoint security is specified, default to 'jwt' for unconfigured endpoints
+    // to prevent accidentally exposing endpoints without authentication
     const defaultSecurity = isGlobalSecurity ? normalizeSecurity(securityConfig) : {
-        level: 'public'
+        level: 'jwt'
     };
     const security = {
         insert: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.insert),
@@ -117,9 +119,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         delete: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.delete)
     };
     let ApiController = class ApiController {
-        // =========================================================================
-        // INSERT (Single Item) - With Idempotency Support
-        // =========================================================================
         async insert(addDto, user) {
             const entity = await this.service.insert(addDto, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
@@ -129,9 +128,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 data
             };
         }
-        // =========================================================================
-        // INSERT MANY (Bulk) - With Idempotency Support
-        // =========================================================================
         async insertMany(addDto, user) {
             const entities = await this.service.insertMany(addDto, user);
             const data = entities.map((item)=>(0, _classtransformer.plainToInstance)(responseDtoClass, item));
@@ -146,9 +142,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 }
             };
         }
-        // =========================================================================
-        // GET BY ID (Single Item)
-        // =========================================================================
         async getById(id, body, user) {
             const entity = await this.service.findById(id, user, body?.select);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
@@ -158,9 +151,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 data
             };
         }
-        // =========================================================================
-        // UPDATE (Single Item)
-        // =========================================================================
         async update(updateDto, user) {
             const entity = await this.service.update(updateDto, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
@@ -170,9 +160,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 data
             };
         }
-        // =========================================================================
-        // UPDATE MANY (Bulk)
-        // =========================================================================
         async updateMany(updateDtos, user) {
             const entities = await this.service.updateMany(updateDtos, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entities);
@@ -187,9 +174,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 }
             };
         }
-        // =========================================================================
-        // GET ALL (Paginated List)
-        // =========================================================================
         async getAll(filterAndPaginationDto, user, search) {
             const result = await this.service.getAll(search ?? '', filterAndPaginationDto, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, result.data);
@@ -210,9 +194,6 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 }
             };
         }
-        // =========================================================================
-        // DELETE (Soft/Restore/Permanent)
-        // =========================================================================
         async delete(deleteDto, user) {
             await this.service.delete(deleteDto, user);
             const count = Array.isArray(deleteDto.id) ? deleteDto.id.length : 1;
@@ -368,16 +349,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         (0, _common.HttpCode)(_common.HttpStatus.OK),
         (0, _swagger.ApiOperation)({
             summary: 'Get all items with filters and pagination',
-            description: `
-Retrieves items with support for:
-- **filter**: Apply field-based filters (e.g., \`{ "isActive": true }\`)
-- **pagination**: Control page and page size
-- **sort**: Order by any field (e.g., \`{ "createdAt": "DESC" }\`)
-- **select**: Choose specific fields to return
-- **withDeleted**: Include soft-deleted items
-- **extraKey**: Include additional relations
-- **q** (query param): Global text search
-      `
+            description: 'Supports filter, pagination, sort, select, withDeleted, and q (search) params'
         }),
         (0, _swagger.ApiQuery)({
             name: 'q',
@@ -406,15 +378,7 @@ Retrieves items with support for:
         (0, _common.HttpCode)(_common.HttpStatus.OK),
         (0, _swagger.ApiOperation)({
             summary: 'Delete, restore, or permanently remove items',
-            description: `
-Performs one of three actions:
-
-- **"delete"** (soft delete): Marks items as deleted but keeps in database
-- **"restore"**: Reverts soft-deleted items to active
-- **"permanent"**: Completely removes items from database
-
-Supports single ID or array of IDs for batch operations.
-      `
+            description: 'Types: delete (soft), restore, permanent. Supports batch IDs.'
         }),
         (0, _swagger.ApiResponse)({
             status: 200,

package/cjs/classes/api-service.class.js

@@ -25,9 +25,6 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let ApiService = class ApiService {
-    // ---------------------------------------------------------------------
-    // INSERT SINGLE ENTITY
-    // ---------------------------------------------------------------------
     async insert(dto, user) {
         await this.ensureRepositoryInitialized();
         const qr = this.repository.manager.connection.createQueryRunner();
@@ -54,9 +51,6 @@ let ApiService = class ApiService {
             await qr.release();
         }
     }
-    // ---------------------------------------------------------------------
-    // INSERT MULTIPLE ENTITIES
-    // ---------------------------------------------------------------------
     async insertMany(dtos, user) {
         await this.ensureRepositoryInitialized();
         const qr = this.repository.manager.connection.createQueryRunner();
@@ -87,9 +81,6 @@ let ApiService = class ApiService {
             await qr.release();
         }
     }
-    // ---------------------------------------------------------------------
-    // UPDATE SINGLE ENTITY
-    // ---------------------------------------------------------------------
     async update(dto, user) {
         await this.ensureRepositoryInitialized();
         const qr = this.repository.manager.connection.createQueryRunner();
@@ -116,9 +107,6 @@ let ApiService = class ApiService {
             await qr.release();
         }
     }
-    // ---------------------------------------------------------------------
-    // UPDATE MULTIPLE ENTITIES
-    // ---------------------------------------------------------------------
     async updateMany(dtos, user) {
         await this.ensureRepositoryInitialized();
         const qr = this.repository.manager.connection.createQueryRunner();
@@ -149,9 +137,6 @@ let ApiService = class ApiService {
             await qr.release();
         }
     }
-    // ---------------------------------------------------------------------
-    // FIND BY IDS
-    // ---------------------------------------------------------------------
     async findByIds(ids, user) {
         await this.ensureRepositoryInitialized();
         try {
@@ -176,9 +161,6 @@ let ApiService = class ApiService {
             this.handleError(error, 'findByIds');
         }
     }
-    // ---------------------------------------------------------------------
-    // FIND BY ID
-    // ---------------------------------------------------------------------
     async findById(id, user, select) {
         await this.ensureRepositoryInitialized();
         try {
@@ -217,9 +199,6 @@ let ApiService = class ApiService {
             this.handleError(error, 'findById');
         }
     }
-    // ---------------------------------------------------------------------
-    // GET ALL (WITH FILTER, SORT, SEARCH, PAGINATION & CACHING)
-    // ---------------------------------------------------------------------
     async getAll(search, filterAndPaginationDto, user) {
         await this.ensureRepositoryInitialized();
         try {
@@ -318,9 +297,6 @@ let ApiService = class ApiService {
             this.handleError(error, 'getAll');
         }
     }
-    // ---------------------------------------------------------------------
-    // DELETE / RESTORE / HARD DELETE
-    // ---------------------------------------------------------------------
     async delete(option, user) {
         await this.ensureRepositoryInitialized();
         const queryRunner = this.repository.manager.connection.createQueryRunner();
@@ -363,9 +339,7 @@ let ApiService = class ApiService {
             await queryRunner.release();
         }
     }
-    // ---------------------------------------------------------------------
-    // CACHING HELPERS
-    // ---------------------------------------------------------------------
+    // Caching
     async clearCacheForAll() {
         await this.utilsService.clearCache(this.entityName, this.cacheManager);
     }
@@ -380,17 +354,8 @@ let ApiService = class ApiService {
         });
         _errorhandlerutil.ErrorHandler.rethrowError(error);
     }
-    // ---------------------------------------------------------------------
-    // HOOKS / HELPERS (OVERRIDE IN CHILD CLASSES)
-    // ---------------------------------------------------------------------
-    /**
-   * Hook called before ANY repository access
-   * CRITICAL: Override this in REQUEST-scoped services that use lazy repository initialization
-   * Example use case: DataSource Provider pattern where repository is set dynamically
-   */ async ensureRepositoryInitialized() {
-    // Default: no-op - repository is already initialized in constructor
-    // Override in child classes that need lazy initialization
-    }
+    // Hooks (override in child classes)
+    async ensureRepositoryInitialized() {}
     async beforeInsertOperation(_dto, _user, _queryRunner) {}
     async afterInsertOperation(_entity, _user, _queryRunner) {}
     async beforeUpdateOperation(_dto, _user, _queryRunner) {}
@@ -439,9 +404,7 @@ let ApiService = class ApiService {
             isRaw: false
         };
     }
-    // ---------------------------------------------------------------------
-    // DTO <-> ENTITY CONVERSION
-    // ---------------------------------------------------------------------
+    // DTO conversion
     async convertRequestDtoToEntity(dto, user) {
         return Array.isArray(dto) ? await this.convertArrayDtoToEntities(dto, user) : [
             await this.convertSingleDtoToEntity(dto, user)

package/cjs/classes/index.js

@@ -8,6 +8,7 @@ _export_star(require("./request-scoped-api.service"), exports);
 _export_star(require("./hybrid-cache.class"), exports);
 _export_star(require("./winston-logger-adapter.class"), exports);
 _export_star(require("./winston.logger.class"), exports);
+_export_star(require("../constants/permissions"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {