Add wrapper client that accepts a u+p and gets a token

Author: mattblank11

.fernignore

@@ -1 +1,8 @@
 # Specify files that shouldn't be modified by Fern
+
+# Manual wrapper client implementation
+src/WrapperClient.ts
+src/index.ts
+
+# Enhanced auth client with basic auth support
+src/api/resources/authtoken/resources/auth/client/Client.ts

src/WrapperClient.ts

@@ -0,0 +1,105 @@
+/**
+ * Simple wrapper client that extends phenomlClient with username/password authentication.
+ * Generates token lazily on first API call when username/password are provided.
+ */
+
+import * as environments from "./environments.js";
+import * as core from "./core/index.js";
+import { phenomlClient } from "./Client.js";
+import { Auth } from "./api/resources/authtoken/resources/auth/client/Client.js";
+
+export declare namespace PhenoMLClient {
+    export interface Options {
+        environment?: core.Supplier<environments.phenomlEnvironment | string>;
+        baseUrl?: core.Supplier<string>;
+        username?: string;
+        password?: string;
+        token?: core.Supplier<core.BearerToken>;
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
+        fetcher?: core.FetchFunction;
+    }
+}
+
+// Create a token supplier that generates tokens on-demand
+class TokenSupplier {
+    private _tokenPromise?: Promise<string>;
+    private _cachedToken?: string;
+    private _username: string;
+    private _password: string;
+    private _baseUrl: string;
+    private _fetcher?: core.FetchFunction;
+
+    constructor(username: string, password: string, baseUrl: string, fetcher?: core.FetchFunction) {
+        this._username = username;
+        this._password = password;
+        this._baseUrl = baseUrl;
+        this._fetcher = fetcher;
+    }
+
+    async get(): Promise<string> {
+        if (this._cachedToken) {
+            return this._cachedToken;
+        }
+
+        if (this._tokenPromise) {
+            this._cachedToken = await this._tokenPromise;
+            return this._cachedToken;
+        }
+
+        this._tokenPromise = this._generateToken();
+        this._cachedToken = await this._tokenPromise;
+        return this._cachedToken;
+    }
+
+    private async _generateToken(): Promise<string> {
+        const authClient = new Auth({
+            baseUrl: this._baseUrl,
+            fetcher: this._fetcher,
+        });
+
+        const response = await authClient.generateToken({
+            username: this._username,
+            password: this._password,
+        });
+
+        return response.token;
+    }
+}
+
+export class PhenoMLClient extends phenomlClient {
+    constructor(options: PhenoMLClient.Options) {
+        // Validate auth options
+        if (!options.token && (!options.username || !options.password)) {
+            throw new Error("Must provide either 'token' or both 'username' and 'password'");
+        }
+
+        if (options.token && (options.username || options.password)) {
+            throw new Error("Cannot provide both 'token' and 'username'/'password'");
+        }
+
+        // If token provided, use directly
+        if (options.token) {
+            super(options as phenomlClient.Options);
+            return;
+        }
+
+        // Create lazy token supplier for username/password
+        const baseUrl = (typeof options.baseUrl === 'string' ? options.baseUrl : undefined) ||
+                       (typeof options.environment === 'string' ? options.environment : undefined) ||
+                       environments.phenomlEnvironment.Default;
+        
+        const tokenSupplier = new TokenSupplier(
+            options.username!,
+            options.password!,
+            baseUrl,
+            options.fetcher
+        );
+
+        super({
+            ...options,
+            token: tokenSupplier.get.bind(tokenSupplier) as core.Supplier<core.BearerToken>,
+            username: undefined,
+            password: undefined,
+        } as phenomlClient.Options);
+    }
+}

src/api/resources/authtoken/resources/auth/client/Client.ts

@@ -13,7 +13,6 @@ export declare namespace Auth {
         environment?: core.Supplier<environments.phenomlEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
         baseUrl?: core.Supplier<string>;
-        token: core.Supplier<core.BearerToken>;
         /** Additional headers to include in requests. */
         headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
         fetcher?: core.FetchFunction;
@@ -68,7 +67,7 @@ export class Auth {
     ): Promise<core.WithRawResponse<phenoml.authtoken.AuthGenerateTokenResponse>> {
         let _headers: core.Fetcher.Args["headers"] = mergeHeaders(
             this._options?.headers,
-            mergeOnlyDefinedHeaders({ Authorization: await this._getAuthorizationHeader() }),
+            mergeOnlyDefinedHeaders({ Authorization: await this._getAuthorizationHeader(request) }),
             requestOptions?.headers,
         );
         const _response = await (this._options.fetcher ?? core.fetcher)({
@@ -83,7 +82,6 @@ export class Auth {
             contentType: "application/json",
             queryParameters: requestOptions?.queryParams,
             requestType: "json",
-            body: request,
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             abortSignal: requestOptions?.abortSignal,
@@ -130,7 +128,21 @@ export class Auth {
         }
     }
 
-    protected async _getAuthorizationHeader(): Promise<string> {
-        return `Bearer ${await core.Supplier.get(this._options.token)}`;
+    protected async _getAuthorizationHeader(request?: phenoml.authtoken.AuthGenerateTokenRequest): Promise<string> {
+        // Auth token endpoint only uses basic auth with username/password
+        if (!request?.username || !request?.password) {
+            throw new Error("Must provide both 'username' and 'password'");
+        }
+
+        const basicAuthHeader = core.BasicAuth.toAuthorizationHeader({
+            username: request.username,
+            password: request.password
+        });
+        
+        if (!basicAuthHeader) {
+            throw new Error("Failed to create basic auth header from username/password");
+        }
+        
+        return basicAuthHeader;
     }
 }

src/index.ts

@@ -1,4 +1,4 @@
 export * as phenoml from "./api/index.js";
 export { phenomlError, phenomlTimeoutError } from "./errors/index.js";
-export { phenomlClient } from "./Client.js";
+export { PhenoMLClient } from "./WrapperClient.js";
 export { phenomlEnvironment } from "./environments.js";