tailprint 0.0.0-stage → 1.0.0

package/dist/services/mockup.d.ts

@@ -0,0 +1,14 @@
+export interface DeviceMockupOptions {
+    url: string;
+    title?: string;
+    delay_ms?: number;
+}
+export declare class MockupService {
+    private static instance;
+    static getInstance(): MockupService;
+    /**
+     * Captures a website and composites it into a realistic Laptop + Phone device mockup.
+     */
+    renderDeviceMockup(options: DeviceMockupOptions): Promise<Buffer>;
+}
+export declare const mockupService: MockupService;

package/dist/services/mockup.js

@@ -0,0 +1,130 @@
+import { browserService } from './browser.js';
+export class MockupService {
+    static instance = null;
+    static getInstance() {
+        if (!MockupService.instance) {
+            MockupService.instance = new MockupService();
+        }
+        return MockupService.instance;
+    }
+    /**
+     * Captures a website and composites it into a realistic Laptop + Phone device mockup.
+     */
+    async renderDeviceMockup(options) {
+        const { url, title, delay_ms = 500 } = options;
+        // 1. Capture Desktop Viewport (1280x800)
+        const desktopBuffer = await browserService.renderImage({
+            url,
+            width: 1280,
+            height: 800,
+            type: 'png',
+            delay_ms,
+        });
+        // 2. Capture Mobile Viewport (390x844)
+        const mobileBuffer = await browserService.renderImage({
+            url,
+            width: 390,
+            height: 844,
+            type: 'png',
+            delay_ms,
+        });
+        const desktopDataUri = `data:image/png;base64,${desktopBuffer.toString('base64')}`;
+        const mobileDataUri = `data:image/png;base64,${mobileBuffer.toString('base64')}`;
+        let parsedDomain = url;
+        try {
+            parsedDomain = new URL(url).hostname;
+        }
+        catch { }
+        const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <script src="https://cdn.tailwindcss.com"></script>
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      padding: 0;
+      width: 1600px;
+      height: 1000px;
+      background: radial-gradient(circle at 50% 30%, #1e1b4b 0%, #0f172a 50%, #020617 100%);
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      display: flex;
+      flex-direction: column;
+      justify-content: space-between;
+      overflow: hidden;
+      position: relative;
+    }
+  </style>
+</head>
+<body class="p-12 text-white">
+
+  <!-- Top Info Badge -->
+  <div class="flex items-center justify-between z-10">
+    <div class="flex items-center space-x-3">
+      <div class="px-4 py-1.5 rounded-full bg-slate-900/80 border border-slate-700/80 backdrop-blur-md flex items-center space-x-2 text-xs font-mono text-slate-300 shadow-xl">
+        <span class="w-2 h-2 rounded-full bg-emerald-400"></span>
+        <span>${parsedDomain}</span>
+      </div>
+      ${title
+            ? `<span class="text-sm font-bold text-slate-300 tracking-tight">${title}</span>`
+            : ''}
+    </div>
+    <div class="text-xs font-mono text-slate-500">
+      Multi-Device Responsive Mockup • Tailprint Engine
+    </div>
+  </div>
+
+  <!-- Devices Stage Container -->
+  <div class="relative w-full h-[820px] flex items-center justify-center">
+
+    <!-- Desktop / Laptop Frame -->
+    <div class="absolute left-10 bottom-6 w-[1050px] shadow-2xl shadow-black/90 z-10 transition">
+      <!-- Laptop Screen Shell -->
+      <div class="rounded-t-2xl bg-slate-900 p-3 border-t-2 border-x-2 border-slate-700/80 shadow-inner">
+        <!-- Top Screen Bezel with Camera -->
+        <div class="flex items-center justify-center pb-2">
+          <div class="w-2 h-2 rounded-full bg-slate-800 border border-slate-700"></div>
+        </div>
+        <!-- Screen Content Container -->
+        <div class="w-full h-[580px] rounded-lg overflow-hidden bg-slate-950 border border-slate-800">
+          <img src="${desktopDataUri}" class="w-full h-full object-cover object-top" />
+        </div>
+      </div>
+      <!-- Laptop Base / Keyboard Deck -->
+      <div class="relative h-4 bg-gradient-to-b from-slate-700 to-slate-800 rounded-b-xl border-t border-slate-600 shadow-lg flex justify-center">
+        <div class="w-24 h-1.5 bg-slate-900 rounded-b-md"></div>
+      </div>
+      <div class="h-1 bg-slate-900/50 rounded-b-full mx-6 blur-[1px]"></div>
+    </div>
+
+    <!-- Mobile / iPhone Floating Frame (Overlapping Bottom Right) -->
+    <div class="absolute right-14 bottom-12 w-[340px] h-[700px] rounded-[48px] p-3 bg-slate-900 border-4 border-slate-700 shadow-2xl shadow-black z-20 flex flex-col justify-between">
+      <!-- Outer Antenna Lines & Bezel -->
+      <div class="relative w-full h-full rounded-[40px] overflow-hidden bg-black border border-slate-800">
+        <!-- Dynamic Island Notch -->
+        <div class="absolute top-2.5 left-1/2 -translate-x-1/2 w-24 h-6 bg-black rounded-full z-30 flex items-center justify-end px-2">
+          <div class="w-2.5 h-2.5 rounded-full bg-slate-900/90 border border-slate-800"></div>
+        </div>
+        <!-- Mobile Screen Content -->
+        <img src="${mobileDataUri}" class="w-full h-full object-cover object-top" />
+        <!-- Bottom Home Indicator -->
+        <div class="absolute bottom-2 left-1/2 -translate-x-1/2 w-32 h-1 bg-white/40 rounded-full z-30"></div>
+      </div>
+    </div>
+
+  </div>
+
+</body>
+</html>`;
+        return browserService.renderImage({
+            html,
+            width: 1600,
+            height: 1000,
+            type: 'png',
+            delay_ms: 200,
+        });
+    }
+}
+export const mockupService = MockupService.getInstance();
+//# sourceMappingURL=mockup.js.map

package/dist/services/mockup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockup.js","sourceRoot":"","sources":["../../src/services/mockup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAQ9C,MAAM,OAAO,aAAa;IAChB,MAAM,CAAC,QAAQ,GAAyB,IAAI,CAAC;IAE9C,MAAM,CAAC,WAAW;QACvB,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC5B,aAAa,CAAC,QAAQ,GAAG,IAAI,aAAa,EAAE,CAAC;QAC/C,CAAC;QACD,OAAO,aAAa,CAAC,QAAQ,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,kBAAkB,CAAC,OAA4B;QAC1D,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC;QAE/C,yCAAyC;QACzC,MAAM,aAAa,GAAG,MAAM,cAAc,CAAC,WAAW,CAAC;YACrD,GAAG;YACH,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,KAAK;YACX,QAAQ;SACT,CAAC,CAAC;QAEH,uCAAuC;QACvC,MAAM,YAAY,GAAG,MAAM,cAAc,CAAC,WAAW,CAAC;YACpD,GAAG;YACH,KAAK,EAAE,GAAG;YACV,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,KAAK;YACX,QAAQ;SACT,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,yBAAyB,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnF,MAAM,aAAa,GAAG,yBAAyB,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAEjF,IAAI,YAAY,GAAG,GAAG,CAAC;QACvB,IAAI,CAAC;YACH,YAAY,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC,CAAA,CAAC;QAEV,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6BD,YAAY;;QAGpB,KAAK;YACH,CAAC,CAAC,iEAAiE,KAAK,SAAS;YACjF,CAAC,CAAC,EACN;;;;;;;;;;;;;;;;;;;;sBAoBgB,cAAc;;;;;;;;;;;;;;;;;;;oBAmBhB,aAAa;;;;;;;;;QASzB,CAAC;QAEL,OAAO,cAAc,CAAC,WAAW,CAAC;YAChC,IAAI;YACJ,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,IAAI;YACZ,IAAI,EAAE,KAAK;YACX,QAAQ,EAAE,GAAG;SACd,CAAC,CAAC;IACL,CAAC;;AAGH,MAAM,CAAC,MAAM,aAAa,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC"}

package/dist/services/pdfStamper.d.ts

@@ -0,0 +1,16 @@
+export interface WatermarkOptions {
+    pdfBuffer: Buffer;
+    text: string;
+    opacity?: number;
+    color?: 'red' | 'gray' | 'blue';
+    fontSize?: number;
+}
+export declare class PdfStamperService {
+    private static instance;
+    static getInstance(): PdfStamperService;
+    /**
+     * Applies a diagonal, semi-transparent watermark across all pages of a PDF document.
+     */
+    applyWatermark(options: WatermarkOptions): Promise<Buffer>;
+}
+export declare const pdfStamperService: PdfStamperService;

package/dist/services/pdfStamper.js

@@ -0,0 +1,47 @@
+import { PDFDocument, rgb, degrees, StandardFonts } from 'pdf-lib';
+export class PdfStamperService {
+    static instance = null;
+    static getInstance() {
+        if (!PdfStamperService.instance) {
+            PdfStamperService.instance = new PdfStamperService();
+        }
+        return PdfStamperService.instance;
+    }
+    /**
+     * Applies a diagonal, semi-transparent watermark across all pages of a PDF document.
+     */
+    async applyWatermark(options) {
+        const { pdfBuffer, text, opacity = 0.15, color = 'red', fontSize = 54, } = options;
+        const pdfDoc = await PDFDocument.load(pdfBuffer, { ignoreEncryption: true });
+        const font = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+        const pages = pdfDoc.getPages();
+        let colorRgb = rgb(0.85, 0.1, 0.1); // default red
+        if (color === 'gray') {
+            colorRgb = rgb(0.4, 0.4, 0.4);
+        }
+        else if (color === 'blue') {
+            colorRgb = rgb(0.1, 0.3, 0.85);
+        }
+        const textWidth = font.widthOfTextAtSize(text, fontSize);
+        const textHeight = font.heightAtSize(fontSize);
+        for (const page of pages) {
+            const { width, height } = page.getSize();
+            // Center position adjusted for 45-degree rotation
+            const x = width / 2 - (textWidth / 2) * Math.cos(Math.PI / 4);
+            const y = height / 2 - (textWidth / 2) * Math.sin(Math.PI / 4) + textHeight;
+            page.drawText(text, {
+                x: Math.max(20, x),
+                y: Math.max(20, y),
+                size: fontSize,
+                font,
+                color: colorRgb,
+                opacity: Math.min(Math.max(opacity, 0.05), 0.8),
+                rotate: degrees(45),
+            });
+        }
+        const modifiedBytes = await pdfDoc.save();
+        return Buffer.from(modifiedBytes);
+    }
+}
+export const pdfStamperService = PdfStamperService.getInstance();
+//# sourceMappingURL=pdfStamper.js.map

package/dist/services/pdfStamper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdfStamper.js","sourceRoot":"","sources":["../../src/services/pdfStamper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAUnE,MAAM,OAAO,iBAAiB;IACpB,MAAM,CAAC,QAAQ,GAA6B,IAAI,CAAC;IAElD,MAAM,CAAC,WAAW;QACvB,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC;YAChC,iBAAiB,CAAC,QAAQ,GAAG,IAAI,iBAAiB,EAAE,CAAC;QACvD,CAAC;QACD,OAAO,iBAAiB,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,cAAc,CAAC,OAAyB;QACnD,MAAM,EACJ,SAAS,EACT,IAAI,EACJ,OAAO,GAAG,IAAI,EACd,KAAK,GAAG,KAAK,EACb,QAAQ,GAAG,EAAE,GACd,GAAG,OAAO,CAAC;QAEZ,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC;QAC7E,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QACjE,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;QAEhC,IAAI,QAAQ,GAAG,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,cAAc;QAClD,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;YACrB,QAAQ,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QAChC,CAAC;aAAM,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;YAC5B,QAAQ,GAAG,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACjC,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACzD,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAE/C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YACzC,kDAAkD;YAClD,MAAM,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;YAC9D,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;YAE5E,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;gBAClB,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;gBAClB,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;gBAClB,IAAI,EAAE,QAAQ;gBACd,IAAI;gBACJ,KAAK,EAAE,QAAQ;gBACf,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC;gBAC/C,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;aACpB,CAAC,CAAC;QACL,CAAC;QAED,MAAM,aAAa,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QAC1C,OAAO,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACpC,CAAC;;AAGH,MAAM,CAAC,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,WAAW,EAAE,CAAC"}

package/dist/services/qr.d.ts

@@ -0,0 +1,20 @@
+export interface GenerateQrOptions {
+    text: string;
+    size?: number;
+    darkColor?: string;
+    lightColor?: string;
+    errorCorrection?: 'L' | 'M' | 'Q' | 'H';
+}
+export declare class QrService {
+    private static instance;
+    static getInstance(): QrService;
+    /**
+     * Generates a high-resolution, scannable PNG QR code buffer.
+     */
+    generatePngBuffer(options: GenerateQrOptions): Promise<Buffer>;
+    /**
+     * Generates an SVG string of the QR code.
+     */
+    generateSvg(options: GenerateQrOptions): Promise<string>;
+}
+export declare const qrService: QrService;

package/dist/services/qr.js

@@ -0,0 +1,44 @@
+import QRCode from 'qrcode';
+export class QrService {
+    static instance = null;
+    static getInstance() {
+        if (!QrService.instance) {
+            QrService.instance = new QrService();
+        }
+        return QrService.instance;
+    }
+    /**
+     * Generates a high-resolution, scannable PNG QR code buffer.
+     */
+    async generatePngBuffer(options) {
+        const { text, size = 512, darkColor = '#000000', lightColor = '#ffffff', errorCorrection = 'M', } = options;
+        return QRCode.toBuffer(text, {
+            type: 'png',
+            width: size,
+            margin: 2,
+            color: {
+                dark: darkColor,
+                light: lightColor,
+            },
+            errorCorrectionLevel: errorCorrection,
+        });
+    }
+    /**
+     * Generates an SVG string of the QR code.
+     */
+    async generateSvg(options) {
+        const { text, size = 512, darkColor = '#000000', lightColor = '#ffffff', errorCorrection = 'M', } = options;
+        return QRCode.toString(text, {
+            type: 'svg',
+            width: size,
+            margin: 2,
+            color: {
+                dark: darkColor,
+                light: lightColor,
+            },
+            errorCorrectionLevel: errorCorrection,
+        });
+    }
+}
+export const qrService = QrService.getInstance();
+//# sourceMappingURL=qr.js.map

package/dist/services/qr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qr.js","sourceRoot":"","sources":["../../src/services/qr.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAU5B,MAAM,OAAO,SAAS;IACZ,MAAM,CAAC,QAAQ,GAAqB,IAAI,CAAC;IAE1C,MAAM,CAAC,WAAW;QACvB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;YACxB,SAAS,CAAC,QAAQ,GAAG,IAAI,SAAS,EAAE,CAAC;QACvC,CAAC;QACD,OAAO,SAAS,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,iBAAiB,CAAC,OAA0B;QACvD,MAAM,EACJ,IAAI,EACJ,IAAI,GAAG,GAAG,EACV,SAAS,GAAG,SAAS,EACrB,UAAU,GAAG,SAAS,EACtB,eAAe,GAAG,GAAG,GACtB,GAAG,OAAO,CAAC;QAEZ,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;YAC3B,IAAI,EAAE,KAAK;YACX,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,CAAC;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,SAAS;gBACf,KAAK,EAAE,UAAU;aAClB;YACD,oBAAoB,EAAE,eAAe;SACtC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,WAAW,CAAC,OAA0B;QACjD,MAAM,EACJ,IAAI,EACJ,IAAI,GAAG,GAAG,EACV,SAAS,GAAG,SAAS,EACrB,UAAU,GAAG,SAAS,EACtB,eAAe,GAAG,GAAG,GACtB,GAAG,OAAO,CAAC;QAEZ,OAAO,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;YAC3B,IAAI,EAAE,KAAK;YACX,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,CAAC;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,SAAS;gBACf,KAAK,EAAE,UAAU;aAClB;YACD,oBAAoB,EAAE,eAAe;SACtC,CAAC,CAAC;IACL,CAAC;;AAGH,MAAM,CAAC,MAAM,SAAS,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC"}

package/dist/services/redis.d.ts

@@ -0,0 +1,65 @@
+export interface ApiKeyRecord {
+    key_prefix: string;
+    customer_id: string;
+    plan: string;
+    monthly_limit: number;
+    status: 'active' | 'inactive';
+    created_at: string;
+}
+export interface QuotaCheckResult {
+    allowed: boolean;
+    currentUsage: number;
+    limit: number;
+    remaining: number;
+}
+export declare class RedisService {
+    private static instance;
+    private client;
+    readonly isMemoryFallback: boolean;
+    private constructor();
+    static getInstance(): RedisService;
+    hashKey(rawKey: string): string;
+    private seedDevKey;
+    getApiKey(rawKey: string): Promise<ApiKeyRecord | null>;
+    storeApiKey(rawKey: string, record: ApiKeyRecord): Promise<void>;
+    updateKeyStatusByCustomer(customerId: string, status: 'active' | 'inactive'): Promise<number>;
+    updateCustomerPlan(customerId: string, plan: string, monthlyLimit: number): Promise<number>;
+    getMonthString(date?: Date): string;
+    incrementAndCheckQuota(rawKey: string, monthlyLimit: number): Promise<QuotaCheckResult>;
+    resetMonthlyQuotaForCustomer(customerId: string): Promise<void>;
+    generateImageCacheHash(params: {
+        html?: string;
+        url?: string;
+        width: number;
+        height: number;
+        type: string;
+        wait_for?: string;
+        delay_ms?: number;
+    }): string;
+    getCachedImage(cacheHash: string): Promise<Buffer | null>;
+    setCachedImage(cacheHash: string, imageBuffer: Buffer, ttlSeconds?: number): Promise<void>;
+    generateScrapeCacheHash(params: {
+        url: string;
+        strip_images: boolean;
+    }): string;
+    getCachedScrape<T = any>(cacheHash: string): Promise<T | null>;
+    setCachedScrape(cacheHash: string, result: any, ttlSeconds?: number): Promise<void>;
+    getCurrentUsage(rawKey: string): Promise<number>;
+    saveSessionKey(sessionId: string, apiKey: string, plan: string, monthlyLimit: number, ttlSeconds?: number): Promise<void>;
+    getSessionKey(sessionId: string): Promise<{
+        apiKey: string;
+        plan: string;
+        monthlyLimit: number;
+    } | null>;
+    checkPlaygroundRateLimit(ip: string, maxPerHour?: number): Promise<{
+        allowed: boolean;
+        remaining: number;
+    }>;
+    getFreeKeyByEmail(email: string): Promise<string | null>;
+    setFreeKeyEmail(email: string, rawApiKey: string): Promise<void>;
+    checkClaimRateLimit(ip: string, maxPerHour?: number): Promise<{
+        allowed: boolean;
+        remaining: number;
+    }>;
+}
+export declare const redisService: RedisService;

package/dist/services/redis.js

@@ -0,0 +1,318 @@
+import { Redis } from '@upstash/redis';
+import crypto from 'node:crypto';
+import { env } from '../config/env.js';
+import { PLANS } from '../config/plans.js';
+// In-Memory store fallback for local development or tests when Upstash is not configured
+class MemoryRedisClient {
+    data = new Map();
+    expirations = new Map();
+    cleanKey(key) {
+        const exp = this.expirations.get(key);
+        if (exp && Date.now() > exp) {
+            this.data.delete(key);
+            this.expirations.delete(key);
+        }
+    }
+    async get(key) {
+        this.cleanKey(key);
+        const val = this.data.get(key);
+        if (val === undefined)
+            return null;
+        return val;
+    }
+    async set(key, value, opts) {
+        this.data.set(key, value);
+        if (opts?.ex) {
+            this.expirations.set(key, Date.now() + opts.ex * 1000);
+        }
+        else {
+            this.expirations.delete(key);
+        }
+        return 'OK';
+    }
+    async incr(key) {
+        this.cleanKey(key);
+        const val = Number(this.data.get(key) || 0) + 1;
+        this.data.set(key, val);
+        return val;
+    }
+    async del(...keys) {
+        let count = 0;
+        for (const k of keys) {
+            if (this.data.delete(k)) {
+                this.expirations.delete(k);
+                count++;
+            }
+        }
+        return count;
+    }
+    async smembers(key) {
+        this.cleanKey(key);
+        const set = this.data.get(key);
+        if (set instanceof Set) {
+            return Array.from(set);
+        }
+        return [];
+    }
+    async sadd(key, member) {
+        this.cleanKey(key);
+        let set = this.data.get(key);
+        if (!(set instanceof Set)) {
+            set = new Set();
+            this.data.set(key, set);
+        }
+        const had = set.has(member);
+        set.add(member);
+        return had ? 0 : 1;
+    }
+}
+export class RedisService {
+    static instance = null;
+    client;
+    isMemoryFallback;
+    constructor() {
+        const isUpstashConfigured = Boolean(env.UPSTASH_REDIS_REST_URL &&
+            env.UPSTASH_REDIS_REST_TOKEN &&
+            !env.UPSTASH_REDIS_REST_URL.includes('your-upstash-redis-url') &&
+            !env.UPSTASH_REDIS_REST_TOKEN.includes('your_upstash_rest_token'));
+        if (isUpstashConfigured) {
+            this.client = new Redis({
+                url: env.UPSTASH_REDIS_REST_URL,
+                token: env.UPSTASH_REDIS_REST_TOKEN,
+            });
+            this.isMemoryFallback = false;
+            this.seedDevKey();
+        }
+        else {
+            this.client = new MemoryRedisClient();
+            this.isMemoryFallback = true;
+            this.seedDevKey();
+        }
+    }
+    static getInstance() {
+        if (!RedisService.instance) {
+            RedisService.instance = new RedisService();
+        }
+        return RedisService.instance;
+    }
+    hashKey(rawKey) {
+        return crypto.createHash('sha256').update(rawKey.trim()).digest('hex');
+    }
+    seedDevKey() {
+        if (env.DEV_DEFAULT_API_KEY) {
+            const hash = this.hashKey(env.DEV_DEFAULT_API_KEY);
+            const devRecord = {
+                key_prefix: env.DEV_DEFAULT_API_KEY.slice(0, 12),
+                customer_id: 'cus_dev_sandbox',
+                plan: 'starter',
+                monthly_limit: PLANS.starter.monthlyLimit,
+                status: 'active',
+                created_at: new Date().toISOString(),
+            };
+            this.client.set(`api_keys:${hash}`, devRecord);
+            if ('sadd' in this.client) {
+                this.client.sadd('customer_keys:cus_dev_sandbox', hash);
+            }
+        }
+    }
+    async getApiKey(rawKey) {
+        const hash = this.hashKey(rawKey);
+        const key = `api_keys:${hash}`;
+        const record = await this.client.get(key);
+        if (!record) {
+            // In development mode, auto-provision any key to avoid friction
+            if (env.NODE_ENV === 'development') {
+                const autoRecord = {
+                    key_prefix: rawKey.slice(0, 12),
+                    customer_id: 'cus_dev_auto',
+                    plan: 'starter',
+                    monthly_limit: PLANS.starter.monthlyLimit,
+                    status: 'active',
+                    created_at: new Date().toISOString(),
+                };
+                await this.storeApiKey(rawKey, autoRecord);
+                return autoRecord;
+            }
+            return null;
+        }
+        if (typeof record === 'string') {
+            try {
+                return JSON.parse(record);
+            }
+            catch {
+                return null;
+            }
+        }
+        return record;
+    }
+    async storeApiKey(rawKey, record) {
+        const hash = this.hashKey(rawKey);
+        const key = `api_keys:${hash}`;
+        await this.client.set(key, record);
+        // Track customer's keys for webhook lifecycle management
+        if ('sadd' in this.client) {
+            await this.client.sadd(`customer_keys:${record.customer_id}`, hash);
+        }
+    }
+    async updateKeyStatusByCustomer(customerId, status) {
+        let hashes = [];
+        if ('smembers' in this.client) {
+            hashes = await this.client.smembers(`customer_keys:${customerId}`);
+        }
+        let updatedCount = 0;
+        for (const hash of hashes) {
+            const key = `api_keys:${hash}`;
+            const record = await this.client.get(key);
+            if (record) {
+                const parsed = typeof record === 'string' ? JSON.parse(record) : record;
+                parsed.status = status;
+                await this.client.set(key, parsed);
+                updatedCount++;
+            }
+        }
+        return updatedCount;
+    }
+    async updateCustomerPlan(customerId, plan, monthlyLimit) {
+        let hashes = [];
+        if ('smembers' in this.client) {
+            hashes = await this.client.smembers(`customer_keys:${customerId}`);
+        }
+        let updatedCount = 0;
+        for (const hash of hashes) {
+            const key = `api_keys:${hash}`;
+            const record = await this.client.get(key);
+            if (record) {
+                const parsed = typeof record === 'string' ? JSON.parse(record) : record;
+                parsed.plan = plan;
+                parsed.monthly_limit = monthlyLimit;
+                parsed.status = 'active';
+                await this.client.set(key, parsed);
+                updatedCount++;
+            }
+        }
+        return updatedCount;
+    }
+    getMonthString(date = new Date()) {
+        const y = date.getUTCFullYear();
+        const m = String(date.getUTCMonth() + 1).padStart(2, '0');
+        return `${y}-${m}`;
+    }
+    async incrementAndCheckQuota(rawKey, monthlyLimit) {
+        const hash = this.hashKey(rawKey);
+        const month = this.getMonthString();
+        const usageKey = `usage:${hash}:${month}`;
+        const usage = await this.client.incr(usageKey);
+        const allowed = usage <= monthlyLimit;
+        const remaining = Math.max(0, monthlyLimit - usage);
+        return {
+            allowed,
+            currentUsage: usage,
+            limit: monthlyLimit,
+            remaining,
+        };
+    }
+    async resetMonthlyQuotaForCustomer(customerId) {
+        let hashes = [];
+        if ('smembers' in this.client) {
+            hashes = await this.client.smembers(`customer_keys:${customerId}`);
+        }
+        const month = this.getMonthString();
+        for (const hash of hashes) {
+            const usageKey = `usage:${hash}:${month}`;
+            await this.client.del(usageKey);
+        }
+    }
+    generateImageCacheHash(params) {
+        const target = params.url ? `url:${params.url}` : `html:${params.html || ''}`;
+        const payload = `${params.type}:${params.width}x${params.height}:${params.wait_for || ''}:${params.delay_ms || ''}:${target}`;
+        return crypto.createHash('sha256').update(payload).digest('hex');
+    }
+    async getCachedImage(cacheHash) {
+        const key = `cache:img:${cacheHash}`;
+        const base64Data = await this.client.get(key);
+        if (!base64Data)
+            return null;
+        return Buffer.from(base64Data, 'base64');
+    }
+    async setCachedImage(cacheHash, imageBuffer, ttlSeconds = env.CACHE_TTL_SECONDS) {
+        const key = `cache:img:${cacheHash}`;
+        const base64Data = imageBuffer.toString('base64');
+        await this.client.set(key, base64Data, { ex: ttlSeconds });
+    }
+    generateScrapeCacheHash(params) {
+        const payload = `scrape:${params.strip_images}:${params.url.trim()}`;
+        return crypto.createHash('sha256').update(payload).digest('hex');
+    }
+    async getCachedScrape(cacheHash) {
+        const key = `cache:scrape:${cacheHash}`;
+        const data = await this.client.get(key);
+        if (!data)
+            return null;
+        if (typeof data === 'string') {
+            try {
+                return JSON.parse(data);
+            }
+            catch {
+                return null;
+            }
+        }
+        return data;
+    }
+    async setCachedScrape(cacheHash, result, ttlSeconds = 86400) {
+        const key = `cache:scrape:${cacheHash}`;
+        await this.client.set(key, JSON.stringify(result), { ex: ttlSeconds });
+    }
+    async getCurrentUsage(rawKey) {
+        const hash = this.hashKey(rawKey);
+        const month = this.getMonthString();
+        const usageKey = `usage:${hash}:${month}`;
+        const val = await this.client.get(usageKey);
+        return Number(val || 0);
+    }
+    async saveSessionKey(sessionId, apiKey, plan, monthlyLimit, ttlSeconds = 86400) {
+        const key = `session_keys:${sessionId}`;
+        await this.client.set(key, JSON.stringify({ apiKey, plan, monthlyLimit }), { ex: ttlSeconds });
+    }
+    async getSessionKey(sessionId) {
+        const key = `session_keys:${sessionId}`;
+        const val = await this.client.get(key);
+        if (!val)
+            return null;
+        if (typeof val === 'string') {
+            try {
+                return JSON.parse(val);
+            }
+            catch {
+                return null;
+            }
+        }
+        return val;
+    }
+    async checkPlaygroundRateLimit(ip, maxPerHour = 25) {
+        const hour = Math.floor(Date.now() / (1000 * 60 * 60));
+        const key = `ratelimit:playground:${ip}:${hour}`;
+        const usage = await this.client.incr(key);
+        const allowed = usage <= maxPerHour;
+        return { allowed, remaining: Math.max(0, maxPerHour - usage) };
+    }
+    async getFreeKeyByEmail(email) {
+        const key = `free_key_email:${email.toLowerCase().trim()}`;
+        const val = await this.client.get(key);
+        return val || null;
+    }
+    async setFreeKeyEmail(email, rawApiKey) {
+        const key = `free_key_email:${email.toLowerCase().trim()}`;
+        await this.client.set(key, rawApiKey);
+    }
+    async checkClaimRateLimit(ip, maxPerHour = 10) {
+        const hour = Math.floor(Date.now() / (1000 * 60 * 60));
+        const key = `ratelimit:claim:${ip}:${hour}`;
+        const count = await this.client.incr(key);
+        return {
+            allowed: count <= maxPerHour,
+            remaining: Math.max(0, maxPerHour - count),
+        };
+    }
+}
+export const redisService = RedisService.getInstance();
+//# sourceMappingURL=redis.js.map