maskify-ts

https://www.npmjs.com/package/maskify-ts
Admin
Production-grade data masking library for Node.js and TypeScript with GDPR/HIPAA/PCI-DSS compliance,...
Tokens:18,218
Snippets:188
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Quick Start: Basic Masking Examples

Source: https://www.npmjs.com/package/maskify-ts?activeTab=dependencies

Demonstrates basic PII detection and masking for single values, including automatic type detection and forcing specific maskers. Also shows free-text masking and deep object masking with a schema.

```typescript
import { Maskify } from 'maskify-ts';

// Single value — detects the PII type automatically
Maskify.mask('jane.doe@company.com');        // → 'j*******e@c******y.com'
Maskify.mask('4111 1111 1111 1111');         // → '**** **** **** 1111'
Maskify.mask('+1 (415) 555-0123');           // → '+**********0123'

// Force a specific masker
Maskify.mask('eyJhbGciOi...xyz', { type: 'jwt' });

// Free-text (logs, chat messages)
Maskify.smart('User jane@company.com logged in from 10.0.0.1');
// → 'User j**@c*******y.com logged in from **.*.*.'

// Deep object masking with a schema
Maskify.maskSensitiveFields(
  { user: { email: 'jane@company.com', cards: [{ number: '4111111111111111' }] } },
  {
    'user.email': { type: 'email' },
    'user.cards[*].number': { type: 'card' },
  },
);
```

--------------------------------

### Quick Start with maskify-ts

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Demonstrates basic usage of maskify-ts for single value masking, free-text sanitization, and deep object masking with a schema.

```typescript
import { Maskify } from 'maskify-ts';

// Single value — detects the PII type automatically
Maskify.mask('jane.doe@company.com');        // → 'j*******e@c******y.com'
Maskify.mask('4111 1111 1111 1111');         // → '**** **** **** 1111'
Maskify.mask('+1 (415) 555-0123');           // → '+**********0123'

// Force a specific masker
Maskify.mask('eyJhbGciOi...xyz', { type: 'jwt' });

// Free-text (logs, chat messages)
Maskify.smart('User jane@company.com logged in from 10.0.0.12');
// → 'User j**@c*******y.com logged in from **.*.*.**'

// Deep object masking with a schema
Maskify.maskSensitiveFields(
  { user: { email: 'jane@company.com', cards: [{ number: '4111111111111111' }] } },
  {
    'user.email': { type: 'email' },
    'user.cards[*].number': { type: 'card' },
  },
);
```

--------------------------------

### Install maskify-ts

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Install the maskify-ts package using npm, pnpm, or yarn. Framework adapters may require additional peer dependencies.

```bash
npm install maskify-ts
# or
pnpm add maskify-ts
# or
yarn add maskify-ts
```

```bash
# Express
npm install express
# Fastify
npm install fastify fastify-plugin
```

--------------------------------

### Install Maskify-TS Package

Source: https://www.npmjs.com/package/maskify-ts

Command to install the maskify-ts package using npm.

```bash
npm i maskify-ts
```

--------------------------------

### Quick Start with maskify-ts

Source: https://www.npmjs.com/package/maskify-ts

Demonstrates basic usage of maskify-ts for single value masking, PII detection, free-text sanitization, and deep object masking with a schema.

```typescript
import { Maskify } from 'maskify-ts';

// Single value — detects the PII type automatically
Maskify.mask('jane.doe@company.com');        // → 'j*******e@c******y.com'
Maskify.mask('4111 1111 1111 1111');         // → '**** **** **** 1111'
Maskify.mask('+1 (415) 555-0123');           // → '+**********0123'

// Force a specific masker
Maskify.mask('eyJhbGciOi...xyz', { type: 'jwt' });

// Free-text (logs, chat messages)
Maskify.smart('User jane@company.com logged in from 10.0.0.1');
// → 'User j**@c*******y.com logged in from **.*.*.**'

// Deep object masking with a schema
Maskify.maskSensitiveFields(
  { user: { email: 'jane@company.com', cards: [{ number: '4111111111111111' }] } },
  {
    'user.email': { type: 'email' },
    'user.cards[*].number': { type: 'card' },
  },
);
```

--------------------------------

### Maskify CLI Usage Examples

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Utilize the Maskify CLI for command-line data masking. Examples cover piping JSON logs, specifying fields, custom mask characters, allowlisting, and accessing help.

```bash
# Pipe JSON log lines through masking
cat app.log | npx maskify

# Pick specific fields
cat app.log | npx maskify --fields email,phone,password

# Custom mask character
npx maskify -f email -c '•' < app.log

# Allowlist mode — mask everything except listed fields
npx maskify --allow --fields id,createdAt < app.log

# Help
npx maskify --help
```

--------------------------------

### Run Benchmarks with npm

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Executes the performance benchmarks for the maskify-ts package using the mitata test runner. This command is useful for verifying performance optimizations.

```bash
npm run bench
```

--------------------------------

### Loading Global Configuration with Strict Mode

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Use `GlobalConfigLoader.load` to load configuration, with the `strict: true` option to throw `MaskifyConfigError` on syntax errors. `GlobalConfigLoader.reload` can be used to clear the cache.

```typescript
import { GlobalConfigLoader } from 'maskify-ts';

GlobalConfigLoader.load({ strict: true });  // throws MaskifyConfigError on bad syntax
GlobalConfigLoader.reload();                // clears the cache
```

--------------------------------

### Configuring Maskify with a Configuration File

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Drop a configuration file (e.g., `maskify.config.ts`) at the project root to automatically apply settings to all `Maskify.*` calls. Supports various file formats and naming conventions.

```typescript
// maskify.config.ts
import { defineConfig } from 'maskify-ts';

export default defineConfig({
  mode: 'mask',
  fields: [
    'email',
    'password',
    { name: 'creditCard', options: { type: 'card' } },
  ],
  maskOptions: {
    maskChar: '•',
    visibleEnd: 4,
  },
});
```

--------------------------------

### Register Custom Maskers with Maskify

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Register custom masking functions either process-wide using the default `registry` or locally for isolated contexts like testing. Demonstrates registering an 'iban' masker and an 'ssn' masker.

```typescript
import { MaskerRegistry, Maskify } from 'maskify-ts';

// Process-wide
import { registry } from 'maskify-ts';
registry.register('iban', (value) =>
  value.slice(0, 4) + '*'.repeat(Math.max(0, value.length - 8)) + value.slice(-4),
);

Maskify.mask('GB82WEST12345698765432', { type: 'iban' });

// Isolated (testing / request-scoped)
const local = MaskerRegistry.create();
local.register('ssn', (v) => '***-**-' + v.slice(-4));
local.types();   // ['ssn']
local.has('ssn'); // true
```

--------------------------------

### Handle Maskify Errors in TypeScript

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Demonstrates how to catch and differentiate between various Maskify errors, such as configuration or validation errors. Use this to provide specific feedback to users or for debugging.

```typescript
import {
  MaskifyError,
  MaskifyValidationError,
  MaskifyConfigError,
} from 'maskify-ts';

try {
  Maskify.deterministic(email, { secret: '' });
} catch (err) {
  if (err instanceof MaskifyConfigError) {
    console.error(err.message, '\nHint:', err.hint);
  }
}
```

--------------------------------

### Maskify.smart for Free-Text

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Tokenizes and masks PII within free-text strings, suitable for log sanitization when data structure is unknown.

```typescript
Maskify.smart('Charged card 4111-1111-1111-1111 from 10.0.0.1 at https://api.com?token=abc');
```

--------------------------------

### Maskify.deterministic(value, options)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Applies deterministic HMAC hashing to a value for analytics-safe pseudonymization. This ensures that the same input always produces the same hashed output.

```APIDOC
## Maskify.deterministic(value, options)

### Description
Deterministic HMAC hashing for analytics-safe pseudonymization. Ensures consistent hashing for the same input.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **value** (string) - Required - The value to hash.
- **options** (object) - Required - Options for deterministic hashing.
  - **secret** (string) - Required - The secret key used for HMAC hashing.
  - **algorithm** (string) - Optional - The HMAC algorithm to use (e.g., 'sha256', 'md5'). Defaults to 'sha256'.

### Request Example
```javascript
Maskify.deterministic('user-id-123', { secret: 'my-super-secret-key' });
```

### Response
#### Success Response (200)
- **hashedValue** (string) - The deterministically hashed value.
```

--------------------------------

### Integrate Maskify with Prisma Client Extensions

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Extend Prisma Client with Maskify to automatically mask specified fields in read operations. Write operations are never masked, ensuring data integrity.

```typescript
import { PrismaClient } from '@prisma/client';
import { Maskify } from 'maskify-ts';

const prisma = new PrismaClient().$extends(
  Maskify.middlewares.prisma({
    fields: [{ name: 'email', options: { type: 'email' } }],
  }),
);

await prisma.user.findMany(); // email is masked
await prisma.user.create({ data: { email } }); // write ops are NEVER masked
```

--------------------------------

### Deterministic Hashing with Maskify.deterministic

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Generates a consistent, one-way hash using HMAC. Useful for analytics or join keys without storing PII. Requires a secret of at least 16 characters. Throws `MaskifyConfigError` if the secret is missing or too short. Never commit the secret.

```typescript
import { Maskify } from 'maskify-ts';

const pseudoId = Maskify.deterministic('jane@company.com', {
  secret: process.env.MASKIFY_SECRET!,   // REQUIRED, must be >= 16 chars
  algorithm: 'sha256',                   // 'sha256' (default) | 'sha512'
  length: 16,                            // hex chars to keep
});
// → 'a3f12b9c8e7d4f21'
```

--------------------------------

### Maskify.pattern(value, pattern, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Applies masking to a string based on an explicit pattern. Characters matching '#' in the pattern are revealed, while others are masked.

```APIDOC
## Maskify.pattern(value, pattern, options?)

### Description
Explicit pattern masking. `#` reveals the original char, everything else is the mask char (default `*`). Supports `{n}` repetition.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **value** (string) - Required - The string value to mask.
- **pattern** (string) - Required - The pattern to use for masking. '#' reveals the original character, other characters are the mask character.
- **options** (object) - Optional - Configuration options for masking.
  - **maskChar** (string) - Optional - The character to use for masking if not specified in the pattern (default: '*').

### Request Example
```javascript
Maskify.pattern('4111111111111111', '####-****-****-####');
Maskify.pattern('abc123', '##*{4}');
```

### Response
#### Success Response (200)
- **maskedValue** (string) - The masked string according to the pattern.
```

--------------------------------

### Maskify.autoMask(data, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Recursively walks through an object or array, masking values that match sensitive key names or PII patterns. Options allow customization of sensitive keys and auto-detection types.

```APIDOC
## Maskify.autoMask(data, options?)

### Description
Walks an object/array and masks values that match sensitive key names (`password`, `token`, `ssn`, …) or look like PII (emails, IPs, JWTs).

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **data** (object | array) - Required - The data structure (object or array) to mask.
- **options** (object) - Optional - Configuration options for auto-masking.
  - **sensitiveKeys** (string[]) - Optional - An array of key names considered sensitive (e.g., `['password', 'apiKey']`).
  - **autoDetectTypes** (string[]) - Optional - An array of PII types to auto-detect (e.g., `['email', 'jwt']`).

### Request Example
```javascript
Maskify.autoMask({
  id: 42,
  email: 'jane@company.com',
  password: 's3cret',
  meta: { ip: '10.0.0.1' },
});

Maskify.autoMask(data, {
  sensitiveKeys: ['password', 'apiKey'],
  autoDetectTypes: ['email', 'jwt'],
});
```

### Response
#### Success Response (200)
- **maskedData** (object | array) - The data structure with sensitive fields and PII masked.
```

--------------------------------

### Maskify.pattern(value, pattern, options?)

Source: https://www.npmjs.com/package/maskify-ts

Applies masking based on an explicit pattern. The '#' character in the pattern reveals the original character, while other characters are used as the mask character (defaulting to '*'). Supports character repetition using `{n}`.

```APIDOC
## Maskify.pattern(value, pattern, options?)

### Description
Explicit pattern masking. `#` reveals the original char, everything else is the mask char (default `*`). Supports `{n}` repetition.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **value** (string) - The string value to mask.
- **pattern** (string) - The pattern to apply for masking. '#' reveals the original char, others are mask chars. Supports `{n}` repetition.
- **options** (object, optional) - Configuration options for masking.
  - **maskChar** (string, optional) - The character to use for masking. Defaults to '*'.

### Request Example
```javascript
Maskify.pattern('4111111111111111', '####-****-****-####');
// → '4111-****-****-1111'

Maskify.pattern('abc123', '##*{4}');
// → 'ab****'
```

### Response
#### Success Response (200)
- **maskedValue** (string) - The masked string value.
```

--------------------------------

### Maskify.mask(value, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=dependencies

Masks a single string value. It can automatically detect the PII type or use a specified type via options. Custom masking characters, visible start/end positions, and transform functions are supported.

```APIDOC
## Maskify.mask(value, options?)

### Description
Masks a single string. If `options.type` is omitted and `autoDetect` is enabled (default), the type is inferred via the detector chain. Supports custom mask characters, visible start/end positions, and transform functions.

### Parameters
- **value** (string) - The string value to mask.
- **options** (object, optional) - Configuration options for masking.
  - **type** (string, optional) - The PII type to detect (e.g., 'email', 'phone'). If omitted, auto-detection is used.
  - **maskChar** (string, optional) - The character to use for masking. Defaults to '*'.
  - **visibleStart** (number, optional) - The number of characters to keep visible from the start.
  - **visibleEnd** (number, optional) - The number of characters to keep visible from the end.
  - **transform** (function, optional) - A custom function to transform the value before masking.
  - **pattern** (string, optional) - A pattern to apply for masking (e.g., '####-####-####-####').

### Request Example
```javascript
Maskify.mask('secret-token', { maskChar: '•', visibleStart: 2, visibleEnd: 2 });
// → 'se•••••••en'

Maskify.mask('4111111111111111', { pattern: '####-####-####-####' });
// → '4111-****-****-1111'

Maskify.mask('jane@example.com', { transform: v => `[redacted:${v.length}]` });
// → '[redacted:16]'
```
```

--------------------------------

### Maskify.mask(value, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=versions

Masks a single string value. It can automatically detect the PII type or use a specified type via options. Custom masking characters, visible start/end positions, and transform functions can be applied.

```APIDOC
## Maskify.mask(value, options?)

### Description
Masks a single string. If `options.type` is omitted and `autoDetect` is enabled (default), the type is inferred via the detector chain. Supports custom mask characters, visible start/end positions, and custom transform functions.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **value** (string) - The string value to mask.
- **options** (object) - Optional. Configuration for masking.
  - **type** (string) - The type of PII to detect (e.g., 'email', 'phone', 'card'). If omitted, auto-detection is used.
  - **maskChar** (string) - The character to use for masking (default: '*').
  - **visibleStart** (number) - The number of characters to keep visible from the start.
  - **visibleEnd** (number) - The number of characters to keep visible from the end.
  - **transform** (function) - A custom function to transform the value before masking. Takes precedence over other options.
  - **pattern** (string) - A pattern to use for masking. '#' reveals the original character, others are mask characters. Supports `{n}` repetition.

### Request Example
```javascript
Maskify.mask('secret-token', { maskChar: '•', visibleStart: 2, visibleEnd: 2 });
Maskify.mask('4111111111111111', { pattern: '####-####-####-####' });
Maskify.mask('jane@example.com', { transform: v => `[redacted:${v.length}]` });
```

### Response
#### Success Response (200)
- **maskedValue** (string) - The masked string.
```

--------------------------------

### Maskify.smart(freeText)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Tokenizes a free-text string and masks detected PII within each token. This method is suitable for sanitizing unstructured data like logs or chat messages.

```APIDOC
## Maskify.smart(freeText)

### Description
Tokenizes a free-text string, detects PII inside each token, and masks in place. Ideal for log sanitization where you don't know the structure.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **freeText** (string) - Required - The free-text string to process.

### Request Example
```javascript
Maskify.smart('Charged card 4111-1111-1111-1111 from 10.0.0.1 at https://api.com?token=abc');
```

### Response
#### Success Response (200)
- **maskedText** (string) - The free-text string with detected PII masked.
```

--------------------------------

### Maskify.mask(value, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Masks a single string value. It can automatically detect the PII type or use a specified type. Options allow customization of the mask character, visible characters, and custom transforms.

```APIDOC
## Maskify.mask(value, options?)

### Description
Masks a single string. If `options.type` is omitted and `autoDetect` is enabled (default), the type is inferred via the detector chain.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **value** (string) - Required - The string value to mask.
- **options** (object) - Optional - Configuration options for masking.
  - **type** (string) - Optional - The type of PII to mask (e.g., 'email', 'phone', 'card'). If omitted, auto-detection is used.
  - **maskChar** (string) - Optional - The character to use for masking (default: '*').
  - **visibleStart** (number) - Optional - The number of characters to keep visible at the start of the string.
  - **visibleEnd** (number) - Optional - The number of characters to keep visible at the end of the string.
  - **pattern** (string) - Optional - A pattern to apply for masking (e.g., '####-####-####-####').
  - **transform** (function) - Optional - A custom function to transform the value before masking.

### Request Example
```javascript
Maskify.mask('secret-token', { maskChar: '•', visibleStart: 2, visibleEnd: 2 });
Maskify.mask('4111111111111111', { pattern: '####-####-####-####' });
Maskify.mask('jane@example.com', { transform: v => `[redacted:${v.length}]` });
```

### Response
#### Success Response (200)
- **maskedValue** (string) - The masked string.
```

--------------------------------

### Maskify.mask(value, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=readme

Masks a single string value. It can automatically detect the PII type or use a specified type from options. Custom masking characters, visible character counts, and transformations can be applied.

```APIDOC
## Maskify.mask(value, options?)

### Description
Masks a single string. If `options.type` is omitted and `autoDetect` is enabled (default), the type is inferred via the detector chain. Supports custom mask characters, visible start/end characters, and custom transform functions.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **value** (string) - The string value to mask.
- **options** (object, optional) - Configuration options for masking.
  - **type** (string, optional) - The PII type to mask (e.g., 'email', 'phone', 'card'). If omitted, auto-detection is used.
  - **maskChar** (string, optional) - The character to use for masking. Defaults to '*'.
  - **visibleStart** (number, optional) - The number of characters to keep visible at the start of the string.
  - **visibleEnd** (number, optional) - The number of characters to keep visible at the end of the string.
  - **pattern** (string, optional) - A pattern to apply for masking (e.g., '####-####-####-####').
  - **transform** (function, optional) - A custom function to transform the value before masking.

### Request Example
```javascript
Maskify.mask('secret-token', { maskChar: '•', visibleStart: 2, visibleEnd: 2 });
Maskify.mask('4111111111111111', { pattern: '####-####-####-####' });
Maskify.mask('jane@example.com', { transform: v => `[redacted:${v.length}]` });
```

### Response
#### Success Response (200)
- **maskedValue** (string) - The masked string.
```

--------------------------------

### Maskify.pattern for Explicit Masking

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Use Maskify.pattern for explicit character-by-character masking based on a defined pattern. '#' reveals original characters, others are mask characters.

```typescript
Maskify.pattern('4111111111111111', '####-****-****-####');
// → '4111-****-****-1111'

Maskify.pattern('abc123', '##*{4}');
// → 'ab****'
```

--------------------------------

### Maskify.deterministic

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Generates a deterministic HMAC-based one-way hash for a given value. Useful for analytics or join keys without storing Personally Identifiable Information (PII).

```APIDOC
## `Maskify.deterministic(value, options)`

### Description
HMAC-based one-way hashing. The same input and secret always produce the same short hash, which is useful for analytics or join keys without storing PII. Throws `MaskifyConfigError` if the secret is missing or too short.

### Parameters
#### Path Parameters
- **value** (string) - Required - The value to hash.
- **options** (object) - Required - Configuration options for hashing.
  - **secret** (string) - REQUIRED - Must be >= 16 characters. Store in an environment variable.
  - **algorithm** (string) - Optional - Hashing algorithm. Defaults to 'sha256'. Can be 'sha256' or 'sha512'.
  - **length** (number) - Optional - The number of hex characters to keep in the resulting hash. Defaults to the full hash length.

### Request Example
```javascript
import { Maskify } from 'maskify-ts';

const pseudoId = Maskify.deterministic('jane@company.com', {
  secret: process.env.MASKIFY_SECRET!,   // REQUIRED, must be >= 16 chars
  algorithm: 'sha256',                   // 'sha256' (default) | 'sha512'
  length: 16,                            // hex chars to keep
});
// → 'a3f12b9c8e7d4f21'
```
```

--------------------------------

### Maskify.mask with Options

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Customize single value masking using options like mask character, visible start/end characters, or by providing a specific pattern.

```typescript
Maskify.mask('secret-token', { maskChar: '•', visibleStart: 2, visibleEnd: 2 });
// → 'se•••••••en'

// Pattern overrides type/auto-detection
Maskify.mask('4111111111111111', { pattern: '####-####-####-####' });
// → '4111-****-****-****'

// Custom transform (takes precedence over everything)
Maskify.mask('jane@example.com', { transform: v => `[redacted:${v.length}]` });
```

--------------------------------

### Import Maskify-TS TypeScript Types

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Imports common TypeScript types used for configuring Maskify options. Ensure these types are imported when defining masking configurations.

```typescript
import type {
  MaskOptions,
  AutoMaskOptions,
  MaskableType,
  MaskSchemaOptions,
  MiddlewareOptions,
  MaskStreamOptions,
} from 'maskify-ts';
```

--------------------------------

### Maskify.mask(value, options?)

Source: https://www.npmjs.com/package/maskify-ts

Masks a single string. If options.type is omitted and autoDetect is enabled (default), the type is inferred via the detector chain. It supports custom mask characters, visible start/end characters, and custom transform functions.

```APIDOC
## Maskify.mask(value, options?)

### Description
Masks a single string. If `options.type` is omitted and `autoDetect` is enabled (default), the type is inferred via the detector chain.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **value** (string) - The string value to mask.
- **options** (object, optional) - Configuration options for masking.
  - **type** (string, optional) - The type of PII to detect (e.g., 'email', 'phone', 'card'). If omitted, auto-detection is used.
  - **maskChar** (string, optional) - The character to use for masking. Defaults to '*'.
  - **visibleStart** (number, optional) - The number of characters to keep visible at the start.
  - **visibleEnd** (number, optional) - The number of characters to keep visible at the end.
  - **pattern** (string, optional) - A pattern to apply for masking. '#' reveals the original char, others are mask chars. Supports `{n}` repetition.
  - **transform** (function, optional) - A custom function to transform the value before masking. Takes precedence over all other options.

### Request Example
```javascript
Maskify.mask('secret-token', { maskChar: '•', visibleStart: 2, visibleEnd: 2 });
// → 'se•••••••en'

Maskify.mask('4111111111111111', { pattern: '####-####-####-####' });
// → '4111-****-****-****'

Maskify.mask('jane@example.com', { transform: v => `[redacted:${v.length}]` });
// → '[redacted:16]'
```

### Response
#### Success Response (200)
- **maskedValue** (string) - The masked string value.
```

--------------------------------

### Maskify.maskClass(instance)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Masks all properties of a class instance based on predefined rules or decorators. This is useful for sanitizing objects before logging or serialization.

```APIDOC
## Maskify.maskClass(instance)

### Description
Masks all properties of a class instance. Useful for sanitizing objects before logging or serialization, especially when using `@Mask` decorators.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **instance** (object) - Required - The class instance to mask.

### Request Example
```javascript
class User {
  @Mask({ type: 'email' })
  email;

  constructor(email) {
    this.email = email;
  }
}

const user = new User('jane.doe@company.com');
const maskedUser = Maskify.maskClass(user);
// maskedUser.email will be 'j***@c******.com'
```

### Response
#### Success Response (200)
- **maskedInstance** (object) - The class instance with its properties masked.
```

--------------------------------

### Integrate Maskify with Fastify Middleware

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Register Maskify's Fastify plugin to mask fields in responses. It uses an `onSend` hook and handles various payload types, ensuring the pipeline is never blocked if masking fails.

```typescript
import Fastify from 'fastify';
import { Maskify } from 'maskify-ts';

const app = Fastify();

await app.register(Maskify.middlewares.fastify, {
  fields: ['email', 'phone'],
});

// …or
Maskify.use(app, { fields: ['email', 'phone'] }, 'fastify');
```

--------------------------------

### Maskify.maskSensitiveFields(data, schema, options?)

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Masks sensitive fields within a data object based on a provided schema. The schema maps dot-paths or array wildcards to specific masking rules.

```APIDOC
## Maskify.maskSensitiveFields(data, schema, options?)

### Description
Deep object masking with a schema. Allows specifying masking rules for nested fields using dot-paths and array wildcards.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **data** (object) - Required - The data object to mask.
- **schema** (object) - Required - A schema defining which fields to mask and how. Keys are dot-paths (e.g., 'user.email') or array wildcards (e.g., 'users[*].email'), and values are masking options.
- **options** (object) - Optional - General masking options that can be overridden by schema-specific options.

### Request Example
```javascript
Maskify.maskSensitiveFields(
  { user: { email: 'jane@company.com', cards: [{ number: '4111111111111111' }] } },
  {
    'user.email': { type: 'email' },
    'user.cards[*].number': { type: 'card' },
  },
);
```

### Response
#### Success Response (200)
- **maskedData** (object) - The data object with specified sensitive fields masked according to the schema.
```

--------------------------------

### Maskify.maskClass(instance)

Source: https://www.npmjs.com/package/maskify-ts

Masks all sensitive fields within an instance of a class decorated with `@Mask`. This is useful for sanitizing objects before logging or sending them over the network.

```APIDOC
## Maskify.maskClass(instance)

### Description
Masks all sensitive fields within an instance of a class decorated with `@Mask`.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **instance** (object) - An instance of a class decorated with the `@Mask` decorator.

### Request Example
```javascript
// Assuming a class User decorated with @Mask
class User {
  @Mask({ type: 'email' })
  email;

  @Mask({ type: 'name' })
  name;

  constructor(email, name) {
    this.email = email;
    this.name = name;
  }
}

const user = new User('jane@company.com', 'Jane Doe');
const maskedUser = Maskify.maskClass(user);
// → { email: 'j***@c******.com', name: 'J*** D**' }
```

### Response
#### Success Response (200)
- **maskedInstance** (object) - The instance with sensitive fields masked.
```

--------------------------------

### Schema-Driven Masking with Maskify.maskSensitiveFields

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Use `maskSensitiveFields` to mask sensitive data based on a provided schema. Supports 'mask' (default) and 'allow' modes. Paths can use dot notation, array wildcards, and numeric indices.

```typescript
Maskify.maskSensitiveFields(
  {
    user: { email: 'jane@co.com', phone: '+14155550123' },
    orders: [{ card: { number: '4111111111111111' } }],
  },
  {
    'user.email': { type: 'email' },
    'user.phone': { type: 'phone' },
    'orders[*].card.number': { type: 'card' },
  },
);
```

```typescript
// Allowlist: nothing escapes except the schema keys
Maskify.maskSensitiveFields(payload, { 'user.id': { type: 'generic' } }, { mode: 'allow' });
```

--------------------------------

### Integrate Maskify with Express Middleware

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Use Maskify's express middleware to automatically mask specified fields in JSON responses. This middleware can be applied globally using `app.use` or via a convenience wrapper.

```typescript
import express from 'express';
import { Maskify } from 'maskify-ts';

const app = express();

app.use(Maskify.middlewares.express({
  fields: [
    { name: 'email', options: { type: 'email' } },
    { name: 'password' },
  ],
}));

// …or the convenience wrapper
Maskify.use(app, { fields: ['email', 'password'] });
```

--------------------------------

### Maskify Data Streams

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Process data streams with `createMaskStream` to mask sensitive information. It handles JSON lines and other text formats, falling back to `Maskify.smart` for non-JSON content and never dropping data.

```typescript
import { createReadStream } from 'node:fs';
import { createMaskStream } from 'maskify-ts/stream';

createReadStream('app.log', { encoding: 'utf8' })
  .pipe(createMaskStream(
    { 'user.email': { type: 'email' } },      // schema (optional)
    { mode: 'mask', maskChar: '•' },          // stream options
  ))
  .pipe(process.stdout);
```

--------------------------------

### Maskify.maskClass

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Returns a shallow clone of an instance with all @Mask-decorated properties replaced. It traverses the prototype chain to include decorators from base classes.

```APIDOC
## `Maskify.maskClass(instance)`

### Description
Returns a shallow clone with every `@Mask`-decorated property replaced. Walks the prototype chain, so decorators on base classes are honored.

### Parameters
#### Path Parameters
- **instance** (object) - Required - The class instance to mask.

### Request Example
```javascript
import 'reflect-metadata';
import { Maskify, Mask } from 'maskify-ts';

class User {
  id = 1;
  @Mask({ type: 'email' }) email = 'jane@company.com';
  @Mask({ type: 'phone' }) phone = '+14155550123';
}

Maskify.maskClass(new User());
// → User { id: 1, email: 'j***@c******.com', phone: '+**********23' }
```
```

--------------------------------

### Integrate Maskify with TypeORM Subscribers

Source: https://www.npmjs.com/package/maskify-ts?activeTab=code

Use Maskify's TypeORM subscriber to add a non-enumerable `toJSON` method to entities, masking output during serialization without altering the in-memory entity.

```typescript
import { DataSource } from 'typeorm';
import { Maskify } from 'maskify-ts';

const subscriber = Maskify.middlewares.typeorm({
  fields: [{ name: 'email', options: { type: 'email' } }],
});

const ds = new DataSource({
  // …connection opts…
  subscribers: [subscriber],
});
```

--------------------------------

### Maskify.maskSensitiveFields

Source: https://www.npmjs.com/package/maskify-ts?activeTab=readme

Masks sensitive fields in data based on a provided schema. Supports 'mask' (default) and 'allow' modes. Paths can use dot notation, array wildcards, and numeric indices.

```APIDOC
## Maskify.maskSensitiveFields(data, schema, options?)

### Description
Masks sensitive fields in data based on a provided schema. Supports 'mask' (default) and 'allow' modes. Paths can use dot notation, array wildcards, and numeric indices.

### Parameters
#### Path Parameters
- **data** (object) - Required - The data object to mask.
- **schema** (object) - Required - An object defining the fields to mask and their types.
- **options** (object) - Optional - Configuration options for masking, including `mode` ('mask' or 'allow').

### Request Example
```javascript
Maskify.maskSensitiveFields(
  { user: { email: 'jane@co.com', phone: '+14155550123' }, orders: [{ card: { number: '4111111111111111' } }] },
  { 'user.email': { type: 'email' }, 'user.phone': { type: 'phone' }, 'orders[*].card.number': { type: 'card' } }
);

// Allowlist mode example
Maskify.maskSensitiveFields(payload, { 'user.id': { type: 'generic' } }, { mode: 'allow' });
```
```
Tokens:
Raw