@mherod/get-cookie 2.0.0-rc.9 → 2.1.0

package/src/util/flatMapAsync.test.ts

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,37 @@
+// 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) {
+    return flatMapAsync(
+      array,
+      async (value: T, index: number, array: T[]) => {
+        try {
+          return await callback(value, index, array);
+        } catch (error) {
+          return typeof or == "function" ? or(error) : or;
+        }
+      },
+      //
+    );
+  }
+
+  // Step 1: Use Array.prototype.map to transform each element of the input array with the provided callback.
+  // This will result in an array of promises.
+  const ps: Promise<O>[] = array.map(callback) as Promise<O>[];
+
+  // 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: Awaited<O>[] = await Promise.all(ps);
+
+  // 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() as O[];
+}

package/src/util/index.ts

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

package/tsconfig.json

@@ -3,21 +3,24 @@
     "src/**.ts",
     "src/**.tsx",
     "src/**.js",
-    "src/**.jsx"
+    "src/**.jsx",
+    "src/**.test.ts",
+    "src/**.test.js"
   ],
   "compilerOptions": {
     "moduleResolution": "node",
-    "target": "es2021",
-    "types": [
-      "node"
-    ],
-    "lib": [
-      "es2015",
-      "es2017",
-      "es2021",
-      "dom"
-    ],
+    "target": "es6",
+    "types": ["node", "jest"],
+    "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"
   }
 }

package/.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "daily"

package/.prettierrc.json

@@ -1 +0,0 @@
-{}

package/src/IsCookieRow.ts

@@ -1,9 +0,0 @@
-import CookieRow from "./CookieRow";
-
-export function isCookieRow(obj: any): obj is CookieRow {
-  return (
-    obj.domain !== undefined &&
-    obj.name !== undefined &&
-    obj.value !== undefined
-  );
-}

package/src/IsExportedCookie.ts

@@ -1,9 +0,0 @@
-import ExportedCookie from "./ExportedCookie";
-
-export function isExportedCookie(obj: any): obj is ExportedCookie {
-  return (
-    obj.domain !== undefined &&
-    obj.name !== undefined &&
-    obj.value !== undefined
-  );
-}

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -1,343 +0,0 @@
-import CookieQueryStrategy from "./CookieQueryStrategy";
-import { execSimple } from "../utils";
-import { env, HOME } from "../global";
-import { existsSync } from "fs";
-import { findAllFiles } from "../findAllFiles";
-import * as crypto from "crypto";
-import * as path from "path";
-import { doSqliteQuery1 } from "../doSqliteQuery1";
-import { merge } from "lodash";
-import { isCookieRow } from "../IsCookieRow";
-import { isExportedCookie } from "../IsExportedCookie";
-import CookieRow from "../CookieRow";
-import ExportedCookie from "../ExportedCookie";
-import { stringToRegex } from "../StringToRegex";
-import { parsedArgs } from "../argv";
-import fs from "fs";
-import * as sqlite3 from "sqlite3";
-import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
-
-export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
-  browserName = "Chrome";
-
-  async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    if (process.platform !== "darwin") {
-      throw new Error("This only works on macOS");
-    }
-    if (env.FIREFOX_ONLY) {
-      return [];
-    }
-    return getChromeCookies({
-      requireJwt: false,
-      name,
-      domain,
-    });
-  }
-}
-
-async function getPromise1(
-  name: string,
-  domain: string,
-  file: string
-): Promise<CookieRow[]> {
-  try {
-    return await getEncryptedChromeCookie({
-      name: name,
-      domain: domain,
-      file: file,
-    });
-  } catch (e) {
-    if (parsedArgs.verbose) {
-      console.log("Error getting encrypted cookie", e);
-    }
-    return [];
-  }
-}
-
-async function getPromise(name: string, domain: string): Promise<CookieRow[]> {
-  try {
-    const files: string[] = await findAllFiles({
-      path: chromeLocal,
-      name: "Cookies",
-    });
-    const promises: Promise<CookieRow[]>[] = files.map((file) =>
-      getPromise1(name, domain, file)
-    );
-    const results1: CookieRow[][] = await Promise.all(promises);
-    return results1.flat().filter(isCookieRow);
-  } catch (error) {
-    if (parsedArgs.verbose) {
-      console.log("error", error);
-    }
-    return [];
-  }
-}
-
-async function decryptValue(password: string, encryptedValue: Buffer) {
-  let d: string | null;
-  try {
-    d = await decrypt(password, encryptedValue);
-  } catch (e) {
-    if (parsedArgs.verbose) {
-      console.log("Error decrypting cookie", e);
-    }
-    d = null;
-  }
-  return d ?? encryptedValue.toString("utf-8");
-}
-
-async function getChromeCookies({
-  name,
-  domain = "%",
-  requireJwt = false,
-}: {
-  name: string;
-  domain: string;
-  requireJwt: boolean | undefined;
-  //
-}): //
-Promise<ExportedCookie[]> {
-  const encryptedDataItems: CookieRow[] = await getPromise(name, domain);
-  const password: string = await getChromePassword();
-  const decrypted: Promise<ExportedCookie | null>[] = encryptedDataItems
-    .filter(({ value }) => value != null && value.length > 0)
-    .map(async (cookieRow: CookieRow) => {
-      const encryptedValue: Buffer = cookieRow.value;
-      const decryptedValue = await decryptValue(password, encryptedValue);
-      const meta = {};
-      merge(meta, cookieRow.meta ?? {});
-      const exportedCookie: ExportedCookie = {
-        domain: cookieRow.domain,
-        name: cookieRow.name,
-        value: decryptedValue,
-        meta: meta,
-      };
-      const expiry = cookieRow.expiry;
-      if (expiry) {
-        merge(exportedCookie, {
-          expiry: new Date(expiry),
-        });
-      }
-      return exportedCookie;
-    });
-  const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
-    isExportedCookie
-  );
-  if (parsedArgs.verbose) {
-    console.log("results", results);
-  }
-  return results;
-}
-
-const chromeLocal = path.join(
-  HOME,
-  "Library",
-  "Application Support",
-  "Google",
-  "Chrome"
-);
-
-async function getEncryptedChromeCookie({
-  name,
-  domain,
-  file = path.join(chromeLocal, "Default", "Cookies"),
-}: //
-{
-  name: string;
-  domain: string;
-  file: string;
-}): Promise<CookieRow[]> {
-  if (!existsSync(file)) {
-    throw new Error(`File ${file} does not exist`);
-  }
-  if (parsedArgs.verbose) {
-    const s = file.split("/").slice(-3).join("/");
-    console.log(`Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`);
-  }
-  let sql;
-  //language=SQL
-  sql = "SELECT * FROM cookies";
-  // sql = "SELECT encrypted_value, name, host_key FROM cookies";
-
-  const wildcardRegexp = /^([*%])$/i;
-  const specifiedName = name.match(wildcardRegexp) == null;
-  const specifiedDomain = domain.match(wildcardRegexp) == null;
-  const wildcardDomain = domain.match(/[%*]/) != null;
-  const queryDomain = specifiedDomain && !wildcardDomain;
-  // if we have a wildcard domain, we need to use a regexp
-  if (specifiedName || queryDomain) {
-    sql += ` WHERE `;
-    if (specifiedName) {
-      sql += `name = '${name}'`;
-      if (queryDomain) {
-        sql += ` AND `;
-      }
-    }
-    if (queryDomain) {
-      // leading dot replaced with % to match subdomains
-      const sqlEmbedDomain = domain.replace(/^[.%]?/, "%");
-      sql += `host_key LIKE '${sqlEmbedDomain}';`;
-    }
-  }
-  const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
-    file: file,
-    sql: sql,
-    rowTransform: (row) => {
-      const cookieRow = {
-        expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
-        domain: row["host_key"],
-        name: row["name"],
-        value: row["encrypted_value"],
-      };
-      if (parsedArgs.verbose) {
-        console.log("CookieRow", cookieRow);
-      }
-      return cookieRow;
-    },
-  });
-  return sqliteQuery1.filter((row) => {
-    return row.domain.match(stringToRegex(domain)) != null;
-  });
-}
-
-async function getChromePassword(): Promise<string> {
-  return execSimple(
-    'security find-generic-password -w -s "Chrome Safe Storage"'
-  );
-}
-
-async function decrypt(
-  password: crypto.BinaryLike,
-  encryptedData: Buffer
-): Promise<string> {
-  if (typeof password !== "string") {
-    throw new Error("password must be a string: " + password);
-  }
-  let encryptedData1: any;
-  encryptedData1 = encryptedData;
-  if (encryptedData1 == null || typeof encryptedData1 !== "object") {
-    throw new Error("encryptedData must be a object: " + encryptedData1);
-  }
-  if (!(encryptedData1 instanceof Buffer)) {
-    if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
-      [encryptedData1] = encryptedData1;
-      if (parsedArgs.verbose) {
-        console.log(
-          `encryptedData is an array of buffers, selected first: ${encryptedData1}`
-        );
-      }
-    } else {
-      throw new Error("encryptedData must be a Buffer: " + encryptedData1);
-    }
-    encryptedData1 = Buffer.from(encryptedData1);
-  }
-  if (parsedArgs.verbose) {
-    console.log(`Trying to decrypt with password ${password}`);
-  }
-  return new Promise((resolve, reject) => {
-    crypto.pbkdf2(password, "saltysalt", 1003, 16, "sha1", (error, buffer) => {
-      try {
-        if (error) {
-          if (parsedArgs.verbose) {
-            console.log("Error doing pbkdf2", error);
-          }
-          reject(error);
-          return;
-        }
-
-        if (buffer.length !== 16) {
-          if (parsedArgs.verbose) {
-            console.log(
-              "Error doing pbkdf2, buffer length is not 16",
-              buffer.length
-            );
-          }
-          reject(new Error("Buffer length is not 16"));
-          return;
-        }
-
-        const str = new Array(17).join(" ");
-        const iv = Buffer.from(str, "binary");
-        const decipher = crypto.createDecipheriv("aes-128-cbc", buffer, iv);
-        decipher.setAutoPadding(false);
-
-        if (encryptedData1 && encryptedData1.slice) {
-          encryptedData1 = encryptedData1.slice(3);
-        }
-
-        if (encryptedData1.length % 16 !== 0) {
-          if (parsedArgs.verbose) {
-            console.log(
-              "Error doing pbkdf2, encryptedData length is not a multiple of 16",
-              encryptedData1.length
-            );
-          }
-          reject(new Error("encryptedData length is not a multiple of 16"));
-          return;
-        }
-
-        let decoded = decipher.update(encryptedData1);
-        try {
-          decipher.final("utf-8");
-        } catch (e) {
-          if (parsedArgs.verbose) {
-            console.log("Error doing decipher.final()", e);
-          }
-          reject(e);
-          return;
-        }
-
-        const padding = decoded[decoded.length - 1];
-        if (padding) {
-          decoded = decoded.slice(0, 0 - padding);
-        }
-        // noinspection JSCheckFunctionSignatures
-        const decodedString = decoded.toString("utf8");
-        resolve(decodedString);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
-}
-
-export async function doChromeSqliteQuery1({
-  file,
-  sql,
-  rowTransform,
-}: DoSqliteQuery1Params): Promise<CookieRow[]> {
-  if (!file || (file && !fs.existsSync(file))) {
-    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
-  }
-  const db = new sqlite3.Database(file);
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err: Error, rows: any[]) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      const rows1: any[] = rows;
-      if (rows1 == null || rows1.length === 0) {
-        resolve([]);
-        return;
-      }
-      if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row: any) => {
-          const newVar = {
-            meta: {
-              file: file,
-            },
-          };
-          const cookieRow: CookieRow = rowTransform(row);
-          return merge(newVar, cookieRow);
-        });
-        resolve(cookieRows);
-        return;
-      }
-      if (parsedArgs.verbose) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}

package/src/doSqliteQuery1.ts

@@ -1,47 +0,0 @@
-import * as fs from "fs";
-import * as sqlite3 from "sqlite3";
-import CookieRow from "./CookieRow";
-import { merge } from "lodash";
-import { parsedArgs } from "./argv";
-import { DoSqliteQuery1Params } from "./doSqliteQuery1Params";
-
-export async function doSqliteQuery1({
-  file,
-  sql,
-  rowTransform,
-}: DoSqliteQuery1Params): Promise<CookieRow[]> {
-  if (!file || (file && !fs.existsSync(file))) {
-    throw new Error(`doSqliteQuery1: file ${file} does not exist`);
-  }
-  const db = new sqlite3.Database(file);
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err: Error, rows: any[]) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      const rows1: any[] = rows;
-      if (rows1 == null || rows1.length === 0) {
-        resolve([]);
-        return;
-      }
-      if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row: any) => {
-          const newVar = {
-            meta: {
-              file: file,
-            },
-          };
-          const cookieRow: CookieRow = rowTransform(row);
-          return merge(newVar, cookieRow);
-        });
-        resolve(cookieRows);
-        return;
-      }
-      if (parsedArgs.verbose) {
-        console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
-      }
-      resolve([rows1]);
-    });
-  });
-}

package/src/doSqliteQuery1Params.ts

@@ -1,7 +0,0 @@
-import CookieRow from "./CookieRow";
-
-export interface DoSqliteQuery1Params {
-  file: string;
-  sql: string;
-  rowTransform: (row: any) => CookieRow;
-}

package/src/utils.ts

@@ -1,25 +0,0 @@
-// noinspection JSUnusedGlobalSymbols
-
-import { exec, ExecException } from "child_process";
-
-export async function execSimple(command: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(
-      command,
-      { encoding: "binary", maxBuffer: 5 * 1024 },
-      (error: ExecException | null, stdout: string, stderr: string) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        if (stderr) {
-          reject(error);
-          return;
-        }
-        if (stdout) {
-          resolve(stdout.trim());
-        }
-      }
-    );
-  });
-}