@mherod/get-cookie 2.1.1 → 2.1.2

package/package.json

@@ -1,57 +1,23 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
   "main": "dist/index.js",
-  "module": "dist/module.js",
   "types": "dist/types.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "clean": "git clean -fdX && rm -rf dist && yarn install",
-    "lintfix": "prettier --write \"src/**/*.ts\"",
-    "prebuild": "npm run lintfix",
     "tsc": "tsc",
-    "build": "parcel build --no-cache",
-    "prepare": "parcel build --no-cache",
+    "build": "bun build src/index.ts --target=node --outdir=dist && bun build src/cli.ts --target=node --outdir=dist && tsc --emitDeclarationOnly",
     "test": "jest",
-    "prepublish": "npm run build",
-    "install:global": "npm run build && npm install --global .",
-    "prettier": "prettier --write ."
-  },
-  "targets": {
-    "types": {},
-    "main": {
-      "source": "src/index.ts",
-      "distDir": "dist",
-      "isLibrary": true,
-      "engines": {
-        "node": ">= 16"
-      },
-      "sourceMap": true,
-      "optimize": false,
-      "includeNodeModules": false
-    },
-    "cli": {
-      "source": "src/cli.ts",
-      "distDir": "dist",
-      "isLibrary": false,
-      "engines": {
-        "node": ">= 16"
-      },
-      "sourceMap": false,
-      "optimize": true,
-      "includeNodeModules": {
-        "@mapbox/node-pre-gyp": false
-      }
-    }
-  },
-  "@parcel/transformer-js": {
-    "inlineFS": false,
-    "inlineEnvironment": true
+    "prepublish": "bun run build",
+    "install:global": "bun run build && npm install --global .",
+    "prettier": "prettier --write .",
+    "copy-files": "cp -r src/cli.js dist/cli.js && cp -r src/index.js dist/index.js && cp -r src/types.d.ts dist/types.d.ts"
   },
   "engines": {
     "node": ">= 16"
@@ -69,32 +35,22 @@
     "lodash-es": "^4.17.21",
     "lru-cache": "^7.14.0",
     "minimist": "^1.2.7",
-    "sqlite3": "^5.1.6",
     "tough-cookie": "^4.1.2"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
-    "@mapbox/node-pre-gyp": "^1.0.11",
-    "@parcel/packager-ts": "^2.10.1",
-    "@parcel/transformer-typescript-tsc": "^2.10.1",
-    "@parcel/transformer-typescript-types": "^2.10.1",
+    "@types/bun": "^1.1.3",
     "@types/jest": "^29.5.6",
     "@types/jsonwebtoken": "^8.5.9",
     "@types/lodash": "^4.14.186",
     "@types/minimist": "^1.2.2",
-    "@types/node": "^18.11.4",
+    "@types/node": "^18.19.34",
     "@types/tough-cookie": "^4.0.2",
     "@types/user-agents": "^1.0.2",
     "jest": "^29.7.0",
-    "parcel": "^2.10.1",
     "prettier": "^3.0.3",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
     "typescript": "^5.1.6"
-  },
-  "parcelDependencies": {
-    "@parcel/transformer-typescript-tsc": "^2.10.1",
-    "@parcel/transformer-typescript-types": "^2.10.1",
-    "@parcel/packager-ts": "^2.10.1"
   }
 }

package/src/CookieRow.ts

@@ -1,15 +1,43 @@
+import consola from "./logger";
+
+/**
+ * The CookieRow interface represents the structure of a cookie row object.
+ */
 export default interface CookieRow {
   expiry?: number;
   domain: string;
   name: string;
-  value: Buffer;
-  meta?: any;
+  value: Uint8Array | Buffer;
+  meta?: Record<string, unknown>;
 }
 
+/**
+ * Type guard to check if an object is a CookieRow.
+ * @param obj - The object to check.
+ * @returns True if the object is a CookieRow, false otherwise.
+ */
 export function isCookieRow(obj: any): obj is CookieRow {
-  return (
-    obj.domain !== undefined &&
-    obj.name !== undefined &&
-    obj.value !== undefined
-  );
+  if (typeof obj !== "object" || obj === null) {
+    consola.warn("Object is not an object or is null:", obj);
+    return false;
+  }
+
+  const { domain, name, value } = obj as CookieRow;
+
+  if (typeof domain !== "string") {
+    consola.warn("Domain is not a string:", domain);
+    return false;
+  }
+
+  if (typeof name !== "string") {
+    consola.warn("Name is not a string:", name);
+    return false;
+  }
+
+  if (!(value instanceof Uint8Array) && !Buffer.isBuffer(value)) {
+    consola.warn("Value is not a Uint8Array or Buffer:", value);
+    return false;
+  }
+
+  return true;
 }

package/src/CookieSpec.ts

@@ -1,24 +1,42 @@
-// Define the CookieSpec interface with domain and name properties
+/**
+ * Define the CookieSpec interface with domain and name properties
+ */
 export default interface CookieSpec {
   domain: string;
   name: string;
 }
 
-// Function to check if an object is of type CookieSpec
-export function isCookieSpec(obj: any): obj is CookieSpec {
-  return (
-    // Check if domain and name properties are of type string
-    typeof obj.domain === "string" && typeof obj.name === "string"
-  );
+/**
+ * Function to check if an object is of type CookieSpec
+ * @param obj - The object to check
+ * @returns True if the object is of type CookieSpec, otherwise false
+ */
+export function isCookieSpec(obj: unknown): obj is CookieSpec {
+  const cookie = obj as CookieSpec;
+  return typeof cookie.domain === "string" && typeof cookie.name === "string";
 }
 
-// Define a type that can be either a single CookieSpec or an array of CookieSpecs
+/**
+ * Define a type that can be either a single CookieSpec or an array of CookieSpecs
+ */
 export type MultiCookieSpec = CookieSpec | CookieSpec[];
 
-// Function to check if an object is of type MultiCookieSpec
-export function isMultiCookieSpec(obj: any): obj is MultiCookieSpec {
-  return (
-    // Check if the object is a CookieSpec or an array of CookieSpecs
-    isCookieSpec(obj) || (Array.isArray(obj) && obj.every(isCookieSpec))
-  );
+/**
+ * Function to check if an object is of type MultiCookieSpec
+ * @param obj - The object to check
+ * @returns True if the object is of type MultiCookieSpec, otherwise false
+ */
+export function isMultiCookieSpec(obj: unknown): obj is MultiCookieSpec {
+  if (isCookieSpec(obj)) {
+    return true;
+  }
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      if (!isCookieSpec(obj[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 }

package/src/SpecialCases.ts

@@ -3,12 +3,13 @@ import CookieSpec from "./CookieSpec";
 export function specialCases({ name, domain }: CookieSpec): {
   specifiedName: boolean;
   specifiedDomain: boolean;
-  //
 } {
-  const wildcardRegexp = /^([*%])$/i;
+  const wildcardRegexp: RegExp = /^([*%])$/i;
+  const specifiedName: boolean = name.match(wildcardRegexp) == null;
+  const specifiedDomain: boolean = domain.match(wildcardRegexp) == null;
+
   return {
-    specifiedName: name.match(wildcardRegexp) == null,
-    specifiedDomain: domain.match(wildcardRegexp) == null,
-    //
+    specifiedName,
+    specifiedDomain,
   };
 }

package/src/StringToRegex.ts

@@ -1,11 +1,11 @@
 // This function converts a string into a regular expression
 export function stringToRegex(s: string): RegExp {
-  // Replace all occurrences of '.' with a literal '.'
-  const s1 = s.replaceAll(/\./gi, ".");
+  // Replace all occurrences of '.' with a literal '\.'
+  let s1: string = s.replace(/\./g, "\\.");
   // Replace all occurrences of '%' with '.*' to match any number of any characters
-  const s2 = s1.replace(/%/g, ".*");
+  let s2: string = s1.replace(/%/g, ".*");
   // Replace all occurrences of '*' with '.*' to match any number of any characters
-  const s3 = s2.replace(/\*/g, ".*");
+  let s3: string = s2.replace(/\*/g, ".*");
   // Return the new string as a RegExp object
   return new RegExp(s3);
 }

package/src/browsers/CompositeCookieQueryStrategy.ts

@@ -5,9 +5,8 @@ import CookieQueryStrategy from "./CookieQueryStrategy";
 import ExportedCookie from "../ExportedCookie";
 import LRUCache from "lru-cache";
 import { merge } from "lodash";
-import { parsedArgs } from "../argv";
-import consola from "consola";
 import { flatMapAsync } from "../util/flatMapAsync";
+import consola from "../logger";
 
 const cache: LRUCache<string, ExportedCookie[]> = new LRUCache<
   string,
@@ -20,51 +19,58 @@ const cache: LRUCache<string, ExportedCookie[]> = new LRUCache<
 export default class CompositeCookieQueryStrategy
   implements CookieQueryStrategy
 {
-  browserName = "all";
+  browserName: string = "all";
 
-  private readonly strategies;
+  private readonly strategies: CookieQueryStrategy[];
 
   constructor() {
     this.strategies = [
-      // CookieStoreQueryStrategy,
       ChromeCookieQueryStrategy,
       FirefoxCookieQueryStrategy,
       SafariCookieQueryStrategy,
-    ].map((strategy) => {
-      return new strategy();
-    });
+    ].map((Strategy) => new Strategy());
   }
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    // domain = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
-    const key = `${name}:${domain}`;
+    const key: string = `${name}:${domain}`;
+    consola.info(`Querying cookies for name: ${name}, domain: ${domain}`);
     if (cache.has(key)) {
-      const cached = cache.get(key);
+      const cached: ExportedCookie[] | undefined = cache.get(key);
       if (cached) {
+        consola.info(
+          `Cache hit for key: ${key}, returning ${cached.length} cookies`,
+        );
         return cached;
       }
     }
-    if (parsedArgs.verbose) {
-      consola.log("Querying cookies:", name, domain);
-    }
-    const results = await flatMapAsync(this.strategies, async (strategy) => {
-      return strategy
-        .queryCookies(name, domain)
-        .then((cookies: ExportedCookie[]) => {
-          return cookies.map((cookie: ExportedCookie) => {
-            return merge(cookie, {
+    const results: ExportedCookie[] = await flatMapAsync(
+      this.strategies,
+      async (strategy) => {
+        try {
+          const cookies: ExportedCookie[] = await strategy.queryCookies(
+            name,
+            domain,
+          );
+          return cookies.map((cookie: ExportedCookie) =>
+            merge(cookie, {
               meta: {
                 browser: strategy.browserName,
               },
-            });
-          });
-        })
-        .catch((e) => {
-          consola.error(`Error querying ${strategy.browserName} cookies`, e);
+            }),
+          );
+        } catch (e) {
+          consola.error(
+            `Error querying cookies for ${name} on ${domain} using ${strategy.browserName}`,
+            e,
+          );
           return [];
-        });
-    });
-    cache.set(`${name}:${domain}`, results);
+        }
+      },
+    );
+    cache.set(key, results);
+    consola.info(
+      `Query result size for key: ${key} is ${results.length} cookies`,
+    );
     return results;
   }
 }

package/src/browsers/CookieQueryStrategy.ts

@@ -3,5 +3,5 @@ import ExportedCookie from "../ExportedCookie";
 export default interface CookieQueryStrategy {
   browserName: string;
 
-  queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
+  queryCookies(name: string, domain: string): Promise<Array<ExportedCookie>>;
 }

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -6,55 +6,76 @@ import { cookieJarPromise, cookieStorePromise } from "../CookieStore";
 import { stringToRegex } from "../StringToRegex";
 
 export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
-  browserName = "internal";
+  browserName: string = "internal";
 
   async queryCookies(name: string, domain: string): Promise<ExportedCookie[]> {
-    const exportedCookies: ExportedCookie[] = [];
+    const exportedCookies: ExportedCookie[] = await this.getAllExportedCookies(
+      name,
+      domain,
+    );
 
-    // if (name.match(/[%*]/) || domain.match(/[%*]/)) {
-    const cookies: Cookie[] = await this.#getAllCookies();
-    const allExportedCookies = cookies.map((cookie: Cookie) => {
-      return this.#extracted(cookie, { name, domain });
-    });
-    exportedCookies.push(...allExportedCookies);
-    // }
-
-    const wildcardRegexp = /^([*%])$/i;
+    const wildcardRegexp: RegExp = /^([*%])$/i;
     if (name.match(wildcardRegexp) && domain.match(wildcardRegexp)) {
       return exportedCookies;
     }
 
-    const path = "/";
-
-    if (domain != "%") {
-      const domain1 = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
-      const url = new URL("https://" + domain1);
-      url.pathname = path;
-      const cookies: Cookie[] = await this.#getCookies(url.href);
-      const domainCookies = cookies.map((cookie: Cookie) => {
-        return this.#extracted(cookie, {
-          domain,
-          name,
-        });
-      });
+    if (domain !== "%") {
+      const domainCookies: ExportedCookie[] = await this.getDomainCookies(
+        name,
+        domain,
+      );
       exportedCookies.push(...domainCookies);
     }
 
-    if (name == "%") {
-      return exportedCookies.filter((cookie: ExportedCookie) => {
-        return cookie.domain.match(stringToRegex(domain));
-      });
+    return this.filterCookies(exportedCookies, name, domain);
+  }
+
+  private async getAllExportedCookies(
+    name: string,
+    domain: string,
+  ): Promise<ExportedCookie[]> {
+    const cookies: Cookie[] = await this.getAllCookies();
+    return cookies.map((cookie: Cookie) =>
+      this.extractCookie(cookie, { name, domain }),
+    );
+  }
+
+  private async getDomainCookies(
+    name: string,
+    domain: string,
+  ): Promise<ExportedCookie[]> {
+    const path: string = "/";
+    const domain1: string = domain.match(/(\w+.+\w+)/gi)?.pop() ?? domain;
+    const url: URL = new URL("https://" + domain1);
+    url.pathname = path;
+    const cookies: Cookie[] = await this.getCookies(url.href);
+    return cookies.map((cookie: Cookie) =>
+      this.extractCookie(cookie, { domain, name }),
+    );
+  }
+
+  private filterCookies(
+    exportedCookies: ExportedCookie[],
+    name: string,
+    domain: string,
+  ): ExportedCookie[] {
+    if (name === "%") {
+      return exportedCookies.filter((cookie: ExportedCookie) =>
+        cookie.domain.match(stringToRegex(domain)),
+      );
     }
 
-    return exportedCookies.filter((cookie: ExportedCookie) => {
-      return (
+    return exportedCookies.filter(
+      (cookie: ExportedCookie) =>
         cookie.name.match(stringToRegex(name)) &&
-        cookie.domain.match(stringToRegex(domain))
-      );
-    });
+        cookie.domain.match(stringToRegex(domain)),
+    );
   }
 
-  #extracted(cookie: Cookie, cookieSpec: CookieSpec): ExportedCookie {
+  private extractCookie(
+    cookie: Cookie,
+    cookieSpec: CookieSpec,
+  ): ExportedCookie {
     return {
       domain: cookie.domain ?? cookieSpec.domain,
       name: cookie.key ?? cookieSpec.name,
@@ -66,34 +87,29 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
     };
   }
 
-  async #getCookies(url: string): Promise<Cookie[]> {
+  private async getCookies(url: string): Promise<Cookie[]> {
     const cookieJar = await cookieJarPromise;
     return new Promise((resolve, reject) => {
-      return cookieJar.getCookies(
-        url,
-        (err: Error | null, cookies: Cookie[]) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(cookies ?? []);
-          }
-        },
-      );
+      cookieJar.getCookies(url, (err: Error | null, cookies: Cookie[]) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(cookies ?? []);
+        }
+      });
     });
   }
 
-  async #getAllCookies(): Promise<Cookie[]> {
+  private async getAllCookies(): Promise<Cookie[]> {
     const cookieStore: Store = await cookieStorePromise;
     return new Promise((resolve, reject) => {
-      return cookieStore.getAllCookies(
-        (err: Error | null, cookies: Cookie[]) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(cookies ?? []);
-          }
-        },
-      );
+      cookieStore.getAllCookies((err: Error | null, cookies: Cookie[]) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(cookies ?? []);
+        }
+      });
     });
   }
 }

package/src/browsers/QuerySqliteThenTransform.ts

@@ -1,9 +1,7 @@
 import CookieRow from "../CookieRow";
 import fs from "fs";
-import { Database } from "sqlite3";
 import { merge } from "lodash";
-import { parsedArgs } from "../argv";
-import consola from "../logger";
+import { Database } from "bun:sqlite";
 
 interface FnOptions {
   file: string;
@@ -12,74 +10,39 @@ interface FnOptions {
   rowTransform: (row: any) => CookieRow;
 }
 
-function checkFileExistence(file: string) {
-  if (!file || !fs.existsSync(file)) {
+async function checkFileExistence(file: string): Promise<void> {
+  if (!file || !fs.existsSync(file))
     throw new Error(`File ${file} does not exist`);
-  }
-}
-
-function createDatabase(file: string): Database {
-  return new Database(file);
 }
 
-function transformRows(
-  //
+async function transformRows(
   rows: any[],
   rowFilter: (row: any) => boolean,
   rowTransform: (row: any) => CookieRow,
   file: string,
-  //
-): CookieRow[] {
-  return rows.filter(rowFilter).map((row: any) => {
-    const metaData = {
-      meta: {
-        file: file,
-      },
-    };
-
-    const cookieRow: CookieRow = rowTransform(row);
-
-    return merge(metaData, cookieRow);
-  });
+): Promise<CookieRow[]> {
+  const filteredRows = rows.filter(rowFilter);
+  const transformedRows = filteredRows.map((row) =>
+    merge({ meta: { file } }, rowTransform(row)),
+  );
+  return transformedRows;
 }
 
-export async function querySqliteThenTransform(
-  //
-  {
-    //
-    file,
-    sql,
-    rowFilter = () => true,
-    rowTransform,
-  }: FnOptions,
-): //
-Promise<CookieRow[]> {
-  checkFileExistence(file);
-
-  const db: Database = createDatabase(file);
-
-  return new Promise((resolve, reject) => {
-    db.all(sql, (err: Error, rows: any[]) => {
-      if (err) {
-        return reject(err);
-      }
-
-      if (!rows || rows.length === 0) {
-        return resolve([]);
-      }
-
-      const cookieRows: CookieRow[] = transformRows(
-        rows,
-        rowFilter,
-        rowTransform,
-        file,
-      );
-
-      if (parsedArgs.verbose) {
-        consola.log(`Rows: ${JSON.stringify(rows)}`);
-      }
-
-      return resolve(cookieRows);
-    });
-  });
+export async function querySqliteThenTransform({
+  file,
+  sql,
+  rowFilter = () => true,
+  rowTransform,
+}: FnOptions): Promise<CookieRow[]> {
+  await checkFileExistence(file);
+  const db = new Database(file);
+
+  try {
+    const rows: any[] = db.query(sql).all();
+    if (!rows || rows.length === 0) return [];
+
+    return await transformRows(rows, rowFilter, rowTransform, file);
+  } catch (err: any) {
+    throw err;
+  }
 }

package/src/browsers/chrome/ChromeApplicationSupport.ts

@@ -1,6 +1,10 @@
 import { join } from "path";
 import { HOME } from "../../global";
 
+if (HOME === undefined) {
+  throw new Error("HOME environment variable is not defined");
+}
+
 export const chromeApplicationSupport: string = join(
   HOME,
   "Library",