@formo/analytics 1.26.0 → 1.28.0

package/dist/esm/src/privy/utils.js

@@ -0,0 +1,185 @@
+/**
+ * Utility functions for extracting profile properties from Privy user objects.
+ */
+/**
+ * Extract profile properties and wallet addresses from a Privy user object.
+ *
+ * Parses the Privy user's linked accounts into a flat properties object
+ * (email, social accounts, etc.) and extracts all linked wallet addresses.
+ *
+ * @param user - The Privy user object from `usePrivy()`
+ * @returns An object with `properties` and `wallets`
+ *
+ * @example
+ * ```ts
+ * import { parsePrivyProperties } from '@formo/analytics';
+ *
+ * const { user } = usePrivy();
+ * if (user) {
+ *   const { properties, wallets } = parsePrivyProperties(user);
+ *
+ *   for (const wallet of wallets) {
+ *     formo.identify({ address: wallet.address, userId: user.id }, properties);
+ *   }
+ * }
+ * ```
+ */
+export function parsePrivyProperties(user) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    var accounts = user.linkedAccounts || [];
+    // Extract profile properties
+    var properties = {
+        privyDid: user.id,
+        privyCreatedAt: user.createdAt,
+    };
+    // Email
+    if ((_a = user.email) === null || _a === void 0 ? void 0 : _a.address) {
+        properties.email = user.email.address;
+    }
+    // Social accounts - extract usernames/identifiers
+    if ((_b = user.apple) === null || _b === void 0 ? void 0 : _b.email) {
+        properties.apple = user.apple.email;
+    }
+    if ((_c = user.discord) === null || _c === void 0 ? void 0 : _c.username) {
+        properties.discord = user.discord.username;
+    }
+    if ((_d = user.farcaster) === null || _d === void 0 ? void 0 : _d.username) {
+        properties.farcaster = user.farcaster.username;
+    }
+    if ((_e = user.github) === null || _e === void 0 ? void 0 : _e.username) {
+        properties.github = user.github.username;
+    }
+    if ((_f = user.google) === null || _f === void 0 ? void 0 : _f.email) {
+        properties.google = user.google.email;
+    }
+    if ((_g = user.instagram) === null || _g === void 0 ? void 0 : _g.username) {
+        properties.instagram = user.instagram.username;
+    }
+    if ((_h = user.line) === null || _h === void 0 ? void 0 : _h.email) {
+        properties.line = user.line.email;
+    }
+    if ((_j = user.linkedin) === null || _j === void 0 ? void 0 : _j.email) {
+        properties.linkedin = user.linkedin.email;
+    }
+    if ((_k = user.spotify) === null || _k === void 0 ? void 0 : _k.email) {
+        properties.spotify = user.spotify.email;
+    }
+    if ((_l = user.telegram) === null || _l === void 0 ? void 0 : _l.username) {
+        properties.telegram = user.telegram.username;
+    }
+    if ((_m = user.tiktok) === null || _m === void 0 ? void 0 : _m.username) {
+        properties.tiktok = user.tiktok.username;
+    }
+    if ((_o = user.twitter) === null || _o === void 0 ? void 0 : _o.username) {
+        properties.twitter = user.twitter.username;
+    }
+    // Fallback to linkedAccounts if convenience accessors are not populated
+    if (!properties.email) {
+        var emailAccount = accounts.find(function (account) { return account.type === "email"; });
+        if (emailAccount === null || emailAccount === void 0 ? void 0 : emailAccount.address) {
+            properties.email = emailAccount.address;
+        }
+    }
+    if (!properties.apple) {
+        var appleAccount = accounts.find(function (a) { return a.type === "apple_oauth"; });
+        if (appleAccount === null || appleAccount === void 0 ? void 0 : appleAccount.email) {
+            properties.apple = appleAccount.email;
+        }
+    }
+    if (!properties.discord) {
+        var discordAccount = accounts.find(function (a) { return a.type === "discord_oauth"; });
+        if (discordAccount === null || discordAccount === void 0 ? void 0 : discordAccount.username) {
+            properties.discord = discordAccount.username;
+        }
+    }
+    if (!properties.farcaster) {
+        var farcasterAccount = accounts.find(function (a) { return a.type === "farcaster"; });
+        if (farcasterAccount === null || farcasterAccount === void 0 ? void 0 : farcasterAccount.username) {
+            properties.farcaster = farcasterAccount.username;
+        }
+        else if (farcasterAccount === null || farcasterAccount === void 0 ? void 0 : farcasterAccount.displayName) {
+            properties.farcaster = farcasterAccount.displayName;
+        }
+    }
+    if (!properties.github) {
+        var githubAccount = accounts.find(function (a) { return a.type === "github_oauth"; });
+        if (githubAccount === null || githubAccount === void 0 ? void 0 : githubAccount.username) {
+            properties.github = githubAccount.username;
+        }
+    }
+    if (!properties.google) {
+        var googleAccount = accounts.find(function (a) { return a.type === "google_oauth"; });
+        if (googleAccount === null || googleAccount === void 0 ? void 0 : googleAccount.email) {
+            properties.google = googleAccount.email;
+        }
+    }
+    if (!properties.instagram) {
+        var instagramAccount = accounts.find(function (a) { return a.type === "instagram_oauth"; });
+        if (instagramAccount === null || instagramAccount === void 0 ? void 0 : instagramAccount.username) {
+            properties.instagram = instagramAccount.username;
+        }
+    }
+    if (!properties.line) {
+        var lineAccount = accounts.find(function (a) { return a.type === "line"; });
+        if (lineAccount === null || lineAccount === void 0 ? void 0 : lineAccount.email) {
+            properties.line = lineAccount.email;
+        }
+    }
+    if (!properties.linkedin) {
+        var linkedinAccount = accounts.find(function (a) { return a.type === "linkedin_oauth"; });
+        if (linkedinAccount === null || linkedinAccount === void 0 ? void 0 : linkedinAccount.email) {
+            properties.linkedin = linkedinAccount.email;
+        }
+    }
+    if (!properties.spotify) {
+        var spotifyAccount = accounts.find(function (a) { return a.type === "spotify_oauth"; });
+        if (spotifyAccount === null || spotifyAccount === void 0 ? void 0 : spotifyAccount.email) {
+            properties.spotify = spotifyAccount.email;
+        }
+    }
+    if (!properties.telegram) {
+        var telegramAccount = accounts.find(function (a) { return a.type === "telegram"; });
+        if (telegramAccount === null || telegramAccount === void 0 ? void 0 : telegramAccount.username) {
+            properties.telegram = telegramAccount.username;
+        }
+        else if (telegramAccount === null || telegramAccount === void 0 ? void 0 : telegramAccount.telegramUserId) {
+            properties.telegram = telegramAccount.telegramUserId;
+        }
+    }
+    if (!properties.tiktok) {
+        var tiktokAccount = accounts.find(function (a) { return a.type === "tiktok_oauth"; });
+        if (tiktokAccount === null || tiktokAccount === void 0 ? void 0 : tiktokAccount.username) {
+            properties.tiktok = tiktokAccount.username;
+        }
+    }
+    if (!properties.twitter) {
+        var twitterAccount = accounts.find(function (a) { return a.type === "twitter_oauth"; });
+        if (twitterAccount === null || twitterAccount === void 0 ? void 0 : twitterAccount.username) {
+            properties.twitter = twitterAccount.username;
+        }
+    }
+    // Use OAuth emails as fallback for email if still blank
+    // Priority: email -> google -> apple -> linkedin
+    if (!properties.email) {
+        if (properties.google) {
+            properties.email = properties.google;
+        }
+        else if (properties.apple) {
+            properties.email = properties.apple;
+        }
+        else if (properties.linkedin) {
+            properties.email = properties.linkedin;
+        }
+    }
+    // Extract wallet addresses
+    var wallets = accounts
+        .filter(function (a) { return a.type === "wallet" && a.address; })
+        .map(function (a) { return ({
+        address: a.address,
+        walletClient: a.walletClientType || a.walletClient,
+        chainType: a.chainType,
+        isEmbedded: a.walletClientType === "privy" || a.walletClient === "privy",
+    }); });
+    return { properties: properties, wallets: wallets };
+}
+//# sourceMappingURL=utils.js.map

package/dist/esm/src/queue/EventQueue.d.ts

@@ -1,5 +1,8 @@
-import { IFormoEvent } from "../types";
+import { IFormoEvent, IFormoEventPayload } from "../types";
 import { IEventQueue } from "./type";
+type IFormoEventFlushPayload = IFormoEventPayload & {
+    sent_at: string;
+};
 type Options = {
     apiHost: string;
     flushAt?: number;
@@ -25,7 +28,26 @@ export declare class EventQueue implements IEventQueue {
     constructor(writeKey: string, options: Options);
     private generateMessageId;
     enqueue(event: IFormoEvent, callback?: (...args: any) => void): Promise<void>;
-    flush(callback?: (...args: any) => void): Promise<any>;
+    flush(callback?: (...args: any) => void): Promise<void | IFormoEventFlushPayload[]>;
+    /**
+     * Returns the UTF-8 byte length of a string. The browser's keepalive limit
+     * is enforced on the wire (UTF-8 bytes), not on JS string length (UTF-16
+     * code units). Non-ASCII characters (CJK, emoji) can be 2–4x larger in
+     * UTF-8 than their string .length suggests.
+     */
+    private static byteLength;
+    /**
+     * Splits events into batches that respect the browser's 64KB keepalive
+     * payload size limit. Each batch pairs its serialized data with the
+     * original queue items (for per-item callback reporting) and a flag
+     * indicating whether keepalive is safe to use.
+     */
+    private splitIntoBatches;
+    /**
+     * Sends batches sequentially, notifying per-item callbacks on success/failure.
+     * Returns the first error encountered (if any) so the caller can report it.
+     */
+    private sendBatches;
     private isErrorRetryable;
     private isDuplicate;
     private onPageLeave;

package/dist/esm/src/queue/EventQueue.js

@@ -51,6 +51,16 @@ import { logger } from "../logger";
 import { EVENTS_API_REQUEST_HEADER } from "../constants";
 import fetch from "../fetch";
 var noop = function () { };
+var safeCall = function (fn) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    try {
+        fn.apply(void 0, args);
+    }
+    catch ( /* swallow */_a) { /* swallow */ }
+};
 var DEFAULT_RETRY = 3;
 var MAX_RETRY = 5;
 var MIN_RETRY = 1;
@@ -60,6 +70,10 @@ var MIN_FLUSH_AT = 1;
 var DEFAULT_QUEUE_SIZE = 1024 * 500; // 500kB
 var MAX_QUEUE_SIZE = 1024 * 500; // 500kB
 var MIN_QUEUE_SIZE = 200; // 200 bytes
+// Browsers enforce a 64KB limit on the total body size of in-flight
+// keepalive fetch requests. Payloads exceeding this are silently cancelled,
+// producing a TypeError: Failed to fetch that cannot be resolved by retrying.
+var KEEPALIVE_PAYLOAD_LIMIT = 64 * 1024; // 64kB
 var DEFAULT_FLUSH_INTERVAL = 1000 * 30; // 1 MINUTE
 var MAX_FLUSH_INTERVAL = 1000 * 300; // 5 MINUTES
 var MIN_FLUSH_INTERVAL = 1000 * 10; // 10 SECONDS
@@ -144,7 +158,6 @@ var EventQueue = /** @class */ (function () {
             });
         }); });
     }
-    //#region Public functions
     EventQueue.prototype.generateMessageId = function (event) {
         return __awaiter(this, void 0, void 0, function () {
             var formattedTimestamp, eventForHashing, eventString;
@@ -200,7 +213,7 @@ var EventQueue = /** @class */ (function () {
     };
     EventQueue.prototype.flush = function (callback) {
         return __awaiter(this, void 0, void 0, function () {
-            var err_1, items, sentAt, data, done;
+            var items, sentAt, data, batches;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -214,75 +227,171 @@ var EventQueue = /** @class */ (function () {
                             callback();
                             return [2 /*return*/, Promise.resolve()];
                         }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 4, , 5]);
-                        if (!this.pendingFlush) return [3 /*break*/, 3];
+                        if (!this.pendingFlush) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.pendingFlush];
-                    case 2:
+                    case 1:
                         _a.sent();
-                        _a.label = 3;
-                    case 3: return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _a.sent();
-                        this.pendingFlush = null;
-                        throw err_1;
-                    case 5:
+                        _a.label = 2;
+                    case 2:
                         items = this.queue.splice(0, this.flushAt);
                         this.payloadHashes.clear();
                         sentAt = new Date().toISOString();
                         data = items.map(function (item) { return (__assign(__assign({}, item.message), { sent_at: sentAt })); });
-                        done = function (err) {
-                            items.forEach(function (_a) {
-                                var message = _a.message, callback = _a.callback;
-                                return callback(err, message, data);
-                            });
-                            callback(err, data);
-                        };
-                        return [2 /*return*/, (this.pendingFlush = fetch("".concat(this.apiHost), {
-                                headers: EVENTS_API_REQUEST_HEADER(this.writeKey),
-                                method: "POST",
-                                body: JSON.stringify(data),
-                                keepalive: true,
-                                retries: this.retryCount,
-                                retryDelay: function (attempt) { return Math.pow(2, attempt) * 1000; }, // exponential backoff
-                                retryOn: function (_, error) { return _this.isErrorRetryable(error); },
-                            })
-                                .then(function () {
-                                done();
+                        batches = this.splitIntoBatches(items, data);
+                        return [2 /*return*/, (this.pendingFlush = this.sendBatches(batches, data)
+                                .then(function (firstError) {
+                                if (firstError) {
+                                    safeCall(callback, firstError, data);
+                                    if (typeof _this.errorHandler === "function") {
+                                        safeCall(_this.errorHandler, firstError);
+                                    }
+                                }
+                                else {
+                                    safeCall(callback, undefined, data);
+                                }
                                 return Promise.resolve(data);
                             })
                                 .catch(function (err) {
+                                // Defensive: should not be reachable since sendBatches catches
+                                // all errors internally, but guard against unexpected failures.
+                                safeCall(callback, err, data);
                                 if (typeof _this.errorHandler === "function") {
-                                    done(err);
-                                    return _this.errorHandler(err);
-                                }
-                                if (err.response) {
-                                    var error = new Error(err.response.statusText);
-                                    done(error);
-                                    throw error;
+                                    safeCall(_this.errorHandler, err);
                                 }
-                                done(err);
-                                throw err;
+                                // Do NOT re-throw — analytics errors should never
+                                // propagate as unhandled rejections to the host app
                             }))];
                 }
             });
         });
     };
-    //#region Utility functions
-    EventQueue.prototype.isErrorRetryable = function (error) {
-        var _a, _b, _c;
+    /**
+     * Returns the UTF-8 byte length of a string. The browser's keepalive limit
+     * is enforced on the wire (UTF-8 bytes), not on JS string length (UTF-16
+     * code units). Non-ASCII characters (CJK, emoji) can be 2–4x larger in
+     * UTF-8 than their string .length suggests.
+     */
+    EventQueue.byteLength = function (str) {
+        return new TextEncoder().encode(str).byteLength;
+    };
+    /**
+     * Splits events into batches that respect the browser's 64KB keepalive
+     * payload size limit. Each batch pairs its serialized data with the
+     * original queue items (for per-item callback reporting) and a flag
+     * indicating whether keepalive is safe to use.
+     */
+    EventQueue.prototype.splitIntoBatches = function (items, data) {
+        var serialized = JSON.stringify(data);
+        if (EventQueue.byteLength(serialized) <= KEEPALIVE_PAYLOAD_LIMIT) {
+            return [{ data: data, items: items, keepalive: true }];
+        }
+        var batches = [];
+        var currentData = [];
+        var currentItems = [];
+        var currentSize = 2; // account for JSON array brackets "[]"
+        for (var i = 0; i < data.length; i++) {
+            var event_1 = data[i];
+            var eventSize = EventQueue.byteLength(JSON.stringify(event_1));
+            var sizeWithEvent = currentSize + (currentData.length > 0 ? 1 : 0) + eventSize;
+            if (sizeWithEvent > KEEPALIVE_PAYLOAD_LIMIT) {
+                if (currentData.length > 0) {
+                    batches.push({ data: currentData, items: currentItems, keepalive: true });
+                }
+                // If a single event exceeds the limit, send it without keepalive
+                if (eventSize + 2 > KEEPALIVE_PAYLOAD_LIMIT) {
+                    batches.push({ data: [event_1], items: [items[i]], keepalive: false });
+                    currentData = [];
+                    currentItems = [];
+                    currentSize = 2;
+                }
+                else {
+                    currentData = [event_1];
+                    currentItems = [items[i]];
+                    currentSize = 2 + eventSize;
+                }
+            }
+            else {
+                currentData.push(event_1);
+                currentItems.push(items[i]);
+                currentSize = sizeWithEvent;
+            }
+        }
+        if (currentData.length > 0) {
+            batches.push({ data: currentData, items: currentItems, keepalive: true });
+        }
+        return batches;
+    };
+    /**
+     * Sends batches sequentially, notifying per-item callbacks on success/failure.
+     * Returns the first error encountered (if any) so the caller can report it.
+     */
+    EventQueue.prototype.sendBatches = function (batches, allData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var firstError, _i, batches_1, batch, body, response, error, err_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _i = 0, batches_1 = batches;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < batches_1.length)) return [3 /*break*/, 6];
+                        batch = batches_1[_i];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        body = JSON.stringify(batch.data);
+                        return [4 /*yield*/, fetch("".concat(this.apiHost), {
+                                headers: EVENTS_API_REQUEST_HEADER(this.writeKey),
+                                method: "POST",
+                                body: body,
+                                keepalive: batch.keepalive,
+                                retries: this.retryCount,
+                                retryDelay: function (attempt) { return Math.pow(2, attempt) * 1000; },
+                                retryOn: function (_, error, response) { return _this.isErrorRetryable(error, response); },
+                            })];
+                    case 3:
+                        response = _a.sent();
+                        if (!response.ok) {
+                            error = new Error(response.statusText || "HTTP ".concat(response.status));
+                            error.response = response;
+                            throw error;
+                        }
+                        batch.items.forEach(function (_a) {
+                            var message = _a.message, cb = _a.callback;
+                            return safeCall(cb, undefined, message, allData);
+                        });
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        firstError = firstError || err_1;
+                        batch.items.forEach(function (_a) {
+                            var message = _a.message, cb = _a.callback;
+                            return safeCall(cb, err_1, message, allData);
+                        });
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/, firstError];
+                }
+            });
+        });
+    };
+    EventQueue.prototype.isErrorRetryable = function (error, response) {
+        var _a, _b;
         // Retry Network Errors.
-        if (isNetworkError(error))
+        if (error && isNetworkError(error))
             return true;
-        // Cannot determine if the request can be retried
-        if (!(error === null || error === void 0 ? void 0 : error.response))
+        // Check response status if available
+        var status = (_a = response === null || response === void 0 ? void 0 : response.status) !== null && _a !== void 0 ? _a : (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status;
+        if (!status)
             return false;
         // Retry Server Errors (5xx).
-        if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) >= 500 && ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status) <= 599)
+        if (status >= 500 && status <= 599)
             return true;
         // Retry if rate limited.
-        if (((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.status) === 429)
+        if (status === 429)
             return true;
         return false;
     };

package/dist/esm/src/session/index.js

@@ -96,7 +96,8 @@ var FormoAnalyticsSession = /** @class */ (function () {
         var _a;
         var identifiedKey = this.generateIdentificationKey(address, rdns);
         var identifiedWallets = ((_a = cookie().get(SESSION_WALLET_IDENTIFIED_KEY)) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
-        if (!identifiedWallets.includes(identifiedKey)) {
+        var alreadyExists = identifiedWallets.includes(identifiedKey);
+        if (!alreadyExists) {
             identifiedWallets.push(identifiedKey);
             var newValue = identifiedWallets.join(",");
             cookie().set(SESSION_WALLET_IDENTIFIED_KEY, newValue, {