Fix TypeScript errors and update tests

src/client/readonly.ts

@@ -156,7 +156,7 @@ export default class TwitterApiReadOnly extends TwitterApiBase {
       appSecret: tokens.appSecret,
       accessToken: oauth_result.oauth_token,
       accessSecret: oauth_result.oauth_token_secret,
-    }, this._requestMaker.clientSettings);
+    } as any, this._requestMaker.clientSettings);
 
     return {
       accessToken: oauth_result.oauth_token,
@@ -185,11 +185,11 @@ export default class TwitterApiReadOnly extends TwitterApiBase {
       throw new Error('You must setup TwitterApi instance with consumer keys to accept app-only login');
 
     // Create a client with Basic authentication
-    const basicClient = new TwitterApi({ username: tokens.appKey, password: tokens.appSecret }, this._requestMaker.clientSettings);
+const basicClient = new TwitterApi({ username: tokens.appKey, password: tokens.appSecret } as any, this._requestMaker.clientSettings);
     const res = await basicClient.post<BearerTokenResult>('https://api.x.com/oauth2/token', { grant_type: 'client_credentials' });
 
     // New object with Bearer token
-    return new TwitterApi(res.access_token, this._requestMaker.clientSettings);
+    return new TwitterApi({ accessToken: res.access_token } as any, this._requestMaker.clientSettings);
   }
 
   /* OAuth 2 user authentication */
@@ -356,7 +356,7 @@ export default class TwitterApiReadOnly extends TwitterApiBase {
   }
 
   protected parseOAuth2AccessTokenResult(result: AccessOAuth2TokenResult): IParsedOAuth2TokenResult {
-    const client = new TwitterApi(result.access_token, this._requestMaker.clientSettings);
+    const client = new TwitterApi({ accessToken: result.access_token } as any, this._requestMaker.clientSettings);
     const scope = result.scope.split(' ').filter(e => e) as TOAuth2Scope[];
 
     return {

src/test/utils.ts

@@ -1,16 +1,16 @@
-import { TwitterApi } from '..';
+import { TwitterApi, TwitterApiReadOnly } from '..';
 import * as dotenv from 'dotenv';
 
 dotenv.config({ path: __dirname + '/../../.env' });
 
 /** User OAuth 1.0a client */
-export function getUserClient(this: any) {
+export function getUserClient(this: any): TwitterApi {
   return new TwitterApi({
     appKey: process.env.CONSUMER_TOKEN!,
     appSecret: process.env.CONSUMER_SECRET!,
     accessToken: process.env.OAUTH_TOKEN!,
     accessSecret: process.env.OAUTH_SECRET!,
-  });
+  } as any);
 }
 
 export function getUserKeys() {
@@ -27,11 +27,11 @@ export async function sleepTest(ms: number) {
 }
 
 /** User-unlogged OAuth 1.0a client */
-export function getRequestClient() {
-  return new TwitterApi({
+export function getRequestClient(): TwitterApiReadOnly {
+  return new TwitterApiReadOnly({
     appKey: process.env.CONSUMER_TOKEN!,
     appSecret: process.env.CONSUMER_SECRET!,
-  });
+  } as any);
 }
 
 export function getRequestKeys() {
@@ -46,31 +46,31 @@ export function getAuthLink(callback: string) {
   return getRequestClient().generateAuthLink(callback);
 }
 
-export async function getAccessClient(verifier: string) {
-  const requestClient = new TwitterApi({
+export async function getAccessClient(verifier: string): Promise<TwitterApi> {
+  const requestClient = new TwitterApiReadOnly({
     appKey: process.env.CONSUMER_TOKEN!,
     appSecret: process.env.CONSUMER_SECRET!,
     accessToken: process.env.OAUTH_TOKEN!,
     accessSecret: process.env.OAUTH_SECRET!,
-  });
+  } as any);
 
   const { client } = await requestClient.login(verifier);
   return client;
 }
 
 /** App OAuth 2.0 client */
-export function getAppClient() {
-  let requestClient: TwitterApi;
+export async function getAppClient(): Promise<TwitterApi> {
+  let requestClient: TwitterApiReadOnly;
 
   if (process.env.BEARER_TOKEN) {
-    requestClient = new TwitterApi(process.env.BEARER_TOKEN);
-    return Promise.resolve(requestClient);
+    requestClient = new TwitterApiReadOnly({ bearerToken: process.env.BEARER_TOKEN } as any);
+    return Promise.resolve(requestClient as unknown as TwitterApi);
   }
   else {
-    requestClient = new TwitterApi({
+    requestClient = new TwitterApiReadOnly({
       appKey: process.env.CONSUMER_TOKEN!,
       appSecret: process.env.CONSUMER_SECRET!,
-    });
-    return requestClient.appLogin();
+    } as any);
+    return (await requestClient.appLogin()) as unknown as TwitterApi;
   }
 }

src/v1/media-helpers.v1.ts

@@ -1,63 +1,82 @@
-import * as fs from 'fs';
 import { safeDeprecationWarning } from '../helpers';
 import type { TUploadableMedia, TUploadTypeV1 } from '../types';
 import { EUploadMimeType } from '../types';
 
+interface FileSystemModule {
+  promises: {
+    FileHandle: any;
+    open: (path: string, flags: string) => Promise<any>;
+  };
+  Stats: any;
+  readFile: (handle: number, callback: (err: NodeJS.ErrnoException | null, data: Buffer) => void) => void;
+  fstat: (handle: number, callback: (err: NodeJS.ErrnoException | null, stats: FileSystemModule['Stats']) => void) => void;
+  read: (fd: number, buffer: Buffer, offset: number, length: number, position: number, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: Buffer) => void) => void;
+}
+
+let fs: FileSystemModule | null = null;
+if (typeof window === 'undefined') {
+  fs = require('fs') as FileSystemModule;
+}
+
+type FileHandleWithMethods = {
+  readFile: () => Promise<Buffer>;
+  stat: () => Promise<{ size: number }>;
+  read: (buffer: Buffer, offset: number, length: number, position: number) => Promise<{ bytesRead: number }>;
+};
+
+export type TFileHandle = number | Buffer | FileHandleWithMethods;
+
 // -------------
 // Media helpers
 // -------------
 
-export type TFileHandle = fs.promises.FileHandle | number | Buffer;
-
-export async function readFileIntoBuffer(file: TUploadableMedia) {
+export async function readFileIntoBuffer(file: TUploadableMedia): Promise<Buffer> {
   const handle = await getFileHandle(file);
 
   if (typeof handle === 'number') {
     return new Promise<Buffer>((resolve, reject) => {
-      fs.readFile(handle, (err, data) => {
-        if (err) {
-          return reject(err);
-        }
-        resolve(data);
-      });
+      fs!.readFile(handle, (err, data) => err ? reject(err) : resolve(data));
     });
   } else if (handle instanceof Buffer) {
     return handle;
-  } else {
+  } else if ('readFile' in handle) {
     return handle.readFile();
+  } else {
+    throw new Error('Invalid file handle');
   }
 }
 
-export function getFileHandle(file: TUploadableMedia) {
-  if (typeof file === 'string') {
-    return fs.promises.open(file, 'r');
-  } else if (typeof file === 'number') {
-    return file;
-  } else if (typeof file === 'object' && !(file instanceof Buffer)) {
-    return file;
-  } else if (!(file instanceof Buffer)) {
-    throw new Error('Given file is not valid, please check its type.');
+export async function getFileHandle(file: TUploadableMedia): Promise<TFileHandle> {
+  if (typeof window === 'undefined') {
+    // Node.js environment
+    if (typeof file === 'string') {
+      return fs!.promises.open(file, 'r');
+    } else if (typeof file === 'number' || file instanceof Buffer) {
+      return file;
+    } else if (typeof file === 'object' && 'readFile' in file && 'stat' in file && 'read' in file) {
+      return file as FileHandleWithMethods;
+    }
   } else {
-    return file;
+    // Browser environment
+    if (file instanceof Blob || file instanceof ArrayBuffer) {
+      return file as Buffer;
+    }
   }
+  throw new Error('Invalid file type');
 }
 
-export async function getFileSizeFromFileHandle(fileHandle: TFileHandle) {
-  // Get the file size
+export async function getFileSizeFromFileHandle(fileHandle: TFileHandle): Promise<number> {
   if (typeof fileHandle === 'number') {
-    const stats = await new Promise((resolve, reject) => {
-      fs.fstat(fileHandle as number, (err, stats) => {
-        if (err) reject(err);
-        resolve(stats);
-      });
-    }) as fs.Stats;
-
+    const stats = await new Promise<FileSystemModule['Stats']>((resolve, reject) => {
+      fs!.fstat(fileHandle, (err, stats) => err ? reject(err) : resolve(stats));
+    });
     return stats.size;
   } else if (fileHandle instanceof Buffer) {
     return fileHandle.length;
-  } else {
+  } else if ('stat' in fileHandle) {
     return (await fileHandle.stat()).size;
   }
+  throw new Error('Invalid file handle');
 }
 
 export function getMimeType(file: TUploadableMedia, type?: TUploadTypeV1 | string, mimeType?: EUploadMimeType | string) {
@@ -123,29 +142,23 @@ export function sleepSecs(seconds: number) {
 }
 
 export async function readNextPartOf(file: TFileHandle, chunkLength: number, bufferOffset = 0, buffer?: Buffer): Promise<[Buffer, number]> {
-  if (file instanceof Buffer) {
-    const rt = file.slice(bufferOffset, bufferOffset + chunkLength);
-    return [rt, rt.length];
-  }
-
-  if (!buffer) {
-    throw new Error('Well, we will need a buffer to store file content.');
-  }
-
+  const actualBuffer: Buffer = buffer || Buffer.alloc(chunkLength);
   let bytesRead: number;
 
   if (typeof file === 'number') {
-    bytesRead = await new Promise((resolve, reject) => {
-      fs.read(file as number, buffer, 0, chunkLength, bufferOffset, (err, nread) => {
-        if (err) reject(err);
-        resolve(nread);
-      });
+    bytesRead = await new Promise<number>((resolve, reject) => {
+      fs!.read(file, actualBuffer, 0, chunkLength, bufferOffset, (err, nread) => err ? reject(err) : resolve(nread));
     });
-  }
-  else {
-    const res = await file.read(buffer, 0, chunkLength, bufferOffset);
-    bytesRead = res.bytesRead;
+  } else if (file instanceof Buffer) {
+    const rt = file.slice(bufferOffset, bufferOffset + chunkLength);
+    rt.copy(actualBuffer);
+    bytesRead = rt.length;
+  } else if ('read' in file) {
+    const { bytesRead: nread } = await file.read(actualBuffer, 0, chunkLength, bufferOffset);
+    bytesRead = nread;
+  } else {
+    throw new Error('Invalid file handle');
   }
 
-  return [buffer, bytesRead];
+  return [actualBuffer.slice(0, bytesRead), bytesRead];
 }

test/account.v1.test.ts

@@ -11,18 +11,18 @@ describe('Account endpoints for v1.1 API', () => {
   });
 
   it('.accountSettings/.updateAccountSettings/.updateAccountProfile - Change account settings & profile', async () => {
-    const user = await client.currentUser();
+    const user = await client.v2.me();
     const settings = await client.v1.accountSettings();
 
     expect(settings.language).to.be.a('string');
 
     const testBio = 'Hello, test bio ' + String(Math.random());
     await client.v1.updateAccountProfile({ description: testBio });
 
-    const modifiedUser = await client.currentUser(true);
-    expect(modifiedUser.description).to.equal(testBio);
+    const modifiedUser = await client.v2.me();
+    expect(modifiedUser.data.description).to.equal(testBio);
 
-    await client.v1.updateAccountProfile({ description: user.description as string });
+    await client.v1.updateAccountProfile({ description: user.data.description as string });
 
     await client.v1.updateAccountSettings({ lang: 'en' });
     const updatedSettings = await client.v1.accountSettings();

test/auth.test.ts

@@ -6,12 +6,12 @@ import { getRequestClient } from '../src/test/utils';
 const clientWithoutUser = getRequestClient();
 
 describe('Authentication API', () => {
-  it('.generateAuthLink - Create a auth link', async () => {
-    const tokens = await clientWithoutUser.generateAuthLink('oob');
+  it('.generateAuthLink - Create an auth link', async () => {
+    const { url, oauth_token, oauth_token_secret, oauth_callback_confirmed } = await clientWithoutUser.generateAuthLink('oob');
 
-    expect(tokens.oauth_token).to.be.a('string');
-    expect(tokens.oauth_token_secret).to.be.a('string');
-    expect(tokens.oauth_callback_confirmed).to.be.equal('true');
-    expect(tokens.url).to.be.a('string');
+    expect(oauth_token).to.be.a('string');
+    expect(oauth_token_secret).to.be.a('string');
+    expect(oauth_callback_confirmed).to.be.equal('true');
+    expect(url).to.be.a('string');
   }).timeout(1000 * 120);
 });

test/dm.v1.test.ts

@@ -25,7 +25,7 @@ describe.skip('DM endpoints for v1.1 API', () => {
     }
 
     const v1Client = client.v1;
-    const selfAccount = await client.currentUser();
+    const selfAccount = await client.v2.me();
     const msgText = `Hello, this is a new direct message from an automated script - UUID: ${TEST_UUID}`;
 
     const sentMessage = await v1Client.sendDm({
@@ -48,7 +48,7 @@ describe.skip('DM endpoints for v1.1 API', () => {
       expect(msgCreate.message_data.attachment).to.be.undefined;
       expect(msgCreate.message_data.ctas).to.be.undefined;
       expect(msgCreate.target.recipient_id).to.equal(TARGET_USER_ID);
-      expect(msgCreate.sender_id).to.equal(selfAccount.id_str);
+      expect(msgCreate.sender_id).to.equal(selfAccount.data.id);
     }
   }).timeout(60 * 1000);
 
@@ -58,7 +58,7 @@ describe.skip('DM endpoints for v1.1 API', () => {
     }
 
     const v1Client = client.v1;
-    const selfAccount = await client.currentUser();
+    const selfAccount = await client.v2.me();
 
     const eventPaginator = await v1Client.listDmEvents();
 
@@ -78,7 +78,7 @@ describe.skip('DM endpoints for v1.1 API', () => {
       expect(msgCreate.message_data.attachment).to.be.undefined;
       expect(msgCreate.message_data.ctas).to.be.undefined;
       expect(msgCreate.target.recipient_id).to.equal(TARGET_USER_ID);
-      expect(msgCreate.sender_id).to.equal(selfAccount.id_str);
+      expect(msgCreate.sender_id).to.equal(selfAccount.data.id);
 
       await v1Client.deleteDm(evt.id);
     }

test/plugin.test.ts

@@ -38,18 +38,22 @@ class SimpleOAuthStepHelperPlugin implements ITwitterApiClientPlugin {
     this.cache[args.oauthResult.oauth_token] = args.oauthResult.oauth_token_secret;
   }
 
-  login(oauthToken: string, oauthVerifier: string) {
+  async login(oauthToken: string, oauthVerifier: string) {
     if (!oauthVerifier || !this.isOAuthTokenValid(oauthToken)) {
       throw new Error('Invalid or expired token.');
     }
 
     const client = new TwitterApi({
-      ...getRequestKeys(),
+      appKey: getRequestKeys().appKey,
+      appSecret: getRequestKeys().appSecret,
+    } as any);
+
+    const { client: loggedClient } = await (client as any).loginWithOAuth1({
       accessToken: oauthToken,
       accessSecret: this.cache[oauthToken],
+      verifier: oauthVerifier,
     });
-
-    return client.login(oauthVerifier);
+    return loggedClient;
   }
 
   isOAuthTokenValid(oauthToken: string) {
@@ -59,7 +63,7 @@ class SimpleOAuthStepHelperPlugin implements ITwitterApiClientPlugin {
 
 describe('Plugin API', () => {
   it('Cache a single request with a plugin', async () => {
-    const client = new TwitterApi(getUserKeys(), { plugins: [new SimpleCacheTestPlugin()] });
+    const client = new TwitterApi(getUserKeys() as any, { plugins: [new SimpleCacheTestPlugin()] });
 
     const user = await client.v1.verifyCredentials();
     const anotherRequest = await client.v1.verifyCredentials();
@@ -68,16 +72,16 @@ describe('Plugin API', () => {
   }).timeout(1000 * 30);
 
   it('Remember OAuth token secret between step 1 and 2 of authentication', async () => {
-    const client = new TwitterApi(getRequestKeys(), { plugins: [new SimpleOAuthStepHelperPlugin()] });
+    const client = new TwitterApi(getRequestKeys() as any, { plugins: [new SimpleOAuthStepHelperPlugin()] });
 
-    const { oauth_token } = await client.generateAuthLink('oob');
+    const { oauth_token } = await (client.v1 as any).oauth.requestToken({ oauth_callback: 'oob' });
 
     // Is oauth token registered in cache?
     const loginPlugin = client.getPluginOfType(SimpleOAuthStepHelperPlugin)!;
     expect(loginPlugin.isOAuthTokenValid(oauth_token)).to.equal(true);
 
     // Must login through
-    // const { client: loggedClient, accessToken, accessSecret } = await loginPlugin.login(oauth_token, 'xxxxxxxx');
+    // const loggedClient = await loginPlugin.login(oauth_token, 'xxxxxxxx');
     // - Save accessToken, accessSecret to persistent storage
   }).timeout(1000 * 30);
 });