@flusys/nestjs-localization 4.0.1 → 4.1.0

package/README.md

@@ -1,152 +1,90 @@
-# Localization Package Guide
+# @flusys/nestjs-localization
 
-> **Package:** `@flusys/nestjs-localization`
-> **Version:** 4.0.1
-> **Type:** Multi-language backend support with TypeORM entities, caching, and translation management
+> Multi-language backend for NestJS — database-driven translations, `{{variable}}` interpolation, RTL support, missing-key detection, verification workflow, and module-scoped partial loading.
+
+[![npm version](https://img.shields.io/npm/v/@flusys/nestjs-localization.svg)](https://www.npmjs.com/package/@flusys/nestjs-localization)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![NestJS](https://img.shields.io/badge/NestJS-11.x-red.svg)](https://nestjs.com/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18.x-green.svg)](https://nodejs.org/)
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Compatibility](#compatibility)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Module Registration](#module-registration)
+  - [forRoot (Sync)](#forroot-sync)
+  - [forRootAsync (Factory)](#forrootasync-factory)
+- [Configuration Reference](#configuration-reference)
+- [Feature Toggles](#feature-toggles)
+- [API Endpoints](#api-endpoints)
+- [Entities](#entities)
+- [Translation Workflow](#translation-workflow)
+- [Variable Interpolation](#variable-interpolation)
+- [Fallback Chain](#fallback-chain)
+- [RTL Support](#rtl-support)
+- [Caching](#caching)
+- [Exported Services](#exported-services)
+- [Integration with API Responses](#integration-with-api-responses)
+- [Troubleshooting](#troubleshooting)
+- [License](#license)
 
 ---
 
 ## Overview
 
-`@flusys/nestjs-localization` provides a complete localization backend system:
+`@flusys/nestjs-localization` manages the backend side of multi-language support. Translations are stored in the database and served to the frontend via API. The package provides a full admin workflow: create languages, define translation keys (grouped by module), add translations per language, verify them, and detect missing ones.
 
-- **Language Management** - CRUD operations for languages with RTL support
-- **Translation Keys** - Module-based key organization with variables
-- **Translations** - Per-language translations with verification status
-- **Caching** - Optional hybrid caching for performance
-- **Dynamic DataSource** - Request-scoped repository pattern
-- **Variable Interpolation** - `{{variable}}` syntax support
-- **Bulk Operations** - Batch update translations
-- **Missing Translation Detection** - Find untranslated keys
+All API responses in the FLUSYS ecosystem return a `messageKey` field (e.g., `'auth.login_success'`). The frontend looks up this key in the translations returned by this package.
 
-### Package Hierarchy
+---
 
-```
-@flusys/nestjs-core           <- Foundation (IDataSourceServiceOptions)
-        |
-@flusys/nestjs-shared         <- Base classes (RequestScopedApiService)
-        |
-@flusys/nestjs-localization   <- Localization system (THIS PACKAGE)
-```
+## Features
+
+- **Language management** — Create languages with ISO 639-1 codes, native names, and RTL/LTR direction
+- **Translation keys** — Module-scoped key registry with variable declarations and readonly protection
+- **Translations** — Per-language values with a verification workflow (draft → verified)
+- **Variable interpolation** — `{{variableName}}` syntax in messages with `messageVariables` field in API responses
+- **Missing key detection** — Find which keys have no translation for a given language
+- **Bulk operations** — Atomic bulk update of multiple translations in one transaction
+- **Default language** — Configurable fallback language (e.g., `'en'`)
+- **Module scoping** — Keys grouped by module for partial frontend loading
+- **Caching** — Optional HybridCache for translation lookups with configurable TTL
+- **Multi-tenant** — Per-tenant DataSource isolation
 
 ---
 
-## Package Architecture
+## Compatibility
 
-```
-nestjs-localization/
-├── config/
-│   ├── localization.constants.ts      # LOCALIZATION_MODULE_OPTIONS
-│   └── index.ts
-├── interfaces/
-│   ├── language.interface.ts          # ILanguage
-│   ├── translation-key.interface.ts   # ITranslationKey
-│   ├── translation.interface.ts       # ITranslation, ITranslationsMap
-│   ├── localization-module-options.interface.ts # Module config
-│   └── index.ts
-├── entities/
-│   ├── language.entity.ts             # Language entity
-│   ├── translation-key.entity.ts      # TranslationKey entity
-│   ├── translation.entity.ts          # Translation entity
-│   └── index.ts
-├── dtos/
-│   ├── language.dto.ts                # Language DTOs
-│   ├── translation-key.dto.ts         # TranslationKey DTOs
-│   ├── translation.dto.ts             # Translation DTOs
-│   └── index.ts
-├── services/
-│   ├── localization-config.service.ts # Config management
-│   ├── localization-datasource.provider.ts # DataSource provider
-│   ├── localization-helper.service.ts # Interpolation utilities
-│   ├── language.service.ts            # Language CRUD
-│   ├── translation-key.service.ts     # TranslationKey CRUD
-│   ├── translation.service.ts         # Translation CRUD + queries
-│   └── index.ts
-├── controllers/
-│   ├── language.controller.ts         # Language endpoints
-│   ├── translation-key.controller.ts  # TranslationKey endpoints
-│   ├── translation.controller.ts      # Translation endpoints
-│   └── index.ts
-├── modules/
-│   └── localization.module.ts         # Module definition
-└── index.ts
-```
+| Package | Version |
+|---------|---------|
+| `@flusys/nestjs-core` | `^4.0.0` |
+| `@flusys/nestjs-shared` | `^4.0.0` |
+| `@nestjs/core` | `^11.0.0` |
+| `typeorm` | `^0.3.0` |
+| Node.js | `>= 18.x` |
 
 ---
 
-## Database Schema
-
-### Language Table
-
-| Column | Type | Nullable | Description |
-|--------|------|----------|-------------|
-| `id` | uuid | No | Primary key |
-| `code` | varchar(10) | No | ISO 639-1 code (e.g., 'en', 'ar') |
-| `name` | varchar(100) | No | English name |
-| `native_name` | varchar(100) | Yes | Native name (e.g., 'العربية') |
-| `direction` | varchar(3) | Yes | 'ltr' or 'rtl' |
-| `is_active` | boolean | No | Active status (default: true) |
-| `is_default` | boolean | No | Default language flag |
-| `serial` | int | Yes | Sort order |
-| `created_at` | timestamp | No | Creation timestamp |
-| `updated_at` | timestamp | No | Update timestamp |
-| `deleted_at` | timestamp | Yes | Soft delete timestamp |
-
-**Indexes:**
-- `UNIQUE (code)`
-- `INDEX (is_active)`
-- `INDEX (is_default)`
-
-### TranslationKey Table
-
-| Column | Type | Nullable | Description |
-|--------|------|----------|-------------|
-| `id` | uuid | No | Primary key |
-| `module` | varchar(100) | No | Module grouping (e.g., 'auth') |
-| `key` | varchar(255) | No | Translation key |
-| `default_message` | varchar(500) | No | Default/fallback message |
-| `description` | text | Yes | Description for translators |
-| `variables` | simple-array | Yes | Required variables |
-| `is_active` | boolean | No | Active status |
-| `serial` | int | Yes | Sort order |
-| `created_at` | timestamp | No | Creation timestamp |
-| `updated_at` | timestamp | No | Update timestamp |
-| `deleted_at` | timestamp | Yes | Soft delete timestamp |
-
-**Indexes:**
-- `UNIQUE (key)`
-- `INDEX (module)`
-- `INDEX (module, key)`
-- `INDEX (is_active)`
-
-### Translation Table
-
-| Column | Type | Nullable | Description |
-|--------|------|----------|-------------|
-| `id` | uuid | No | Primary key |
-| `language_id` | uuid | No | FK to language |
-| `translation_key_id` | uuid | No | FK to translation_key |
-| `value` | text | No | Translated value |
-| `is_verified` | boolean | No | Verified by translator |
-| `is_active` | boolean | No | Active status |
-| `created_at` | timestamp | No | Creation timestamp |
-| `updated_at` | timestamp | No | Update timestamp |
-| `deleted_at` | timestamp | Yes | Soft delete timestamp |
-
-**Indexes:**
-- `UNIQUE (language_id, translation_key_id)`
-- `INDEX (language_id)`
-- `INDEX (translation_key_id)`
-- `INDEX (is_active)`
+## Installation
+
+```bash
+npm install @flusys/nestjs-localization @flusys/nestjs-shared @flusys/nestjs-core
+```
 
 ---
 
-## Module Setup
+## Quick Start
 
-### Basic Setup
+### Minimal Setup (Single Database)
 
 ```typescript
-// app.module.ts
+import { Module } from '@nestjs/common';
 import { LocalizationModule } from '@flusys/nestjs-localization';
 
 @Module({
@@ -155,11 +93,20 @@ import { LocalizationModule } from '@flusys/nestjs-localization';
       global: true,
       includeController: true,
       bootstrapAppConfig: {
-        dataSource: AppDataSource,
+        databaseMode: 'single',
+        enableCompanyFeature: false,
       },
       config: {
+        defaultDatabaseConfig: {
+          type: 'postgres',
+          host: process.env.DB_HOST,
+          port: Number(process.env.DB_PORT ?? 5432),
+          username: process.env.DB_USER,
+          password: process.env.DB_PASSWORD,
+          database: process.env.DB_NAME,
+        },
         defaultLanguageCode: 'en',
-        enableCaching: true,
+        enableCaching: false,
         cacheTtlSeconds: 300,
       },
     }),
@@ -168,703 +115,421 @@ import { LocalizationModule } from '@flusys/nestjs-localization';
 export class AppModule {}
 ```
 
-### Async Setup
+After startup, create languages and translation keys via the API. The frontend fetches translations on init and uses the `messageKey` returned by each API response to look up the localized message.
 
-```typescript
-// app.module.ts
-import { LocalizationModule } from '@flusys/nestjs-localization';
-import { ConfigModule, ConfigService } from '@nestjs/config';
+---
 
-@Module({
-  imports: [
-    LocalizationModule.forRootAsync({
-      global: true,
-      includeController: true,
-      imports: [ConfigModule],
-      bootstrapAppConfig: {
-        dataSource: AppDataSource,
-      },
-      useFactory: (configService: ConfigService) => ({
-        defaultLanguageCode: configService.get('DEFAULT_LANGUAGE', 'en'),
-        enableCaching: configService.get('ENABLE_CACHE', true),
-        cacheTtlSeconds: configService.get('CACHE_TTL', 300),
-      }),
-      inject: [ConfigService],
-    }),
-  ],
-})
-export class AppModule {}
-```
+## Module Registration
 
-### Module Options
+### forRoot (Sync)
 
 ```typescript
-interface ILocalizationModuleConfig {
-  defaultLanguageCode?: string;  // Default: 'en'
-  enableCaching?: boolean;       // Enable hybrid cache
-  cacheTtlSeconds?: number;      // Cache TTL in seconds
-}
-
-interface LocalizationModuleOptions {
-  global?: boolean;              // Register as global module
-  includeController?: boolean;   // Include controllers (default: true)
-  bootstrapAppConfig: IBootstrapAppConfig;
-  config?: ILocalizationModuleConfig;
-}
+LocalizationModule.forRoot({
+  global?: boolean;
+  includeController?: boolean;        // Default: true
+  bootstrapAppConfig?: {
+    databaseMode: 'single' | 'multi-tenant';
+    enableCompanyFeature: boolean;    // No company variants — shared data only
+  };
+  config: ILocalizationModuleConfig;
+})
 ```
 
----
-
-## Entities
-
-### Language Entity
+### forRootAsync (Factory)
 
 ```typescript
-@Entity({ name: 'language' })
-export class Language extends Identity {
-  @Column({ type: 'varchar', length: 10 })
-  code!: string;
-
-  @Column({ type: 'varchar', length: 100 })
-  name!: string;
-
-  @Column({ type: 'varchar', length: 100, nullable: true, name: 'native_name' })
-  nativeName!: string | null;
-
-  @Column({ type: 'varchar', length: 3, nullable: true })
-  direction!: 'ltr' | 'rtl' | null;
-
-  @Column({ type: 'boolean', default: true, name: 'is_active' })
-  isActive!: boolean;
-
-  @Column({ type: 'boolean', default: false, name: 'is_default' })
-  isDefault!: boolean;
-
-  @Column({ type: 'int', nullable: true })
-  serial!: number | null;
-
-  @OneToMany('Translation', 'language')
-  translations?: Translation[];
-}
+import { ConfigService } from '@nestjs/config';
+
+LocalizationModule.forRootAsync({
+  global: true,
+  includeController: true,
+  bootstrapAppConfig: {
+    databaseMode: 'single',
+    enableCompanyFeature: false,
+  },
+  imports: [ConfigModule],
+  useFactory: (configService: ConfigService) => ({
+    defaultDatabaseConfig: {
+      type: 'postgres',
+      host: configService.get('DB_HOST'),
+      port: configService.get<number>('DB_PORT'),
+      username: configService.get('DB_USER'),
+      password: configService.get('DB_PASSWORD'),
+      database: configService.get('DB_NAME'),
+    },
+    defaultLanguageCode: configService.get('DEFAULT_LANGUAGE', 'en'),
+    enableCaching: configService.get<boolean>('LOCALIZATION_CACHE', false),
+    cacheTtlSeconds: 300,
+  }),
+  inject: [ConfigService],
+})
 ```
 
-### TranslationKey Entity
+### Multi-Tenant Setup
 
 ```typescript
-@Entity({ name: 'translation_key' })
-export class TranslationKey extends Identity {
-  @Column({ type: 'varchar', length: 100 })
-  module!: string;
-
-  @Column({ type: 'varchar', length: 255 })
-  key!: string;
+LocalizationModule.forRootAsync({
+  global: true,
+  bootstrapAppConfig: {
+    databaseMode: 'multi-tenant',
+    enableCompanyFeature: false,
+  },
+  useFactory: (): ILocalizationModuleConfig => ({
+    tenantDefaultDatabaseConfig: {
+      type: 'postgres',
+      host: process.env.DB_HOST,
+      port: Number(process.env.DB_PORT),
+      username: process.env.DB_USER,
+      password: process.env.DB_PASSWORD,
+    },
+    tenants: [
+      { id: 'tenant1', database: 'tenant1_db' },
+      { id: 'tenant2', database: 'tenant2_db' },
+    ],
+    defaultLanguageCode: 'en',
+  }),
+})
+```
 
-  @Column({ type: 'varchar', length: 500, name: 'default_message' })
-  defaultMessage!: string;
+**Exported services:**
+- `LocalizationConfigService`
+- `LocalizationDataSourceProvider`
+- `LanguageService`
+- `TranslationKeyService`
+- `TranslationService`
 
-  @Column({ type: 'text', nullable: true })
-  description!: string | null;
+---
 
-  @Column({ type: 'simple-array', nullable: true })
-  variables!: string[] | null;
+## Configuration Reference
 
-  @Column({ type: 'boolean', default: true, name: 'is_active' })
-  isActive!: boolean;
+```typescript
+interface ILocalizationModuleConfig extends IDataSourceServiceOptions {
+  /** Default language code for fallback (default: 'en') */
+  defaultLanguageCode?: string;
 
-  @Column({ type: 'int', nullable: true })
-  serial!: number | null;
+  /** Enable translation caching (default: false) */
+  enableCaching?: boolean;
 
-  @OneToMany('Translation', 'translationKey')
-  translations?: Translation[];
+  /** Cache TTL in seconds (default: 300) */
+  cacheTtlSeconds?: number;
 }
 ```
 
-### Translation Entity
-
-```typescript
-@Entity({ name: 'translation' })
-export class Translation extends Identity {
-  @Column({ type: 'uuid', name: 'language_id' })
-  languageId!: string;
-
-  @Column({ type: 'uuid', name: 'translation_key_id' })
-  translationKeyId!: string;
-
-  @Column({ type: 'text' })
-  value!: string;
-
-  @Column({ type: 'boolean', default: false, name: 'is_verified' })
-  isVerified!: boolean;
+---
 
-  @Column({ type: 'boolean', default: true, name: 'is_active' })
-  isActive!: boolean;
+## Feature Toggles
 
-  @ManyToOne(() => Language)
-  @JoinColumn({ name: 'language_id' })
-  language?: Language;
+| Feature | Config | Default | Effect |
+|---------|--------|---------|--------|
+| Caching | `enableCaching: true` | `false` | Translations cached in HybridCache with `cacheTtlSeconds` TTL |
+| Multi-tenant | `databaseMode: 'multi-tenant'` | `'single'` | Per-tenant DataSource connections |
 
-  @ManyToOne(() => TranslationKey)
-  @JoinColumn({ name: 'translation_key_id' })
-  translationKey?: TranslationKey;
-}
-```
+> **Note:** Localization entities do **not** have company variants (`enableCompanyFeature` is ignored). All translation data is shared across companies.
 
 ---
 
-## Services
+## API Endpoints
 
-### LanguageService
+All endpoints use **POST**. Authentication is required unless noted.
 
-CRUD operations for languages:
+### Languages — `POST /localization/language/*`
 
-```typescript
-@Injectable({ scope: Scope.REQUEST })
-export class LanguageService extends RequestScopedApiService<...> {
-  // Inherited CRUD from RequestScopedApiService
-  // insert(), update(), delete(), findById(), findAll()
-
-  // Get active languages (public, no auth)
-  async getActiveLanguages(): Promise<Language[]>;
+| Endpoint | Permission | Description |
+|----------|-----------|-------------|
+| `POST /localization/language/insert` | `language.create` | Create a language |
+| `POST /localization/language/get-all` | Public | List all active languages |
+| `POST /localization/language/get/:id` | `language.read` | Get language by ID |
+| `POST /localization/language/update` | `language.update` | Update language |
+| `POST /localization/language/delete` | `language.delete` | Delete language |
+| `POST /localization/language/set-default` | `language.update` | Set as default language |
 
-  // Get default language
-  async getDefaultLanguage(): Promise<Language | null>;
+**Create language:**
 
-  // Set default language (unsets previous default)
-  async setDefaultLanguage(id: string): Promise<Language>;
+```json
+POST /localization/language/insert
+{
+  "name": "English",
+  "nativeName": "English",
+  "code": "en",
+  "direction": "ltr",
+  "isActive": true,
+  "isDefault": true
 }
 ```
 
-### TranslationKeyService
-
-CRUD operations for translation keys:
-
-```typescript
-@Injectable({ scope: Scope.REQUEST })
-export class TranslationKeyService extends RequestScopedApiService<...> {
-  // Inherited CRUD from RequestScopedApiService
-
-  // Get keys by module
-  async getByModule(module: string): Promise<TranslationKey[]>;
-
-  // Get all unique modules
-  async getModules(): Promise<string[]>;
+```json
+POST /localization/language/insert
+{
+  "name": "Arabic",
+  "nativeName": "العربية",
+  "code": "ar",
+  "direction": "rtl",
+  "isActive": true
 }
 ```
 
-### TranslationService
-
-Translation operations with queries:
+### Translation Keys — `POST /localization/translation-key/*`
 
-```typescript
-@Injectable({ scope: Scope.REQUEST })
-export class TranslationService extends RequestScopedApiService<...> {
-  // Inherited CRUD from RequestScopedApiService
+| Endpoint | Permission | Description |
+|----------|-----------|-------------|
+| `POST /localization/translation-key/insert` | `translation-key.create` | Register a new translation key |
+| `POST /localization/translation-key/get-all` | `translation-key.read` | List all keys |
+| `POST /localization/translation-key/get/:id` | `translation-key.read` | Get key by ID |
+| `POST /localization/translation-key/get-by-module` | `translation-key.read` | Get all keys for a module |
+| `POST /localization/translation-key/update` | `translation-key.update` | Update key (not readonly keys) |
+| `POST /localization/translation-key/delete` | `translation-key.delete` | Delete key (not readonly) |
+| `POST /localization/translation-key/get-missing` | `translation-key.read` | Get keys with no translation for a language |
 
-  // Get all translations for a language (public, no auth)
-  async getByLanguageCode(languageCode: string): Promise<ITranslationsMap>;
+**Register a key:**
 
-  // Get translations by module and language (public, no auth)
-  async getByModuleAndLanguage(module: string, languageCode: string): Promise<ITranslationsMap>;
+```json
+POST /localization/translation-key/insert
+{
+  "key": "auth.login_success",
+  "module": "auth",
+  "description": "Shown after successful login",
+  "defaultValue": "Login successful",
+  "variables": [],
+  "isReadonly": true
+}
+```
 
-  // Bulk update translation values
-  async bulkUpdate(updates: BulkUpdateTranslationDto[]): Promise<Translation[]>;
+**Key with variables:**
 
-  // Get translation keys missing translations for a language
-  async getMissingTranslations(languageCode: string): Promise<TranslationKey[]>;
+```json
+{
+  "key": "user.welcome",
+  "module": "auth",
+  "description": "Welcome message with user name",
+  "defaultValue": "Welcome, {{name}}!",
+  "variables": ["name"],
+  "isReadonly": false
 }
 ```
 
-### LocalizationHelperService
+### Translations — `POST /localization/translation/*`
 
-Variable interpolation utilities:
+| Endpoint | Permission | Description |
+|----------|-----------|-------------|
+| `POST /localization/translation/insert` | `translation.create` | Add a translation value |
+| `POST /localization/translation/get-all` | `translation.read` | List all translations |
+| `POST /localization/translation/get-by-language` | Public | Get all translations for a language |
+| `POST /localization/translation/get-by-language-module` | Public | Get translations for a language + module |
+| `POST /localization/translation/update` | `translation.update` | Update a translation value |
+| `POST /localization/translation/bulk-update` | `translation.update` | Bulk update translations (atomic) |
+| `POST /localization/translation/delete` | `translation.delete` | Delete a translation |
+| `POST /localization/translation/verify` | `translation.update` | Mark a translation as verified |
+| `POST /localization/translation/unverify` | `translation.update` | Mark a translation as unverified |
 
-```typescript
-@Injectable()
-export class LocalizationHelperService {
-  // Replace {{variable}} placeholders with values
-  interpolate(template: string, variables?: Record<string, string | number>): string;
+**Add a translation:**
 
-  // Extract variable names from template
-  extractVariables(template: string): string[];
+```json
+POST /localization/translation/insert
+{
+  "keyId": "uuid-of-translation-key",
+  "languageId": "uuid-of-language",
+  "value": "Connexion réussie"
 }
 ```
 
-**Example:**
-
-```typescript
-const helper = inject(LocalizationHelperService);
-
-const result = helper.interpolate('Hello, {{name}}!', { name: 'John' });
-// Output: "Hello, John!"
+**Bulk update (atomic transaction):**
 
-const vars = helper.extractVariables('Welcome {{user}}, you have {{count}} items');
-// Output: ['user', 'count']
+```json
+POST /localization/translation/bulk-update
+{
+  "languageId": "uuid-of-french",
+  "translations": [
+    { "keyId": "uuid-1", "value": "Connexion réussie" },
+    { "keyId": "uuid-2", "value": "Bienvenue, {{name}}!" },
+    { "keyId": "uuid-3", "value": "Mot de passe incorrect" }
+  ]
+}
 ```
 
 ---
 
-## Controllers
-
-All endpoints follow **POST-only RPC** style (not REST).
-
-### Language Controller
-
-| Endpoint | Auth | Permission | Description |
-|----------|------|------------|-------------|
-| `POST /localization/language/insert` | JWT | `language.create` | Create language |
-| `POST /localization/language/update` | JWT | `language.update` | Update language |
-| `POST /localization/language/delete` | JWT | `language.delete` | Delete language |
-| `POST /localization/language/get-by-id` | JWT | `language.read` | Get by ID |
-| `POST /localization/language/get-all` | JWT | `language.read` | Get all with pagination |
-| `POST /localization/language/get-active` | None | - | Get active languages |
-| `POST /localization/language/get-default` | None | - | Get default language |
-| `POST /localization/language/set-default` | JWT | `language.update` | Set default language |
-
-### TranslationKey Controller
-
-| Endpoint | Auth | Permission | Description |
-|----------|------|------------|-------------|
-| `POST /localization/translation-key/insert` | JWT | `translation-key.create` | Create key |
-| `POST /localization/translation-key/update` | JWT | `translation-key.update` | Update key |
-| `POST /localization/translation-key/delete` | JWT | `translation-key.delete` | Delete key |
-| `POST /localization/translation-key/get-by-id` | JWT | `translation-key.read` | Get by ID |
-| `POST /localization/translation-key/get-all` | JWT | `translation-key.read` | Get all with pagination |
-| `POST /localization/translation-key/get-by-module` | JWT | `translation-key.read` | Get keys by module |
-| `POST /localization/translation-key/get-modules` | JWT | `translation-key.read` | Get all unique module names |
-
-### Translation Controller
-
-| Endpoint | Auth | Permission | Description |
-|----------|------|------------|-------------|
-| `POST /localization/translation/insert` | JWT | `translation.create` | Create translation |
-| `POST /localization/translation/update` | JWT | `translation.update` | Update translation |
-| `POST /localization/translation/delete` | JWT | `translation.delete` | Delete translation |
-| `POST /localization/translation/get-by-id` | JWT | `translation.read` | Get by ID |
-| `POST /localization/translation/get-all` | JWT | `translation.read` | Get all with pagination |
-| `POST /localization/translation/get-by-language` | None | - | Get translations by language code |
-| `POST /localization/translation/get-by-module` | None | - | Get translations by module + language |
-| `POST /localization/translation/update-many-values` | JWT | `translation.update` | Bulk update translations |
-| `POST /localization/translation/get-missing` | JWT | `translation.read` | Get missing translations |
-
----
+## Entities
 
-## DTOs
+| Entity | Table | Description |
+|--------|-------|-------------|
+| `Language` | `localization_language` | Language with code, direction, default flag |
+| `TranslationKey` | `localization_translation_key` | Key registry with module, variables, readonly flag |
+| `Translation` | `localization_translation` | Per-language translation values with verification status |
 
-### Language DTOs
+> Localization entities have **no company variants**. All translation data is shared globally.
 
 ```typescript
-// Create
-interface CreateLanguageDto {
-  code: string;         // Required, ISO 639-1
-  name: string;         // Required
-  nativeName?: string;
-  direction?: 'ltr' | 'rtl';
-  isActive?: boolean;
-  isDefault?: boolean;
-  serial?: number;
-}
-
-// Update
-interface UpdateLanguageDto extends Partial<CreateLanguageDto> {
-  id: string;  // Required
-}
+import { LocalizationModule } from '@flusys/nestjs-localization';
 
-// Response
-interface LanguageResponseDto {
-  id: string;
-  code: string;
-  name: string;
-  nativeName: string | null;
-  direction: 'ltr' | 'rtl' | null;
-  isActive: boolean;
-  isDefault: boolean;
-  serial: number | null;
-  createdAt: Date;
-  updatedAt: Date;
-}
+TypeOrmModule.forRoot({
+  entities: [
+    ...LocalizationModule.getEntities(),
+    // other entities
+  ],
+})
 ```
 
-### TranslationKey DTOs
+---
 
-```typescript
-// Create
-interface CreateTranslationKeyDto {
-  module: string;        // Required
-  key: string;           // Required
-  defaultMessage: string; // Required
-  description?: string;
-  variables?: string[];
-  isActive?: boolean;
-  serial?: number;
-}
+## Translation Workflow
 
-// Update
-interface UpdateTranslationKeyDto extends Partial<CreateTranslationKeyDto> {
-  id: string;  // Required
-}
+```
+1. Create Language       → POST /localization/language/insert
+2. Register Key          → POST /localization/translation-key/insert
+3. Add Translation       → POST /localization/translation/insert
+4. Verify Translation    → POST /localization/translation/verify
+5. Detect Missing        → POST /localization/translation-key/get-missing
+6. Bulk Update           → POST /localization/translation/bulk-update
 ```
 
-### Translation DTOs
-
-```typescript
-// Create
-interface CreateTranslationDto {
-  languageId: string;      // Required
-  translationKeyId: string; // Required
-  value: string;           // Required
-  isVerified?: boolean;
-  isActive?: boolean;
-}
+Translation statuses:
+- **Unverified** (default) — Draft translation, may not be production-ready
+- **Verified** — Approved by a translator or admin
 
-// Update
-interface UpdateTranslationDto extends Partial<CreateTranslationDto> {
-  id: string;  // Required
-}
+---
 
-// Bulk Update
-interface BulkUpdateTranslationDto {
-  id: string;
-  value: string;
-  isVerified?: boolean;
-}
+## Variable Interpolation
 
-interface BulkUpdateTranslationsDto {
-  translations: BulkUpdateTranslationDto[];
-}
+Translation values use `{{variableName}}` syntax. The `messageVariables` field in API responses carries the variable values that should be interpolated by the frontend:
 
-// Query DTOs
-interface GetTranslationsByLanguageDto {
-  languageCode: string;
-}
+**Server response:**
 
-interface GetTranslationsByModuleDto {
-  module: string;
-  languageCode: string;
+```json
+{
+  "success": true,
+  "message": "Welcome, John!",
+  "messageKey": "user.welcome",
+  "messageVariables": { "name": "John" }
 }
 ```
 
----
-
-## Interfaces
-
-### ILanguage
+**Frontend interpolation:**
 
 ```typescript
-interface ILanguage {
-  id: string;
-  code: string;
-  name: string;
-  nativeName: string | null;
-  direction: 'ltr' | 'rtl' | null;
-  isActive: boolean;
-  isDefault: boolean;
-  serial: number | null;
-}
+// Fetch translation for 'user.welcome': "Bienvenue, {{name}}!"
+const template = translations['user.welcome'];
+const message = template.replace(/\{\{(\w+)\}\}/g, (_, key) => variables[key] ?? key);
+// Result: "Bienvenue, John!"
 ```
 
-### ITranslationKey
+---
 
-```typescript
-interface ITranslationKey {
-  id: string;
-  module: string;
-  key: string;
-  defaultMessage: string;
-  description: string | null;
-  variables: string[] | null;
-  isActive: boolean;
-  serial: number | null;
-}
-```
+## Fallback Chain
 
-### ITranslation
+When a translation is not found for the requested language, the resolution falls back in this order:
 
-```typescript
-interface ITranslation {
-  id: string;
-  languageId: string;
-  translationKeyId: string;
-  value: string;
-  isVerified: boolean;
-  isActive: boolean;
-}
 ```
-
-### ITranslationsMap
-
-```typescript
-type ITranslationsMap = Record<string, string>;
-
-// Example
-{
-  'shared.save': 'Save',
-  'shared.cancel': 'Cancel',
-  'auth.login.title': 'Login',
-}
+Requested language → Default language (e.g., 'en') → key.defaultValue → key itself
 ```
 
 ---
 
-## Permissions
-
-| Resource | Permission | Description |
-|----------|------------|-------------|
-| Language | `language.create` | Create languages |
-| Language | `language.read` | Read languages |
-| Language | `language.update` | Update languages |
-| Language | `language.delete` | Delete languages |
-| TranslationKey | `translation-key.create` | Create keys |
-| TranslationKey | `translation-key.read` | Read keys |
-| TranslationKey | `translation-key.update` | Update keys |
-| TranslationKey | `translation-key.delete` | Delete keys |
-| Translation | `translation.create` | Create translations |
-| Translation | `translation.read` | Read translations |
-| Translation | `translation.update` | Update translations |
-| Translation | `translation.delete` | Delete translations |
+## RTL Support
 
----
+Each language has a `direction` field: `'ltr'` (left-to-right) or `'rtl'` (right-to-left).
 
-## Data Flow
+The frontend uses this to switch layout direction:
 
-### Public Translation Request
-
-```
-Frontend requests translations
-        ↓
-POST /localization/translation/get-by-language
-{ languageCode: 'en' }
-        ↓
-TranslationController.getByLanguage()
-        ↓
-TranslationService.getByLanguageCode('en')
-        ↓
-Find language by code (active only)
-        ↓
-Query translations with JOIN on translation_key
-        ↓
-Build ITranslationsMap { key: value }
-        ↓
-Return SingleResponseDto<ITranslationsMap>
-```
-
-### Admin Translation Update
-
-```
-Admin updates translations
-        ↓
-POST /localization/translation/update-many-values
-{ translations: [{ id, value, isVerified }] }
-        ↓
-JWT Auth + permission check (translation.update)
-        ↓
-TranslationController.updateManyValues()
-        ↓
-TranslationService.bulkUpdate(translations)
-        ↓
-Update each translation in database
-        ↓
-Return BulkResponseDto with updated count
+```typescript
+// Angular
+const lang = await this.http.post('/localization/language/get-all', {}).toPromise();
+const current = lang.data.find(l => l.code === userLanguageCode);
+document.dir = current.direction; // 'ltr' or 'rtl'
 ```
 
 ---
 
-## Usage Examples
-
-### Inject Services
-
-```typescript
-import { TranslationService, LanguageService } from '@flusys/nestjs-localization';
-
-@Injectable()
-export class MyService {
-  constructor(
-    private readonly translationService: TranslationService,
-    private readonly languageService: LanguageService,
-  ) {}
-
-  async getTranslationsForUser(languageCode: string) {
-    return this.translationService.getByLanguageCode(languageCode);
-  }
-
-  async getActiveLanguages() {
-    return this.languageService.getActiveLanguages();
-  }
-}
-```
+## Caching
 
-### Variable Interpolation
+When `enableCaching: true`, translation lookups are cached with the key pattern `loc:{languageCode}:{module}`. Cache is invalidated when translations are updated via the bulk-update or individual update endpoints.
 
 ```typescript
-import { LocalizationHelperService } from '@flusys/nestjs-localization';
-
-@Injectable()
-export class NotificationService {
-  constructor(private readonly helper: LocalizationHelperService) {}
-
-  formatMessage(template: string, user: User) {
-    return this.helper.interpolate(template, {
-      name: user.name,
-      count: user.notifications.length,
-    });
-  }
+config: {
+  enableCaching: true,
+  cacheTtlSeconds: 600, // 10 minutes
 }
 ```
 
-### Seeding Languages
+Requires `HybridCache` (Redis or in-memory) to be configured via `CacheModule` from `@flusys/nestjs-shared`.
 
-```typescript
-// seed/languages.seed.ts
-const languages = [
-  { code: 'en', name: 'English', nativeName: 'English', direction: 'ltr', isDefault: true, isActive: true },
-  { code: 'ar', name: 'Arabic', nativeName: 'العربية', direction: 'rtl', isActive: true },
-  { code: 'fr', name: 'French', nativeName: 'Français', direction: 'ltr', isActive: true },
-];
-
-// Use LanguageService to seed
-for (const lang of languages) {
-  await languageService.insert(lang);
-}
-```
+---
 
-### Seeding Translation Keys
+## Exported Services
 
-```typescript
-const keys = [
-  { module: 'shared', key: 'shared.save', defaultMessage: 'Save' },
-  { module: 'shared', key: 'shared.cancel', defaultMessage: 'Cancel' },
-  { module: 'auth', key: 'auth.login.title', defaultMessage: 'Login' },
-  { module: 'auth', key: 'auth.welcome', defaultMessage: 'Welcome, {{name}}!', variables: ['name'] },
-];
-```
+| Service | Description |
+|---------|-------------|
+| `LanguageService` | Language CRUD, default language management |
+| `TranslationKeyService` | Key CRUD, missing-key detection, module filtering |
+| `TranslationService` | Translation CRUD, bulk update, verification |
+| `LocalizationConfigService` | Runtime config (default language, caching settings) |
+| `LocalizationDataSourceProvider` | Dynamic DataSource per request |
 
 ---
 
-## Caching
+## Integration with API Responses
 
-When `enableCaching: true`:
+All FLUSYS response DTOs include `messageKey` and optionally `messageVariables`. The frontend uses these to display localized messages:
 
-- Translations are cached using HybridCache
-- Cache key format: `localization:translations:{languageCode}`
-- TTL configured via `cacheTtlSeconds`
-- Cache invalidated on translation updates
-
----
+**Backend (any service):**
 
-## Frontend Integration
+```typescript
+return {
+  success: true,
+  message: 'Welcome, John!',
+  messageKey: 'user.welcome',
+  messageVariables: { name: 'John' },
+  data: userDto,
+};
+```
 
-The backend serves translations to the frontend using **module-wise loading**:
+**Frontend flow:**
 
-### Module-Wise Loading Pattern
+1. On app init: `GET /localization/translation/get-by-language` for the user's language
+2. Cache translations in a map: `{ 'user.welcome': 'Bienvenue, {{name}}!' }`
+3. On every API response: look up `messageKey`, interpolate `messageVariables`
+4. Display the localized message
 
-Frontend loads translations **per-module** as users navigate, NOT all at once:
+---
 
-```
-App Init
-        ↓
-POST /localization/language/get-active → Load available languages
-        ↓
-User navigates to protected route
-        ↓
-POST /localization/translation/get-by-module
-{ module: 'shared', languageCode: 'en' }
-        ↓
-POST /localization/translation/get-by-module
-{ module: 'layout', languageCode: 'en' }
-        ↓
-User navigates to /storage
-        ↓
-POST /localization/translation/get-by-module
-{ module: 'storage', languageCode: 'en' }
-```
+## Troubleshooting
 
-### Available Modules
+**`Language not found` for a valid code**
 
-> **Key Format:** All translation keys use **full dot-case** — every word separated by a dot, all lowercase. No camelCase anywhere in keys.
-> ```
-> ✅ event.manager.event.create.success
-> ❌ eventManager.eventCreateSuccess
-> ```
+Use the language's UUID (`id`), not the ISO code, in most endpoints. Use `get-by-language` with the code only for the public translation endpoints.
 
-| Module | Keys Prefix | Description |
-|--------|-------------|-------------|
-| `shared` | `shared.*` | Common UI labels, actions, validation messages |
-| `layout` | `layout.*` | Layout, navigation, topbar labels |
-| `auth` | `auth.*` | Login, register, password, user management |
-| `iam` | `iam.*` | Roles, permissions, actions |
-| `storage` | `storage.*` | File upload, folders, storage config |
-| `formBuilder` | `formBuilder.*` | Form builder UI |
-| `email` | `email.*` | Email templates, config |
-| `notification` | `notification.*` | Notifications |
-| `eventManager` | `event.manager.*` | Calendar, events |
-| `localization` | `localization.*` | Language & translation admin UI |
+---
 
-### When Frontend Localization is ENABLED
+**Translation not returned for a module**
 
-1. **App Init:** Frontend calls `POST /localization/language/get-active`
-2. **Route Navigation:** Frontend calls `POST /localization/translation/get-by-module` for each feature
-3. **Language Switch:** Frontend reloads translations for already-loaded modules
+Check the `module` field on the `TranslationKey`. The `get-by-language-module` endpoint filters strictly by module name. Ensure it matches exactly (case-sensitive).
 
-### When Frontend Localization is DISABLED
+---
 
-1. Frontend skips all API calls to localization endpoints
-2. Frontend uses hardcoded fallback messages only
-3. Backend localization module is not utilized (can still be included for admin use)
+**Missing keys not detected**
 
-### Response Format
+`get-missing` returns keys that have no `Translation` record for the given language. If you created a translation but left `value` empty, it is still counted as "present" (not missing). Delete or update the empty translation to see it in the missing list.
 
-All public endpoints return consistent format:
+---
 
-```typescript
-// GET Active Languages
-{
-  success: true,
-  data: [
-    { id: '...', code: 'en', name: 'English', nativeName: 'English', direction: 'ltr', isDefault: true },
-    { id: '...', code: 'ar', name: 'Arabic', nativeName: 'العربية', direction: 'rtl', isDefault: false }
-  ]
-}
+**Caching returning stale translations**
 
-// GET Translations by Module
-{
-  success: true,
-  data: {
-    'storage.folders.title': 'Folders',
-    'storage.upload.success': 'File uploaded successfully',
-    'storage.delete.confirm': 'Are you sure you want to delete this file?'
-  }
-}
-```
+When `enableCaching: true`, call `POST /localization/translation/bulk-update` (which invalidates the cache) instead of individual updates if you need immediate cache refresh.
 
 ---
 
-## Best Practices
+**`No metadata for entity`**
 
-| Practice | Description |
-|----------|-------------|
-| **Module Organization** | Group keys by module (auth, shared, storage) |
-| **Key Naming** | Use full dot-case: `module.feature.action` — all lowercase, dots only, no camelCase |
-| **Default Messages** | Always provide meaningful defaults |
-| **Document Variables** | Use `variables` array to document required placeholders |
-| **Description Field** | Add context for translators |
-| **Soft Delete** | Use soft delete for translations (recoverable) |
-| **Bulk Operations** | Use bulk update for efficiency |
+Register entities:
+```typescript
+entities: [...LocalizationModule.getEntities()]
+```
 
 ---
 
-## Public API Exports
+## License
 
-| Category | Exports |
-|----------|---------|
-| **Entities** | `Language`, `TranslationKey`, `Translation` |
-| **Interfaces** | `ILanguage`, `ITranslationKey`, `ITranslation`, `ITranslationsMap`, `ILocalizationModuleConfig`, `LocalizationModuleOptions` |
-| **DTOs** | `CreateLanguageDto`, `UpdateLanguageDto`, `LanguageResponseDto`, `CreateTranslationKeyDto`, `UpdateTranslationKeyDto`, `TranslationKeyResponseDto`, `CreateTranslationDto`, `UpdateTranslationDto`, `TranslationResponseDto`, `BulkUpdateTranslationsDto`, `GetTranslationsByLanguageDto`, `GetTranslationsByModuleDto` |
-| **Services** | `LanguageService`, `TranslationKeyService`, `TranslationService`, `LocalizationHelperService`, `LocalizationConfigService`, `LocalizationDataSourceProvider` |
-| **Controllers** | `LanguageController`, `TranslationKeyController`, `TranslationController` |
-| **Module** | `LocalizationModule` |
-| **Constants** | `LOCALIZATION_MODULE_OPTIONS` |
+MIT © FLUSYS
 
 ---
 
-**Last Updated:** 2026-03-01
-**Version:** 3.0.2
-**NestJS Version:** 11
+> Part of the **FLUSYS** framework — a full-stack monorepo powering Angular 21 + NestJS 11 applications.

package/controllers/language.controller.d.ts

@@ -4,12 +4,17 @@ import { CreateLanguageDto, LanguageResponseDto, UpdateLanguageDto } from '../dt
 import { ILanguage } from '../interfaces';
 import { LanguageService } from '../services';
 declare const LanguageController_base: abstract new (service: LanguageService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared/classes").ApiEndpoint[] | "all";
     service: LanguageService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared/classes").ApiEndpoint): boolean;
     insert(addDto: CreateLanguageDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
     insertMany(addDto: CreateLanguageDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<LanguageResponseDto>>;
     getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared/dtos").GetByIdsDto, user: ILoggedUserInfo | null): Promise<ListResponseDto<LanguageResponseDto>>;
     update(updateDto: UpdateLanguageDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
     updateMany(updateDtos: UpdateLanguageDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<LanguageResponseDto>>;
+    bulkUpsert(dtos: (CreateLanguageDto | UpdateLanguageDto)[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<LanguageResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
     getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<LanguageResponseDto>>;
     delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").MessageResponseDto>;
 };

package/controllers/translation-key.controller.d.ts

@@ -4,12 +4,17 @@ import { CreateTranslationKeyDto, GetByModuleDto, TranslationKeyResponseDto, Upd
 import { ITranslationKey } from '../interfaces';
 import { TranslationKeyService } from '../services';
 declare const TranslationKeyController_base: abstract new (service: TranslationKeyService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared/classes").ApiEndpoint[] | "all";
     service: TranslationKeyService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared/classes").ApiEndpoint): boolean;
     insert(addDto: CreateTranslationKeyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationKeyResponseDto>>;
     insertMany(addDto: CreateTranslationKeyDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<TranslationKeyResponseDto>>;
     getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationKeyResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared/dtos").GetByIdsDto, user: ILoggedUserInfo | null): Promise<ListResponseDto<TranslationKeyResponseDto>>;
     update(updateDto: UpdateTranslationKeyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationKeyResponseDto>>;
     updateMany(updateDtos: UpdateTranslationKeyDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<TranslationKeyResponseDto>>;
+    bulkUpsert(dtos: (CreateTranslationKeyDto | UpdateTranslationKeyDto)[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<TranslationKeyResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationKeyResponseDto>>;
     getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<TranslationKeyResponseDto>>;
     delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").MessageResponseDto>;
 };

package/controllers/translation.controller.d.ts

@@ -4,12 +4,17 @@ import { BulkUpdateTranslationsDto, CreateTranslationDto, GetTranslationsByLangu
 import { ITranslation, ITranslationKey, ITranslationsMap } from '../interfaces';
 import { TranslationService } from '../services';
 declare const TranslationController_base: abstract new (service: TranslationService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared/classes").ApiEndpoint[] | "all";
     service: TranslationService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared/classes").ApiEndpoint): boolean;
     insert(addDto: CreateTranslationDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationResponseDto>>;
     insertMany(addDto: CreateTranslationDto[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<TranslationResponseDto>>;
     getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared/dtos").GetByIdsDto, user: ILoggedUserInfo | null): Promise<ListResponseDto<TranslationResponseDto>>;
     update(updateDto: UpdateTranslationDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationResponseDto>>;
     updateMany(updateDtos: UpdateTranslationDto[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<TranslationResponseDto>>;
+    bulkUpsert(dtos: (CreateTranslationDto | UpdateTranslationDto)[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<TranslationResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TranslationResponseDto>>;
     getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<TranslationResponseDto>>;
     delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").MessageResponseDto>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-localization",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Localization module for multi-language support",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -75,7 +75,7 @@
     "express": "^4.18.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "4.0.1",
-    "@flusys/nestjs-shared": "4.0.1"
+    "@flusys/nestjs-core": "4.1.0",
+    "@flusys/nestjs-shared": "4.1.0"
   }
 }