@mherod/get-cookie 2.1.0 → 2.1.2

package/src/queryCookies.ts

@@ -3,34 +3,39 @@ import { parsedArgs } from "./argv";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
 import isValidJwt from "./isValidJwt";
-import CookieSpec, { MultiCookieSpec } from "./CookieSpec";
+import CookieSpec from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
 import { CookieQueryOptions } from "./cookieQueryOptions";
+import consola from "./logger";
 
 export async function queryCookies(
-  {
-    name,
-    domain,
-  }: //
-  CookieSpec,
+  { 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);
 
-  if (parsedArgs["require-jwt"]) {
-    const jwtCookies = [];
-    for (const result of allCookies) {
-      const value: string = result.value;
-      if (isValidJwt(value)) {
-        jwtCookies.push(result);
+  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 parsedArgs["single"] ? [jwtCookies[0]] : jwtCookies;
-  } else {
-    return parsedArgs["single"] ? [allCookies[0]] : allCookies;
-  }
+    return filteredCookies;
+  };
+
+  const jwtCookies: ExportedCookie[] = parsedArgs["require-jwt"]
+    ? filterCookies(allCookies, isValidJwt)
+    : allCookies;
+
+  return parsedArgs["single"] ? [jwtCookies[0]] : jwtCookies;
 }

package/src/resultsRendered.ts

@@ -1,11 +1,24 @@
 import { orderBy, uniqBy } from "lodash";
 import ExportedCookie from "./ExportedCookie";
 
-export function resultsRendered(results: ExportedCookie[]) {
-  // sort by name and expiry descending
-  // takes the latest expiry for each name
-  const orderedResults = orderBy(results, ["name", "expiry"], ["asc", "desc"]);
-  return uniqBy(orderedResults, (r: ExportedCookie) => r.name)
-    .map((r: ExportedCookie) => r.name + "=" + r.value)
-    .join("; ");
+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,16 +1,18 @@
-export function unpackHeaders(headerArgs: string[] | string | null) {
-  const headers: any = {};
-  if (headerArgs == null) {
+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 (const h of headerArgs) {
-      const [key, value] = h.split("=");
+    for (let i = 0; i < headerArgs.length; i++) {
+      const [key, value] = headerArgs[i].split("=");
       headers[key] = value;
     }
-    return headers;
+  } else {
+    const [key, value] = headerArgs.split("=");
+    headers[key] = value;
   }
-  const [key, value] = headerArgs.split("=");
-  headers[key] = value;
   return headers;
 }

package/src/util/flatMapAsync.ts

@@ -3,35 +3,39 @@
 
 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.,
+  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;
-        }
-      },
-      //
-    );
+    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 Array.prototype.map to transform each element of the input array with the provided callback.
+  // 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 ps: Promise<O>[] = array.map(callback) as Promise<O>[];
+  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: Awaited<O>[] = await Promise.all(ps);
+  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() as O[];
+  return awaitedAll.flat();
 }

package/tsconfig.json

@@ -5,12 +5,12 @@
     "src/**.js",
     "src/**.jsx",
     "src/**.test.ts",
-    "src/**.test.js"
+    "src/**.test.js",
   ],
   "compilerOptions": {
     "moduleResolution": "node",
     "target": "es6",
-    "types": ["node", "jest"],
+    "types": ["node", "jest", "bun-types"],
     "lib": ["es2015", "es2017", "es2021", "dom"],
     "strict": true,
     "skipDefaultLibCheck": true,
@@ -21,6 +21,6 @@
     "esModuleInterop": true,
     "module": "commonjs",
     "outDir": "dist",
-    "outFile": "dist/types.d.ts"
-  }
+    "outFile": "dist/types.d.ts",
+  },
 }