lytx 0.3.0

package/src/utilities/encrypt.ts

@@ -0,0 +1,103 @@
+/**
+ * Generate a new encryption key (run this locally once, not in production)
+ * @returns Base64 encoded encryption key
+ */
+export async function generateEncryptionKey(): Promise<string> {
+    const key = await crypto.subtle.generateKey(
+        { name: "AES-GCM", length: 256 },
+        true,
+        ["encrypt", "decrypt"]
+    );
+
+    const exportedKey = await crypto.subtle.exportKey("raw", key);
+    return btoa(String.fromCharCode(...new Uint8Array(exportedKey)));
+}
+
+
+/**
+ * Import an encryption key from base64 format
+ * @param keyBase64 Base64 encoded encryption key
+ * @returns CryptoKey object for encryption/decryption
+ */
+export async function getEncryptionKey(keyBase64: string): Promise<CryptoKey> {
+    const keyBytes = Uint8Array.from(atob(keyBase64), c => c.charCodeAt(0));
+    return await crypto.subtle.importKey(
+        "raw",
+        keyBytes,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt", "decrypt"]
+    );
+}
+
+
+/**
+ * Encrypt a string value
+ * @param value The string to encrypt
+ * @param keyBase64 Base64 encoded encryption key
+ * @returns Object containing encrypted value and initialization vector
+ */
+export async function encrypt(value: string, keyBase64: string): Promise<{
+    encryptedValue: string;
+    iv: string;
+}> {
+    // Create a random initialization vector
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+
+    // Get the key
+    const key = await getEncryptionKey(keyBase64);
+
+    // Encode the string as bytes
+    const encoder = new TextEncoder();
+    const valueBytes = encoder.encode(value);
+
+    // Encrypt the value
+    const encryptedBytes = await crypto.subtle.encrypt(
+        { name: "AES-GCM", iv },
+        key,
+        valueBytes
+    );
+
+    // Convert to base64 for storage
+    const encryptedValue = btoa(String.fromCharCode(...new Uint8Array(encryptedBytes)));
+    const ivBase64 = btoa(String.fromCharCode(...iv));
+
+    return { encryptedValue, iv: ivBase64 };
+}
+
+
+/**
+ * Decrypt an encrypted string value
+ * @param encryptedValue Base64 encoded encrypted value
+ * @param ivBase64 Base64 encoded initialization vector
+ * @param keyBase64 Base64 encoded encryption key
+ * @returns The decrypted string
+ */
+export async function decrypt(
+    encryptedValue: string,
+    ivBase64: string,
+    keyBase64: string
+): Promise<string> {
+    try {
+        // Convert from base64
+        const encryptedBytes = Uint8Array.from(atob(encryptedValue), c => c.charCodeAt(0));
+        const iv = Uint8Array.from(atob(ivBase64), c => c.charCodeAt(0));
+
+        // Get the key
+        const key = await getEncryptionKey(keyBase64);
+
+        // Decrypt
+        const decryptedBytes = await crypto.subtle.decrypt(
+            { name: "AES-GCM", iv },
+            key,
+            encryptedBytes
+        );
+
+        // Convert back to string
+        const decoder = new TextDecoder();
+        return decoder.decode(decryptedBytes);
+    } catch (error) {
+        console.error("Decryption failed:", error);
+        throw new Error("Failed to decrypt value. The data may be corrupted or the key is incorrect.", { cause: error });
+    }
+}

package/src/utilities/index.ts

@@ -0,0 +1,13 @@
+//import { crypto } from "@cloudflare/workers-types";
+
+export async function hashIpAddress(ipAddress:string, salt:string) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(ipAddress + salt); // Combine IP address and salt
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer)); 
+    const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    return hashHex;
+  }
+  
+//crypto
+

package/src/utilities/parser.ts

@@ -0,0 +1,117 @@
+import { PageEvent, parseData } from "@/templates/lytxpixel";
+import { trackEvents } from "@/templates/trackWebEvents";
+const dataVariableName = "lytxDataLayer" as const;
+
+// Comprehensive function cleaner for build artifacts
+function cleanFunctionForEmbedding(func: Function): string {
+    let source = func.toString();
+
+    // Remove all variations of __name and @__PURE__ annotations
+    source = source
+        // Remove standalone @__PURE__ comments
+        .replace(/\/\*\s*@__PURE__\s*\*\/\s*/g, '')
+        // Remove __name calls with various patterns
+        .replace(/__name\s*\([^)]*\)\s*[,;]?\s*/g, '')
+        // Remove combined patterns like "= /* @__PURE__ */ __name("
+        .replace(/=\s*\/\*\s*@__PURE__\s*\*\/\s*__name\s*\([^,)]*,\s*[^)]*\)/g, '= ')
+        // Remove const declarations with __name
+        .replace(/const\s+(\w+)\s*=\s*\/\*\s*@__PURE__\s*\*\/\s*__name\s*\([^,)]*,\s*[^)]*\)/g, 'const $1 = ')
+        // Clean up function expressions
+        .replace(/function\s*\(\)\s*\{\s*return\s*([^}]+)\s*\}\s*\(\)/g, '$1')
+        // Remove any remaining __name references
+        .replace(/__name/g, '')
+        // Clean up extra commas and semicolons
+        .replace(/,\s*[,;]/g, ',')
+        .replace(/;\s*;/g, ';')
+        // Normalize whitespace
+        .replace(/\s+/g, ' ')
+        .trim();
+
+    return source;
+}
+type TagConfig = { site: string, tag: string, track_web_events: boolean, gdpr: boolean };
+type QueryParams = {
+    [key: string]: string[];
+};
+type DataVariableName = typeof dataVariableName;
+
+type ScriptConfig = { config: TagConfig, queryParamsStr?: string, data: PageEvent[], dataVariableName: DataVariableName };
+//TODO fix types for config and queryParamsStr
+export function generateScript(conf: ScriptConfig) {
+    const { config, queryParamsStr, data, dataVariableName } = conf;
+
+
+    //TODO check these
+    const dataObjects = data.map(item => {
+        return `
+            {
+                event_name: ${JSON.stringify(item.event_name)},
+                condition: ${JSON.stringify(item.condition)},
+                data_passback: ${JSON.stringify(item.data_passback)},
+                parameters: ${JSON.stringify(item.parameters)},
+                paramConfig: ${JSON.stringify(item.paramConfig)},
+                query_parameters: ${JSON.stringify(item.query_parameters)},
+                customScript: ${JSON.stringify(item.customScript)},
+                rules: ${JSON.stringify(item.rules)},
+                Notes: ${JSON.stringify(item.Notes)}
+            }
+        `;
+    }).join(',');
+
+    //part to impor
+
+    //!dont forget to check for config gdp and change data
+
+    //var config = ${JSON.stringify(config)};
+    //var queryParamsStr = "${queryParamsStr}";
+    const jsTemplate = `
+        (function() {
+            const dataVariableName = [${dataObjects}];
+            
+            
+            if(window.${dataVariableName}){
+                window.${dataVariableName}.push(
+                  {site:"${config.site}",tag:"${config.tag}",events:${dataVariableName},tracked:[]}
+                )
+            }else{
+                window.${dataVariableName} = [
+                  {site:"${config.site}",tag:"${config.tag}",events:${dataVariableName},tracked:[]}
+                ]
+            }
+
+            //parseData
+            //trackEvents
+            ${cleanFunctionForEmbedding(parseData)}
+            ${cleanFunctionForEmbedding(trackEvents)}
+            parseData(${dataVariableName},{site:"${config.site}",tag:"${config.tag}"},trackEvents,${config.track_web_events},'{{platform}}');
+            //replace handlebars
+
+            parseData(${dataVariableName},{site:"${config.site}",tag:"${config.tag}"},trackEvents,${config.track_web_events},'{{platform}}');
+            ${config.track_web_events
+            ? `trackEvents("${config.tag}",'{{platform}}',null,'{{{macros}}}');`
+            : ``
+        }
+              window.lytxApi.event = trackEvents;
+              window.lytxApi.capture = function(eventName, customData) {
+                window.lytxApi.event("${config.tag}", "{{platform}}", { custom: eventName }, "", customData || undefined);
+              };
+        })();
+    `;
+
+    return jsTemplate;
+}
+
+
+
+
+function buildQueryString(queryParams: QueryParams): string {
+    // Filter out unwanted keys
+    const filteredParams = Object.entries(queryParams).filter(([key]) => key !== 'account' && key !== 'platform');
+
+    // Convert the object to a query string
+    const queryString = filteredParams.map(([key, value]) => {
+        return encodeURIComponent(key) + '=' + encodeURIComponent(value.join('&'));
+    }).join('&');
+
+    return queryString ? `&${queryString}` : '';
+}