@mherod/get-cookie 2.1.1 → 2.1.2

package/src/fetchWithCookies.ts

@@ -2,28 +2,53 @@
 
 import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
-// noinspection SpellCheckingInspection
 import destr from "destr";
-import { parsedArgs } from "./argv";
 import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
 import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
 import CookieSpec from "./CookieSpec";
-import consola from "consola";
 
 if (typeof fetchImpl !== "function") {
   throw new Error("fetch is not a function");
 }
 
-function constructUserAgent(
-  platform = "Macintosh; Intel Mac OS X 10_15_7",
-  engine = "AppleWebKit/537.36 (KHTML, like Gecko)",
-  browser = "Chrome/118.0.0.0",
-  layout = "Safari/537.36",
-): string {
-  return [platform, engine, browser, layout].join(" ");
+/**
+ * Class to build a User-Agent string.
+ */
+class UserAgentBuilder {
+  private platform: string;
+  private engine: string;
+  private browser: string;
+  private layout: string;
+
+  /**
+   * Constructs a UserAgentBuilder instance.
+   * @param platform - The platform information.
+   * @param engine - The engine information.
+   * @param browser - The browser information.
+   * @param layout - The layout information.
+   */
+  constructor(
+    platform: string = "Macintosh; Intel Mac OS X 10_15_7",
+    engine: string = "AppleWebKit/537.36 (KHTML, like Gecko)",
+    browser: string = "Chrome/118.0.0.0",
+    layout: string = "Safari/537.36",
+  ) {
+    this.platform = platform;
+    this.engine = engine;
+    this.browser = browser;
+    this.layout = layout;
+  }
+
+  /**
+   * Builds the User-Agent string.
+   * @returns The User-Agent string.
+   */
+  build(): string {
+    return `${this.platform} ${this.engine} ${this.browser} ${this.layout}`;
+  }
 }
 
-const userAgent = constructUserAgent();
+const userAgent: string = new UserAgentBuilder().build();
 
 interface FetchRequestInit {
   url: RequestInfo | URL | string;
@@ -34,156 +59,159 @@ export type FetchFn =
   | typeof fetchImpl
   | ((url: URL, options?: RequestInit) => Promise<Response>);
 
-export async function fetchWithCookies(
-  url: RequestInfo | URL | string,
-  options: RequestInit | undefined = {},
-  fetch: FetchFn = fetchImpl as FetchFn,
-  originalRequest?: FetchRequestInit,
-): Promise<Response> {
-  if (typeof fetch !== "function") {
-    const message = "fetch is not a function";
-    consola.error(message);
-    throw new Error(message);
-  }
-  const originalRequest1 = originalRequest || { url, options };
-  const headers: HeadersInit = {
-    "User-Agent": userAgent,
-  };
-  const defaultOptions: RequestInit = {
-    headers,
-    redirect: "manual",
-  };
-  const url2: string = `${url}`;
-  const url1: URL = new URL(url2);
-  consola.start("fetchWithCookies", url2);
-  const cookieSpecs: CookieSpec[] = cookieSpecsFromUrl(url1);
-  const renderedCookie = await getMergedRenderedCookies(cookieSpecs).catch(
-    (err) => {
-      consola.error(err);
-      return "";
-    },
-  );
-  if (renderedCookie) {
-    headers["Cookie"] = renderedCookie;
-  } else {
-    consola.info("No cookies found for this request");
-  }
-  if (parsedArgs["dump-request-headers"]) {
-    consola.info("Request URL:", url1.href);
-    consola.info("Request headers:", headers);
-  }
-  const newOptions1: RequestInit = merge(defaultOptions, { headers }, options);
-  try {
-    const res: Response = await fetch(url1, newOptions1);
-    // noinspection JSMismatchedCollectionQueryUpdate
-    const headers: [string, string][] = [];
-    res.headers.forEach((value, key) => {
-      headers.push([key, value]);
-    });
-    // for (const [key, value] of headers) {
-    //   if (key === "set-cookie") {
-    //     const cookieJar1 = await cookieJarPromise;
-    //     await cookieJar1.setCookie(value, url2);
-    //     if (parsedArgs.verbose) {
-    //       console.log(blue(`Set-Cookie:`), yellow(value), yellow(url2));
-    //     }
-    //   }
-    // }
+/**
+ * Class to handle fetch requests with cookies.
+ */
+class FetchWithCookies {
+  private fetch: FetchFn;
+  private userAgent: string;
 
-    const newUrl: string = res.headers.get("location") ?? res.url;
-    // const sameHost = new URL(newUrl).host === url1.host;
-    if (res.status == 301 || res.status == 302) {
-      // follow the redirect
-      if (newUrl && newUrl !== url2) {
-        if (parsedArgs.verbose || parsedArgs["dump-response-headers"]) {
-          consola.info(`Redirected to `, newUrl);
-        }
-        return fetchWithCookies(
-          //
-          newUrl,
-          newOptions1,
-          fetch,
-          originalRequest1,
-          //
-        );
-      }
-    }
-    if (res.status == 303 && newUrl && newUrl !== url2) {
-      // follow the redirect with GET
-      let newOptions2: RequestInit = {};
-      switch (newOptions1.method) {
-        case "POST":
-        case "PUT":
-        case "DELETE":
-          merge(newOptions2, newOptions1, { method: "GET" });
-          newOptions2.body = undefined; // TODO: is this needed?
-          break;
-        case "HEAD":
-        case "GET":
-          merge(newOptions2, newOptions1);
-          newOptions2.body = undefined; // TODO: is this needed?
-          break;
-        default:
-          merge(newOptions2, newOptions1);
-          break;
-      }
-      if (parsedArgs.verbose) {
-        console.log(`Redirected to `, newUrl);
-      }
-      return fetchWithCookies(
-        //
-        newUrl,
-        newOptions2,
-        fetch,
-        originalRequest1,
-        //
-      );
+  /**
+   * Constructs a FetchWithCookies instance.
+   * @param fetch - The fetch function to use.
+   * @param userAgent - The User-Agent string to use.
+   */
+  constructor(fetch: FetchFn, userAgent: string) {
+    if (typeof fetch !== "function") {
+      throw new Error("fetch is not a function");
     }
+    this.fetch = fetch;
+    this.userAgent = userAgent;
+  }
 
-    // all deserialize functions will use the arraybuffer
-    const arrayBufferPromise: Promise<ArrayBuffer> = res.arrayBuffer();
-    const bufferPromise = arrayBufferPromise.then(Buffer.from);
+  /**
+   * Gets the headers for a given URL.
+   * @param url - The URL to get headers for.
+   * @returns A promise that resolves to the headers.
+   */
+  private async getHeaders(url: URL): Promise<HeadersInit> {
+    const headers: HeadersInit = { "User-Agent": this.userAgent };
+    const cookieSpecs: CookieSpec[] = cookieSpecsFromUrl(url);
+    const renderedCookie: string = await getMergedRenderedCookies(
+      cookieSpecs,
+    ).catch(() => "");
 
-    async function arrayBuffer(): Promise<ArrayBuffer> {
-      return arrayBufferPromise;
+    if (renderedCookie) {
+      headers["Cookie"] = renderedCookie;
     }
 
-    async function buffer(): Promise<Buffer> {
-      return bufferPromise;
-    }
+    return headers;
+  }
+
+  /**
+   * Handles redirects for a given response.
+   * @param res - The response to handle redirects for.
+   * @param url - The original URL.
+   * @param options - The request options.
+   * @param originalRequest - The original request information.
+   * @returns A promise that resolves to the final response.
+   */
+  private async handleRedirects(
+    res: Response,
+    url: URL,
+    options: RequestInit,
+    originalRequest: FetchRequestInit,
+  ): Promise<Response> {
+    const newUrl: string = res.headers.get("location") ?? res.url;
 
-    async function text(): Promise<string> {
-      const buffer1 = await bufferPromise;
-      return buffer1.toString("utf8");
+    if (
+      [301, 302].includes(res.status) &&
+      newUrl &&
+      newUrl !== url.toString()
+    ) {
+      return this.fetchWithCookies(newUrl, options, originalRequest);
     }
 
-    async function json(): Promise<any> {
-      const text1 = await text();
-      return destr(text1);
+    if (res.status === 303 && newUrl && newUrl !== url.toString()) {
+      const newOptions: RequestInit = {
+        ...options,
+        method: "GET",
+        body: undefined,
+      };
+      return this.fetchWithCookies(newUrl, newOptions, originalRequest);
     }
 
-    async function formData(): Promise<FormData> {
-      const urlSearchParams: URLSearchParams = await text().then(
-        (text) => new URLSearchParams(text),
+    return res;
+  }
+
+  /**
+   * Enhances the response with additional methods.
+   * @param res - The response to enhance.
+   * @returns A promise that resolves to the enhanced response.
+   */
+  private async enhanceResponse(res: Response): Promise<Response> {
+    const originalArrayBuffer: ArrayBuffer = await res.arrayBuffer();
+    const originalBuffer: Buffer = Buffer.from(originalArrayBuffer);
+    const originalText: string = originalBuffer.toString("utf8");
+
+    const arrayBuffer = async (): Promise<ArrayBuffer> => originalArrayBuffer;
+    const buffer = async (): Promise<Buffer> => originalBuffer;
+    const text = async (): Promise<string> => originalText;
+    const json = async (): Promise<any> => destr(originalText);
+    const formData = async (): Promise<FormData> => {
+      const urlSearchParams: URLSearchParams = new URLSearchParams(
+        originalText,
       );
-      const formData = new FormData();
+      const formData: FormData = new FormData();
       for (const [key, value] of urlSearchParams.entries()) {
         formData.append(key, value);
       }
       return formData;
-    }
+    };
 
-    const res1: Response = res;
-    const source2 = {
-      arrayBuffer,
-      text,
-      json,
-      buffer,
-      formData,
-      //
+    return merge(res, { arrayBuffer, text, json, buffer, formData });
+  }
+
+  /**
+   * Fetches a URL with cookies.
+   * @param url - The URL to fetch.
+   * @param options - The request options.
+   * @param originalRequest - The original request information.
+   * @returns A promise that resolves to the response.
+   */
+  public async fetchWithCookies(
+    url: RequestInfo | URL | string,
+    options: RequestInit | undefined = {},
+    originalRequest?: FetchRequestInit,
+  ): Promise<Response> {
+    const originalRequest1: FetchRequestInit = originalRequest || {
+      url,
+      options,
     };
-    return merge(res1, source2);
-  } catch (e) {
-    throw e;
+    const url1: URL = new URL(`${url}`);
+    const headers: HeadersInit = await this.getHeaders(url1);
+    const defaultOptions: RequestInit = { headers, redirect: "manual" };
+    const newOptions: RequestInit = merge(defaultOptions, { headers }, options);
+
+    try {
+      const res: Response = await this.fetch(url1, newOptions);
+      const redirectedRes: Response = await this.handleRedirects(
+        res,
+        url1,
+        newOptions,
+        originalRequest1,
+      );
+      return this.enhanceResponse(redirectedRes);
+    } catch (e) {
+      throw e;
+    }
   }
 }
+
+/**
+ * Fetches a URL with cookies.
+ * @param url - The URL to fetch.
+ * @param options - The request options.
+ * @param fetch - The fetch function to use.
+ * @param originalRequest - The original request information.
+ * @returns A promise that resolves to the response.
+ */
+export async function fetchWithCookies(
+  url: RequestInfo | URL | string,
+  options: RequestInit | undefined = {},
+  fetch: FetchFn = fetchImpl as FetchFn,
+  originalRequest?: FetchRequestInit,
+): Promise<Response> {
+  const fetcher = new FetchWithCookies(fetch, userAgent);
+  return fetcher.fetchWithCookies(url, options, originalRequest);
+}

package/src/findAllFiles.ts

@@ -9,6 +9,16 @@ type FindFilesOptions = {
   maxDepth?: number;
 };
 
+/**
+ * Finds all files matching the specified name within a given path and depth.
+ *
+ * @param {FindFilesOptions} options - The options for finding files.
+ * @param {string} options.path - The path to search within.
+ * @param {string} options.name - The name of the files to search for.
+ * @param {number} [options.maxDepth=2] - The maximum depth to search within.
+ * @returns {string[]} An array of file paths that match the search criteria.
+ * @throws Will throw an error if the specified path does not exist.
+ */
 export function findAllFiles({
   path,
   name,

package/src/getChromeCookie.ts

@@ -7,15 +7,13 @@ import { isExportedCookie } from "./ExportedCookie";
 export async function getChromeCookie(
   params: CookieSpec,
 ): Promise<ExportedCookie | undefined> {
-  const cookies = await queryCookies(
-    params,
-    {
-      strategy: new ChromeCookieQueryStrategy(),
-    },
-    //
-  );
-  if (cookies.length == 0) {
+  const cookies: ExportedCookie[] = await queryCookies(params, {
+    strategy: new ChromeCookieQueryStrategy(),
+  });
+
+  if (cookies.length === 0) {
     throw new Error("Cookie not found");
   }
+
   return cookies.find(isExportedCookie);
 }

package/src/getCookie.ts

@@ -3,20 +3,20 @@ import ExportedCookie from "./ExportedCookie";
 import { queryCookies } from "./queryCookies";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 
+const queryStrategy: CompositeCookieQueryStrategy =
+  new CompositeCookieQueryStrategy();
+
 export async function getCookie(
   params: CookieSpec,
 ): Promise<ExportedCookie | undefined> {
-  //
-  const cookies: ExportedCookie[] = await queryCookies(
-    params,
-    {
-      strategy: new CompositeCookieQueryStrategy(),
-    },
-    //
-  );
+  const cookies: ExportedCookie[] = await queryCookies(params, {
+    strategy: queryStrategy,
+  });
   if (Array.isArray(cookies) && cookies.length > 0) {
     return cookies.find((cookie) => cookie != null);
   } else {
     throw new Error("Cookie not found");
   }
 }
+
+export default getCookie;

package/src/getFirefoxCookie.ts

@@ -6,16 +6,20 @@ import FirefoxCookieQueryStrategy from "./browsers/firefox/FirefoxCookieQueryStr
 export async function getFirefoxCookie(
   params: CookieSpec,
 ): Promise<ExportedCookie | undefined> {
-  const cookies: ExportedCookie[] = await queryCookies(
-    params,
-    {
-      strategy: new FirefoxCookieQueryStrategy(),
-    },
-    //
+  const cookies: ExportedCookie[] = await queryCookies(params, {
+    strategy: new FirefoxCookieQueryStrategy(),
+  });
+
+  if (!Array.isArray(cookies) || cookies.length === 0) {
+    throw new Error("Cookie not found");
+  }
+
+  const validCookie: ExportedCookie | undefined = cookies.find(
+    (cookie) => cookie != null,
   );
-  if (Array.isArray(cookies) && cookies.length > 0) {
-    return cookies.find((cookie) => cookie != null);
-  } else {
+  if (!validCookie) {
     throw new Error("Cookie not found");
   }
+
+  return validCookie;
 }

package/src/getGroupedRenderedCookies.ts

@@ -7,13 +7,36 @@ import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
 export async function getGroupedRenderedCookies(
   cookieSpec: MultiCookieSpec,
 ): Promise<string[]> {
+  const cookies: ExportedCookie[] = await fetchCookies(cookieSpec);
+  const groupedByFile = groupCookiesByFile(cookies);
+  return renderGroupedCookies(groupedByFile);
+}
+
+async function fetchCookies(
+  cookieSpec: MultiCookieSpec,
+): Promise<ExportedCookie[]> {
   const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
-  if (cookies.length == 0) {
+  if (cookies.length === 0) {
     throw new Error("Cookie not found");
   }
-  const groupedByFile = groupBy(cookies, (r: ExportedCookie) => r.meta?.file);
-  return Object.keys(groupedByFile).map((file: string) => {
-    const results: ExportedCookie[] = groupedByFile[file];
-    return resultsRendered(results);
-  });
+  return cookies;
+}
+
+function groupCookiesByFile(
+  cookies: ExportedCookie[],
+): Record<string, ExportedCookie[]> {
+  return groupBy(cookies, (r: ExportedCookie) => r.meta?.file);
+}
+
+function renderGroupedCookies(
+  groupedByFile: Record<string, ExportedCookie[]>,
+): string[] {
+  const renderedResults: string[] = [];
+  for (const file in groupedByFile) {
+    if (groupedByFile.hasOwnProperty(file)) {
+      const results: ExportedCookie[] = groupedByFile[file];
+      renderedResults.push(resultsRendered(results));
+    }
+  }
+  return renderedResults;
 }

package/src/getMergedRenderedCookies.ts

@@ -2,7 +2,6 @@ import { resultsRendered } from "./resultsRendered";
 import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
 import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
-import consola from "consola";
 import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 
@@ -13,5 +12,8 @@ export async function getMergedRenderedCookies(
   const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec, {
     strategy,
   });
-  return cookies.length > 0 ? resultsRendered(cookies) : "";
+  if (cookies.length > 0) {
+    return resultsRendered(cookies);
+  }
+  return "";
 }

package/src/global.ts

@@ -1,8 +1,8 @@
 import { merge } from "lodash";
 
-export const env: any = {};
+export const env: { [key: string]: string | undefined } = {};
 merge(env, process?.env ?? {});
-export const HOME: string = env["HOME"];
+export const HOME: string | undefined = env["HOME"];
 if (!HOME) {
   throw new Error("HOME environment variable is not set");
 }

package/src/index.ts

@@ -1,9 +1,19 @@
-import { getCookie } from "./getCookie";
-import { getChromeCookie } from "./getChromeCookie";
-import { getFirefoxCookie } from "./getFirefoxCookie";
-import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
-import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
-import { fetchWithCookies } from "./fetchWithCookies";
+const getCookie = () =>
+  import("./getCookie").then((module) => module.getCookie);
+const getChromeCookie = () =>
+  import("./getChromeCookie").then((module) => module.getChromeCookie);
+const getFirefoxCookie = () =>
+  import("./getFirefoxCookie").then((module) => module.getFirefoxCookie);
+const getGroupedRenderedCookies = () =>
+  import("./getGroupedRenderedCookies").then(
+    (module) => module.getGroupedRenderedCookies,
+  );
+const getMergedRenderedCookies = () =>
+  import("./getMergedRenderedCookies").then(
+    (module) => module.getMergedRenderedCookies,
+  );
+const fetchWithCookies = () =>
+  import("./fetchWithCookies").then((module) => module.fetchWithCookies);
 
 export {
   getCookie,

package/src/isValidJwt.ts

@@ -1,17 +1,19 @@
 import jsonwebtoken, { JwtPayload } from "jsonwebtoken";
 import { parsedArgs } from "./argv";
 
-export default function isValidJwt(token: string) {
+export default function isValidJwt(token: string): boolean {
   try {
     const result = jsonwebtoken.decode(token, { complete: true });
     if (parsedArgs.verbose && result) {
       console.debug(result);
     }
-    const payload: JwtPayload = result?.payload as JwtPayload;
+    const payload: JwtPayload | undefined = result?.payload as
+      | JwtPayload
+      | undefined;
     if (payload) {
-      const exp = payload.exp;
+      const exp: number | undefined = payload.exp;
       if (exp) {
-        const now = new Date().getTime() / 1000;
+        const now: number = new Date().getTime() / 1000;
         if (now > exp) {
           return false;
         }

package/src/listChromeProfiles.ts

@@ -2,27 +2,35 @@ import { sync } from "fast-glob";
 import { chromeApplicationSupport } from "./browsers/chrome/ChromeApplicationSupport";
 import { dirname } from "path";
 import { readFile } from "fs/promises";
-import { flatMapAsync } from "./util/flatMapAsync";
 import destr from "destr";
 
 export async function listChromeProfilePaths(): Promise<string[]> {
-  return sync(`./**/Cookies`, {
+  const files: string[] = sync(`./**/Cookies`, {
     cwd: chromeApplicationSupport,
     absolute: true,
     onlyFiles: true,
     deep: 2,
-  }).map((f) => {
-    // parent dir
-    return dirname(f);
   });
+
+  const directories: string[] = [];
+  for (const file of files) {
+    directories.push(dirname(file));
+  }
+
+  return directories;
 }
 
 export async function listChromeProfiles(): Promise<ChromeProfile[]> {
-  const paths = await listChromeProfilePaths();
-  return await flatMapAsync(paths, async (p) => {
-    const content = await readFile(`${p}/Preferences`, "utf-8");
-    return await destr(content);
-  });
+  const paths: string[] = await listChromeProfilePaths();
+  const profiles: ChromeProfile[] = [];
+
+  for (const path of paths) {
+    const content: string = await readFile(`${path}/Preferences`, "utf-8");
+    const profile: ChromeProfile = await destr(content);
+    profiles.push(profile);
+  }
+
+  return profiles;
 }
 
 export type ChromeProfileAccountInfo = {

package/src/logger.ts

@@ -8,6 +8,5 @@ const consola = createConsola({
     date: false,
   },
 });
-consola.wrapConsole();
 
 export default consola;

package/src/processBeforeReturn.ts

@@ -7,20 +7,23 @@ export function processBeforeReturn<T extends CookieQueryStrategy>(
   cookies: ExportedCookie[],
   options?: CookieQueryOptions<T>,
 ): ExportedCookie[] {
-  if (options?.removeExpired) {
-    return cookies.filter((c: ExportedCookie) => {
+  let processedCookies: ExportedCookie[] = cookies;
+
+  if (options && options.removeExpired) {
+    const now: number = Date.now();
+    processedCookies = processedCookies.filter((c: ExportedCookie) => {
       const expiry: Date | "Infinity" | undefined = c.expiry;
-      if (expiry === undefined) {
-        return true;
-      } else if (expiry === "Infinity") {
-        return true;
-      } else {
-        return expiry.getTime() > Date.now();
-      }
+      return (
+        expiry === undefined || expiry === "Infinity" || expiry.getTime() > now
+      );
     });
   }
-  if (options?.limit) {
-    return cookies.slice(0, options.limit);
+
+  if (options && options.limit) {
+    processedCookies = processedCookies.slice(0, options.limit);
   }
-  return uniqBy(cookies, JSON.stringify);
+
+  return uniqBy(processedCookies, (cookie: ExportedCookie) =>
+    JSON.stringify(cookie),
+  );
 }