@studio-foundation/anonymizer 0.3.0-beta.1

package/tests/anonymizer.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { anonymize, deanonymize } from '../src/index.js';
+
+describe('anonymize', () => {
+  it('replaces emails with tokens', () => {
+    const result = anonymize('Send to mc@acme.com please');
+    expect(result.text).not.toContain('mc@acme.com');
+    expect(result.text).toContain('EMAIL_1');
+    expect(result.keymap['EMAIL_1']).toBe('mc@acme.com');
+  });
+
+  it('replaces the same PII twice in one call with the same token', () => {
+    const result = anonymize('Email mc@acme.com then mc@acme.com again');
+    const emails = result.text.match(/EMAIL_\d+/g) ?? [];
+    expect(emails.every(e => e === 'EMAIL_1')).toBe(true);
+    expect(result.text.split('EMAIL_1').length - 1).toBe(2);
+  });
+
+  it('assigns different tokens to different PII of same category', () => {
+    const result = anonymize('Email mc@acme.com and other@example.com');
+    expect(result.keymap['EMAIL_1']).toBeDefined();
+    expect(result.keymap['EMAIL_2']).toBeDefined();
+    expect(result.keymap['EMAIL_1']).not.toBe(result.keymap['EMAIL_2']);
+  });
+
+  it('handles multiple categories', () => {
+    const result = anonymize('Email: mc@acme.com, Phone: 514-555-1234');
+    expect(Object.keys(result.keymap).length).toBeGreaterThanOrEqual(2);
+    expect(result.text).not.toContain('mc@acme.com');
+    expect(result.text).not.toContain('514-555-1234');
+  });
+
+  it('returns unchanged text when no PII found', () => {
+    const result = anonymize('This text has no sensitive data');
+    expect(result.text).toBe('This text has no sensitive data');
+    expect(result.keymap).toEqual({});
+  });
+
+  it('seedKeymap ensures cross-call consistency', () => {
+    // First call establishes EMAIL_1 for mc@acme.com
+    const first = anonymize('mc@acme.com');
+    // Second call with the keymap as seed
+    const second = anonymize('other@example.com and mc@acme.com', {
+      seedKeymap: first.keymap,
+    });
+    // mc@acme.com should still be EMAIL_1 (from seed)
+    expect(second.keymap['EMAIL_1']).toBe('mc@acme.com');
+    // other@example.com gets EMAIL_2
+    expect(second.keymap['EMAIL_2']).toBe('other@example.com');
+  });
+});
+
+describe('deanonymize', () => {
+  it('restores original values from keymap', () => {
+    const { text, keymap } = anonymize('Send to mc@acme.com please');
+    const restored = deanonymize(text, keymap);
+    expect(restored).toBe('Send to mc@acme.com please');
+  });
+
+  it('leaves unknown tokens unchanged', () => {
+    const result = deanonymize('Hello PERSON_99', {});
+    expect(result).toBe('Hello PERSON_99');
+  });
+
+  it('restores multiple tokens', () => {
+    const keymap = { 'EMAIL_1': 'a@b.com', 'PERSON_1': 'Alice' };
+    const restored = deanonymize('EMAIL_1 sent by PERSON_1', keymap);
+    expect(restored).toBe('a@b.com sent by Alice');
+  });
+
+  it('round-trip: anonymize then deanonymize restores original', () => {
+    const original = 'Email: mc@acme.com, Phone: 514-555-1234';
+    const { text, keymap } = anonymize(original);
+    const restored = deanonymize(text, keymap);
+    expect(restored).toBe(original);
+  });
+
+  it('deanonymizes correctly when there are more than 9 PII values of same category', () => {
+    // Build a keymap with EMAIL_1 through EMAIL_11
+    const keymap: Record<string, string> = {};
+    for (let i = 1; i <= 11; i++) {
+      keymap[`EMAIL_${i}`] = `user${i}@example.com`;
+    }
+    const text = 'EMAIL_1 EMAIL_10 EMAIL_11 EMAIL_2';
+    const restored = deanonymize(text, keymap);
+    expect(restored).toBe('user1@example.com user10@example.com user11@example.com user2@example.com');
+  });
+});

package/tests/detector.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { detectPII } from '../src/detector.js';
+
+describe('detectPII', () => {
+  it('detects email addresses', () => {
+    const spans = detectPII('Contact mc@acme.com for info');
+    const emails = spans.filter(s => s.category === 'email');
+    expect(emails.length).toBeGreaterThan(0);
+    expect(emails[0].value).toBe('mc@acme.com');
+  });
+
+  it('detects phone numbers', () => {
+    const spans = detectPII('Call 514-555-1234 now');
+    const phones = spans.filter(s => s.category === 'phone');
+    expect(phones.length).toBeGreaterThan(0);
+  });
+
+  it('detects credit card numbers', () => {
+    const spans = detectPII('Card number: 4111111111111111');
+    const cards = spans.filter(s => s.category === 'credit_card');
+    expect(cards.length).toBeGreaterThan(0);
+  });
+
+  it('returns empty array for clean text', () => {
+    const spans = detectPII('This is a normal sentence without PII');
+    expect(spans).toEqual([]);
+  });
+
+  it('returns spans with correct position bounds', () => {
+    const text = 'Email: mc@acme.com here';
+    const spans = detectPII(text);
+    const email = spans.find(s => s.category === 'email');
+    expect(email).toBeDefined();
+    expect(text.slice(email!.start, email!.end)).toBe(email!.value);
+  });
+
+  it('does not return overlapping spans', () => {
+    const text = 'Email mc@acme.com and phone 514-555-1234';
+    const spans = detectPII(text);
+    // Verify no two spans overlap
+    for (let i = 0; i < spans.length; i++) {
+      for (let j = i + 1; j < spans.length; j++) {
+        expect(spans[i].end <= spans[j].start || spans[j].end <= spans[i].start).toBe(true);
+      }
+    }
+  });
+});

package/tests/tokenizer.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Tokenizer } from '../src/tokenizer.js';
+
+describe('Tokenizer', () => {
+  let tokenizer: Tokenizer;
+
+  beforeEach(() => {
+    tokenizer = new Tokenizer();
+  });
+
+  it('assigns sequential tokens per category', () => {
+    const t1 = tokenizer.tokenize('Marie-Claire', 'person');
+    const t2 = tokenizer.tokenize('Jean-François', 'person');
+    const t3 = tokenizer.tokenize('mc@acme.com', 'email');
+    expect(t1).toBe('PERSON_1');
+    expect(t2).toBe('PERSON_2');
+    expect(t3).toBe('EMAIL_1');
+  });
+
+  it('returns the same token for the same value', () => {
+    const t1 = tokenizer.tokenize('Marie-Claire', 'person');
+    const t2 = tokenizer.tokenize('Marie-Claire', 'person');
+    expect(t1).toBe(t2);
+    expect(t1).toBe('PERSON_1');
+  });
+
+  it('builds keymap correctly', () => {
+    tokenizer.tokenize('Marie-Claire', 'person');
+    tokenizer.tokenize('mc@acme.com', 'email');
+    const keymap = tokenizer.getKeymap();
+    expect(keymap).toEqual({
+      'PERSON_1': 'Marie-Claire',
+      'EMAIL_1': 'mc@acme.com',
+    });
+  });
+
+  it('handles all supported categories', () => {
+    const categories = ['person', 'email', 'phone', 'address', 'ssn', 'credit_card'] as const;
+    for (const cat of categories) {
+      const token = tokenizer.tokenize('test-value', cat);
+      expect(token).toMatch(/^[A-Z_]+_1$/);
+    }
+  });
+
+  it('loadKeymap restores state for cross-call consistency', () => {
+    // Simulate loading a pre-existing keymap
+    tokenizer.loadKeymap({ 'PERSON_1': 'Alice', 'EMAIL_1': 'alice@example.com' });
+    // New tokenization should continue from counter 1
+    const t = tokenizer.tokenize('Bob', 'person');
+    expect(t).toBe('PERSON_2');
+    // Existing value should reuse its token
+    const tAlice = tokenizer.tokenize('Alice', 'person');
+    expect(tAlice).toBe('PERSON_1');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}