@mherod/get-cookie 2.0.0-beta.8 → 2.0.0-rc.1

package/src/doSqliteQuery1.ts

@@ -1,9 +1,20 @@
 import * as fs from "fs";
 import * as sqlite3 from "sqlite3";
-import CookieRow from "./CookieRow";
+import { CookieRow } from "./CookieRow";
+import { merge } from "lodash";
 
-export async function doSqliteQuery1(file: string, sql: string): Promise<CookieRow[]> {
-  if (!fs.existsSync(file)) {
+interface DoSqliteQuery1Params {
+  file: string;
+  sql: string;
+  rowTransform: (row: any) => CookieRow;
+}
+
+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);
@@ -19,15 +30,14 @@ export async function doSqliteQuery1(file: string, sql: string): Promise<CookieR
         return;
       }
       if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row) => {
-          return {
-            domain: row["host_key"],
-            name: row["name"],
-            value: row["encrypted_value"],
+        const cookieRows: CookieRow[] = rows1.map((row: any) => {
+          const newVar = {
             meta: {
-              file: file
-            }
+              file: file,
+            },
           };
+          const cookieRow: CookieRow = rowTransform(row);
+          return merge(newVar, cookieRow);
         });
         resolve(cookieRows);
         return;

package/src/fetchWithCookies.ts

@@ -4,32 +4,48 @@ import { fetch } from "cross-fetch";
 import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
-import FetchResponse from "./fetchResponse";
+import FetchResponse from "./FetchResponse";
 import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
 
 export async function fetchWithCookies(
   url: RequestInfo | URL,
   options: RequestInit | undefined = {}
 ): Promise<FetchResponse> {
-  const url1 = new URL(`${url}`);
-  const cookie: string[] = await getGroupedRenderedCookies({
+  const defaultOptions: RequestInit = {
+    headers: {
+      "User-Agent":
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
+    },
+    redirect: "manual",
+  };
+  const url2: string = `${url}`;
+  const url1: URL = new URL(url2);
+  const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1) => {
+    return `%${p1}`;
+  });
+  const cookies: string[] = await getGroupedRenderedCookies({
     name: "%",
-    domain: url1.hostname
+    domain: domain,
   });
-  merge(options, {
-    credentials: "include",
+  const cookie = cookies.pop();
+  const newOptions1: RequestInit = merge(defaultOptions, options, {
     headers: {
-      Cookie: cookie.pop()
-    }
+      Cookie: cookie,
+    },
   });
   try {
-    const res = await fetch(url, options);
+    const res: Response = await fetch(url2, newOptions1);
+    const newUrl = res.headers.get("location") as string;
+    if (res.redirected || (newUrl && newUrl !== url2)) {
+      return fetchWithCookies(newUrl, newOptions1);
+    }
     const arrayBuffer1 = res.arrayBuffer();
     const arrayBuffer = async () => arrayBuffer1;
     const buffer = async () => arrayBuffer().then(Buffer.from);
     const text = async () => buffer().then((buffer) => buffer.toString("utf8"));
     const json = async () => text().then(destr);
-    const formData = async () => text().then((text) => new URLSearchParams(text));
+    const formData = async () =>
+      text().then((text) => new URLSearchParams(text));
     const source2 = {
       status: res.status,
       statusText: res.statusText,
@@ -38,7 +54,7 @@ export async function fetchWithCookies(
       buffer,
       text,
       json,
-      formData
+      formData,
       //
     };
     return merge({}, res, source2);

package/src/findAllFiles.ts

@@ -1,18 +1,16 @@
 import { env } from "./global";
 import * as fs from "fs";
 
-export async function findAllFiles(
-  {
-    path,
-    name,
-    maxDepth = 2
-//
-  }: {
-    path: string;
-    name: string;
-    maxDepth?: number;
-  }
-): Promise<string[]> {
+export async function findAllFiles({
+  path,
+  name,
+  maxDepth = 2,
+}: //
+{
+  path: string;
+  name: string;
+  maxDepth?: number;
+}): Promise<string[]> {
   const rootSegments = path.split("/").length;
 
   if (env.VERBOSE) {
@@ -45,7 +43,7 @@ export async function findAllFiles(
           const subFiles = await findAllFiles({
             path: filePath,
             name: name,
-            maxDepth: 2
+            maxDepth: 2,
           });
           files.push(...subFiles);
         } catch (e) {

package/src/getGroupedRenderedCookies.ts

@@ -1,19 +1,19 @@
-import ExportedCookie from "./ExportedCookie";
 import { queryCookies } from "./queryCookies";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import { groupBy } from "lodash";
 import { resultsRendered } from "./resultsRendered";
-import CookieRequest from "./CookieRequest";
+import { CookieSpec } from "./CookieSpec";
+import { ExportedCookie } from "./ExportedCookie";
 
 export async function getGroupedRenderedCookies(
   //
   {
     name,
-    domain
-    //
-  }: CookieRequest
-  //
-): Promise<string[]> {
+    domain,
+  }: //
+  CookieSpec
+): //
+Promise<string[]> {
   const cookies: ExportedCookie[] = await queryCookies(
     { name, domain },
     new CompositeCookieQueryStrategy()

package/src/global.ts

@@ -1,4 +1,5 @@
-const { merge } = require("lodash");
+import { merge } from "lodash";
+
 export const env: any = {};
 merge(env, process.env);
 export const HOME: string = env["HOME"];

package/src/index.ts

@@ -5,10 +5,14 @@ import { queryCookies } from "./queryCookies";
 import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
 import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { CookieSpec } from "./CookieSpec";
+import { ExportedCookie } from "./ExportedCookie";
 import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
 import { fetchWithCookies } from "./fetchWithCookies";
 
-export async function getCookie(params: { name: string; domain: string; }) {
+export async function getCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
   const cookies = await queryCookies(
     params,
     new CompositeCookieQueryStrategy()
@@ -21,12 +25,9 @@ export async function getCookie(params: { name: string; domain: string; }) {
   }
 }
 
-/**
- *
- * @param params
- * @returns {Promise<*>}
- */
-export async function getFirefoxCookie(params: { name: string; domain: string; }) {
+export async function getFirefoxCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
   const cookies = await queryCookies(
     params,
     new FirefoxCookieQueryStrategy()
@@ -39,12 +40,9 @@ export async function getFirefoxCookie(params: { name: string; domain: string; }
   }
 }
 
-/**
- *
- * @param params
- * @returns {Promise<*>}
- */
-export async function getChromeCookie(params: { name: string; domain: string; }) {
+export async function getChromeCookie(
+  params: CookieSpec
+): Promise<ExportedCookie | undefined> {
   const cookies = await queryCookies(
     params,
     new ChromeCookieQueryStrategy()
@@ -57,10 +55,8 @@ export async function getChromeCookie(params: { name: string; domain: string; })
   }
 }
 
-export default {
-  getCookie,
-  getFirefoxCookie,
-  getChromeCookie,
-  getGroupedRenderedCookies,
-  fetchWithCookies
-}
+export { getGroupedRenderedCookies, fetchWithCookies };
+
+export * from "./CookieSpec";
+export * from "./CookieRow";
+export * from "./ExportedCookie";

package/src/isValidJwt.ts

@@ -1,4 +1,4 @@
-import jsonwebtoken from "jsonwebtoken";
+import jsonwebtoken, { JwtPayload } from "jsonwebtoken";
 import { env } from "./global";
 
 export default function isValidJwt(token: any) {
@@ -7,6 +7,16 @@ export default function isValidJwt(token: any) {
     if (env.VERBOSE) {
       console.log(result);
     }
+    const payload: JwtPayload = result?.payload as JwtPayload;
+    if (payload) {
+      const exp = payload.exp;
+      if (exp) {
+        const now = new Date().getTime() / 1000;
+        if (now > exp) {
+          return false;
+        }
+      }
+    }
     return true;
   } catch (err) {
     return false;

package/src/queryCookies.ts

@@ -3,14 +3,11 @@ import { uniqBy } from "lodash";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
 import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
 import isValidJwt from "./isValidJwt";
-import ExportedCookie from "./ExportedCookie";
-import CookieRequest from "./CookieRequest";
+import { CookieSpec } from "./CookieSpec";
+import { ExportedCookie } from "./ExportedCookie";
 
 export async function queryCookies(
-  {
-    name,
-    domain
-  }: CookieRequest,
+  { name, domain }: CookieSpec,
   strategy: CookieQueryStrategy = new CompositeCookieQueryStrategy()
 ) {
   const results: ExportedCookie[] = await strategy.queryCookies(name, domain);

package/src/resultsRendered.ts

@@ -1,5 +1,5 @@
-import ExportedCookie from "./ExportedCookie";
 import { uniqBy } from "lodash";
+import { ExportedCookie } from "./ExportedCookie";
 
 export function resultsRendered(results: ExportedCookie[]) {
   return uniqBy(results, (r) => r.name)

package/src/unpackHeaders.ts

@@ -0,0 +1,13 @@
+export function unpackHeaders(headerArgs: string[] | string) {
+  const headers: any = {};
+  if (Array.isArray(headerArgs)) {
+    for (const h of headerArgs) {
+      const [key, value] = h.split("=");
+      headers[key] = value;
+    }
+  } else {
+    const [key, value] = headerArgs.split("=");
+    headers[key] = value;
+  }
+  return headers;
+}

package/src/utils.ts

@@ -1,6 +1,6 @@
 // noinspection JSUnusedGlobalSymbols
 
-import {exec, ExecException} from "child_process";
+import { exec, ExecException } from "child_process";
 
 export async function execSimple(command: string): Promise<string> {
   return new Promise((resolve, reject) => {
@@ -24,11 +24,6 @@ export async function execSimple(command: string): Promise<string> {
   });
 }
 
-/**
- *
- * @param result
- * @returns {string|null}
- */
 export function toStringOrNull(result: any) {
   if (result == null) {
     return null;
@@ -50,7 +45,6 @@ export function invalidString(input: any): boolean {
   return typeof input !== "string" || input.length === 0;
 }
 
-
 export function validString(input: any): input is string {
   return typeof input == "string" && input.length > 0;
 }