@unidy.io/sdk 1.1.2 → 1.1.4

package/dist/cjs/app-globals-DSKjcXX_.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var index = require('./index-B_N5xKgH.js');
+
+const globalScripts = index.appGlobalScript;
+
+exports.globalScripts = globalScripts;
+//# sourceMappingURL=app-globals-DSKjcXX_.js.map
+
+//# sourceMappingURL=app-globals-DSKjcXX_.js.map

package/dist/cjs/app-globals-DSKjcXX_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-globals-DSKjcXX_.js","sources":["@stencil/core/internal/app-globals"],"sourcesContent":["import appGlobalScript from '/Users/coki/Projects/unidy.io/unidy-sdk/packages/sdk/src/globalScript.ts';\nexport const globalScripts = appGlobalScript;\nexport const globalStyles = \"\";\n"],"names":["appGlobalScript"],"mappings":";;;;AACY,MAAC,aAAa,GAAGA;;;;"}

package/dist/cjs/auth-NU3DBc-6.js

@@ -0,0 +1,581 @@
+'use strict';
+
+var authStore = require('./auth-store-BaxuIp4z.js');
+var i18n = require('./i18n-BoDZ8kd2.js');
+var index = require('./index-B_N5xKgH.js');
+var profileStore = require('./profile-store-P_BcYkef.js');
+var componentUtils = require('./component-utils-BpMyeVQo.js');
+var flashStore = require('./flash-store-BuIBuQDx.js');
+var unidyStore = require('./unidy-store-7AbWnZ6g.js');
+var index$1 = require('./index-R2MKLaem.js');
+
+class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+    return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+        let code = p.charCodeAt(0).toString(16).toUpperCase();
+        if (code.length < 2) {
+            code = "0" + code;
+        }
+        return "%" + code;
+    }));
+}
+function base64UrlDecode(str) {
+    let output = str.replace(/-/g, "+").replace(/_/g, "/");
+    switch (output.length % 4) {
+        case 0:
+            break;
+        case 2:
+            output += "==";
+            break;
+        case 3:
+            output += "=";
+            break;
+        default:
+            throw new Error("base64 string is not of the correct length");
+    }
+    try {
+        return b64DecodeUnicode(output);
+    }
+    catch (err) {
+        return atob(output);
+    }
+}
+function jwtDecode(token, options) {
+    if (typeof token !== "string") {
+        throw new InvalidTokenError("Invalid token specified: must be a string");
+    }
+    options || (options = {});
+    const pos = options.header === true ? 0 : 1;
+    const part = token.split(".")[pos];
+    if (typeof part !== "string") {
+        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+    }
+    let decoded;
+    try {
+        decoded = base64UrlDecode(part);
+    }
+    catch (e) {
+        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+    }
+    try {
+        return JSON.parse(decoded);
+    }
+    catch (e) {
+        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+    }
+}
+
+const logger = index.createLogger("PasskeyAuth");
+const PASSKEY_ERRORS = {
+    NotSupportedError: "passkey_not_supported",
+    NotAllowedError: "passkey_cancelled",
+    SecurityError: "passkey_security_error",
+    InvalidStateError: "passkey_invalid_state",
+};
+function decodeBase64Url(base64url) {
+    const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+    return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+}
+function buildPublicKeyOptions(options) {
+    return {
+        challenge: Uint8Array.from(atob(options.challenge), (c) => c.charCodeAt(0)),
+        timeout: options.timeout || 60000,
+        rpId: options.rpId,
+        userVerification: options.userVerification || "required",
+        allowCredentials: options.allowCredentials?.map((cred) => ({
+            ...cred,
+            id: decodeBase64Url(cred.id),
+        })),
+    };
+}
+function formatCredentialForServer(credential) {
+    const response = credential.response;
+    return {
+        id: credential.id,
+        rawId: btoa(String.fromCharCode(...new Uint8Array(credential.rawId))),
+        response: {
+            authenticatorData: btoa(String.fromCharCode(...new Uint8Array(response.authenticatorData))),
+            clientDataJSON: btoa(String.fromCharCode(...new Uint8Array(response.clientDataJSON))),
+            signature: btoa(String.fromCharCode(...new Uint8Array(response.signature))),
+        },
+        type: credential.type,
+    };
+}
+function extractAndSetSignInId(tokenResponse) {
+    if (tokenResponse.sid) {
+        authStore.authStore.setSignInId(tokenResponse.sid);
+        return;
+    }
+    // Fallback: extract sid from JWT token payload
+    try {
+        const decoded = jwtDecode(tokenResponse.jwt);
+        if (decoded.sid) {
+            authStore.authStore.setSignInId(decoded.sid);
+        }
+    }
+    catch {
+        // Failed to decode JWT token to extract sid, continue without it
+    }
+}
+function handlePasskeyError(error) {
+    logger.error("Passkey error:", error);
+    let errorMessage = "passkey_error";
+    if (error instanceof DOMException) {
+        errorMessage = PASSKEY_ERRORS[error.name] || "passkey_error";
+    }
+    authStore.authStore.setFieldError("passkey", errorMessage);
+    authStore.authStore.setLoading(false);
+}
+async function authenticateWithPasskey(client, onSuccess) {
+    authStore.authStore.setLoading(true);
+    authStore.authStore.clearErrors();
+    if (!window.PublicKeyCredential) {
+        authStore.authStore.setFieldError("passkey", "passkey_not_supported");
+        authStore.authStore.setLoading(false);
+        return;
+    }
+    try {
+        const [optionsError, options] = await client.auth.getPasskeyOptions(authStore.state.sid || undefined);
+        if (optionsError || !options) {
+            authStore.authStore.setFieldError("passkey", optionsError || "bad_request");
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        const publicKeyOptions = buildPublicKeyOptions(options);
+        const credential = (await navigator.credentials.get({
+            publicKey: publicKeyOptions,
+        }));
+        if (!credential) {
+            authStore.authStore.setFieldError("passkey", "passkey_cancelled");
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        const formattedCredential = formatCredentialForServer(credential);
+        const [verifyError, tkResponse] = await client.auth.authenticateWithPasskey(formattedCredential);
+        const tokenResponse = tkResponse;
+        if (verifyError || !tokenResponse) {
+            authStore.authStore.setGlobalError("auth", verifyError || "authentication_failed");
+            authStore.authStore.setLoading(false);
+            return;
+        }
+        authStore.authStore.setToken(tokenResponse.jwt);
+        extractAndSetSignInId(tokenResponse);
+        onSuccess(tokenResponse);
+    }
+    catch (error) {
+        handlePasskeyError(error);
+    }
+}
+
+class AuthHelpers {
+    client;
+    logger = index.createLogger("AuthHelpers");
+    static PASSWORD_ERROR_IDENTIFIERS = [
+        "invalid_password",
+        "password_required",
+        "password_not_set",
+        "passwords_do_not_match",
+    ];
+    constructor(client) {
+        this.client = client;
+    }
+    async createSignIn(email, password, sendMagicCode) {
+        if (!email) {
+            throw new Error(i18n.t("errors.required_field", { field: "Email" }));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.createSignIn(email, password, sendMagicCode);
+        if (error) {
+            this.handleAuthError(error, response);
+            return;
+        }
+        if (password) {
+            const token = jwtDecode(response.jwt);
+            authStore.authStore.setSignInId(token.sid);
+            authStore.authStore.setToken(response.jwt);
+            authStore.authStore.setLoading(false);
+            authStore.authStore.getRootComponentRef()?.onAuth(response);
+            return;
+        }
+        if (sendMagicCode) {
+            authStore.authStore.setSignInId(response.sid);
+            authStore.authStore.setMagicCodeStep("sent");
+            authStore.authStore.setStep("magic-code");
+            authStore.authStore.setLoading(false);
+            return [error, response];
+        }
+        const signInResponse = response;
+        authStore.authStore.setStep("verification");
+        authStore.authStore.setEmail(email);
+        authStore.authStore.setSignInId(signInResponse.sid);
+        authStore.authStore.setLoginOptions(signInResponse.login_options);
+        authStore.authStore.setLoading(false);
+    }
+    async authenticateWithPassword(password) {
+        if (!authStore.state.sid) {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        if (!password) {
+            throw new Error(i18n.t("errors.required_field", { field: "Password" }));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.authenticateWithPassword(authStore.state.sid, password);
+        if (error) {
+            this.handleAuthError(error, response);
+        }
+        else {
+            authStore.authStore.setLoading(false);
+            this.handleAuthSuccess(response);
+            return;
+        }
+    }
+    handleAuthError(error, response) {
+        switch (error) {
+            case "account_not_found":
+                authStore.authStore.setFieldError("email", error);
+                break;
+            case "missing_required_fields": {
+                authStore.authStore.setMissingFields(response.fields);
+                profileStore.state.data = response.fields;
+                if (response.sid) {
+                    authStore.authStore.setSignInId(response.sid);
+                }
+                authStore.authStore.setStep("missing-fields");
+                break;
+            }
+            default:
+                if (AuthHelpers.PASSWORD_ERROR_IDENTIFIERS.includes(error)) {
+                    authStore.authStore.setFieldError("password", error);
+                }
+                else {
+                    // e.g. "account_locked", "internal_server_error"
+                    authStore.authStore.setGlobalError("auth", error);
+                }
+                break;
+        }
+        authStore.authStore.setLoading(false);
+    }
+    async logout() {
+        const [error, _] = await this.client.auth.signOut(authStore.state.sid);
+        if (error) {
+            authStore.authStore.setGlobalError("auth", error);
+        }
+        return [error, _];
+    }
+    async refreshToken() {
+        if (authStore.state.step === "missing-fields") {
+            return;
+        }
+        this.extractSignInIdFromQuery();
+        if (!authStore.state.sid) {
+            this.logger.warn("No sign-in ID in the session");
+            return;
+        }
+        const [error, response] = await this.client.auth.refreshToken(authStore.state.sid);
+        if (error) {
+            authStore.authStore.reset();
+            authStore.authStore.setGlobalError("auth", error);
+        }
+        else {
+            authStore.authStore.setToken(response.jwt);
+        }
+    }
+    handleSocialAuthRedirect() {
+        // missing required fields flow
+        const url = new URL(window.location.href);
+        const params = url.searchParams;
+        const error = params.get("error");
+        if (error !== "missing_required_fields") {
+            return;
+        }
+        const fieldsFromUrl = params.get("fields");
+        if (!fieldsFromUrl) {
+            return;
+        }
+        const signInId = params.get("sid");
+        if (signInId) {
+            authStore.authStore.setSignInId(signInId);
+        }
+        else {
+            return;
+        }
+        try {
+            const fields = JSON.parse(fieldsFromUrl);
+            authStore.authStore.setMissingFields(fields);
+            profileStore.state.data = fields;
+            authStore.authStore.setStep("missing-fields");
+            params.delete("error");
+            params.delete("fields");
+            const cleanUrl = `${url.origin}${url.pathname}${url.hash}`;
+            window.history.replaceState(null, "", cleanUrl);
+        }
+        catch (e) {
+            this.logger.error("Failed to parse missing fields payload:", e);
+            authStore.authStore.setGlobalError("auth", "invalid_required_fields_payload");
+        }
+    }
+    async sendMagicCode() {
+        if (!authStore.state.sid && authStore.state.step !== "single-login") {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        authStore.authStore.setMagicCodeStep("requested");
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        if (authStore.state.step === "single-login") {
+            const [error, response] = await this.createSignIn(authStore.state.email, undefined, true);
+            authStore.authStore.setLoading(false);
+            return [error, response];
+        }
+        const [error, response] = await this.client.auth.sendMagicCode(authStore.state.sid);
+        authStore.authStore.setLoading(false);
+        authStore.authStore.setStep("magic-code");
+        if (!error) {
+            authStore.authStore.setMagicCodeStep("sent");
+            return [null, response];
+        }
+        authStore.authStore.setFieldError("magicCode", error);
+        if (error === "magic_code_recently_created") {
+            authStore.authStore.setMagicCodeStep("sent");
+        }
+        return [error, response];
+    }
+    async authenticateWithMagicCode(code) {
+        if (!authStore.state.sid) {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        if (!code) {
+            throw new Error(i18n.t("errors.magic_code_is_missing"));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.authenticateWithMagicCode(authStore.state.sid, code);
+        if (!error) {
+            this.handleAuthSuccess(response);
+            return;
+        }
+        if (error === "missing_required_fields") {
+            this.handleMissingFields(response);
+            return;
+        }
+        authStore.authStore.setLoading(false);
+        authStore.authStore.setFieldError("magicCode", error);
+    }
+    async sendResetPasswordEmail() {
+        if (!authStore.state.sid) {
+            throw new Error(i18n.t("errors.no_sign_in_id"));
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.setResetPasswordStep("requested");
+        const [error, _] = await this.client.auth.sendResetPasswordEmail(authStore.state.sid, window.location.href);
+        if (error) {
+            authStore.authStore.setFieldError("resetPassword", error);
+        }
+        else {
+            authStore.authStore.setResetPasswordStep("sent");
+            authStore.authStore.clearErrors();
+        }
+        authStore.authStore.setLoading(false);
+    }
+    async handleResetPasswordRedirect() {
+        const url = new URL(window.location.href);
+        const params = url.searchParams;
+        const resetToken = params.get("reset_password_token");
+        if (!resetToken) {
+            return false;
+        }
+        if (authStore.state.sid) {
+            authStore.authStore.setLoading(true);
+            const [error] = await this.client.auth.validateResetPasswordToken(authStore.state.sid, resetToken);
+            if (error) {
+                authStore.authStore.setFieldError("resetPassword", error);
+                authStore.authStore.setStep("reset-password");
+                authStore.authStore.setLoading(false);
+                return false;
+            }
+        }
+        authStore.authStore.setResetToken(resetToken);
+        authStore.authStore.setStep("reset-password");
+        authStore.authStore.setLoading(false);
+        return true;
+    }
+    async resetPassword() {
+        if (!authStore.state.resetPassword.token) {
+            throw new Error("No reset token available");
+        }
+        if (!authStore.state.resetPassword.newPassword) {
+            authStore.authStore.setFieldError("resetPassword", "password_required");
+            return;
+        }
+        if (authStore.state.resetPassword.passwordConfirmation &&
+            authStore.state.resetPassword.newPassword !== authStore.state.resetPassword.passwordConfirmation) {
+            authStore.authStore.setFieldError("resetPassword", "passwords_do_not_match");
+            return;
+        }
+        authStore.authStore.setLoading(true);
+        authStore.authStore.clearErrors();
+        const [error, response] = await this.client.auth.resetPassword(authStore.state.sid, authStore.state.resetPassword.token, authStore.state.resetPassword.newPassword, authStore.state.resetPassword.passwordConfirmation);
+        if (error) {
+            authStore.authStore.setFieldError("resetPassword", error);
+            // TODO: add proper password requirements handling --> for now this is fine
+            if (error === "invalid_password") {
+                authStore.authStore.setFieldError("password", response.error_details?.password.map((p) => i18n.t(`errors.password_requirements.${p}`)).join("\n"));
+            }
+        }
+        else {
+            authStore.authStore.setStep("email");
+            authStore.authStore.updateResetPassword({
+                step: "completed",
+                token: null,
+                newPassword: "",
+                passwordConfirmation: "",
+            });
+            componentUtils.clearUrlParam("reset_password_token");
+            flashStore.Flash.success.addMessage("Password reset successfully");
+        }
+        authStore.authStore.setLoading(false);
+    }
+    authenticateWithPasskey() {
+        return authenticateWithPasskey(this.client, (response) => this.handleAuthSuccess(response));
+    }
+    extractSignInIdFromQuery() {
+        const sid = componentUtils.clearUrlParam("sid");
+        if (sid) {
+            authStore.authStore.setSignInId(sid);
+        }
+    }
+    handleMissingFields(response) {
+        authStore.authStore.setMissingFields(response.fields);
+        profileStore.state.data = response.fields;
+        authStore.authStore.setStep("missing-fields");
+        authStore.authStore.setLoading(false);
+    }
+    handleAuthSuccess(response) {
+        authStore.authStore.setToken(response.jwt);
+        authStore.authStore.setLoading(false);
+        authStore.authStore.getRootComponentRef()?.onAuth(response);
+    }
+}
+
+class Auth {
+    static instance;
+    helpers;
+    constructor(client) {
+        this.helpers = new AuthHelpers(client);
+        this.helpers.handleSocialAuthRedirect();
+        this.helpers.handleResetPasswordRedirect();
+    }
+    static Errors = {
+        email: {
+            NOT_FOUND: "account_not_found",
+        },
+        magicCode: {
+            RECENTLY_CREATED: "magic_code_recently_created",
+            NOT_VALID: "magic_code_not_valid",
+            EXPIRED: "magic_code_expired",
+            USED: "magic_code_used",
+        },
+        password: {
+            INVALID: "invalid_password",
+            NOT_SET: "password_not_set",
+            RESET_PASSWORD_ALREADY_SENT: "reset_password_already_sent",
+        },
+        general: {
+            ACCOUNT_LOCKED: "account_locked",
+            SIGN_IN_EXPIRED: "sign_in_expired",
+        },
+    };
+    static async getInstance() {
+        if (!Auth.isInitialized()) {
+            await unidyStore.waitForConfig();
+            return Auth.initialize(index$1.getUnidyClient());
+        }
+        return Auth.instance;
+    }
+    static initialize(client) {
+        Auth.instance = new Auth(client);
+        if (Auth.instance.isTokenValid(authStore.state.token)) {
+            authStore.authStore.setAuthenticated(true);
+        }
+        return Auth.instance;
+    }
+    static isInitialized() {
+        return !!Auth.instance;
+    }
+    isTokenValid(token) {
+        try {
+            let decoded;
+            if (typeof token === "string") {
+                decoded = jwtDecode(token);
+            }
+            else {
+                decoded = token;
+            }
+            if (!decoded)
+                return false;
+            const currentTime = Date.now() / 1000;
+            return decoded.exp > currentTime;
+        }
+        catch (error) {
+            index.captureException(error);
+            return false;
+        }
+    }
+    async isAuthenticated() {
+        const token = await this.getToken();
+        return typeof token === "string";
+    }
+    async getToken() {
+        const currentToken = authStore.state.token;
+        if (currentToken && this.isTokenValid(currentToken)) {
+            return currentToken;
+        }
+        await this.helpers.refreshToken();
+        if (authStore.state.globalErrors.auth || !authStore.state.token) {
+            return this.createAuthError(i18n.t("errors.refresh_failed"), "REFRESH_FAILED", true);
+        }
+        return authStore.state.token;
+    }
+    async userData() {
+        const token = await this.getToken();
+        if (typeof token !== "string") {
+            return null;
+        }
+        if (!token) {
+            return null;
+        }
+        try {
+            return jwtDecode(token);
+        }
+        catch (error) {
+            index.captureException(error);
+            return null;
+        }
+    }
+    async logout() {
+        const [error, _] = await this.helpers.logout();
+        if (error) {
+            return this.createAuthError(i18n.t("errors.sign_out_failed", { reason: error }), "SIGN_OUT_FAILED", false);
+        }
+        authStore.authStore.reset();
+        return true;
+    }
+    getEmail() {
+        return authStore.state.email;
+    }
+    createAuthError(message, code, requiresReauth = false) {
+        const error = new Error(message);
+        error.code = code;
+        error.requiresReauth = requiresReauth;
+        return error;
+    }
+}
+
+exports.Auth = Auth;
+//# sourceMappingURL=auth-NU3DBc-6.js.map
+
+//# sourceMappingURL=auth-NU3DBc-6.js.map