@estifanos-sh/convex-auth 0.0.1-preview.0

package/dist/client/runtime/invite.js

@@ -0,0 +1,50 @@
+//#region src/client/runtime/invite.ts
+/** @internal */
+function createInviteManager(args) {
+	const { param, storageGet, storageSet, storageRemove, cleanUrlParams, tokenKey, emailKey } = args;
+	let pendingInvite = null;
+	const urlInviteToken = param("invite");
+	if (urlInviteToken) pendingInvite = {
+		token: urlInviteToken,
+		email: param("email")
+	};
+	const initPromise = urlInviteToken ? Promise.resolve() : (async () => {
+		const storedToken = await storageGet(tokenKey);
+		if (storedToken && !pendingInvite) {
+			pendingInvite = {
+				token: storedToken,
+				email: await storageGet(emailKey) ?? null
+			};
+			storageRemove(tokenKey);
+			storageRemove(emailKey);
+		}
+	})();
+	return {
+		getPendingInvite() {
+			return pendingInvite;
+		},
+		ready() {
+			return initPromise;
+		},
+		async persistInvite() {
+			await initPromise;
+			if (!pendingInvite) return;
+			await storageSet(tokenKey, pendingInvite.token);
+			if (pendingInvite.email) await storageSet(emailKey, pendingInvite.email);
+		},
+		async acceptInvite() {
+			await initPromise;
+			if (!pendingInvite) throw new Error("No pending invite to accept.");
+			const { token } = pendingInvite;
+			pendingInvite = null;
+			storageRemove(tokenKey);
+			storageRemove(emailKey);
+			cleanUrlParams(["invite", "email"]);
+			return { token };
+		}
+	};
+}
+
+//#endregion
+export { createInviteManager };
+//# sourceMappingURL=invite.js.map

package/dist/client/runtime/mutex.js

@@ -0,0 +1,25 @@
+//#region src/client/runtime/mutex.ts
+const mutexTails = {};
+/** @internal */
+async function localMutex(key, callback) {
+	const previousTail = mutexTails[key] ?? Promise.resolve();
+	let releaseCurrent;
+	const currentTail = new Promise((resolve) => {
+		releaseCurrent = resolve;
+	});
+	const currentTailPromise = previousTail.then(() => currentTail, () => currentTail);
+	mutexTails[key] = currentTailPromise;
+	try {
+		await previousTail;
+	} catch {}
+	try {
+		return await callback();
+	} finally {
+		releaseCurrent?.();
+		if (mutexTails[key] === currentTailPromise) delete mutexTails[key];
+	}
+}
+
+//#endregion
+export { localMutex };
+//# sourceMappingURL=mutex.js.map

package/dist/client/runtime/proxy.js

@@ -0,0 +1,75 @@
+import { ErrorCode } from "../../shared/codes.js";
+import { ConvexError } from "convex/values";
+
+//#region src/client/runtime/proxy.ts
+const NETWORK_ERROR_PATTERN = /(network|fetch|load failed|failed to fetch)/i;
+/**
+* Error codes that mean a forced refresh was definitively rejected — the
+* presented refresh credential is invalid, so the session must be signed out
+* rather than retried. Mirrors the server's refresh classification, which
+* clears cookies only on {@link ErrorCode.INVALID_REFRESH_TOKEN}.
+*/
+const AUTH_REFRESH_REJECTION_CODES = new Set([
+	ErrorCode.INVALID_REFRESH_TOKEN,
+	ErrorCode.OAUTH_INVALID_REFRESH_TOKEN,
+	ErrorCode.INVALID_VERIFIER
+]);
+/**
+* Error thrown when a proxy request returns a non-OK HTTP response. Carries the
+* HTTP `status` structurally so retriability is classified without re-parsing a
+* formatted message.
+*
+* @internal
+*/
+var ProxyRequestError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message ?? `Proxy request failed: ${status}`);
+		this.name = "ProxyRequestError";
+		this.status = status;
+	}
+};
+/** @internal */
+function isTransientNetworkError(error) {
+	return error instanceof TypeError || error instanceof Error && NETWORK_ERROR_PATTERN.test(error.message || "");
+}
+/** @internal */
+function isRetriableProxyRefreshError(error) {
+	if (isTransientNetworkError(error)) return true;
+	if (!(error instanceof ProxyRequestError)) return false;
+	const { status } = error;
+	return status === 429 || status >= 500 && status < 600;
+}
+/**
+* Classify whether a forced-refresh failure is a definitive credential
+* rejection (the session must be signed out) rather than a transient/network
+* failure (the session should be kept so a later forced refresh can recover).
+*
+* A proxy `401`/`403` and a structured {@link ConvexError} carrying an
+* invalid-refresh code are treated as sign-out; everything else (network
+* errors, `429`, `5xx`, unknown shapes) is treated as transient. This mirrors
+* the server, which clears the session only on an explicit auth rejection.
+*
+* @internal
+*/
+function isAuthRefreshRejection(error) {
+	if (error instanceof ProxyRequestError) return error.status === 401 || error.status === 403;
+	if (error instanceof ConvexError) {
+		const code = error.data?.code;
+		return typeof code === "string" && AUTH_REFRESH_REJECTION_CODES.has(code);
+	}
+	return false;
+}
+/** @internal */
+function parseProxyErrorBody(value) {
+	if (typeof value !== "object" || value === null) return {};
+	const obj = value;
+	return {
+		error: typeof obj.error === "string" ? obj.error : void 0,
+		authError: obj.authError
+	};
+}
+
+//#endregion
+export { ProxyRequestError, isAuthRefreshRejection, isRetriableProxyRefreshError, isTransientNetworkError, parseProxyErrorBody };
+//# sourceMappingURL=proxy.js.map

package/dist/client/runtime/storage.js

@@ -0,0 +1,65 @@
+import { LOG_LEVELS, logMessage } from "../../shared/log.js";
+
+//#region src/client/runtime/storage.ts
+/**
+* How many times a write/remove is attempted before giving up. Runtime stores
+* such as Expo SecureStore can throw transiently; a failed delete on sign-out
+* that is silently swallowed would leave the token on disk and boot the next
+* launch signed in, so the security-critical mutations retry once.
+*/
+const STORAGE_MUTATION_ATTEMPTS = 2;
+/** @internal */
+function createStorageHelpers(args) {
+	const { storage, key } = args;
+	const get = async (name) => {
+		if (!storage) return null;
+		try {
+			return await storage.getItem(key(name)) ?? null;
+		} catch (error) {
+			logMessage("convex-auth/client", LOG_LEVELS.ERROR, [`[convex-auth] Failed to read ${name} from storage:`, error]);
+			return null;
+		}
+	};
+	const set = async (name, value) => {
+		if (!storage) return true;
+		let lastError = null;
+		for (let attempt = 1; attempt <= STORAGE_MUTATION_ATTEMPTS; attempt++) try {
+			await storage.setItem(key(name), value);
+			return true;
+		} catch (error) {
+			lastError = error;
+		}
+		logMessage("convex-auth/client", LOG_LEVELS.ERROR, [`[convex-auth] Failed to write ${name} to storage after ${STORAGE_MUTATION_ATTEMPTS} attempts:`, lastError]);
+		return false;
+	};
+	const remove = async (name) => {
+		if (!storage) return true;
+		let lastError = null;
+		for (let attempt = 1; attempt <= STORAGE_MUTATION_ATTEMPTS; attempt++) {
+			try {
+				await storage.removeItem(key(name));
+				lastError = null;
+			} catch (error) {
+				lastError = error;
+				continue;
+			}
+			try {
+				if (await storage.getItem(key(name)) == null) return true;
+				lastError = /* @__PURE__ */ new Error(`Storage key still present after removeItem: ${name}`);
+			} catch {
+				return true;
+			}
+		}
+		logMessage("convex-auth/client", LOG_LEVELS.ERROR, [`[convex-auth] Failed to remove ${name} from storage after ${STORAGE_MUTATION_ATTEMPTS} attempts:`, lastError]);
+		return false;
+	};
+	return {
+		get,
+		set,
+		remove
+	};
+}
+
+//#endregion
+export { createStorageHelpers };
+//# sourceMappingURL=storage.js.map

package/dist/component/_generated/api.js

@@ -0,0 +1,26 @@
+import { anyApi, componentsGeneric } from "convex/server";
+
+//#region src/component/_generated/api.ts
+/**
+* A utility for referencing Convex functions in your app's public API.
+*
+* Usage:
+* ```js
+* const myFunctionReference = api.myModule.myFunction;
+* ```
+*/
+const api = anyApi;
+/**
+* A utility for referencing Convex functions in your app's internal API.
+*
+* Usage:
+* ```js
+* const myFunctionReference = internal.myModule.myFunction;
+* ```
+*/
+const internal = anyApi;
+const components = componentsGeneric();
+
+//#endregion
+export { api, components, internal };
+//# sourceMappingURL=api.js.map