binoauth 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,347 @@
+"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;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "binoauth",
+  "version": "0.0.1",
+  "description": "Node.js SDK for BinoAuth authentication",
+  "author": "BinoAuth",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/binoauth/binoauth.git"
+  },
+  "main": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "module": "./dist/esm/index.js",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.esm.json",
+    "prepare": "npm run build",
+    "test": "jest",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "authentication",
+    "auth",
+    "binoauth",
+    "oauth2",
+    "jwt",
+    "otp",
+    "mfa",
+    "api-key"
+  ],
+  "dependencies": {
+    "@binoauth/tenant-sdk": "../tenant-sdk",
+    "@binoauth/admin-sdk": "../admin-sdk"
+  },
+  "devDependencies": {
+    "typescript": "^4.0 || ^5.0",
+    "@types/jest": "^29.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^4.0 || ^5.0"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}