dremiojs 1.1.0 → 1.2.0

package/README.md

@@ -10,6 +10,49 @@ npm install dremiojs
 
 ## Usage
 
+The recommended way to use `dremiojs` is by configuring your connection in `~/.dremio/profiles.yaml` (compatible with `dremio-cli`).
+
+### 1. Setup Profile
+Create `~/.dremio/profiles.yaml`:
+
+```yaml
+profiles:
+  cloud:
+    type: cloud
+    base_url: https://api.dremio.cloud
+    project_id: <PROJECT_ID>
+    auth:
+      type: pat
+      token: <PAT>
+  local:
+    type: software
+    base_url: http://localhost:9047
+    auth:
+      type: username_password
+      username: admin
+      password: password1
+default_profile: cloud
+```
+
+### 2. Connect & Query
+
+```typescript
+import { Dremio } from 'dremiojs';
+
+async function main() {
+    // Automatically loads 'default' profile from yaml
+    const client = await Dremio.fromProfile();
+    
+    // Execute SQL
+    const results = await client.jobs.executeQuery('SELECT 1');
+    console.log(results);
+}
+```
+
+## Advanced Usage (Explicit Configuration)
+
+You can also configure clients manually without a profile file.
+
 ### Dremio Cloud
 
 ```typescript
@@ -20,16 +63,6 @@ const client = new DremioCloudClient({
     authToken: 'YOUR_PAT',
     projectId: 'YOUR_PROJECT_ID'
 });
-
-async function main() {
-    // List catalog
-    const catalog = await client.catalog.getByPath([]);
-    console.log(catalog.children);
-    
-    // Execute SQL
-    const results = await client.jobs.executeQuery('SELECT * FROM sys.version');
-    console.log(results);
-}
 ```
 
 ### Dremio Software
@@ -37,29 +70,27 @@ async function main() {
 ```typescript
 import { DremioSoftwareClient } from 'dremiojs';
 
+// OAuth (Client Credentials)
 const client = new DremioSoftwareClient({
-    baseUrl: 'http://dremio:9047/api/v3',
-    authToken: 'YOUR_PAT'
-    // OR username/password:
-    // username: 'dremio',
-    // password: 'password123'
+    baseUrl: 'https://dremio.local/api/v3',
+    auth: {
+        type: 'oauth',
+        client_id: 'service-id',
+        client_secret: 'secret'
+    }
 });
-
-async function main() {
-    const results = await client.jobs.executeQuery('SELECT 1');
-}
 ```
 
 ## Features
 
+- **Profile Support**: Seamless `profiles.yaml` integration for Cloud/Software.
+- **Advanced Auth**: Support for PAT Exchange and OAuth Client Credentials.
 - **Universal Support**: Works with both Dremio Cloud and Dremio Software.
 - **Strict Typing**: Full TypeScript definitions for Catalog, Jobs, Reflections, etc.
 - **SQL Helper**: Easy `executeQuery` method that handles job submission and polling.
 - **Catalog Management**: Create, update, delete Spaces, Sources, Folders, and Datasets.
 - **Reflections**: Manage reflections programmatically.
 
-## Documentation
-
 - [Configuration & Environment Variables](docs/configuration.md)
 - [Client Usage](docs/client.md)
 - [Catalog API](docs/catalog.md)

package/docs/configuration.md

@@ -1,54 +1,150 @@
-# Configuration & Environment Variables
+# Configuration & Authentication
 
-`dremiojs` is designed to be flexible and secure. It supports configuration via a typed configuration object passed to the client constructor. While it does not automatically read environment variables (to avoid strict dependency on `dotenv` in client-side bundling scenarios), we recommend using standard environment variables in your application.
+`dremiojs` offers a flexible configuration system that supports:
+1.  **Profiles (New):** Automatically load configuration from `~/.dremio/profiles.yaml`.
+2.  **Explicit Config:** Pass configuration objects directly to the client constructor.
+3.  **Environment Variables:** Fallback support for standard environment variables.
 
-## Best Practices
+## 1. Using Profiles (Recommended)
 
-Store your sensitive credentials in a `.env` file and use a library like `dotenv` to load them.
+The easiest way to specificy connection details is using the `Dremio` factory, which reads from your local `~/.dremio/profiles.yaml` file (compatible with `dremio-cli` and `dremio-simple-query`).
 
-```bash
-# .env example
-DREMIO_CLOUD_TOKEN=your_pat_here
-DREMIO_CLOUD_PROJECT_ID=your_project_id
-DREMIO_SOFTWARE_URL=http://dremio:9047/api/v3
-DREMIO_SOFTWARE_USER=admin
-DREMIO_SOFTWARE_PASS=password123
+### Installation
+Ensure you have a profiles file at `~/.dremio/profiles.yaml`.
+
+```typescript
+import { Dremio } from 'dremiojs';
+
+async function main() {
+    // 1. Load the 'default' profile
+    const client = await Dremio.fromProfile();
+    
+    // 2. Load a specific named profile (e.g. 'prod')
+    const prodClient = await Dremio.fromProfile('prod');
+    
+    const results = await client.jobs.executeQuery('SELECT 1');
+    console.log(results);
+}
 ```
 
-## Configuration Interfaces
+### Profile Reference (`profiles.yaml`)
+
+Below is a complete reference of supported profile types.
+
+```yaml
+profiles:
+  # --- Dremio Cloud (PAT Auth) ---
+  cloud:
+    type: cloud
+    # Base URL (defaults to https://api.dremio.cloud)
+    base_url: https://api.dremio.cloud
+    project_id: <YOUR_PROJECT_ID>
+    auth:
+      type: pat
+      token: <YOUR_PAT_TOKEN>
+
+  # --- Dremio Software (PAT Auth) ---
+  software_pat:
+    type: software
+    base_url: https://dremio.company.com
+    auth:
+      type: pat
+      token: <YOUR_PAT_TOKEN>
+
+  # --- Dremio Software (Username/Password) ---
+  # Useful for local development or legacy auth
+  local:
+    type: software
+    base_url: http://localhost:9047
+    ssl: 'false' # Disable SSL verification for localhost
+    auth:
+      type: username_password
+      username: admin
+      password: password123
 
-### Dremio Cloud Config
+  # --- Dremio Software (OAuth 2.0 / Service Account) ---
+  # Uses Client Credentials Grant
+  service_account:
+    type: software
+    base_url: https://dremio.company.com
+    auth:
+      type: oauth
+      client_id: <CLIENT_ID>
+      client_secret: <CLIENT_SECRET>
+      # Scope is optional, defaults to implicit or 'dremio.all' on retry
+      scope: dremio.all 
+
+default_profile: cloud
+```
+
+## 2. Explicit Configuration
+
+You can also instantiate clients manually, which is useful for web applications or when configuration is injected at runtime.
+
+### Dremio Cloud Client
 
 ```typescript
-interface DremioCloudConfig {
-  baseUrl: string;      // Usually 'https://api.dremio.cloud/v0'
-  authToken: string;    // Your Personal Access Token
-  projectId: string;    // The Project ID provided in the Cloud Console URL
-  timeout?: number;     // Request timeout in ms (default: 30000)
-}
+import { DremioCloudClient } from 'dremiojs';
+
+const client = new DremioCloudClient({
+    projectId: 'your-project-id',
+    authToken: 'your-pat', // Can be a PAT or a Session Token
+    baseUrl: 'https://api.dremio.cloud/v0', // Optional
+    // Or use the auth object
+    auth: {
+        type: 'pat',
+        token: 'your-pat'
+    }
+});
 ```
 
-### Dremio Software Config
+### Dremio Software Client
 
 ```typescript
-interface DremioSoftwareConfig {
-  baseUrl: string;      // e.g. 'http://localhost:9047/api/v3'
-  authToken?: string;   // PAT (Recommended)
-  username?: string;    // For legacy auth
-  password?: string;    // For legacy auth
-  checkSSLCerts?: boolean; // Set to false for self-signed certs (Node.js only)
-  timeout?: number;     // Request timeout in ms
-}
+import { DremioSoftwareClient } from 'dremiojs';
+
+// PAT Auth
+const client = new DremioSoftwareClient({
+    baseUrl: 'http://localhost:9047/api/v3',
+    authToken: 'your-pat'
+});
+
+// Username/Password
+const client = new DremioSoftwareClient({
+    baseUrl: 'http://localhost:9047/api/v3',
+    auth: {
+        type: 'username_password',
+        username: 'admin',
+        password: 'password123'
+    }
+});
+
+// OAuth (Client Credentials)
+const client = new DremioSoftwareClient({
+    baseUrl: 'https://dremio.example.com/api/v3',
+    auth: {
+        type: 'oauth',
+        client_id: '...',
+        client_secret: '...'
+    }
+});
 ```
 
-## SSL/TLS Configuration (Self-Signed Certs)
+## 3. Environment Variables (Fallback)
+
+If no profiles are found, `ConfigLoader` checks for these legacy environment variables:
 
-If you are connecting to a Dremio Software instance with a self-signed certificate, you may need to disable SSL verification in Node.js.
+- **Cloud**: `DREMIO_CLOUD_TOKEN`, `DREMIO_CLOUD_PROJECTID`, `DREMIO_CLOUD_BASE_URL`
+- **Software**: `DREMIO_SOFTWARE_TOKEN`, `DREMIO_SOFTWARE_BASE_URL`, `DREMIO_USER`, `DREMIO_PASSWORD`
+
+## SSL/TLS Configuration
+
+For self-signed certificates (common in local software deployments), set `checkSSLCerts: false`. In `profiles.yaml`, set `ssl: 'false'`.
 
 ```typescript
 const client = new DremioSoftwareClient({
-    baseUrl: 'https://dremio.local:9047/api/v3',
-    authToken: '...',
-    checkSSLCerts: false // WARNING: Use only for development
+    baseUrl: 'https://localhost:9047',
+    checkSSLCerts: false 
 });
 ```
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dremiojs",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A TypeScript client library for Dremio Cloud and Software.",
   "repository": {
     "type": "git",
@@ -16,6 +16,7 @@
   "type": "commonjs",
   "devDependencies": {
     "@types/jest": "^30.0.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.0.3",
     "axios": "^1.13.2",
     "dotenv": "^17.2.3",
@@ -25,5 +26,8 @@
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.1"
   }
-}
+}

package/src/client/cloud.ts

@@ -1,18 +1,25 @@
 import { BaseClient } from './base';
 import { DremioCloudConfig } from '../types/config';
+import axios from 'axios';
 
 export class DremioCloudClient extends BaseClient {
     protected config: DremioCloudConfig;
+    private sessionToken: string | null = null;
 
     constructor(config: DremioCloudConfig) {
-        if (!config.authToken) {
-            throw new Error('Auth token is required for Dremio Cloud.');
-        }
+        // Validation: Must have Project ID, and EITHER authToken OR auth.type='pat'
         if (!config.projectId) {
             throw new Error('Project ID is required for Dremio Cloud.');
         }
+        const hasLegacyToken = !!config.authToken;
+        const hasAuthObj = config.auth && config.auth.type === 'pat';
+        
+        if (!hasLegacyToken && !hasAuthObj) {
+            throw new Error('Auth token (PAT) is required for Dremio Cloud.');
+        }
 
         // Adjust BaseUrl to include project context
+        // We do this for the main axios instance, but we keep original config for login
         const configWithProject = { ...config };
         if (!configWithProject.baseUrl.includes('/projects/')) {
             // Remove trailing slash if present
@@ -24,12 +31,47 @@ export class DremioCloudClient extends BaseClient {
         this.config = config;
     }
 
-    protected getAuthHeaders(): Record<string, string> {
+    protected async getAuthHeaders(): Promise<Record<string, string>> {
+        if (!this.sessionToken) {
+            await this.login();
+        }
         return {
-            Authorization: `Bearer ${this.config.authToken}`,
+            Authorization: `Bearer ${this.sessionToken}`,
         };
     }
 
+    private async login(): Promise<void> {
+        const pat = this.config.auth?.type === 'pat' ? this.config.auth.token : this.config.authToken;
+        
+        if (!pat) {
+            throw new Error('No PAT available for login.');
+        }
+
+        // Try to exchange PAT for Session Token
+        try {
+            // Original Base URL (e.g. https://api.dremio.cloud/v0)
+            const cleanBase = this.config.baseUrl.replace(/\/$/, '');
+            const loginUrl = `${cleanBase}/login`;
+
+            const response = await axios.post(loginUrl, { token: pat }, {
+                headers: { 'Content-Type': 'application/json' },
+                timeout: this.config.timeout || 10000
+            });
+
+            if (response.data && response.data.token) {
+                this.sessionToken = response.data.token;
+            } else {
+                // Unexpected response structure
+                console.warn('Login response did not contain token, falling back to PAT/Legacy mode.');
+                this.sessionToken = pat;
+            }
+        } catch (error) {
+            console.warn('PAT Exchange failed, falling back to raw PAT usage. Error:', (error as any).message);
+            // Fallback to using PAT directly
+            this.sessionToken = pat;
+        }
+    }
+
     // Cloud specific methods can go here or generic methods can use projectId from config
     getProjectId(): string {
         return this.config.projectId;

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/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();