@funnelsgrove/runtime 0.11.2 → 0.11.3

package/dist/services/funnel-sdk.service.js

@@ -1,457 +1,39 @@
-import { buildMainApiUrl, FUNNEL_ID, FUNNEL_SDK_PUBLISHABLE_KEY, FUNNEL_VERSION_ID, } from './runtime-api.config.js';
-import { resolvePreviewPaymentPublishableKey } from './public-env.js';
-import { CURRENT_STEP_CONTRACT_VERSION } from '../steps/step-contract.js';
-import { toV2CheckoutSelection, toV2CheckoutSessionRequest } from './funnel-sdk-payments.functions.js';
-const trimTrailingSlash = (value) => value.replace(/\/+$/, '');
-const toNormalizedPath = (path) => (path.startsWith('/') ? path : `/${path}`);
-const asTrimmedStringOrNull = (value) => {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed || null;
+import { bootstrapUser } from './funnel-sdk/users/bootstrapUser.js';
+import { captureEmail } from './funnel-sdk/users/captureEmail.js';
+import { getCurrentUser } from './funnel-sdk/users/getCurrentUser.js';
+import { getUserSubscriptionStatus } from './funnel-sdk/users/getUserSubscriptionStatus.js';
+import { claimUserSubscription } from './funnel-sdk/users/claimUserSubscription.js';
+import { updateFunnelUser } from './funnel-sdk/users/updateFunnelUser.js';
+import { uploadPhoto } from './funnel-sdk/uploads/uploadPhoto.js';
+import { preparePhotoUpload } from './funnel-sdk/uploads/preparePhotoUpload.js';
+import { uploadPhotoFile } from './funnel-sdk/uploads/uploadPhotoFile.js';
+import { createHostedCheckoutSession } from './funnel-sdk/checkout/createHostedCheckoutSession.js';
+import { createSubscriptionCheckout } from './funnel-sdk/checkout/createSubscriptionCheckout.js';
+import { createOneTimeCheckout } from './funnel-sdk/checkout/createOneTimeCheckout.js';
+import { updateSubscriptionCheckoutPlan } from './funnel-sdk/checkout/updateSubscriptionCheckoutPlan.js';
+import { verifySubscriptionCheckout } from './funnel-sdk/checkout/verifySubscriptionCheckout.js';
+import { createOneTimePaymentIntent } from './funnel-sdk/checkout/createOneTimePaymentIntent.js';
+import { chargeOneClickPayment } from './funnel-sdk/checkout/chargeOneClickPayment.js';
+import { updateSubscription } from './funnel-sdk/subscriptions/updateSubscription.js';
+import { listSubscriptions } from './funnel-sdk/subscriptions/listSubscriptions.js';
+// Stable public facade; each use case owns its request and sequencing.
+export const funnelSdkService = {
+    bootstrapUser,
+    captureEmail,
+    getCurrentUser,
+    getUserSubscriptionStatus,
+    claimUserSubscription,
+    updateFunnelUser,
+    uploadPhoto,
+    preparePhotoUpload,
+    uploadPhotoFile,
+    createHostedCheckoutSession,
+    createSubscriptionCheckout,
+    createOneTimeCheckout,
+    updateSubscriptionCheckoutPlan,
+    verifySubscriptionCheckout,
+    createOneTimePaymentIntent,
+    chargeOneClickPayment,
+    updateSubscription,
+    listSubscriptions,
 };
-const removeEmptyFields = (input) => {
-    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ''));
-};
-const resolveRuntimeConfig = (runtimeConfig) => {
-    var _a, _b, _c;
-    return ({
-        apiBaseUrl: asTrimmedStringOrNull(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.apiBaseUrl),
-        funnelId: (_a = asTrimmedStringOrNull(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.funnelId)) !== null && _a !== void 0 ? _a : asTrimmedStringOrNull(FUNNEL_ID),
-        funnelVersionId: (_b = asTrimmedStringOrNull(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.funnelVersionId)) !== null && _b !== void 0 ? _b : asTrimmedStringOrNull(FUNNEL_VERSION_ID),
-        funnelSdkPublishableKey: resolvePreviewPaymentPublishableKey((_c = asTrimmedStringOrNull(runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.funnelSdkPublishableKey)) !== null && _c !== void 0 ? _c : asTrimmedStringOrNull(FUNNEL_SDK_PUBLISHABLE_KEY)) || null,
-        paymentsApiVersion: (runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.paymentsApiVersion) === 'v2' ? 'v2' : 'v1',
-    });
-};
-const buildApiUrl = (path, runtimeConfig) => {
-    const { apiBaseUrl } = resolveRuntimeConfig(runtimeConfig);
-    if (!apiBaseUrl) {
-        return buildMainApiUrl(path);
-    }
-    return `${trimTrailingSlash(apiBaseUrl)}${toNormalizedPath(path)}`;
-};
-const buildHeaders = (runtimeConfig, headers) => {
-    const { funnelSdkPublishableKey } = resolveRuntimeConfig(runtimeConfig);
-    if (!funnelSdkPublishableKey) {
-        return Object.assign({}, (headers !== null && headers !== void 0 ? headers : {}));
-    }
-    return Object.assign({ 'x-sdk-publishable-key': funnelSdkPublishableKey }, (headers !== null && headers !== void 0 ? headers : {}));
-};
-const withRuntimeFields = (runtimeConfig, body, options) => {
-    const { funnelId, funnelVersionId, funnelSdkPublishableKey } = resolveRuntimeConfig(runtimeConfig);
-    return removeEmptyFields(Object.assign({ publishableKey: (options === null || options === void 0 ? void 0 : options.includePublishableKey) === false
-            ? undefined
-            : funnelSdkPublishableKey || undefined, funnelId: funnelId || undefined, funnelVersionId: funnelVersionId || undefined }, (body !== null && body !== void 0 ? body : {})));
-};
-const parseErrorMessage = async (response, fallbackMessage) => {
-    try {
-        const payload = (await response.json());
-        const apiError = asTrimmedStringOrNull(payload.error);
-        if (apiError) {
-            return apiError;
-        }
-    }
-    catch (_a) {
-        // ignore JSON parsing errors
-    }
-    try {
-        const text = await response.text();
-        if (text.trim()) {
-            return text;
-        }
-    }
-    catch (_b) {
-        // ignore text parsing errors
-    }
-    return fallbackMessage;
-};
-class FunnelSdkService {
-    async getJson(path, input) {
-        var _a;
-        const url = new URL(buildApiUrl(path, input.runtimeConfig));
-        for (const [key, value] of Object.entries((_a = input.searchParams) !== null && _a !== void 0 ? _a : {})) {
-            const normalizedValue = asTrimmedStringOrNull(value);
-            if (normalizedValue) {
-                url.searchParams.set(key, normalizedValue);
-            }
-        }
-        const response = await fetch(url.toString(), {
-            method: 'GET',
-            headers: buildHeaders(input.runtimeConfig),
-        });
-        if (!response.ok) {
-            throw new Error(await parseErrorMessage(response, input.errorMessage));
-        }
-        return (await response.json());
-    }
-    async writeJson(method, path, input) {
-        var _a;
-        const response = await fetch(buildApiUrl(path, input.runtimeConfig), {
-            method,
-            headers: buildHeaders(input.runtimeConfig, {
-                'Content-Type': 'application/json',
-            }),
-            body: JSON.stringify(input.includeRuntimeFields === false
-                ? removeEmptyFields((_a = input.body) !== null && _a !== void 0 ? _a : {})
-                : withRuntimeFields(input.runtimeConfig, input.body, {
-                    includePublishableKey: input.includePublishableKey,
-                })),
-        });
-        if (!response.ok) {
-            throw new Error(await parseErrorMessage(response, input.errorMessage));
-        }
-        return (await response.json());
-    }
-    postJson(path, input) {
-        return this.writeJson('POST', path, input);
-    }
-    async patchJson(path, input) {
-        return this.writeJson('PATCH', path, input);
-    }
-    async bootstrapUser(input = {}) {
-        return this.postJson('/sdk/public/users/bootstrap', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                user_id: input.userId,
-                idempotencyKey: input.idempotencyKey,
-                email: input.email,
-                fullName: input.fullName,
-                metadata: input.metadata,
-                attribution: input.attribution,
-            },
-            errorMessage: 'Failed to bootstrap user session',
-        });
-    }
-    async captureEmail(input) {
-        return this.postJson('/sdk/public/users/email-capture', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                user_id: input.userId,
-                email: input.email,
-                environment: input.environment,
-                answers: input.answers,
-                stepContractVersion: CURRENT_STEP_CONTRACT_VERSION,
-            },
-            errorMessage: 'Failed to capture email',
-        });
-    }
-    async getCurrentUser(input) {
-        const { funnelId } = resolveRuntimeConfig(input.runtimeConfig);
-        return this.getJson('/sdk/public/users/me', {
-            runtimeConfig: input.runtimeConfig,
-            searchParams: {
-                funnelId,
-                user_id: input.userId,
-            },
-            errorMessage: 'Failed to load user',
-        });
-    }
-    async getUserSubscriptionStatus(input = {}) {
-        const { funnelId } = resolveRuntimeConfig(input.runtimeConfig);
-        return this.getJson('/sdk/public/users/subscription', {
-            runtimeConfig: input.runtimeConfig,
-            searchParams: {
-                funnelId,
-                user_id: input.userId,
-                email: input.email,
-            },
-            errorMessage: 'Failed to load user subscription status',
-        });
-    }
-    async claimUserSubscription(input) {
-        return this.postJson(`/sdk/public/users/${encodeURIComponent(input.userId)}/claim_subscription`, {
-            runtimeConfig: input.runtimeConfig,
-            errorMessage: 'Failed to claim user subscription',
-        });
-    }
-    async updateFunnelUser(input) {
-        return this.postJson('/public/funnel-users/upsert', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                user_id: input.userId,
-                email: input.email,
-                fullName: input.fullName,
-                document: input.document,
-                progress: input.progress,
-                metadata: input.metadata,
-                attribution: input.attribution,
-                subscription: input.subscription,
-                subscriptionStatus: input.subscriptionStatus,
-            },
-            errorMessage: 'Failed to update user',
-        });
-    }
-    async uploadPhoto(input) {
-        return this.postJson('/sdk/public/uploads/photos', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                user_id: input.userId,
-                fileName: input.fileName,
-                mimeType: input.mimeType,
-                imageDataUrl: input.imageDataUrl,
-                source: input.source,
-            },
-            errorMessage: 'Failed to upload photo',
-        });
-    }
-    async preparePhotoUpload(input) {
-        const { funnelId } = resolveRuntimeConfig(input.runtimeConfig);
-        return this.postJson('/sdk/public/uploads/photos/prepare', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                funnelId,
-                userId: input.userId,
-                fileName: input.fileName,
-                contentType: input.contentType,
-                sizeBytes: input.sizeBytes,
-                source: input.source,
-            },
-            includeRuntimeFields: false,
-            includePublishableKey: false,
-            errorMessage: 'Failed to prepare photo upload',
-        });
-    }
-    async uploadPhotoFile(input) {
-        const prepared = await this.preparePhotoUpload({
-            fileName: input.fileName,
-            contentType: input.contentType,
-            sizeBytes: input.file.size,
-            source: input.source,
-            userId: input.userId,
-            runtimeConfig: input.runtimeConfig,
-        });
-        const response = await fetch(prepared.uploadUrl, {
-            method: 'PUT',
-            headers: prepared.uploadHeaders,
-            body: input.file,
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to upload photo (${response.status})`);
-        }
-        return {
-            key: prepared.key,
-            publicUrl: prepared.publicUrl,
-            contentType: prepared.contentType,
-            sizeBytes: prepared.sizeBytes,
-            uploadedAt: new Date().toISOString(),
-        };
-    }
-    async createHostedCheckoutSession(input) {
-        return this.postJson('/sdk/public/payments/checkout-session', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                offerSetId: input.offerSetId,
-                offerSetKey: input.offerSetKey,
-                planId: input.planId,
-                providerPlanId: input.providerPlanId,
-                title: input.title,
-                description: input.description,
-                amountCents: input.amountCents,
-                billingInterval: input.billingInterval,
-                billingIntervalCount: input.billingIntervalCount,
-                couponId: input.couponId,
-                analyticsMetadata: input.analyticsMetadata,
-                successUrl: input.successUrl,
-                cancelUrl: input.cancelUrl,
-                customerEmail: input.customerEmail,
-                user_id: input.userId,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to create checkout session',
-        });
-    }
-    async createSubscriptionCheckout(input) {
-        const { paymentsApiVersion } = resolveRuntimeConfig(input.runtimeConfig);
-        if (paymentsApiVersion === 'v2') {
-            return this.postJson('/sdk/public/v2/payments/checkout-sessions', {
-                runtimeConfig: input.runtimeConfig,
-                body: toV2CheckoutSessionRequest(input, 'subscription'),
-                errorMessage: 'Unable to create subscription checkout',
-            });
-        }
-        return this.postJson('/sdk/public/payments/subscriptions', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                offerSetId: input.offerSetId,
-                offerSetKey: input.offerSetKey,
-                planId: input.planId,
-                providerPlanId: input.providerPlanId,
-                title: input.title,
-                description: input.description,
-                amountCents: input.amountCents,
-                billingInterval: input.billingInterval,
-                billingIntervalCount: input.billingIntervalCount,
-                followUpProviderPlanId: input.followUpProviderPlanId,
-                followUpPlanTitle: input.followUpPlanTitle,
-                followUpBillingInterval: input.followUpBillingInterval,
-                followUpBillingIntervalCount: input.followUpBillingIntervalCount,
-                introIterations: input.introIterations,
-                couponId: input.couponId,
-                analyticsMetadata: input.analyticsMetadata,
-                customerEmail: input.customerEmail,
-                returnUrl: input.returnUrl,
-                user_id: input.userId,
-                anonymousUserId: input.anonymousUserId,
-                idempotencyKey: input.idempotencyKey,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to create subscription checkout',
-        });
-    }
-    async createOneTimeCheckout(input) {
-        if (resolveRuntimeConfig(input.runtimeConfig).paymentsApiVersion === 'v2') {
-            return this.postJson('/sdk/public/v2/payments/checkout-sessions', {
-                runtimeConfig: input.runtimeConfig,
-                body: toV2CheckoutSessionRequest(input, 'one_time'),
-                errorMessage: 'Unable to create one-time checkout',
-            });
-        }
-        return this.postJson('/sdk/public/payments/one-time-checkout', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                offerSetId: input.offerSetId,
-                offerSetKey: input.offerSetKey,
-                planId: input.planId,
-                providerPlanId: input.providerPlanId,
-                title: input.title,
-                description: input.description,
-                amountCents: input.amountCents,
-                couponId: input.couponId,
-                analyticsMetadata: input.analyticsMetadata,
-                customerEmail: input.customerEmail,
-                returnUrl: input.returnUrl,
-                user_id: input.userId,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to create one-time checkout',
-        });
-    }
-    async updateSubscriptionCheckoutPlan(input) {
-        const { paymentsApiVersion } = resolveRuntimeConfig(input.runtimeConfig);
-        if (paymentsApiVersion === 'v2') {
-            return this.patchJson(`/sdk/public/v2/payments/checkout-sessions/${encodeURIComponent(input.checkoutSessionId)}`, {
-                runtimeConfig: input.runtimeConfig,
-                body: Object.assign(Object.assign({}, toV2CheckoutSelection(input)), { couponId: input.couponId, analyticsMetadata: input.analyticsMetadata, environment: input.environment }),
-                errorMessage: 'Unable to update subscription checkout',
-            });
-        }
-        return this.postJson('/sdk/public/payments/subscriptions/update-plan', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                checkoutSessionId: input.checkoutSessionId,
-                offerSetId: input.offerSetId,
-                offerSetKey: input.offerSetKey,
-                planId: input.planId,
-                providerPlanId: input.providerPlanId,
-                title: input.title,
-                description: input.description,
-                amountCents: input.amountCents,
-                billingInterval: input.billingInterval,
-                billingIntervalCount: input.billingIntervalCount,
-                couponId: input.couponId,
-                analyticsMetadata: input.analyticsMetadata,
-                customerEmail: input.customerEmail,
-                user_id: input.userId,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to update subscription checkout',
-        });
-    }
-    async verifySubscriptionCheckout(input) {
-        const { funnelId, paymentsApiVersion } = resolveRuntimeConfig(input.runtimeConfig);
-        if (paymentsApiVersion === 'v2') {
-            return this.getJson(`/sdk/public/v2/payments/checkout-sessions/${encodeURIComponent(input.checkoutSessionId)}`, {
-                runtimeConfig: input.runtimeConfig,
-                searchParams: { funnelId },
-                errorMessage: 'Unable to verify subscription checkout',
-            });
-        }
-        return this.postJson('/sdk/public/payments/subscriptions/checkout-session-status', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                checkoutSessionId: input.checkoutSessionId,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to verify subscription checkout',
-        });
-    }
-    /**
-     * @deprecated Use createOneTimeCheckout for one-time paywall checkout.
-     */
-    async createOneTimePaymentIntent(input) {
-        return this.postJson('/sdk/public/payments/intents', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                offerSetId: input.offerSetId,
-                offerSetKey: input.offerSetKey,
-                planId: input.planId,
-                amountCents: input.amountCents,
-                couponId: input.couponId,
-                analyticsMetadata: input.analyticsMetadata,
-                user_id: input.userId,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to create payment intent',
-        });
-    }
-    async chargeOneClickPayment(input) {
-        var _a, _b, _c;
-        if (resolveRuntimeConfig(input.runtimeConfig).paymentsApiVersion === 'v2') {
-            const selection = toV2CheckoutSelection(input);
-            if (!((_a = input.checkoutSessionId) === null || _a === void 0 ? void 0 : _a.trim()) || !((_b = input.userId) === null || _b === void 0 ? void 0 : _b.trim()) || !((_c = input.idempotencyKey) === null || _c === void 0 ? void 0 : _c.trim())) {
-                throw new Error('V2 one-click requires checkoutSessionId, userId and idempotencyKey');
-            }
-            return this.postJson('/sdk/public/v2/payments/one-click', {
-                runtimeConfig: input.runtimeConfig,
-                body: Object.assign(Object.assign({}, selection), { checkoutSessionId: input.checkoutSessionId, userId: input.userId, idempotencyKey: input.idempotencyKey, analyticsMetadata: input.analyticsMetadata, environment: input.environment }),
-                errorMessage: 'Unable to charge one-click payment',
-            });
-        }
-        return this.postJson('/sdk/public/payments/one-click', {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                planId: input.planId,
-                providerPlanId: input.providerPlanId,
-                amountCents: input.amountCents,
-                currency: input.currency,
-                description: input.description,
-                analyticsMetadata: input.analyticsMetadata,
-                user_id: input.userId,
-                stripe_customer_id: input.stripeCustomerId,
-                checkoutSessionId: input.checkoutSessionId,
-                idempotencyKey: input.idempotencyKey,
-                environment: input.environment,
-            },
-            errorMessage: 'Unable to charge one-click payment',
-        });
-    }
-    async updateSubscription(input) {
-        return this.postJson(`/sdk/public/subscriptions/${encodeURIComponent(input.subscriptionId)}/${input.action}`, {
-            runtimeConfig: input.runtimeConfig,
-            body: {
-                user_id: input.userId,
-                stripe_customer_id: input.stripeCustomerId,
-                funnelId: input.funnelId,
-                coupon_id: input.couponId,
-            },
-            includeRuntimeFields: false,
-            includePublishableKey: false,
-            errorMessage: 'Failed to update subscription',
-        });
-    }
-    async listSubscriptions(input = {}) {
-        var _a;
-        const { funnelId } = resolveRuntimeConfig(input.runtimeConfig);
-        return this.getJson('/sdk/public/subscriptions', {
-            runtimeConfig: input.runtimeConfig,
-            searchParams: {
-                user_id: input.userId,
-                stripe_customer_id: input.stripeCustomerId,
-                funnelId: (_a = input.funnelId) !== null && _a !== void 0 ? _a : funnelId,
-            },
-            errorMessage: 'Failed to load subscriptions',
-        });
-    }
-}
-export const funnelSdkService = new FunnelSdkService();

package/dist/services/session/bootstrap/bootstrapSession.d.ts

@@ -0,0 +1,8 @@
+import type { FunnelUserAttribution } from '../../../runtime/funnel-attribution.js';
+import type { AppUser } from '../users/types.js';
+export declare function bootstrapSession(input?: {
+    userId?: string;
+    email?: string;
+    name?: string;
+    attribution?: FunnelUserAttribution;
+}): Promise<AppUser>;

package/dist/services/session/bootstrap/bootstrapSession.js

@@ -0,0 +1,23 @@
+import { FUNNEL_ID, FUNNEL_VERSION_ID, getFunnelSdkPublishableKey } from '../../runtime-api.config.js';
+import { getRuntimeMode } from '../../runtime-mode.service.js';
+import { funnelSdkService } from '../../funnel-sdk.service.js';
+import { resolveUrlUserAttributes } from '../../../runtime/url-user-attributes.js';
+import { persistUserId } from '../identity.js';
+import { resolveBootstrapUserId } from './currentUser.js';
+import { digestBootstrapRequest, getOrCreateBootstrapIdempotencyRecord, clearBootstrapIdempotencyRecord } from './idempotency.js';
+import { toBootstrapProfile, toBootstrapRequest, toBootstrapFingerprint } from './requests.js';
+import { resolveBootstrapResponseUserId, toBootstrapUser } from './responses.js';
+export async function bootstrapSession(input) {
+    const urlUserAttributes = resolveUrlUserAttributes();
+    const profile = toBootstrapProfile(input);
+    const userId = await resolveBootstrapUserId((input === null || input === void 0 ? void 0 : input.userId) || urlUserAttributes.userId);
+    if (!getFunnelSdkPublishableKey())
+        return toBootstrapUser(userId, profile);
+    const request = toBootstrapRequest(userId, profile, getRuntimeMode());
+    const fingerprint = await digestBootstrapRequest(toBootstrapFingerprint(request, FUNNEL_VERSION_ID));
+    const record = getOrCreateBootstrapIdempotencyRecord(fingerprint);
+    const payload = await funnelSdkService.bootstrapUser(Object.assign(Object.assign({}, request), { idempotencyKey: record.key }));
+    clearBootstrapIdempotencyRecord(record);
+    const persistedUserId = persistUserId(resolveBootstrapResponseUserId(payload, userId), FUNNEL_ID) || userId;
+    return toBootstrapUser(persistedUserId, profile, payload);
+}

package/dist/services/session/bootstrap/currentUser.d.ts

@@ -0,0 +1 @@
+export declare function resolveBootstrapUserId(candidateUserId?: string | null): Promise<string>;

package/dist/services/session/bootstrap/currentUser.js

@@ -0,0 +1,37 @@
+import { FUNNEL_ID, getFunnelSdkPublishableKey } from '../../runtime-api.config.js';
+import { funnelSdkService } from '../../funnel-sdk.service.js';
+import { asString, normalizeUserId } from '../shared/values.js';
+import { readStoredUserId, generateUserId, persistUserId } from '../identity.js';
+async function fetchCurrentUserState(userId) {
+    const publishableKey = getFunnelSdkPublishableKey();
+    if (!publishableKey || !FUNNEL_ID) {
+        return null;
+    }
+    try {
+        return await funnelSdkService.getCurrentUser({
+            userId,
+        });
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export async function resolveBootstrapUserId(candidateUserId) {
+    var _a;
+    const storedUserId = readStoredUserId(FUNNEL_ID);
+    const fallbackUserId = storedUserId || generateUserId();
+    const normalizedCandidateUserId = normalizeUserId(candidateUserId);
+    const publishableKey = getFunnelSdkPublishableKey();
+    if (!normalizedCandidateUserId) {
+        return persistUserId(fallbackUserId, FUNNEL_ID);
+    }
+    if (normalizedCandidateUserId === storedUserId) {
+        return persistUserId(normalizedCandidateUserId, FUNNEL_ID);
+    }
+    if (!publishableKey || !FUNNEL_ID) {
+        return persistUserId(fallbackUserId, FUNNEL_ID);
+    }
+    const existingUser = await fetchCurrentUserState(normalizedCandidateUserId);
+    const resolvedCandidateUserId = normalizeUserId(asString((_a = existingUser === null || existingUser === void 0 ? void 0 : existingUser.user) === null || _a === void 0 ? void 0 : _a.user_id) || asString(existingUser === null || existingUser === void 0 ? void 0 : existingUser.user_id));
+    return persistUserId(resolvedCandidateUserId || fallbackUserId, FUNNEL_ID);
+}

package/dist/services/session/bootstrap/idempotency.d.ts

@@ -0,0 +1,9 @@
+type BootstrapIdempotencyRecord = {
+    version: 1;
+    key: string;
+    fingerprint: string;
+};
+export declare const digestBootstrapRequest: (value: unknown) => Promise<string>;
+export declare const getOrCreateBootstrapIdempotencyRecord: (fingerprint: string) => BootstrapIdempotencyRecord;
+export declare const clearBootstrapIdempotencyRecord: (completed: BootstrapIdempotencyRecord) => void;
+export {};

package/dist/services/session/bootstrap/idempotency.js

@@ -0,0 +1,97 @@
+import { FUNNEL_ID } from '../../runtime-api.config.js';
+import { asString, canUseDom, isRecord } from '../shared/values.js';
+const DEFAULT_BOOTSTRAP_IDEMPOTENCY_KEY_STORAGE_KEY = 'funnel:bootstrap-idempotency-key';
+const buildBootstrapIdempotencyKeyStorageKey = (funnelId = FUNNEL_ID) => {
+    const normalizedFunnelId = asString(funnelId);
+    return normalizedFunnelId
+        ? `funnel:${normalizedFunnelId}:bootstrap-idempotency-key`
+        : DEFAULT_BOOTSTRAP_IDEMPOTENCY_KEY_STORAGE_KEY;
+};
+const generateBootstrapIdempotencyKey = () => {
+    var _a;
+    if (canUseDom() && typeof ((_a = window.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === 'function') {
+        return window.crypto.randomUUID();
+    }
+    return `${Date.now()}_${Math.random().toString(16).slice(2, 10)}`;
+};
+const parseBootstrapIdempotencyRecord = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        const key = asString(parsed.key);
+        const fingerprint = asString(parsed.fingerprint);
+        return parsed.version === 1 && key && fingerprint
+            ? { version: 1, key, fingerprint }
+            : null;
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const toStableJsonValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(toStableJsonValue);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.keys(value).sort().reduce((result, key) => {
+        if (value[key] !== undefined) {
+            result[key] = toStableJsonValue(value[key]);
+        }
+        return result;
+    }, {});
+};
+const buildFallbackDigest = (value) => {
+    var _a;
+    const bytes = new TextEncoder().encode(value);
+    const hashes = Array.from({ length: 8 }, (_, index) => ((0x811c9dc5 ^ Math.imul(index + 1, 0x9e3779b1)) >>> 0));
+    for (const byte of bytes) {
+        for (let index = 0; index < hashes.length; index += 1) {
+            hashes[index] = Math.imul(((_a = hashes[index]) !== null && _a !== void 0 ? _a : 0) ^ byte, 0x01000193 + index * 2) >>> 0;
+        }
+    }
+    return hashes.map((hash) => hash.toString(16).padStart(8, '0')).join('');
+};
+export const digestBootstrapRequest = async (value) => {
+    var _a;
+    const serialized = JSON.stringify(toStableJsonValue(value));
+    const bytes = new TextEncoder().encode(serialized);
+    const subtle = (_a = globalThis.crypto) === null || _a === void 0 ? void 0 : _a.subtle;
+    if (!subtle) {
+        return `fallback:${buildFallbackDigest(serialized)}`;
+    }
+    const digest = await subtle.digest('SHA-256', bytes);
+    const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+    return `sha256:${hex}`;
+};
+export const getOrCreateBootstrapIdempotencyRecord = (fingerprint) => {
+    const created = () => ({
+        version: 1,
+        key: generateBootstrapIdempotencyKey(),
+        fingerprint,
+    });
+    if (!canUseDom()) {
+        return created();
+    }
+    const storageKey = buildBootstrapIdempotencyKeyStorageKey();
+    const existing = parseBootstrapIdempotencyRecord(window.localStorage.getItem(storageKey));
+    if ((existing === null || existing === void 0 ? void 0 : existing.fingerprint) === fingerprint) {
+        return existing;
+    }
+    const next = created();
+    window.localStorage.setItem(storageKey, JSON.stringify(next));
+    return next;
+};
+export const clearBootstrapIdempotencyRecord = (completed) => {
+    if (!canUseDom()) {
+        return;
+    }
+    const storageKey = buildBootstrapIdempotencyKeyStorageKey();
+    const current = parseBootstrapIdempotencyRecord(window.localStorage.getItem(storageKey));
+    if ((current === null || current === void 0 ? void 0 : current.key) === completed.key && current.fingerprint === completed.fingerprint) {
+        window.localStorage.removeItem(storageKey);
+    }
+};