dremiojs 1.0.0 → 1.2.0

package/src/client/software.ts

@@ -1,9 +1,15 @@
 import { BaseClient } from './base';
 import { DremioSoftwareConfig } from '../types/config';
+import axios from 'axios';
 
 interface LoginResponse {
     token: string;
-    // Add other fields if necessary
+}
+
+interface OAuthResponse {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
 }
 
 export class DremioSoftwareClient extends BaseClient {
@@ -13,8 +19,11 @@ export class DremioSoftwareClient extends BaseClient {
     constructor(config: DremioSoftwareConfig) {
         super(config);
         this.config = config;
+        // Priority: Explicit authToken -> auth.type='pat' -> null (will login)
         if (config.authToken) {
             this.token = config.authToken;
+        } else if (config.auth && config.auth.type === 'pat') {
+            this.token = config.auth.token;
         }
     }
 
@@ -27,46 +36,81 @@ export class DremioSoftwareClient extends BaseClient {
         };
     }
 
-    private async login(): Promise<void> {
-        if (!this.config.username || !this.config.password) {
-            throw new Error('Username and password are required for login if no token is provided.');
-        }
+    private getRootUrl(): string {
+        // Robustly strip /api/v3 to find the server root
+        // Handles: https://dremio.org/api/v3 -> https://dremio.org
+        //          http://localhost:9047 -> http://localhost:9047
+        //          http://localhost:9047/ -> http://localhost:9047
+        return this.config.baseUrl.replace(/\/api\/v3\/?$/, '').replace(/\/$/, '');
+    }
 
-        // Heuristic to handle base URL variations for login
-        // If base URL is .../api/v3, login is often at .../apiv2/login
-        let loginUrl = '/apiv2/login';
-        if (this.config.baseUrl.endsWith('/api/v3')) {
-            const baseUrlRoot = this.config.baseUrl.replace('/api/v3', '');
-            // We will perform a direct axios call to the root + /apiv2/login
-            // But since our instance is bound to baseUrl, we might need a separate call or specific path
-            // Actually, axios instance is bound to /api/v3 usually.
+    private async login(): Promise<void> {
+        const auth = this.config.auth;
+        const rootUrl = this.getRootUrl();
 
-            // Let's rely on the user providing a correct Base URL. 
-            // IMPLEMENTATION NOTE: Dremio Software V3 API usually sits at /api/v3. 
-            // Login is at /apiv2/login.
-            // We need to construct the login URL relative to the server root, not the V3 API root.
-            // For simplicity, we will try to infer the root.
+        if (auth?.type === 'oauth') {
+            await this.loginOAuth(rootUrl, auth.client_id, auth.client_secret, auth.scope);
+        } else if (auth?.type === 'username_password' || (this.config.username && this.config.password)) {
+            const user = auth?.type === 'username_password' ? auth.username : this.config.username;
+            const pass = auth?.type === 'username_password' ? auth.password : this.config.password;
+            
+            if (!user || !pass) throw new Error('Username/Password required');
+            await this.loginBasic(rootUrl, user, pass);
+        } else {
+             throw new Error('No valid authentication configuration found (Token, User/Pass, or OAuth).');
         }
+    }
 
-        // Workaround: create a new axios request for login that overrides the baseURL if necessary
-        // or just use absolute URL if we can derive it.
-
-        // Simplest approach: Assume config.baseUrl is the API base.
-        // We'll strip the API part for the login call.
-        const apiBase = this.config.baseUrl;
-        const rootUrl = apiBase.replace(/\/api\/v3\/?$/, '');
-
+    private async loginBasic(rootUrl: string, user: string, pass: string): Promise<void> {
         try {
-            // Direct call using imported axios (not the instance) to avoid prefix issues if needed,
-            // or just re-config the instance call.
-            const response = await this.axiosInstance.post<LoginResponse>(`${rootUrl}/apiv2/login`, {
-                userName: this.config.username,
-                password: this.config.password,
+            const response = await axios.post<LoginResponse>(`${rootUrl}/apiv2/login`, {
+                userName: user,
+                password: pass,
+            }, {
+                timeout: this.config.timeout || 10000
             });
-
             this.token = response.data.token;
         } catch (error) {
-            console.error('Login failed');
+            console.error('Login (Basic) failed:', (error as any).message);
+            throw error;
+        }
+    }
+
+    private async loginOAuth(rootUrl: string, clientId: string, clientSecret: string, scope?: string): Promise<void> {
+        const params = new URLSearchParams();
+        params.append('grant_type', 'client_credentials');
+        params.append('client_id', clientId);
+        params.append('client_secret', clientSecret);
+        if (scope) {
+            params.append('scope', scope);
+        }
+
+        const doRequest = async (p: URLSearchParams) => {
+            return axios.post<OAuthResponse>(`${rootUrl}/oauth/token`, p, {
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                timeout: this.config.timeout || 10000
+            });
+        };
+
+        try {
+            const response = await doRequest(params);
+            this.token = response.data.access_token;
+        } catch (error: any) {
+            // Check for Scope error (400) and retry with dremio.all if not already present
+            if (error.response && error.response.status === 400 && !scope) {
+                // Heuristic: Check error message content if possible, or just blind retry
+                console.warn('OAuth login failed (400). Retrying with scope=dremio.all default...');
+                params.set('scope', 'dremio.all');
+                try {
+                    const retryResponse = await doRequest(params);
+                    this.token = retryResponse.data.access_token;
+                    return;
+                } catch (retryError: any) {
+                    console.error('OAuth retry failed:', retryError.message);
+                    throw retryError;
+                }
+            }
+            console.error('OAuth login failed:', error.message);
             throw error;
         }
     }

package/src/factory.ts

@@ -0,0 +1,20 @@
+import { ConfigLoader } from './utils/config';
+import { DremioCloudClient } from './client/cloud';
+import { DremioSoftwareClient } from './client/software';
+import { DremioCloudConfig, DremioSoftwareConfig } from './types/config';
+
+export class Dremio {
+    /**
+     * Create a Dremio Client from a named profile in ~/.dremio/profiles.yaml
+     * If no profile is specified, it loads the default profile.
+     */
+    static async fromProfile(profileName?: string): Promise<DremioCloudClient | DremioSoftwareClient> {
+        const config = await ConfigLoader.loadProfile(profileName);
+
+        if ('projectId' in config) {
+            return new DremioCloudClient(config as DremioCloudConfig);
+        } else {
+            return new DremioSoftwareClient(config as DremioSoftwareConfig);
+        }
+    }
+}

package/src/index.ts

@@ -1,6 +1,6 @@
-// Clients
 export { DremioCloudClient } from './client/cloud';
 export { DremioSoftwareClient } from './client/software';
+export { Dremio } from './factory';
 
 // Types
 export * from './types/config';

package/src/types/config.ts

@@ -1,18 +1,41 @@
 export interface BaseDremioConfig {
     baseUrl: string;
     timeout?: number;
+    checkSSLCerts?: boolean;
 }
 
+export type AuthConfig = 
+    | { type: 'pat'; token: string }
+    | { type: 'username_password'; username: string; password: string }
+    | { type: 'oauth'; client_id: string; client_secret: string; scope?: string };
+
 export interface DremioCloudConfig extends BaseDremioConfig {
-    authToken: string;
+    authToken?: string; // Legacy/Direct support
     projectId: string;
+    auth?: AuthConfig;
 }
 
 export interface DremioSoftwareConfig extends BaseDremioConfig {
-    authToken?: string;
-    username?: string;
-    password?: string;
-    checkSSLCerts?: boolean;
+    authToken?: string; // Legacy/Direct support
+    username?: string;  // Legacy/Direct support
+    password?: string;  // Legacy/Direct support
+    auth?: AuthConfig;
 }
 
 export type DremioConfig = DremioCloudConfig | DremioSoftwareConfig;
+
+// Profile definition matching profiles.yaml
+export interface ProfileConfig {
+    type: 'cloud' | 'software';
+    base_url?: string;
+    project_id?: string;
+    test_folder?: string;
+    ssl?: string; 
+    auth: AuthConfig;
+    mode?: string; // e.g. 'v25'
+}
+
+export interface ProfilesFile {
+    profiles: Record<string, ProfileConfig>;
+    default_profile?: string;
+}

package/src/utils/config.ts

@@ -0,0 +1,113 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import yaml from 'js-yaml';
+import { ProfilesFile, ProfileConfig, DremioConfig, DremioCloudConfig, DremioSoftwareConfig } from '../types/config';
+
+export class ConfigLoader {
+    private static PROFILES_PATH = path.join(os.homedir(), '.dremio', 'profiles.yaml');
+
+    static async loadProfile(profileName?: string): Promise<DremioConfig> {
+        let profileConfig: ProfileConfig | undefined;
+
+        // 1. Try to load from profiles.yaml
+        if (fs.existsSync(this.PROFILES_PATH)) {
+            try {
+                const fileContent = fs.readFileSync(this.PROFILES_PATH, 'utf8');
+                const profilesData = yaml.load(fileContent) as ProfilesFile;
+
+                const targetProfile = profileName || profilesData.default_profile || 'default';
+                
+                if (profilesData.profiles && profilesData.profiles[targetProfile]) {
+                    profileConfig = profilesData.profiles[targetProfile];
+                } else if (profileName) {
+                    throw new Error(`Profile '${profileName}' not found in ${this.PROFILES_PATH}`);
+                }
+            } catch (error) {
+                console.warn(`Warning: Failed to parse ${this.PROFILES_PATH}`, error);
+            }
+        }
+
+        // 2. Convert to DremioConfig
+        if (profileConfig) {
+            return this.convertProfileToConfig(profileConfig);
+        }
+
+        // 3. Fallback to Env Vars (legacy support)
+        return this.loadFromEnv();
+    }
+
+    private static convertProfileToConfig(profile: ProfileConfig): DremioConfig {
+        const checkSSLCerts = profile.ssl === 'false' ? false : true; // Default true unless 'false' string
+        
+        if (profile.type === 'cloud') {
+            if (!profile.project_id) throw new Error('Cloud profile missing project_id');
+            // Cloud profile usually has base_url
+            let baseUrl = profile.base_url || 'https://api.dremio.cloud';
+
+            // Normalize: Ensure /v0 assumption for Cloud if not present
+            if (!baseUrl.endsWith('/v0')) {
+                 baseUrl = baseUrl.replace(/\/$/, '');
+                 baseUrl = `${baseUrl}/v0`;
+            }
+            
+            return {
+                baseUrl,
+                projectId: profile.project_id,
+                authToken: profile.auth.type === 'pat' ? profile.auth.token : undefined, 
+                auth: profile.auth,
+                checkSSLCerts
+            } as DremioCloudConfig;
+        } else {
+            // Software
+            let baseUrl = profile.base_url || 'http://localhost:9047';
+            
+            // Normalize URL: Ensure it ends with /api/v3 for Software
+            if (!baseUrl.endsWith('/api/v3')) {
+                // Strip trailing slash first
+                baseUrl = baseUrl.replace(/\/$/, '');
+                baseUrl = `${baseUrl}/api/v3`;
+            }
+
+            const config: DremioSoftwareConfig = {
+                baseUrl,
+                checkSSLCerts,
+                auth: profile.auth
+            };
+
+            // Map flat properties if present, though 'auth' object is preferred now
+            if (profile.auth.type === 'pat') {
+                config.authToken = profile.auth.token;
+            } else if (profile.auth.type === 'username_password') {
+                config.username = profile.auth.username;
+                config.password = profile.auth.password;
+            }
+
+            return config;
+        }
+    }
+
+    private static loadFromEnv(): DremioConfig {
+        // Fallback implementation for existing .env support
+        // This mirrors the logic users might expect if no profile exists
+        if (process.env.DREMIO_CLOUD_TOKEN && process.env.DREMIO_CLOUD_PROJECTID) {
+            return {
+                baseUrl: process.env.DREMIO_CLOUD_BASE_URL || 'https://api.dremio.cloud/v0',
+                authToken: process.env.DREMIO_CLOUD_TOKEN,
+                projectId: process.env.DREMIO_CLOUD_PROJECTID
+            } as DremioCloudConfig;
+        }
+
+        if (process.env.DREMIO_SOFTWARE_TOKEN || (process.env.DREMIO_USER && process.env.DREMIO_PASSWORD)) {
+            return {
+                baseUrl: process.env.DREMIO_SOFTWARE_BASE_URL || 'http://localhost:9047',
+                authToken: process.env.DREMIO_SOFTWARE_TOKEN,
+                username: process.env.DREMIO_USER,
+                password: process.env.DREMIO_PASSWORD,
+                checkSSLCerts: process.env.DREMIO_SSL_VERIFY === 'false' ? false : true
+            } as DremioSoftwareConfig;
+        }
+
+        throw new Error('No configuration found in profiles.yaml or environment variables.');
+    }
+}

package/tests/integration_manual.ts

@@ -39,6 +39,22 @@ const runTests = async () => {
                 console.warn('   Warning: Could not list reflections:', e.message);
             }
 
+            console.log(' - Validating Provisioning (Engines)...');
+            try {
+                const engines = await cloudClient.provisioning.listEngines();
+                console.log('   Success! Found', engines.length, 'engines');
+            } catch (e: any) {
+                console.warn('   Warning: Could not list engines:', e.message);
+            }
+
+            console.log(' - Validating Scripts...');
+            try {
+                const scripts = await cloudClient.scripts.list();
+                console.log('   Success! Found', scripts.length, 'scripts');
+            } catch (e: any) {
+                console.warn('   Warning: Could not list scripts:', e.message);
+            }
+
             console.log(' - Running Test Query: SELECT 1');
             const results = await cloudClient.jobs.executeQuery('SELECT 1');
             console.log('   Query Success! Result:', results);
@@ -80,6 +96,39 @@ const runTests = async () => {
                 console.warn('   Warning: Could not list reflections:', e.message);
             }
 
+            console.log(' - Validating Scripts...');
+            try {
+                const scripts = await softwareClient.scripts.list();
+                console.log('   Success! Found', scripts.length, 'scripts');
+            } catch (e: any) {
+                console.warn('   Warning: Could not list scripts (Check if supported/enabled in this version):', e.message);
+            }
+
+            console.log(' - Validating Service User Lifecycle...');
+            try {
+                // 1. Create Service User
+                const userName = `test_svc_${Date.now()}`;
+                console.log(`   Creating Service User: ${userName}...`);
+                const newUser = await softwareClient.users.create({
+                    name: userName,
+                    identityType: 'SERVICE_USER'
+                });
+                console.log('   Success! Created User ID:', newUser.id);
+
+                // 2. Create Credential
+                console.log('   Creating Credential...');
+                const cred = await softwareClient.credentials.create(newUser.id, 'test-secret', 30);
+                console.log('   Success! Created Credential ID:', cred.id);
+
+                // 3. Delete User
+                console.log('   Deleting User...');
+                await softwareClient.users.delete(newUser.id, newUser.tag);
+                console.log('   Success! User Deleted.');
+
+            } catch (e: any) {
+                console.warn('   Warning: Service User test failed (Admin privileges required?):', e.message);
+            }
+
             console.log(' - Running Test Query: SELECT 1');
             const results = await softwareClient.jobs.executeQuery('SELECT 1');
             console.log('   Query Success! Result:', results);

package/tests/verify_profiles.ts

@@ -0,0 +1,28 @@
+import { Dremio } from '../src/factory';
+
+async function testProfile(name: string) {
+    console.log(`\n--- Testing Profile: ${name} ---`);
+    try {
+        const client = await Dremio.fromProfile(name);
+        console.log(`Initialized client for ${name}. Executing 'SELECT 1'...`);
+        
+        const job = await client.jobs.executeQuery('SELECT 1');
+        console.log('Query result:', JSON.stringify(job, null, 2));
+        console.log(`✅ [PASS] ${name}`);
+    } catch (error: any) {
+        console.error(`❌ [FAIL] ${name}`);
+        console.error('Error:', error.message);
+        if (error.response) {
+             console.error('API Response:', error.response.data);
+        }
+    }
+}
+
+async function runTests() {
+    await testProfile('cloud');
+    await testProfile('software');
+    await testProfile('v25');
+    await testProfile('service');
+}
+
+runTests();