@mherod/get-cookie 2.1.3 → 4.0.2

package/src/comboQueryCookieSpec.test.ts

@@ -1,92 +0,0 @@
-import { MultiCookieSpec } from "./CookieSpec";
-import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
-import MockCookieQueryStrategy from "./browsers/mock/MockCookieQueryStrategy";
-import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
-import { CookieQueryOptions } from "./cookieQueryOptions";
-
-describe("comboQueryCookieSpec", () => {
-  let cookieSpec: MultiCookieSpec;
-  let options: CookieQueryOptions<CookieQueryStrategy>;
-
-  beforeEach(() => {
-    cookieSpec = {
-      domain: "example.com",
-      name: "test",
-    };
-    options = {
-      strategy: new MockCookieQueryStrategy([
-        // mock available cookies here
-        {
-          name: "test",
-          value: "test",
-          domain: "example.com",
-          expiry: "Infinity",
-        },
-      ]),
-      limit: 10,
-      removeExpired: true,
-    };
-  });
-
-  it("should return an array of cookies", async () => {
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result).toBeInstanceOf(Array);
-  });
-
-  it("should limit the number of cookies returned", async () => {
-    options.limit = 5;
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result.length).toBeLessThanOrEqual(5);
-  });
-
-  it("should return cookies with the correct domain", async () => {
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result[0].domain).toBe("example.com");
-  });
-
-  it("should return cookies with the correct name", async () => {
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result[0].name).toBe("test");
-  });
-
-  it("should return cookies with the correct value", async () => {
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result[0].value).toBe("test");
-  });
-
-  it("should return cookies with the correct expiry", async () => {
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result[0].expiry).toBe("Infinity");
-  });
-
-  it("should return cookies with the correct meta", async () => {
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result[0].meta).toBeUndefined();
-  });
-
-  it("should return cookies when limit is undefined", async () => {
-    options.limit = undefined;
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result.length).toBe(1);
-  });
-
-  it("should return cookies when removeExpired is false", async () => {
-    options.removeExpired = false;
-    const result = await comboQueryCookieSpec(cookieSpec, options);
-    expect(result.length).toBe(1);
-  });
-
-  // it('should not return cookies when removeExpired is true and expiry is past', async () => {
-  //     options.removeExpired = true;
-  //     cookieSpec.expiry = new Date('2000-01-01');
-  //     const result = await comboQueryCookieSpec(cookieSpec, options);
-  //     expect(result.length).toBe(0);
-  // });
-
-  // it('should return cookies when removeExpired is true and expiry is future', async () => {
-  //     options.removeExpired = true;
-  //     cookieSpec.expiry = new Date('3000-01-01');
-  //     const result = await comboQueryCookieSpec(cookieSpec, options);
-  //     expect(result.length).toBe(1);
-  // });
-});

package/src/comboQueryCookieSpec.ts

@@ -1,26 +0,0 @@
-import CookieSpec, { MultiCookieSpec } from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
-import { queryCookies } from "./queryCookies";
-import { flatMapAsync } from "./util";
-import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
-import { CookieQueryOptions, mergedWithDefaults } from "./cookieQueryOptions";
-import { processBeforeReturn } from "./processBeforeReturn";
-
-export async function comboQueryCookieSpec(
-  cookieSpec: MultiCookieSpec,
-  options?: CookieQueryOptions<CookieQueryStrategy>,
-): Promise<ExportedCookie[]> {
-  const optsWithDefaults: CookieQueryOptions<CookieQueryStrategy> =
-    mergedWithDefaults(options);
-  const queryFn = async (cs: CookieSpec): Promise<ExportedCookie[]> =>
-    queryCookies(cs, optsWithDefaults);
-
-  let cookies: ExportedCookie[];
-  if (Array.isArray(cookieSpec)) {
-    cookies = await flatMapAsync(cookieSpec, queryFn);
-  } else {
-    cookies = await queryFn(cookieSpec);
-  }
-
-  return processBeforeReturn(cookies, options);
-}

package/src/cookieQueryOptions.ts

@@ -1,27 +0,0 @@
-import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import { merge } from "lodash";
-
-export type CookieQueryOptions<T extends CookieQueryStrategy> = {
-  strategy?: T;
-  limit?: number;
-  removeExpired?: boolean;
-};
-
-export const defaultCookieQueryOptions: CookieQueryOptions<CookieQueryStrategy> =
-  {
-    strategy: new CompositeCookieQueryStrategy(),
-    limit: undefined,
-    removeExpired: undefined,
-  };
-
-export function mergedWithDefaults<T extends CookieQueryStrategy>(
-  options?: CookieQueryOptions<T>,
-): CookieQueryOptions<T> {
-  const mergedOptions: CookieQueryOptions<T> = merge(
-    {},
-    defaultCookieQueryOptions,
-    options,
-  );
-  return mergedOptions;
-}

package/src/cookieSpecsFromUrl.test.ts

@@ -1,65 +0,0 @@
-import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
-import { isCookieSpec } from "./CookieSpec";
-import { uniqBy } from "lodash";
-
-describe("cookieSpecsFromUrl", () => {
-  it("should return an array of cookie specs", () => {
-    const url = "https://example.com/";
-    const result = cookieSpecsFromUrl(url);
-    expect(result).toBeInstanceOf(Array);
-    expect(isCookieSpec(result[0])).toBe(true);
-  });
-
-  it("should handle string URLs", () => {
-    const url = "https://example.com/";
-    const result = cookieSpecsFromUrl(url);
-    expect(result[0].domain).toContain("example.com");
-  });
-
-  it("should handle URL objects", () => {
-    const url = new URL("https://example.com/");
-    const result = cookieSpecsFromUrl(url);
-    expect(result[0].domain).toContain("example.com");
-  });
-
-  it("should handle empty string URL", () => {
-    const url = "";
-    const result = cookieSpecsFromUrl(url);
-    expect(result).toEqual([]);
-  });
-
-  it("should handle invalid URL", () => {
-    const url = "invalid_url";
-    try {
-      const result = cookieSpecsFromUrl(url);
-    } catch (error: any) {
-      expect(error.message).toContain("Invalid URL");
-    }
-  });
-
-  it("should return unique cookie specs", () => {
-    const url = "https://example.com/";
-    const result = cookieSpecsFromUrl(url);
-    const uniqueResults = uniqBy(result, JSON.stringify);
-    expect(result.length).toEqual(uniqueResults.length);
-  });
-
-  it("should return correct cookie specs for URL with subdomain", () => {
-    const url = "https://sub.example.com/";
-    const result = cookieSpecsFromUrl(url);
-    expect(result).toContainEqual({ name: "%", domain: "sub.example.com" });
-    expect(result).toContainEqual({ name: "%", domain: "%.example.com" });
-    expect(result).toContainEqual({ name: "%", domain: "example.com" });
-  });
-
-  it("should return correct cookie specs for URL with multiple subdomains", () => {
-    const url = "https://sub.sub2.example.com/";
-    const result = cookieSpecsFromUrl(url);
-    expect(result).toContainEqual({
-      name: "%",
-      domain: "sub.sub2.example.com",
-    });
-    expect(result).toContainEqual({ name: "%", domain: "%.example.com" });
-    expect(result).toContainEqual({ name: "%", domain: "example.com" });
-  });
-});

package/src/cookieSpecsFromUrl.ts

@@ -1,73 +0,0 @@
-import CookieSpec from "./CookieSpec";
-import { uniqBy } from "lodash";
-
-/**
- * Generates a list of cookie specifications from a given URL.
- * Each cookie spec consists of a domain and a name, where the name is a wildcard.
- * The domain is formatted to enable querying against the cookie store for matching cookies.
- * @param url - The URL to generate cookie specs from.
- * @returns An array of unique cookie specifications.
- */
-export function cookieSpecsFromUrl(url: URL | string): CookieSpec[] {
-  if (!url || url === "") {
-    return [];
-  }
-
-  const urlObj: URL = parseUrl(url);
-  const hostnameParts: string[] = splitHostname(urlObj.hostname);
-  const topLevelDomain: string = getTopLevelDomain(hostnameParts);
-
-  const cookieSpecs: CookieSpec[] = createCookieSpecs(
-    urlObj.hostname,
-    topLevelDomain,
-  );
-
-  return uniqBy(
-    cookieSpecs,
-    (spec: CookieSpec) => `${spec.name}:${spec.domain}`,
-  );
-}
-
-/**
- * Parses the input URL string or URL object and returns a URL object.
- * @param url - The URL to parse.
- * @returns A URL object.
- */
-function parseUrl(url: URL | string): URL {
-  return typeof url === "string" ? new URL(url) : url;
-}
-
-/**
- * Splits the hostname into its constituent parts.
- * @param hostname - The hostname to split.
- * @returns An array of strings representing the parts of the hostname.
- */
-function splitHostname(hostname: string): string[] {
-  return hostname.split(".");
-}
-
-/**
- * Extracts the top-level domain from the hostname parts.
- * @param hostnameParts - The parts of the hostname.
- * @returns A string representing the top-level domain.
- */
-function getTopLevelDomain(hostnameParts: string[]): string {
-  return hostnameParts.slice(-2).join(".");
-}
-
-/**
- * Creates cookie specifications based on the hostname and top-level domain.
- * @param hostname - The full hostname.
- * @param topLevelDomain - The top-level domain.
- * @returns An array of CookieSpec objects.
- */
-function createCookieSpecs(
-  hostname: string,
-  topLevelDomain: string,
-): CookieSpec[] {
-  return [
-    { name: "%", domain: `%.${topLevelDomain}` },
-    { name: "%", domain: hostname },
-    { name: "%", domain: topLevelDomain },
-  ];
-}

package/src/decodeBinaryCookies.ts

@@ -1,72 +0,0 @@
-import CookieRow from "./CookieRow";
-import fs from "fs/promises";
-
-export const decodeBinaryCookies = async (cookieDbPath: string): Promise<CookieRow[]> => {
-  try {
-    // Check if file exists
-    await fs.access(cookieDbPath);
-  } catch {
-    // If file doesn't exist, return empty array
-    return [];
-  }
-
-  // Magic bytes: "COOK" = 0x636F6F6B
-  const magicBytes: Buffer = Buffer.from([0x63, 0x6F, 0x6B, 0x6B]);
-  const buffer: Buffer = await fs.readFile(cookieDbPath);
-
-  if (!buffer.slice(0, 4).equals(magicBytes)) {
-    throw new Error("Not a cookie file");
-  }
-
-  const count: number = buffer.readUInt32BE(4);
-  const cookies: CookieRow[] = [];
-
-  let offset: number = 8;
-  for (let i: number = 0; i < count; i++) {
-    const pageSize: number = buffer.readUInt32BE(offset);
-    offset += 4;
-    const page: Buffer = buffer.slice(offset, offset + pageSize);
-    offset += pageSize;
-
-    if (!page.slice(0, 4).equals(Buffer.from([0x00, 0x00, 0x01, 0x00]))) {
-      throw new Error("Bad page header");
-    }
-
-    const cookieCount: number = page.readUInt32LE(4);
-    let pageOffset: number = 8;
-    for (let j: number = 0; j < cookieCount; j++) {
-      const cookieOffset: number = page.readUInt32LE(pageOffset);
-      pageOffset += 4;
-      const cookieLength: number = page.readUInt32LE(cookieOffset);
-      const cookie: Buffer = page.slice(cookieOffset, cookieOffset + cookieLength);
-
-      const flags: number = cookie.readUInt32LE(8);
-      const urlOffset: number = cookie.readUInt32LE(16);
-      const nameOffset: number = cookie.readUInt32LE(20);
-      const valueOffset: number = cookie.readUInt32LE(28);
-      const expiry: number = cookie.readDoubleLE(40) + 978307200;
-
-      const url: string = cookie.slice(urlOffset, nameOffset).toString('utf8').replace(/\0/g, '');
-      const name: string = cookie.slice(nameOffset, valueOffset).toString('utf8').replace(/\0/g, '');
-      const value: string = cookie.slice(valueOffset, cookie.length).toString('utf8').replace(/\0/g, '');
-
-      cookies.push({
-        domain: url,
-        name: name,
-        value: Buffer.from(value, 'utf8'),
-        expiry: new Date(expiry * 1000).getTime(),
-        meta: {
-          path: cookie.slice(cookie.readUInt32LE(24), valueOffset).toString('utf8').replace(/\0/g, ''),
-          httpOnly: (flags & 0x04) === 0x04,
-          secure: (flags & 0x01) === 0x01
-        }
-      });
-    }
-
-    if (!page.slice(cookieCount * 4 + 8, cookieCount * 4 + 12).equals(Buffer.from([0x00, 0x00, 0x00, 0x00]))) {
-      throw new Error("Bad page trailer");
-    }
-  }
-
-  return cookies;
-};

package/src/execSimple.ts

@@ -1,12 +0,0 @@
-export async function execSimple(command: string): Promise<string> {
-  try {
-    const { execSync } = await import("child_process");
-    const stdout = execSync(command, {
-      encoding: "binary",
-      maxBuffer: 5 * 1024,
-    });
-    return stdout.trim();
-  } catch (error) {
-    throw error;
-  }
-}

package/src/fetchWithCookies.test.ts

@@ -1,32 +0,0 @@
-import { fetchWithCookies } from "./fetchWithCookies";
-import { FetchFn } from "./fetchWithCookies";
-
-describe("fetchWithCookies", () => {
-  let mockFetch: FetchFn;
-  let mockResponse: Response;
-
-  beforeEach(() => {
-    mockFetch = jest.fn();
-    mockResponse = new Response("mock body", { status: 200 });
-    (mockFetch as jest.Mock).mockResolvedValue(mockResponse);
-  });
-
-  // it("should call fetch with the correct arguments", async () => {
-  //   const url = "https://example.com/";
-  //   const options: RequestInit = {
-  //     method: "GET",
-  //     headers: { "User-Agent": userAgent },
-  //     redirect: "manual"
-  //     //
-  //   };
-  //   await fetchWithCookies(url, options, mockFetch);
-  //   expect(mockFetch).toBeCalledWith(url, options);
-  // });
-
-  it("should return the response from fetch", async () => {
-    const url = "https://example.com/";
-    const options = { method: "GET" };
-    const response = await fetchWithCookies(url, options, mockFetch);
-    expect(response).toBe(mockResponse);
-  });
-});

package/src/fetchWithCookies.ts

@@ -1,217 +0,0 @@
-// noinspection JSUnusedGlobalSymbols,ExceptionCaughtLocallyJS
-
-import { fetch as fetchImpl } from "cross-fetch";
-import { merge } from "lodash";
-import destr from "destr";
-import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
-import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
-import CookieSpec from "./CookieSpec";
-
-if (typeof fetchImpl !== "function") {
-  throw new Error("fetch is not a function");
-}
-
-/**
- * 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: string = new UserAgentBuilder().build();
-
-interface FetchRequestInit {
-  url: RequestInfo | URL | string;
-  options?: RequestInit;
-}
-
-export type FetchFn =
-  | typeof fetchImpl
-  | ((url: URL, options?: RequestInit) => Promise<Response>);
-
-/**
- * Class to handle fetch requests with cookies.
- */
-class FetchWithCookies {
-  private fetch: FetchFn;
-  private userAgent: string;
-
-  /**
-   * 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;
-  }
-
-  /**
-   * 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(() => "");
-
-    if (renderedCookie) {
-      headers["Cookie"] = renderedCookie;
-    }
-
-    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;
-
-    if (
-      [301, 302].includes(res.status) &&
-      newUrl &&
-      newUrl !== url.toString()
-    ) {
-      return this.fetchWithCookies(newUrl, options, originalRequest);
-    }
-
-    if (res.status === 303 && newUrl && newUrl !== url.toString()) {
-      const newOptions: RequestInit = {
-        ...options,
-        method: "GET",
-        body: undefined,
-      };
-      return this.fetchWithCookies(newUrl, newOptions, originalRequest);
-    }
-
-    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: FormData = new FormData();
-      for (const [key, value] of urlSearchParams.entries()) {
-        formData.append(key, value);
-      }
-      return 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,
-    };
-    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

@@ -1,48 +0,0 @@
-import { existsSync } from "fs";
-import { parsedArgs } from "./argv";
-import consola from "consola";
-import { sync } from "fast-glob";
-
-type FindFilesOptions = {
-  path: string;
-  name: string;
-  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,
-  maxDepth = 2,
-}: FindFilesOptions): string[] {
-  if (!existsSync(path)) {
-    throw new Error(`Path ${path} does not exist`);
-  }
-
-  if (parsedArgs.verbose) {
-    consola.start(`Searching for ${name} files in ${path}`);
-  }
-
-  const files: string[] = sync(`${path}/**/${name}`, {
-    onlyFiles: true,
-    deep: maxDepth,
-  });
-
-  if (parsedArgs.verbose) {
-    if (files.length > 0) {
-      consola.success(`Found ${files.length} ${name} files`);
-      consola.info(files);
-    }
-  }
-
-  return files;
-}

package/src/getChromeCookie.ts

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