@mherod/get-cookie 2.0.0-beta.1 → 2.0.0-beta.10

package/src/fetchWithCookies.ts

@@ -0,0 +1,62 @@
+// noinspection JSUnusedGlobalSymbols
+
+import { fetch } from "cross-fetch";
+import { merge } from "lodash";
+// noinspection SpellCheckingInspection
+import destr from "destr";
+import FetchResponse from "./fetchResponse";
+import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+
+export async function fetchWithCookies(
+  url: RequestInfo | URL,
+  options: RequestInit | undefined = {}
+): Promise<FetchResponse> {
+  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: domain
+  });
+  const cookie = cookies.pop();
+  const newOptions1: RequestInit = merge(defaultOptions, options, {
+    headers: {
+      Cookie: cookie
+    }
+  });
+  try {
+    const res = 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 source2 = {
+      status: res.status,
+      statusText: res.statusText,
+      headers: res.headers,
+      arrayBuffer,
+      buffer,
+      text,
+      json,
+      formData
+      //
+    };
+    return merge({}, res, source2);
+  } catch (e) {
+    throw e;
+  }
+}

package/src/{findAllFiles.js → findAllFiles.ts}

@@ -1,28 +1,24 @@
 import { env } from "./global";
-import fs from "fs";
+import * as fs from "fs";
 
-/**
- *
- * @param path
- * @param name
- * @param rootSegments
- * @param maxDepth
- * @returns {Promise<[string]>}
- */
-export async function findAllFiles({ path, name, maxDepth = 2 }) {
-  if (typeof path !== "string") {
-    throw new Error("path must be a string");
+export async function findAllFiles(
+  {
+    path,
+    name,
+    maxDepth = 2
+//
+  }: {
+    path: string;
+    name: string;
+    maxDepth?: number;
   }
-  if (typeof name !== "string") {
-    throw new Error("name must be a string");
-  }
-
+): Promise<string[]> {
   const rootSegments = path.split("/").length;
 
   if (env.VERBOSE) {
     console.log(`Searching for ${name} in ${path}`);
   }
-  const files = [];
+  const files: string[] = [];
   let readdirSync;
   try {
     readdirSync = fs.readdirSync(path);
@@ -30,7 +26,7 @@ export async function findAllFiles({ path, name, maxDepth = 2 }) {
     if (env.VERBOSE) {
       console.log(`Error reading ${path}`, e);
     }
-    return files;
+    return [];
   }
   for (const file of readdirSync) {
     const filePath = path + "/" + file;
@@ -49,8 +45,7 @@ export async function findAllFiles({ path, name, maxDepth = 2 }) {
           const subFiles = await findAllFiles({
             path: filePath,
             name: name,
-            rootSegments: rootSegments,
-            maxDepth: 2,
+            maxDepth: 2
           });
           files.push(...subFiles);
         } catch (e) {

package/src/getGroupedRenderedCookies.ts

@@ -0,0 +1,32 @@
+import { queryCookies } from "./queryCookies";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { groupBy } from "lodash";
+import { resultsRendered } from "./resultsRendered";
+import { CookieRequest } from "./CookieRequest";
+import { ExportedCookie } from "./ExportedCookie";
+
+export async function getGroupedRenderedCookies(
+  //
+  {
+    name,
+    domain
+    //
+  }: CookieRequest
+  //
+): Promise<string[]> {
+  const cookies: ExportedCookie[] = await queryCookies(
+    { name, domain },
+    new CompositeCookieQueryStrategy()
+    //
+  );
+  if (Array.isArray(cookies) && cookies.length > 0) {
+    const results: ExportedCookie[] = await queryCookies({ name, domain });
+    const groupedByFile = groupBy(results, (r) => r.meta?.file);
+    return Object.keys(groupedByFile).map((file: string) => {
+      const results: ExportedCookie[] = groupedByFile[file];
+      return resultsRendered(results);
+    });
+  } else {
+    throw new Error("Cookie not found");
+  }
+}

package/src/{global.js → global.ts}

@@ -1,7 +1,7 @@
 const { merge } = require("lodash");
-export const env = {};
+export const env: any = {};
 merge(env, process.env);
-export const HOME = env["HOME"];
+export const HOME: string = env["HOME"];
 if (!HOME) {
   throw new Error("HOME environment variable is not set");
 }

package/src/{index.js → index.ts}

@@ -5,13 +5,12 @@ import { queryCookies } from "./queryCookies";
 import FirefoxCookieQueryStrategy from "./browsers/FirefoxCookieQueryStrategy";
 import ChromeCookieQueryStrategy from "./browsers/ChromeCookieQueryStrategy";
 import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import { CookieRequest } from "./CookieRequest";
+import { ExportedCookie } from "./ExportedCookie";
+import { getGroupedRenderedCookies } from "./getGroupedRenderedCookies";
+import { fetchWithCookies } from "./fetchWithCookies";
 
-/**
- *
- * @param params
- * @returns {Promise<string>}
- */
-export async function getCookie(params) {
+export async function getCookie(params: CookieRequest): Promise<ExportedCookie | undefined> {
   const cookies = await queryCookies(
     params,
     new CompositeCookieQueryStrategy()
@@ -24,12 +23,7 @@ export async function getCookie(params) {
   }
 }
 
-/**
- *
- * @param params
- * @returns {Promise<*>}
- */
-export async function getFirefoxCookie(params) {
+export async function getFirefoxCookie(params: CookieRequest): Promise<ExportedCookie | undefined> {
   const cookies = await queryCookies(
     params,
     new FirefoxCookieQueryStrategy()
@@ -42,12 +36,7 @@ export async function getFirefoxCookie(params) {
   }
 }
 
-/**
- *
- * @param params
- * @returns {Promise<*>}
- */
-export async function getChromeCookie(params) {
+export async function getChromeCookie(params: CookieRequest): Promise<ExportedCookie | undefined> {
   const cookies = await queryCookies(
     params,
     new ChromeCookieQueryStrategy()
@@ -59,3 +48,12 @@ export async function getChromeCookie(params) {
     throw new Error("Cookie not found");
   }
 }
+
+export {
+  getGroupedRenderedCookies,
+  fetchWithCookies,
+};
+
+export * from "./CookieRequest";
+export * from "./CookieRow";
+export * from "./ExportedCookie";

package/src/{isValidJwt.js → isValidJwt.ts}

@@ -1,10 +1,7 @@
 import jsonwebtoken from "jsonwebtoken";
 import { env } from "./global";
 
-export default function isValidJwt(token) {
-  if (typeof token !== "string") {
-    return false;
-  }
+export default function isValidJwt(token: any) {
   try {
     const result = jsonwebtoken.decode(token, { complete: true });
     if (env.VERBOSE) {

package/src/queryCookies.ts

@@ -0,0 +1,27 @@
+import { env } from "./global";
+import { uniqBy } from "lodash";
+import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
+import CookieQueryStrategy from "./browsers/CookieQueryStrategy";
+import isValidJwt from "./isValidJwt";
+import { CookieRequest } from "./CookieRequest";
+import { ExportedCookie } from "./ExportedCookie";
+
+export async function queryCookies(
+  {
+    name,
+    domain
+  }: CookieRequest,
+  strategy: CookieQueryStrategy = new CompositeCookieQueryStrategy()
+) {
+  const results: ExportedCookie[] = await strategy.queryCookies(name, domain);
+  const results1: ExportedCookie[] = uniqBy(results, JSON.stringify);
+  const jwtCookies = [];
+  for (const result of results1) {
+    const value = result.value;
+    if (isValidJwt(value)) {
+      jwtCookies.push(result);
+    }
+  }
+  const resultsUniq = env.REQUIRE_JWT ? jwtCookies : results1;
+  return env.SINGLE ? [resultsUniq[0]] : resultsUniq;
+}

package/src/resultsRendered.ts

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

package/src/utils.ts

@@ -0,0 +1,56 @@
+// 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());
+        }
+      }
+    );
+  });
+}
+
+/**
+ *
+ * @param result
+ * @returns {string|null}
+ */
+export function toStringOrNull(result: any) {
+  if (result == null) {
+    return null;
+  }
+  if (process.env.VERBOSE) {
+    console.log("result", result);
+  }
+  if (typeof result === "string" && result.length > 0) {
+    return result;
+  }
+  if (result.slice && result.toString) {
+    // noinspection JSCheckFunctionSignatures
+    return result.toString("utf8");
+  }
+  return null;
+}
+
+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;
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "include": [
+    "src/**.ts",
+    "src/**.tsx",
+    "src/**.js",
+    "src/**.jsx"
+  ],
+  "compilerOptions": {
+    "moduleResolution": "node",
+    "target": "es2021",
+    "types": [
+      "node"
+    ],
+    "lib": [
+      "es2015",
+      "es2017",
+      "es2021",
+      "dom"
+    ],
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+  }
+}