@mherod/get-cookie 2.1.3 → 4.0.2

package/src/getCookie.ts

@@ -1,22 +0,0 @@
-import CookieSpec from "./CookieSpec";
-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: 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

@@ -1,25 +0,0 @@
-import CookieSpec from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
-import { queryCookies } from "./queryCookies";
-import FirefoxCookieQueryStrategy from "./browsers/firefox/FirefoxCookieQueryStrategy";
-
-export async function getFirefoxCookie(
-  params: CookieSpec,
-): Promise<ExportedCookie | undefined> {
-  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 (!validCookie) {
-    throw new Error("Cookie not found");
-  }
-
-  return validCookie;
-}

package/src/getGroupedRenderedCookies.ts

@@ -1,42 +0,0 @@
-import { groupBy } from "lodash";
-import { resultsRendered } from "./resultsRendered";
-import { MultiCookieSpec } from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
-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) {
-    throw new Error("Cookie not found");
-  }
-  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.test.ts

@@ -1,43 +0,0 @@
-import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
-import { MultiCookieSpec } from "./CookieSpec";
-import MockCookieQueryStrategy from "./browsers/mock/MockCookieQueryStrategy";
-
-describe("getMergedRenderedCookies", () => {
-  it("should return empty string if no cookies are present", async () => {
-    const cookieSpec: MultiCookieSpec = [];
-    const result = await getMergedRenderedCookies(cookieSpec);
-    expect(result).toBe("");
-  });
-
-  it("should return rendered cookies if cookies are present", async () => {
-    const cookieSpec: MultiCookieSpec = [
-      {
-        name: "sessionCookie",
-        domain: "www.example.com",
-      },
-      {
-        name: "persistentCookie",
-        domain: "www.example.com",
-      },
-    ];
-    const result = await getMergedRenderedCookies(
-      cookieSpec,
-      new MockCookieQueryStrategy([
-        {
-          name: "sessionCookie",
-          value: "sessionCookieValue",
-          domain: "www.example.com",
-        },
-        {
-          name: "persistentCookie",
-          value: "persistentCookieValue",
-          domain: "www.example.com",
-        },
-      ]),
-      //
-    );
-    expect(result).not.toBe("");
-    expect(result).toContain("sessionCookie=sessionCookieValue");
-    expect(result).toContain("persistentCookie=persistentCookieValue");
-  });
-});

package/src/getMergedRenderedCookies.ts

@@ -1,19 +0,0 @@
-import { resultsRendered } from "./resultsRendered";
-import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
-import { MultiCookieSpec } from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
-import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-
-export async function getMergedRenderedCookies(
-  cookieSpec: MultiCookieSpec,
-  strategy: CookieQueryStrategy = new CompositeCookieQueryStrategy(),
-): Promise<string> {
-  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec, {
-    strategy,
-  });
-  if (cookies.length > 0) {
-    return resultsRendered(cookies);
-  }
-  return "";
-}

package/src/global.ts

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

package/src/index.ts

@@ -1,16 +0,0 @@
-import { getCookie } from "./getCookie";
-import { getChromeCookie } from "./getChromeCookie";
-import { getFirefoxCookie } from "./getFirefoxCookie";
-import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
-import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
-import { fetchWithCookies } from "./fetchWithCookies";
-
-export {
-  getCookie,
-  getChromeCookie,
-  getFirefoxCookie,
-  getMergedRenderedCookies,
-  getGroupedRenderedCookies,
-  fetchWithCookies,
-  //
-};

package/src/isValidJwt.ts

@@ -1,26 +0,0 @@
-import jsonwebtoken, { JwtPayload } from "jsonwebtoken";
-import { parsedArgs } from "./argv";
-
-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 | undefined = result?.payload as
-      | JwtPayload
-      | undefined;
-    if (payload) {
-      const exp: number | undefined = payload.exp;
-      if (exp) {
-        const now: number = new Date().getTime() / 1000;
-        if (now > exp) {
-          return false;
-        }
-      }
-    }
-    return true;
-  } catch (err) {
-    return false;
-  }
-}

package/src/listChromeProfiles.ts

@@ -1,53 +0,0 @@
-import { sync } from "fast-glob";
-import { chromeApplicationSupport } from "./browsers/chrome/ChromeApplicationSupport";
-import { dirname } from "path";
-import { readFile } from "fs/promises";
-import destr from "destr";
-
-export async function listChromeProfilePaths(): Promise<string[]> {
-  const files: string[] = sync(`./**/Cookies`, {
-    cwd: chromeApplicationSupport,
-    absolute: true,
-    onlyFiles: true,
-    deep: 2,
-  });
-
-  const directories: string[] = [];
-  for (const file of files) {
-    directories.push(dirname(file));
-  }
-
-  return directories;
-}
-
-export async function listChromeProfiles(): Promise<ChromeProfile[]> {
-  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 = {
-  account_id: string;
-  accountcapabilities: any;
-  email: string;
-  full_name: string;
-  gaia: string;
-  given_name: string;
-  hd: string;
-  is_supervised_child: number;
-  is_under_advanced_protection: boolean;
-  last_downloaded_image_url_with_size: string;
-  locale: string;
-  picture_url: string;
-};
-
-export type ChromeProfile = {
-  account_info: ChromeProfileAccountInfo[];
-};

package/src/logger.ts

@@ -1,12 +0,0 @@
-import { createConsola } from "consola";
-
-const consola = createConsola({
-  fancy: true,
-  formatOptions: {
-    showLogLevel: true,
-    colors: true,
-    date: false,
-  },
-});
-
-export default consola;

package/src/processBeforeReturn.ts

@@ -1,29 +0,0 @@
-import ExportedCookie from "./ExportedCookie";
-import { uniqBy } from "lodash";
-import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
-import { CookieQueryOptions } from "./cookieQueryOptions";
-
-export function processBeforeReturn<T extends CookieQueryStrategy>(
-  cookies: ExportedCookie[],
-  options?: CookieQueryOptions<T>,
-): 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;
-      return (
-        expiry === undefined || expiry === "Infinity" || expiry.getTime() > now
-      );
-    });
-  }
-
-  if (options && options.limit) {
-    processedCookies = processedCookies.slice(0, options.limit);
-  }
-
-  return uniqBy(processedCookies, (cookie: ExportedCookie) =>
-    JSON.stringify(cookie),
-  );
-}

package/src/queryCookies.ts

@@ -1,41 +0,0 @@
-import { uniqBy } from "lodash";
-import { parsedArgs } from "./argv";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
-import isValidJwt from "./isValidJwt";
-import CookieSpec from "./CookieSpec";
-import ExportedCookie from "./ExportedCookie";
-import { CookieQueryOptions } from "./cookieQueryOptions";
-import consola from "./logger";
-
-export async function queryCookies(
-  { name, domain }: CookieSpec,
-  options?: CookieQueryOptions<CookieQueryStrategy>,
-): Promise<ExportedCookie[]> {
-  const strategy: CookieQueryStrategy =
-    options?.strategy || new CompositeCookieQueryStrategy();
-
-  consola.debug(`Using strategy: ${strategy.browserName}`);
-
-  const results: ExportedCookie[] = await strategy.queryCookies(name, domain);
-  const allCookies: ExportedCookie[] = uniqBy(results, JSON.stringify);
-
-  const filterCookies = (
-    cookies: ExportedCookie[],
-    filterFn: (value: string) => boolean,
-  ): ExportedCookie[] => {
-    const filteredCookies: ExportedCookie[] = [];
-    for (const cookie of cookies) {
-      if (filterFn(cookie.value)) {
-        filteredCookies.push(cookie);
-      }
-    }
-    return filteredCookies;
-  };
-
-  const jwtCookies: ExportedCookie[] = parsedArgs["require-jwt"]
-    ? filterCookies(allCookies, isValidJwt)
-    : allCookies;
-
-  return parsedArgs["single"] ? [jwtCookies[0]] : jwtCookies;
-}

package/src/resultsRendered.ts

@@ -1,24 +0,0 @@
-import { orderBy, uniqBy } from "lodash";
-import ExportedCookie from "./ExportedCookie";
-
-function sortResults(results: ExportedCookie[]): ExportedCookie[] {
-  return orderBy(results, ["name", "expiry"], ["asc", "desc"]);
-}
-
-function getUniqueResults(results: ExportedCookie[]): ExportedCookie[] {
-  return uniqBy(results, "name");
-}
-
-function formatResults(results: ExportedCookie[]): string {
-  const resultStrings: string[] = [];
-  for (const result of results) {
-    resultStrings.push(`${result.name}=${result.value}`);
-  }
-  return resultStrings.join("; ");
-}
-
-export function resultsRendered(results: ExportedCookie[]): string {
-  const orderedResults: ExportedCookie[] = sortResults(results);
-  const uniqueResults: ExportedCookie[] = getUniqueResults(orderedResults);
-  return formatResults(uniqueResults);
-}

package/src/unpackHeaders.ts

@@ -1,18 +0,0 @@
-export function unpackHeaders(
-  headerArgs: string[] | string | null,
-): Record<string, string> {
-  const headers: Record<string, string> = {};
-  if (headerArgs === null) {
-    return headers;
-  }
-  if (Array.isArray(headerArgs)) {
-    for (let i = 0; i < headerArgs.length; i++) {
-      const [key, value] = headerArgs[i].split("=");
-      headers[key] = value;
-    }
-  } else {
-    const [key, value] = headerArgs.split("=");
-    headers[key] = value;
-  }
-  return headers;
-}

package/src/util/flatMapAsync.test.ts

@@ -1,55 +0,0 @@
-import { flatMapAsync } from "./flatMapAsync";
-
-describe("flatMapAsync", () => {
-  it("should apply async callback to each element, wait for all promises to fulfill and flatten the resulting array", async () => {
-    const array = [1, 2, 3];
-    const callback = async (value: number) => [value, value * 2];
-    const result = await flatMapAsync(array, callback);
-    expect(result).toEqual([1, 2, 2, 4, 3, 6]);
-  });
-
-  it("should handle errors with the provided error callback", async () => {
-    const array = [1, 2, 3];
-    const callback = async (value: number) => {
-      if (value === 2) {
-        throw new Error("Test error");
-      }
-      return [value, value * 2];
-    };
-    const errorCallback = (error: any) => [0];
-    const result = await flatMapAsync(array, callback, errorCallback);
-    expect(result).toEqual([1, 2, 0, 3, 6]);
-  });
-
-  it("should return an empty array when input array is empty", async () => {
-    const array: number[] = [];
-    const callback = async (value: number) => [value, value * 2];
-    const result = await flatMapAsync(array, callback);
-    expect(result).toEqual([]);
-  });
-
-  it("should return an array with single element when input array has one element", async () => {
-    const array = [1];
-    const callback = async (value: number) => [value, value * 2];
-    const result = await flatMapAsync(array, callback);
-    expect(result).toEqual([1, 2]);
-  });
-
-  it("should handle null values in the array", async () => {
-    const array = [1, null, 3];
-    const callback = async (value: number) =>
-      value ? [value, value * 2] : [0];
-    // @ts-expect-error
-    const result = await flatMapAsync(array, callback);
-    expect(result).toEqual([1, 2, 0, 3, 6]);
-  });
-
-  it("should handle undefined values in the array", async () => {
-    const array = [1, undefined, 3];
-    const callback = async (value: number) =>
-      value ? [value, value * 2] : [0];
-    // @ts-expect-error
-    const result = await flatMapAsync(array, callback);
-    expect(result).toEqual([1, 2, 0, 3, 6]);
-  });
-});

package/src/util/flatMapAsync.ts

@@ -1,41 +0,0 @@
-// This utility function applies an async callback to each element of the input array (just like Array.prototype.map),
-// waits for all resulting promises to fulfill (similar to Promise.all), and then flattens the resulting array (like Array.prototype.flat).
-
-export async function flatMapAsync<T, O>(
-  array: T[], // The input array to transform.
-  callback: (value: T, index: number, array: T[]) => Promise<O[]>, // The async function to apply to each input array element.
-  or?: O[] | ((error: any) => O[] | Promise<O[]>), // An optional callback to handle errors.
-): Promise<O[]> {
-  if (or) {
-    const errorHandlingCallback = async (
-      value: T,
-      index: number,
-      array: T[],
-    ): Promise<O[]> => {
-      try {
-        return await callback(value, index, array);
-      } catch (error) {
-        return typeof or === "function" ? await or(error) : or;
-      }
-    };
-    return flatMapAsync(array, errorHandlingCallback);
-  }
-
-  // Step 1: Use a for loop to transform each element of the input array with the provided callback.
-  // This will result in an array of promises.
-  const promises: Promise<O[]>[] = [];
-  for (let i = 0; i < array.length; i++) {
-    promises.push(callback(array[i], i, array));
-  }
-
-  // Step 2: Use Promise.all to wait for all promises in the array to fulfill.
-  // This will give us an array of fulfilled promise values.
-  const awaitedAll: O[][] = await Promise.all(promises);
-
-  // Step 3: Flatten the array of fulfilled promise values into a single array.
-  // Note: The '@ts-ignore' comment is used to suppress TypeScript compiler warnings, as .flat() method might not be recognized
-  // as a valid method for an array of Awaited<O> instances. However, this code assumes that the result of Promise.all
-  // is indeed an array that can be flattened.
-  // @ts-ignore
-  return awaitedAll.flat();
-}

package/src/util/index.ts

@@ -1 +0,0 @@
-export * from "./flatMapAsync";

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "include": [
-    "src/**.ts",
-    "src/**.tsx",
-    "src/**.js",
-    "src/**.jsx",
-    "src/**.test.ts",
-    "src/**.test.js",
-  ],
-  "compilerOptions": {
-    "moduleResolution": "node",
-    "target": "es6",
-    "types": ["node", "jest", "bun-types"],
-    "lib": ["es2015", "es2017", "es2021", "dom"],
-    "strict": true,
-    "skipDefaultLibCheck": true,
-    "skipLibCheck": true,
-    "allowSyntheticDefaultImports": true,
-    "emitDeclarationOnly": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "module": "commonjs",
-    "outDir": "dist",
-    "outFile": "dist/types.d.ts",
-  },
-}