nocal-auth-sdk 0.1.8 → 0.2.0

package/dist/NocalAuth.d.ts

@@ -1,10 +1,30 @@
 export interface NocalAuthOptions {
     authorizeUrl?: string;
+    clientId?: string;
+    redirectUri?: string;
+    scope?: string;
+    state?: string;
     [key: string]: any;
 }
+export interface NocalPopupResult {
+    success: boolean;
+    data?: Record<string, any>;
+    error?: string;
+    message?: string;
+}
+export interface LoginWithPopupOptions {
+    url?: string;
+    popupName?: string;
+    width?: number;
+    height?: number;
+    features?: string;
+}
 export declare class NocalAuth {
     private authorizeUrl;
-    [key: string]: any;
+    private options;
     constructor(options?: NocalAuthOptions);
-    loginWithPopup(): Promise<unknown>;
+    static notifyPopupResult(result: NocalPopupResult, targetWindow?: Window | null): boolean;
+    getAuthorizeUrl(): string;
+    static loginWithPopup(options?: LoginWithPopupOptions): Promise<unknown>;
+    loginWithPopup(options?: LoginWithPopupOptions): Promise<unknown>;
 }

package/dist/NocalAuth.js

@@ -1,19 +1,61 @@
 export class NocalAuth {
     constructor(options = {}) {
-        this.authorizeUrl = options.authorizeUrl || "";
+        this.options = options;
+        this.authorizeUrl =
+            options.authorizeUrl || "https://auth.nocal.vn/oauth/authorize";
     }
-    loginWithPopup() {
-        // Thêm check an toàn nếu chạy ở môi trường SSR (Next.js/Nuxt) không có window
+    static notifyPopupResult(result, targetWindow = typeof window !== "undefined"
+        ? window.opener
+        : null) {
+        if (typeof window === "undefined")
+            return false;
+        const opener = targetWindow ?? window.opener;
+        if (!opener)
+            return false;
+        const payload = {
+            type: "nocal_auth_result",
+            success: result.success,
+            ...(result.success
+                ? { data: result.data ?? {} }
+                : {
+                    error: result.error || "AUTH_FAILED",
+                    message: result.message || result.error || "AUTH_FAILED",
+                }),
+        };
+        opener.postMessage(payload, "*");
+        return true;
+    }
+    getAuthorizeUrl() {
+        const url = new URL(this.authorizeUrl || "https://auth.nocal.vn/oauth/authorize");
+        const params = {
+            client_id: this.options.clientId,
+            redirect_uri: this.options.redirectUri,
+            scope: this.options.scope,
+            state: this.options.state,
+            ...this.options,
+        };
+        Object.entries(params).forEach(([key, value]) => {
+            if (value === undefined || value === null || value === "")
+                return;
+            if (key === "authorizeUrl")
+                return;
+            url.searchParams.set(key, String(value));
+        });
+        return url.toString();
+    }
+    static loginWithPopup(options = {}) {
         if (typeof window === "undefined") {
             return Promise.reject(new Error("loginWithPopup() can only be used in a browser environment"));
         }
+        const url = options.url || "https://auth.nocal.vn/oauth/authorize";
+        const width = options.width ?? 500;
+        const height = options.height ?? 700;
+        const left = window.screenX + (window.innerWidth - width) / 2;
+        const top = window.screenY + (window.innerHeight - height) / 2;
+        const features = options.features ??
+            `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`;
         return new Promise((resolve, reject) => {
-            const width = 500;
-            const height = 700;
-            const left = window.screenX + (window.innerWidth - width) / 2;
-            const top = window.screenY + (window.innerHeight - height) / 2;
-            const features = `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`;
-            const popup = window.open(this.authorizeUrl, "nocal_auth_popup", features);
+            const popup = window.open(url, options.popupName ?? "nocal_auth_popup", features);
             if (!popup)
                 return reject(new Error("POPUP_BLOCKED"));
             popup.focus();
@@ -33,10 +75,10 @@ export class NocalAuth {
                     return;
                 cleanup();
                 if (payload.success) {
-                    resolve(payload.data);
+                    resolve(payload.data ?? {});
                 }
                 else {
-                    reject(new Error(payload.error || "AUTH_FAILED"));
+                    reject(new Error(payload.error || payload.message || "AUTH_FAILED"));
                 }
             };
             window.addEventListener("message", handleMessage);
@@ -47,10 +89,16 @@ export class NocalAuth {
                         reject(new Error("POPUP_CLOSED"));
                     }
                 }
-                catch (e) {
-                    // Bỏ qua lỗi Cross-Origin khi popup chuyển hướng
+                catch {
+                    // Ignore cross-origin checks while popup is redirecting.
                 }
             }, 500);
         });
     }
+    loginWithPopup(options = {}) {
+        return NocalAuth.loginWithPopup({
+            ...options,
+            url: options.url || this.getAuthorizeUrl(),
+        });
+    }
 }

package/dist/index.d.mts

@@ -0,0 +1,46 @@
+import * as _supabase_auth_js from '@supabase/auth-js';
+import { User, Session } from '@supabase/supabase-js';
+export { Session, User } from '@supabase/supabase-js';
+
+interface NocalClientConfig {
+    clientId: string;
+    redirectUri: string;
+}
+type NocalOAuthProvider = "google" | "facebook" | "github" | "apple";
+interface OAuthLoginReq {
+    provider?: NocalOAuthProvider;
+    redirectTo?: string;
+}
+
+declare class NocalAuthSDK {
+    private supabase;
+    private clientId;
+    private redirectUri;
+    constructor(config: NocalClientConfig);
+    /**
+     * Mở Popup UI Đăng nhập/Đăng ký tập trung của Nocal
+     */
+    signInWithNocal(req?: OAuthLoginReq): Promise<User>;
+    /**
+     * Lấy thông tin User hiện tại
+     */
+    getUser(): Promise<User | null>;
+    /**
+     * Lấy Session / Access Token hiện tại
+     */
+    getSession(): Promise<Session | null>;
+    /**
+     * Đăng xuất khỏi hệ thống
+     */
+    signOut(): Promise<void>;
+    /**
+     * Lắng nghe sự kiện đăng nhập / đăng xuất
+     */
+    onAuthStateChange(callback: (event: string, session: Session | null) => void): {
+        data: {
+            subscription: _supabase_auth_js.Subscription;
+        };
+    };
+}
+
+export { NocalAuthSDK, type NocalClientConfig, type NocalOAuthProvider, type OAuthLoginReq };

package/dist/index.d.ts

@@ -1,2 +1,22 @@
-export { NocalAuth } from "./NocalAuth";
-export type { NocalAuthOptions } from "./NocalAuth";
+import { NocalClientConfig, OAuthLoginReq, NocalUser, NocalSession } from "./types";
+export declare class NocalAuthSDK {
+    private clientId;
+    private redirectUri;
+    private authServerUrl;
+    private currentSession;
+    private currentUser;
+    constructor(config: NocalClientConfig);
+    /**
+     * Mở Popup UI Đăng nhập & Ủy quyền OAuth 2.0 với PKCE
+     */
+    signInWithNocal(req?: OAuthLoginReq): Promise<{
+        user: NocalUser;
+        session: NocalSession;
+    }>;
+    private exchangeCodeForToken;
+    private fetchUserInfo;
+    getUser(): Promise<NocalUser | null>;
+    getSession(): Promise<NocalSession | null>;
+    signOut(): Promise<void>;
+}
+export * from "./types";

package/dist/index.js

@@ -1 +1,171 @@
-export { NocalAuth } from "./NocalAuth";
+const DEFAULT_AUTH_SERVER_URL = "http://localhost:3001";
+// Helper for PKCE crypto
+function base64URLEncode(buffer) {
+    let binary = "";
+    const bytes = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+async function generateCodeChallenge(verifier) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(verifier);
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    return base64URLEncode(new Uint8Array(digest));
+}
+function generateRandomString(length = 32) {
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export class NocalAuthSDK {
+    constructor(config) {
+        this.currentSession = null;
+        this.currentUser = null;
+        this.clientId = config.clientId;
+        this.redirectUri = config.redirectUri;
+        this.authServerUrl = config.authServerUrl || DEFAULT_AUTH_SERVER_URL;
+        // Load session from localStorage if available
+        if (typeof window !== "undefined") {
+            try {
+                const stored = localStorage.getItem("nocal_auth_session");
+                if (stored) {
+                    const parsed = JSON.parse(stored);
+                    this.currentSession = parsed.session;
+                    this.currentUser = parsed.user;
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    }
+    /**
+     * Mở Popup UI Đăng nhập & Ủy quyền OAuth 2.0 với PKCE
+     */
+    async signInWithNocal(req) {
+        const state = req?.state || generateRandomString(16);
+        const codeVerifier = generateRandomString(32);
+        const codeChallenge = await generateCodeChallenge(codeVerifier);
+        const authUrl = new URL(`${this.authServerUrl}/oauth/authorize`);
+        authUrl.searchParams.set("client_id", this.clientId);
+        authUrl.searchParams.set("redirect_uri", this.redirectUri);
+        authUrl.searchParams.set("response_type", "code");
+        authUrl.searchParams.set("state", state);
+        authUrl.searchParams.set("code_challenge", codeChallenge);
+        authUrl.searchParams.set("code_challenge_method", "S256");
+        const width = 480;
+        const height = 680;
+        const left = typeof window !== "undefined" ? window.screenX + (window.outerWidth - width) / 2 : 0;
+        const top = typeof window !== "undefined" ? window.screenY + (window.outerHeight - height) / 2 : 0;
+        const popup = window.open(authUrl.toString(), "NocalAuthPopup", `width=${width},height=${height},left=${left},top=${top},status=yes,scrollbars=yes`);
+        if (!popup) {
+            throw new Error("POPUP_BLOCKED");
+        }
+        return new Promise((resolve, reject) => {
+            const allowedOrigin = new URL(this.authServerUrl).origin;
+            const messageListener = async (event) => {
+                if (event.origin !== allowedOrigin)
+                    return;
+                const data = event.data;
+                if (!data || (data.type !== "NOCAL_OAUTH_CODE" && data.type !== "NOCAL_OAUTH_ERROR")) {
+                    return;
+                }
+                window.removeEventListener("message", messageListener);
+                clearInterval(checkClosedTimer);
+                if (data.type === "NOCAL_OAUTH_ERROR" || data.error) {
+                    popup.close();
+                    reject(new Error(data.error || "OAUTH_ERROR"));
+                    return;
+                }
+                if (data.state && data.state !== state) {
+                    popup.close();
+                    reject(new Error("OAUTH_STATE_MISMATCH"));
+                    return;
+                }
+                const code = data.code;
+                if (!code) {
+                    popup.close();
+                    reject(new Error("MISSING_AUTHORIZATION_CODE"));
+                    return;
+                }
+                try {
+                    popup.close();
+                    // Đổi code lấy token
+                    const session = await this.exchangeCodeForToken(code, codeVerifier);
+                    const user = await this.fetchUserInfo(session.access_token);
+                    this.currentSession = session;
+                    this.currentUser = user;
+                    if (typeof window !== "undefined") {
+                        localStorage.setItem("nocal_auth_session", JSON.stringify({ session, user }));
+                    }
+                    resolve({ user, session });
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            window.addEventListener("message", messageListener);
+            const checkClosedTimer = setInterval(() => {
+                try {
+                    if (popup.closed) {
+                        clearInterval(checkClosedTimer);
+                        window.removeEventListener("message", messageListener);
+                        reject(new Error("POPUP_CLOSED_BY_USER"));
+                    }
+                }
+                catch (e) {
+                    // ignore
+                }
+            }, 500);
+        });
+    }
+    async exchangeCodeForToken(code, codeVerifier) {
+        const res = await fetch(`${this.authServerUrl}/api/oauth/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                grant_type: "authorization_code",
+                code,
+                client_id: this.clientId,
+                redirect_uri: this.redirectUri,
+                code_verifier: codeVerifier,
+            }),
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            throw new Error(data.error_description || data.error || "FAILED_TO_EXCHANGE_TOKEN");
+        }
+        return data;
+    }
+    async fetchUserInfo(accessToken) {
+        const res = await fetch(`${this.authServerUrl}/api/oauth/userinfo`, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            throw new Error(data.error_description || data.error || "FAILED_TO_FETCH_USERINFO");
+        }
+        return data;
+    }
+    async getUser() {
+        return this.currentUser;
+    }
+    async getSession() {
+        return this.currentSession;
+    }
+    async signOut() {
+        this.currentSession = null;
+        this.currentUser = null;
+        if (typeof window !== "undefined") {
+            localStorage.removeItem("nocal_auth_session");
+        }
+    }
+}
+export * from "./types";

package/dist/index.mjs

@@ -0,0 +1,110 @@
+// src/index.ts
+import {
+  createClient
+} from "@supabase/supabase-js";
+var NOCAL_AUTH_SERVER_URL = "https://hldymiruucsqqzicnwdv.supabase.co";
+var NOCAL_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImhsZHltaXJ1dWNzcXF6aWNud2R2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODk2MTQ2NzAsImV4cCI6MjEwNTE5MDY3MH0.dLaPWdgTV8mRVToNT1XLg1EUjHvyvRRK2qc0DQAu8YI";
+var NocalAuthSDK = class {
+  constructor(config) {
+    this.clientId = config.clientId;
+    this.redirectUri = config.redirectUri;
+    this.supabase = createClient(NOCAL_AUTH_SERVER_URL, NOCAL_ANON_KEY, {
+      auth: {
+        autoRefreshToken: true,
+        persistSession: true,
+        detectSessionInUrl: true
+      }
+    });
+  }
+  /**
+   * Mở Popup UI Đăng nhập/Đăng ký tập trung của Nocal
+   */
+  async signInWithNocal(req) {
+    const targetRedirect = req?.redirectTo || this.redirectUri;
+    const provider = req?.provider || "google";
+    const { data, error } = await this.supabase.auth.signInWithOAuth({
+      provider,
+      options: {
+        redirectTo: targetRedirect,
+        skipBrowserRedirect: true,
+        // Lấy URL trả về, không nhảy trang tab chính
+        queryParams: {
+          client_id: this.clientId
+          // Gắn Client ID để Auth Server nhận diện App
+        }
+      }
+    });
+    if (error) throw error;
+    if (!data?.url) throw new Error("CANNOT_GENERATE_AUTH_URL");
+    const width = 480;
+    const height = 680;
+    const left = typeof window !== "undefined" ? window.screenX + (window.outerWidth - width) / 2 : 0;
+    const top = typeof window !== "undefined" ? window.screenY + (window.outerHeight - height) / 2 : 0;
+    const popup = window.open(
+      data.url,
+      "NocalAuthPopup",
+      `width=${width},height=${height},left=${left},top=${top},status=yes,scrollbars=yes`
+    );
+    if (!popup) {
+      throw new Error("POPUP_BLOCKED");
+    }
+    return new Promise((resolve, reject) => {
+      const isPopupClosed = () => {
+        try {
+          return popup.closed;
+        } catch (e) {
+          return false;
+        }
+      };
+      const timer = setInterval(async () => {
+        if (isPopupClosed()) {
+          clearInterval(timer);
+          const { data: sessionData } = await this.supabase.auth.getSession();
+          if (sessionData?.session?.user) {
+            resolve(sessionData.session.user);
+          } else {
+            reject(new Error("LOGIN_CANCELLED_OR_FAILED"));
+          }
+        }
+      }, 500);
+    });
+  }
+  /**
+   * Lấy thông tin User hiện tại
+   */
+  async getUser() {
+    const {
+      data: { user },
+      error
+    } = await this.supabase.auth.getUser();
+    if (error) throw error;
+    return user;
+  }
+  /**
+   * Lấy Session / Access Token hiện tại
+   */
+  async getSession() {
+    const {
+      data: { session },
+      error
+    } = await this.supabase.auth.getSession();
+    if (error) throw error;
+    return session;
+  }
+  /**
+   * Đăng xuất khỏi hệ thống
+   */
+  async signOut() {
+    const { error } = await this.supabase.auth.signOut();
+    if (error) throw error;
+  }
+  /**
+   * Lắng nghe sự kiện đăng nhập / đăng xuất
+   */
+  onAuthStateChange(callback) {
+    return this.supabase.auth.onAuthStateChange(callback);
+  }
+};
+export {
+  NocalAuthSDK
+};

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+export interface NocalClientConfig {
+    clientId: string;
+    redirectUri: string;
+    authServerUrl?: string;
+}
+export interface OAuthLoginReq {
+    state?: string;
+}
+export interface NocalUser {
+    sub: string;
+    email?: string;
+    phone?: string;
+    email_confirmed?: boolean;
+    phone_confirmed?: boolean;
+    user_metadata?: Record<string, any>;
+    [key: string]: any;
+}
+export interface NocalSession {
+    access_token: string;
+    refresh_token: string;
+    token_type: string;
+    expires_in: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nocal-auth-sdk",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Nocal Auth - client-side SDK for Login with Nocal (popup flow)",
   "type": "module",
   "main": "dist/index.js",