pdfdancer-client-typescript 1.0.11 → 1.0.13

package/src/__tests__/e2e/token_from_env.test.ts

@@ -1,35 +1,95 @@
 import {requireEnvAndFixture} from "./test-helpers";
 import {PDFDancer} from "../../pdfdancer_v1";
-import {ObjectType} from "../../models";
+import {HttpClientException, ValidationException} from "../../exceptions";
 
 describe('Env Token E2E Tests', () => {
+    const MISSING_TOKEN_MESSAGE = "Missing PDFDancer API token. Pass a token via the `token` argument or set the PDFDANCER_TOKEN environment variable.";
+    let originalToken: string | undefined;
+    let originalBaseUrl: string | undefined;
+    let baseUrl: string;
+    let pdfData: Uint8Array;
+    let validToken: string;
 
-    test('get pages with token from env', async () => {
-        process.env.PDFDANCER_TOKEN = "42";
-        process.env.PDFDANCER_BASE_URL = "http://localhost:8080";
-        const [, , pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await PDFDancer.open(pdfData);
-        const pages = await client.pages();
-        expect(pages).toBeDefined();
-        expect(pages[0].type).toBe(ObjectType.PAGE);
-        expect(pages).toHaveLength(12);
+    const restoreEnv = () => {
+        if (originalToken !== undefined) {
+            process.env.PDFDANCER_TOKEN = originalToken;
+        } else {
+            delete process.env.PDFDANCER_TOKEN;
+        }
+
+        if (originalBaseUrl !== undefined) {
+            process.env.PDFDANCER_BASE_URL = originalBaseUrl;
+        } else {
+            delete process.env.PDFDANCER_BASE_URL;
+        }
+    };
+
+    beforeAll(async () => {
+        originalToken = process.env.PDFDANCER_TOKEN;
+        originalBaseUrl = process.env.PDFDANCER_BASE_URL;
+
+        [baseUrl, validToken, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    });
+
+    beforeEach(() => {
+        restoreEnv();
+    });
+
+    afterEach(() => {
+        restoreEnv();
+    });
+
+    afterAll(() => {
+        restoreEnv();
     });
 
-    test('fail without token', async () => {
+    test('requires token from env or argument', async () => {
         delete process.env.PDFDANCER_TOKEN;
-        delete process.env.PDFDANCER_BASE_URL;
-        const [, , pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        await expect(PDFDancer.open(pdfData))
-            .rejects
-            .toThrow("Missing PDFDancer token");
-    });
-
-    test('fail with wrong token', async () => {
-        process.env.PDFDANCER_TOKEN = "43";
-        process.env.PDFDANCER_BASE_URL = "http://localhost:8080";
-        const [, , pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        await expect(PDFDancer.open(pdfData))
-            .rejects
-            .toThrow("Failed to create session: Unauthorized");
+
+        await expect(async () => {
+            try {
+                await PDFDancer.open(pdfData, undefined, baseUrl);
+            } catch (error) {
+                expect(error).toBeInstanceOf(ValidationException);
+                expect((error as Error).message).toBe(MISSING_TOKEN_MESSAGE);
+                throw error;
+            }
+        }).rejects.toThrow(MISSING_TOKEN_MESSAGE);
+    });
+
+    test('opens with token from env', async () => {
+        process.env.PDFDANCER_TOKEN = validToken;
+        const client = await PDFDancer.open(pdfData, undefined, baseUrl);
+        expect(client).toBeInstanceOf(PDFDancer);
+    });
+
+    test('fails with unreachable base url', async () => {
+        process.env.PDFDANCER_TOKEN = validToken;
+        process.env.PDFDANCER_BASE_URL = "http://www.google.com";
+
+        await expect(async () => {
+            try {
+                await PDFDancer.open(pdfData);
+            } catch (error) {
+                expect(error).toBeInstanceOf(HttpClientException);
+                throw error;
+            }
+        }).rejects.toThrow(HttpClientException);
+    });
+
+    test('fails with invalid token', async () => {
+        process.env.PDFDANCER_TOKEN = "invalid-token";
+        process.env.PDFDANCER_BASE_URL = "https://api.pdfdancer.com";
+
+        await expect(async () => {
+            try {
+                await PDFDancer.open(pdfData);
+            } catch (error) {
+                expect(error).toBeInstanceOf(ValidationException);
+                expect((error as Error).message)
+                    .toContain("Authentication with the PDFDancer API failed. Confirm that your API token is valid, has not expired");
+                throw error;
+            }
+        }).rejects.toThrow(ValidationException);
     });
 });

package/src/__tests__/fingerprint.test.ts

@@ -0,0 +1,36 @@
+/**
+ * Tests for fingerprint generation
+ */
+
+import {generateFingerprint} from '../fingerprint';
+
+describe('Fingerprint', () => {
+    it('should generate a valid SHA256 fingerprint', async () => {
+        const fingerprint = await generateFingerprint();
+
+        // SHA256 produces 64 hex characters
+        expect(fingerprint).toHaveLength(64);
+        expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it('should generate different fingerprints for different user IDs', async () => {
+        const fingerprint1 = await generateFingerprint('user1');
+        const fingerprint2 = await generateFingerprint('user2');
+
+        expect(fingerprint1).not.toBe(fingerprint2);
+        expect(fingerprint1).toHaveLength(64);
+        expect(fingerprint2).toHaveLength(64);
+    });
+
+    it('should generate consistent fingerprints for same user ID', async () => {
+        const fingerprint1 = await generateFingerprint('user123');
+        const fingerprint2 = await generateFingerprint('user123');
+
+        // Note: These might differ due to install salt randomness in test environment
+        // but they should both be valid SHA256 hashes
+        expect(fingerprint1).toHaveLength(64);
+        expect(fingerprint2).toHaveLength(64);
+        expect(fingerprint1).toMatch(/^[a-f0-9]{64}$/);
+        expect(fingerprint2).toMatch(/^[a-f0-9]{64}$/);
+    });
+});

package/src/fingerprint.ts

@@ -0,0 +1,169 @@
+/**
+ * Fingerprint generation for PDFDancer client
+ * Generates a unique fingerprint hash to identify client requests
+ */
+
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+/**
+ * Get the install salt from localStorage (browser) or file storage (Node.js)
+ * This creates a persistent identifier for this client installation
+ */
+function getInstallSalt(): string {
+    const storageKey = 'pdfdancer_install_salt';
+
+    // Check if we're in a browser environment
+    if (typeof localStorage !== 'undefined') {
+        let salt = localStorage.getItem(storageKey);
+        if (!salt) {
+            salt = crypto.randomBytes(16).toString('hex');
+            localStorage.setItem(storageKey, salt);
+        }
+        return salt;
+    }
+
+    // Node.js environment - use file storage
+    try {
+        const saltDir = path.join(os.homedir(), '.pdfdancer');
+        const saltFile = path.join(saltDir, 'install_salt');
+
+        // Create directory if it doesn't exist
+        if (!fs.existsSync(saltDir)) {
+            fs.mkdirSync(saltDir, { recursive: true, mode: 0o700 });
+        }
+
+        // Read existing salt or generate new one
+        if (fs.existsSync(saltFile)) {
+            return fs.readFileSync(saltFile, 'utf8').trim();
+        } else {
+            const salt = crypto.randomBytes(16).toString('hex');
+            fs.writeFileSync(saltFile, salt, { mode: 0o600 });
+            return salt;
+        }
+    } catch (error) {
+        // Fallback to generating a new salt if file operations fail
+        return crypto.randomBytes(16).toString('hex');
+    }
+}
+
+/**
+ * Attempt to get the client's IP address
+ * Note: This is limited on the client side and may not always be accurate
+ */
+async function getClientIP(): Promise<string> {
+    try {
+        // In browser, we can't reliably get the real IP
+        // Return a placeholder that will be consistent per session
+        return 'client-unknown';
+    } catch {
+        return 'client-unknown';
+    }
+}
+
+/**
+ * Get the OS type
+ */
+function getOSType(): string {
+    // Check if we're in Node.js
+    if (typeof process !== 'undefined' && process.platform) {
+        return process.platform;
+    }
+
+    // Browser environment
+    if (typeof navigator !== 'undefined') {
+        const userAgent = navigator.userAgent.toLowerCase();
+        if (userAgent.includes('win')) return 'windows';
+        if (userAgent.includes('mac')) return 'macos';
+        if (userAgent.includes('linux')) return 'linux';
+        if (userAgent.includes('android')) return 'android';
+        if (userAgent.includes('iphone') || userAgent.includes('ipad')) return 'ios';
+    }
+
+    return 'unknown';
+}
+
+/**
+ * Get the current hostname
+ */
+function getHostname(): string {
+    // Node.js environment
+    if (typeof process !== 'undefined') {
+        try {
+            return os.hostname();
+        } catch {
+            // Fall through to browser logic
+        }
+    }
+
+    // Browser environment
+    if (typeof window !== 'undefined' && window.location) {
+        return window.location.hostname;
+    }
+
+    return 'unknown';
+}
+
+/**
+ * Get the timezone
+ */
+function getTimezone(): string {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+        return 'unknown';
+    }
+}
+
+/**
+ * Get the locale
+ */
+function getLocale(): string {
+    try {
+        if (typeof navigator !== 'undefined' && navigator.language) {
+            return navigator.language;
+        }
+        return Intl.DateTimeFormat().resolvedOptions().locale;
+    } catch {
+        return 'unknown';
+    }
+}
+
+/**
+ * Generate a fingerprint hash from client data points
+ *
+ * @param userId Optional user ID to include in the fingerprint
+ * @returns SHA256 hash of fingerprint components
+ */
+export async function generateFingerprint(userId?: string): Promise<string> {
+    const ip = await getClientIP();
+    const uid = userId || 'unknown';
+    const osType = getOSType();
+    const sdkLanguage = 'typescript';
+    const timezone = getTimezone();
+    const locale = getLocale();
+    const domain = getHostname();
+    const installSalt = getInstallSalt();
+
+    // Hash individual components
+    const ipHash = crypto.createHash('sha256').update(ip).digest('hex');
+    const uidHash = crypto.createHash('sha256').update(uid).digest('hex');
+    const domainHash = crypto.createHash('sha256').update(domain).digest('hex');
+
+    // Concatenate all components and hash
+    const fingerprintData =
+        ipHash +
+        uidHash +
+        osType +
+        sdkLanguage +
+        timezone +
+        locale +
+        domainHash +
+        installSalt;
+
+    const fingerprintHash = crypto.createHash('sha256').update(fingerprintData).digest('hex');
+
+    return fingerprintHash;
+}

package/src/image-builder.ts

@@ -8,13 +8,11 @@ interface PDFDancerInternals {
 }
 
 export class ImageBuilder {
-    private _client: PDFDancer;
     private _imageData: Uint8Array<ArrayBuffer> | undefined;
     private _position: Position | undefined;
-    private _internals: PDFDancerInternals;
+    private readonly _internals: PDFDancerInternals;
 
-    constructor(_client: PDFDancer) {
-        this._client = _client;
+    constructor(private _client: PDFDancer, private readonly _defaultPageIndex?: number) {
         // Cast to the internal interface to get access
         this._internals = this._client as unknown as PDFDancerInternals;
     }
@@ -33,8 +31,17 @@ export class ImageBuilder {
         return this;
     }
 
-    at(pageIndex: number, x: number, y: number) {
-        this._position = Position.atPageCoordinates(pageIndex, x, y);
+    at(x: number, y: number): this;
+    at(pageIndex: number, x: number, y: number): this;
+    at(pageIndexOrX: number, xOrY: number, maybeY?: number): this {
+        if (maybeY === undefined) {
+            if (this._defaultPageIndex === undefined) {
+                throw new Error('Page index must be provided when adding an image');
+            }
+            this._position = Position.atPageCoordinates(this._defaultPageIndex, pageIndexOrX, xOrY);
+        } else {
+            this._position = Position.atPageCoordinates(pageIndexOrX, xOrY, maybeY);
+        }
         return this;
     }
 

package/src/index.ts

@@ -6,6 +6,7 @@
 
 export { PDFDancer } from './pdfdancer_v1';
 export { ParagraphBuilder } from './paragraph-builder';
+export { PageBuilder } from './page-builder';
 
 export {
   PdfDancerException,
@@ -28,15 +29,19 @@ export {
   Image,
   BoundingRect,
   Paragraph,
+  TextLine,
   PositionMode,
   ShapeType,
   Point,
   StandardFonts,
+  STANDARD_PAGE_SIZES,
   Orientation,
   CommandResult,
   TextStatus,
   FontRecommendation,
-  FontType
+  FontType,
+  DocumentSnapshot,
+  PageSnapshot
 } from './models';
 
 export const VERSION = "1.0.0";