binoauth 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,51 +0,0 @@
-export interface BinoAuthConfig {
-    apiKey: string;
-    tenant: string;
-    baseUrl?: string;
-}
-export interface LoginCredentials {
-    email?: string;
-    password?: string;
-    otp?: string;
-    phone?: string;
-}
-export interface BinoAuthResponse<T = any> {
-    ok: boolean;
-    data?: T;
-    error?: string;
-    error_description?: string;
-}
-export declare class BinoAuth {
-    private tenantConfig;
-    private adminConfig;
-    private authApi;
-    private oauthApi;
-    private userProfileApi;
-    private adminApi;
-    constructor(config: BinoAuthConfig);
-    sendEmailOTP(email: string): Promise<BinoAuthResponse>;
-    sendPhoneOTP(phone: string): Promise<BinoAuthResponse>;
-    sendMagicLink(email: string): Promise<BinoAuthResponse>;
-    login(type: 'password' | 'otp', credentials: LoginCredentials): Promise<BinoAuthResponse>;
-    sendResetPasswordEmailOTP(email: string): Promise<BinoAuthResponse>;
-    sendResetPasswordPhoneOTP(phone: string): Promise<BinoAuthResponse>;
-    resetPassword(params: {
-        otp: string;
-        newPassword: string;
-        repeatNewPassword: string;
-    }): Promise<BinoAuthResponse>;
-    refreshToken(refreshToken: string): Promise<BinoAuthResponse>;
-    logout(accessToken?: string): Promise<BinoAuthResponse>;
-    getProfile(): Promise<BinoAuthResponse>;
-    requestDeviceCode(): Promise<BinoAuthResponse>;
-    pollDeviceToken(deviceCode: string): Promise<BinoAuthResponse>;
-    createUser(userData: any): Promise<BinoAuthResponse>;
-    getUser(userId: string): Promise<BinoAuthResponse>;
-    getUsers(params?: {
-        page?: number;
-        limit?: number;
-    }): Promise<BinoAuthResponse>;
-    updateUser(userId: string, userData: any): Promise<BinoAuthResponse>;
-    deleteUser(userId: string): Promise<BinoAuthResponse>;
-}
-export default BinoAuth;

package/dist/index.js

@@ -1,347 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinoAuth = void 0;
-const tenant_sdk_1 = require("@binoauth/tenant-sdk");
-const admin_sdk_1 = require("@binoauth/admin-sdk");
-class BinoAuth {
-    constructor(config) {
-        const baseUrl = config.baseUrl || 'https://api.binoauth.com';
-        // Configure tenant SDK
-        this.tenantConfig = new tenant_sdk_1.Configuration({
-            basePath: baseUrl,
-            headers: {
-                'X-API-Key': config.apiKey,
-                'X-Tenant-ID': config.tenant
-            }
-        });
-        // Configure admin SDK
-        this.adminConfig = new admin_sdk_1.Configuration({
-            basePath: baseUrl,
-            headers: {
-                'X-API-Key': config.apiKey,
-                'X-Tenant-ID': config.tenant
-            }
-        });
-        // Initialize APIs
-        this.authApi = new tenant_sdk_1.AuthenticationApi(this.tenantConfig);
-        this.oauthApi = new tenant_sdk_1.OAuth2Api(this.tenantConfig);
-        this.userProfileApi = new tenant_sdk_1.UserProfileApi(this.tenantConfig);
-        this.adminApi = new admin_sdk_1.AdminApi(this.adminConfig);
-    }
-    // Authentication Methods
-    async sendEmailOTP(email) {
-        try {
-            const response = await this.authApi.requestMagicLinkApiV1AuthMlPost({
-                magicLinkRequest: { email }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to send email OTP',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async sendPhoneOTP(phone) {
-        try {
-            const response = await this.authApi.requestOtpViaPhoneApiV1AuthPhonePost({
-                phoneOTPRequest: { phone }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to send phone OTP',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async sendMagicLink(email) {
-        try {
-            const response = await this.authApi.requestMagicLinkApiV1AuthMlPost({
-                magicLinkRequest: { email }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to send magic link',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async login(type, credentials) {
-        try {
-            let response;
-            if (type === 'password') {
-                if (!credentials.email || !credentials.password) {
-                    return {
-                        ok: false,
-                        error: 'Missing credentials',
-                        error_description: 'Email and password are required for password login'
-                    };
-                }
-                response = await this.authApi.loginApiV1AuthLoginPost({
-                    loginRequest: {
-                        email: credentials.email,
-                        password: credentials.password
-                    }
-                });
-            }
-            else if (type === 'otp') {
-                if (!credentials.otp) {
-                    return {
-                        ok: false,
-                        error: 'Missing OTP',
-                        error_description: 'OTP code is required for OTP login'
-                    };
-                }
-                // For OTP login, we need to verify the OTP
-                if (credentials.phone) {
-                    response = await this.authApi.verifyPhoneOtpApiV1AuthPhoneVerifyPost({
-                        phoneOTPVerificationRequest: {
-                            otp: credentials.otp.toString()
-                        }
-                    });
-                }
-                else {
-                    response = await this.authApi.verifyMagicLinkCodeApiV1AuthMlCodeVerifyPost({
-                        verifyMagicLinkCodeRequest: {
-                            code: credentials.otp.toString()
-                        }
-                    });
-                }
-            }
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Login failed',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    // Password Reset
-    async sendResetPasswordEmailOTP(email) {
-        try {
-            const response = await this.authApi.requestMagicLinkApiV1AuthMlPost({
-                magicLinkRequest: { email }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to send reset password email',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async sendResetPasswordPhoneOTP(phone) {
-        try {
-            const response = await this.authApi.requestOtpViaPhoneApiV1AuthPhonePost({
-                phoneOTPRequest: { phone }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to send reset password phone OTP',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async resetPassword(params) {
-        try {
-            if (params.newPassword !== params.repeatNewPassword) {
-                return {
-                    ok: false,
-                    error: 'Password mismatch',
-                    error_description: 'New password and repeat password do not match'
-                };
-            }
-            // This would typically be handled by verifying the OTP first, then updating password
-            // For now, we'll verify the magic link code
-            const response = await this.authApi.verifyMagicLinkCodeApiV1AuthMlCodeVerifyPost({
-                verifyMagicLinkCodeRequest: {
-                    code: params.otp
-                }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to reset password',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    // Token Management
-    async refreshToken(refreshToken) {
-        try {
-            const response = await this.oauthApi.getTokensApiV1OauthTokenPost({
-                tokenRequest: {
-                    grantType: 'refresh_token',
-                    clientId: 'binoauth-sdk',
-                    refreshToken: refreshToken
-                }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to refresh token',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async logout(accessToken) {
-        try {
-            const response = await this.authApi.logoutApiV1AuthLogoutPost({
-                sessionBinoauth: accessToken || ''
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to logout',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    // User Profile
-    async getProfile() {
-        try {
-            const response = await this.userProfileApi.getCurrentUserApiV1AuthUserinfoGet();
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to get profile',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    // Device Code Flow
-    async requestDeviceCode() {
-        try {
-            const response = await this.oauthApi.deviceAuthorizationApiV1OauthDeviceCodePost({
-                deviceAuthorizationRequest: {
-                    clientId: 'binoauth-sdk'
-                }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to request device code',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async pollDeviceToken(deviceCode) {
-        try {
-            const response = await this.oauthApi.getTokensApiV1OauthTokenPost({
-                tokenRequest: {
-                    grantType: 'urn:ietf:params:oauth:grant-type:device_code',
-                    clientId: 'binoauth-sdk',
-                    deviceCode: deviceCode
-                }
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to poll device token',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    // User Management (Admin API)
-    async createUser(userData) {
-        try {
-            // Admin API user creation method may not be available - this is a placeholder
-            throw new Error('User creation not implemented in admin SDK');
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to create user',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async getUser(userId) {
-        try {
-            const response = await this.adminApi.getUserApiV1UsersUserIdGet({
-                userId,
-                xTenantId: ''
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to get user',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async getUsers(params = {}) {
-        try {
-            const response = await this.adminApi.getUsersApiV1UsersGet({
-                page: params.page || 1,
-                limit: params.limit || 10,
-                xTenantId: ''
-            });
-            return { ok: true, data: response };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to get users',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async updateUser(userId, userData) {
-        try {
-            // Admin API user update method may not be available - this is a placeholder
-            throw new Error('User update not implemented in admin SDK');
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to update user',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-    async deleteUser(userId) {
-        try {
-            // Admin API user delete method may not be available - this is a placeholder
-            throw new Error('User delete not implemented in admin SDK');
-        }
-        catch (error) {
-            return {
-                ok: false,
-                error: error.message || 'Failed to delete user',
-                error_description: error.response?.data?.detail || error.message
-            };
-        }
-    }
-}
-exports.BinoAuth = BinoAuth;
-exports.default = BinoAuth;