@intuned/runtime-dev 0.1.0-test.10 → 0.1.0-test.12

package/dist/commands/build.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { program, Argument } from "commander";
+import { rollup } from "rollup";
+import typescript from "@rollup/plugin-typescript";
+import commonjs from "@rollup/plugin-commonjs";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import dynamicImportVars from "@rollup/plugin-dynamic-import-vars";
+import json from "@rollup/plugin-json";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { moveWebTemplateFiles } from "./common/utils/webTemplate.js";
+function isThirdPartyWarning(warning) {
+  if (warning.id && /node_modules/.test(warning.id)) return true;
+  if (warning.ids && warning.ids.every(id => /node_modules/.test(id))) return true;
+  return false;
+}
+import dotenv from "dotenv";
+dotenv.config();
+program.description("build the intuned server").addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright"]).default("playwright").argOptional()).argument("[outfile]", "output bundle", "./output/bundle_v2.js").allowUnknownOption().action(async (mode, outfile) => {
+  await moveWebTemplateFiles();
+  const currentTemplateTsConfig = path.resolve(__dirname, "..", "..", "template.tsconfig.json");
+  await fs.copy(currentTemplateTsConfig, "./intuned/WebTemplate/tsconfig.json");
+  await build(outfile, mode);
+});
+async function build(outfile, mode) {
+  let bundle = null;
+  let buildFailed = false;
+  try {
+    bundle = await rollup({
+      input: `./intuned/WebTemplate/index.${mode}.ts`,
+      output: {
+        globals: {
+          crypto: "crypto"
+        }
+      },
+      plugins: [json(), nodeResolve({
+        exportConditions: ["node"],
+        preferBuiltins: true
+      }), typescript({
+        tsconfig: "./intuned/WebTemplate/tsconfig.json"
+      }), commonjs({
+        include: ["node_modules/**", "intuned/WebTemplate/**", "dist", "../typescript-sdk/**", "../typescript-runtime/**"],
+        extensions: [".js"],
+        ignoreGlobal: false,
+        sourceMap: false,
+        dynamicRequireTargets: ["api/**/*.js", "auth-sessions/**/*.js"],
+        requireReturnsDefault: "auto",
+        transformMixedEsModules: true
+      }), dynamicImportVars({
+        include: ["**/*.js", "**/*.ts"],
+        exclude: ["**/*.d.ts", "**/*.js.map"]
+      })],
+      onwarn: (warning, warn) => {
+        if (isThirdPartyWarning(warning)) return;
+        warn(warning);
+      },
+      external: ["@intuned/playwright", "@intuned/playwright-core", "@intuned/runtime", "jsdom", "canvas", "pdfjs-dist", "pdf-to-png-converter", "crypto", "applicationinsights", "fingerprint-generator", "fingerprint-injector"]
+    });
+    console.log(`📦 Building ${outfile}`);
+    const outfileFolder = path.dirname(outfile);
+    const assetsDir = path.resolve(__dirname, "..", "common", "assets");
+    await fs.copy(assetsDir, `${outfileFolder}/assets`);
+    await bundle.write({
+      format: "cjs",
+      file: outfile,
+      inlineDynamicImports: true
+    });
+    console.log(`✨ Build succeeded: ${outfile}`);
+  } catch (error) {
+    buildFailed = true;
+    console.error("error", error);
+  }
+  if (buildFailed) {
+    console.error("build failed");
+    process.exit(1);
+  }
+}
+program.parse(process.argv);

package/dist/commands/common/browserUtils.js

@@ -1,58 +1,56 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getChromiumLaunchArgs = exports.REMOTE_DEBUGGING_PORT = void 0;
-exports.loadState = loadState;
-exports.saveSession = saveSession;
-exports.saveSessionFromOpenedBrowser = saveSessionFromOpenedBrowser;
-exports.startOrRestartBrowser = startOrRestartBrowser;
-var _child_process = require("child_process");
-var playwright = _interopRequireWildcard(require("@intuned/playwright-core"));
-var fs = _interopRequireWildcard(require("fs-extra"));
-var _fileUtils = require("./utils/fileUtils");
-var _contextStorageStateHelpers = require("../../common/contextStorageStateHelpers");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const REMOTE_DEBUGGING_PORT = exports.REMOTE_DEBUGGING_PORT = 9222;
-const getChromiumLaunchArgs = () => ["--no-sandbox", `--remote-debugging-port=${REMOTE_DEBUGGING_PORT}`, `--user-data-dir=/tmp/${Date.now()}`, "--new-window", "--start-maximized", "--disable-popup-blocking"];
-exports.getChromiumLaunchArgs = getChromiumLaunchArgs;
+// this file is to make testing easier only.
+import { spawn } from "child_process";
+import * as playwright from "@intuned/playwright-core";
+import * as fs from "fs-extra";
+import { getFullPathInProject } from "./utils/fileUtils.js";
+import { getContextStorageState } from "../../common/contextStorageStateHelpers";
+export const REMOTE_DEBUGGING_PORT = 9222;
+export const getChromiumLaunchArgs = () => [
+    "--no-sandbox",
+    `--remote-debugging-port=${REMOTE_DEBUGGING_PORT}`,
+    `--user-data-dir=/tmp/${Date.now()}`,
+    "--new-window",
+    "--start-maximized",
+    "--disable-popup-blocking",
+];
+// this is needed cause we need to keep the same browser instance alive between start recording and stop recording calls.
 async function getBrowser() {
-  let playwrightBrowser = null;
-  try {
-    playwrightBrowser = await playwright.chromium.connectOverCDP(`http://localhost:${REMOTE_DEBUGGING_PORT}`);
-  } catch (e) {
-    throw new Error("Browser is not running");
-  }
-  return playwrightBrowser;
+    let playwrightBrowser = null;
+    try {
+        playwrightBrowser = await playwright.chromium.connectOverCDP(`http://localhost:${REMOTE_DEBUGGING_PORT}`);
+    }
+    catch (e) {
+        throw new Error("Browser is not running");
+    }
+    return playwrightBrowser;
 }
-async function startOrRestartBrowser() {
-  const chromiumPath = await playwright.chromium.executablePath();
-  const chromeInstanceProcess = (0, _child_process.spawn)(chromiumPath, getChromiumLaunchArgs());
-  chromeInstanceProcess.stdout.on("data", data => {
-    console.log(`Chrome stdout: ${data}`);
-  });
-  chromeInstanceProcess.stderr.on("data", data => {
-    console.error(`Chrome stderr: ${data}`);
-  });
+export async function startOrRestartBrowser() {
+    const chromiumPath = await playwright.chromium.executablePath();
+    const chromeInstanceProcess = spawn(chromiumPath, getChromiumLaunchArgs());
+    chromeInstanceProcess.stdout.on("data", (data) => {
+        console.log(`Chrome stdout: ${data}`);
+    });
+    chromeInstanceProcess.stderr.on("data", (data) => {
+        console.error(`Chrome stderr: ${data}`);
+    });
 }
-async function saveSessionFromOpenedBrowser(path) {
-  const browser = await getBrowser();
-  const context = await browser.contexts()[0];
-  return saveSession(path, context);
+export async function saveSessionFromOpenedBrowser(path) {
+    const browser = await getBrowser();
+    const context = await browser.contexts()[0];
+    return saveSession(path, context);
 }
-async function loadState(path, context) {
-  const fullPath = (0, _fileUtils.getFullPathInProject)(path);
-  if (!(await fs.pathExists(fullPath))) {
-    throw new Error("session file does not exist");
-  }
-  const data = await fs.readJson(fullPath);
-  await context.addCookies(data.cookies);
+export async function loadState(path, context) {
+    const fullPath = getFullPathInProject(path);
+    if (!(await fs.pathExists(fullPath))) {
+        throw new Error("session file does not exist");
+    }
+    const data = await fs.readJson(fullPath);
+    await context.addCookies(data.cookies);
+    // ToDo: logic to load storage without using the page.
+}
+export async function saveSession(path, context) {
+    const fullState = await getContextStorageState(context);
+    const fullPath = getFullPathInProject(path);
+    fs.ensureFileSync(fullPath);
+    await fs.writeJSON(fullPath, fullState);
 }
-async function saveSession(path, context) {
-  const fullState = await (0, _contextStorageStateHelpers.getContextStorageState)(context);
-  const fullPath = (0, _fileUtils.getFullPathInProject)(path);
-  fs.ensureFileSync(fullPath);
-  await fs.writeJSON(fullPath, fullState);
-}

package/dist/commands/common/browserUtils.ts

@@ -0,0 +1,45 @@
+import { spawn } from "child_process";
+import * as playwright from "@intuned/playwright-core";
+import * as fs from "fs-extra";
+import { getFullPathInProject } from "./utils/fileUtils.js";
+import { getContextStorageState } from "../../common/contextStorageStateHelpers";
+export const REMOTE_DEBUGGING_PORT = 9222;
+export const getChromiumLaunchArgs = () => ["--no-sandbox", `--remote-debugging-port=${REMOTE_DEBUGGING_PORT}`, `--user-data-dir=/tmp/${Date.now()}`, "--new-window", "--start-maximized", "--disable-popup-blocking"];
+async function getBrowser() {
+  let playwrightBrowser = null;
+  try {
+    playwrightBrowser = await playwright.chromium.connectOverCDP(`http://localhost:${REMOTE_DEBUGGING_PORT}`);
+  } catch (e) {
+    throw new Error("Browser is not running");
+  }
+  return playwrightBrowser;
+}
+export async function startOrRestartBrowser() {
+  const chromiumPath = await playwright.chromium.executablePath();
+  const chromeInstanceProcess = spawn(chromiumPath, getChromiumLaunchArgs());
+  chromeInstanceProcess.stdout.on("data", data => {
+    console.log(`Chrome stdout: ${data}`);
+  });
+  chromeInstanceProcess.stderr.on("data", data => {
+    console.error(`Chrome stderr: ${data}`);
+  });
+}
+export async function saveSessionFromOpenedBrowser(path) {
+  const browser = await getBrowser();
+  const context = await browser.contexts()[0];
+  return saveSession(path, context);
+}
+export async function loadState(path, context) {
+  const fullPath = getFullPathInProject(path);
+  if (!(await fs.pathExists(fullPath))) {
+    throw new Error("session file does not exist");
+  }
+  const data = await fs.readJson(fullPath);
+  await context.addCookies(data.cookies);
+}
+export async function saveSession(path, context) {
+  const fullState = await getContextStorageState(context);
+  const fullPath = getFullPathInProject(path);
+  fs.ensureFileSync(fullPath);
+  await fs.writeJSON(fullPath, fullState);
+}

package/dist/commands/common/getDefaultExportFromFile.js

@@ -1,17 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getDefaultExportFromFile = getDefaultExportFromFile;
-async function getDefaultExportFromFile(apiFilePath) {
-  require("ts-node").register({
-    transpileOnly: true,
-    compilerOptions: {
-      lib: ["dom", "es2020"]
-    }
-  });
-  const imported = await Promise.resolve(require(apiFilePath));
-  const defaultExport = imported.default;
-  return defaultExport;
-}
+export async function getDefaultExportFromFile(apiFilePath) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require("ts-node").register({
+        transpileOnly: true,
+        compilerOptions: {
+            lib: ["dom", "es2020"],
+        },
+    });
+    const imported = await import(apiFilePath);
+    const defaultExport = imported.default;
+    return defaultExport;
+}

package/dist/commands/common/getDefaultExportFromFile.ts

@@ -0,0 +1,11 @@
+export async function getDefaultExportFromFile(apiFilePath) {
+  require("ts-node").register({
+    transpileOnly: true,
+    compilerOptions: {
+      lib: ["dom", "es2020"]
+    }
+  });
+  const imported = await import(apiFilePath);
+  const defaultExport = imported.default;
+  return defaultExport;
+}

package/dist/commands/common/getFirstLineNumber.js

@@ -1,103 +1,103 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getFirstLineNumber;
-exports.findFirstExecutableLine = findFirstExecutableLine;
-var _tsMorph = require("ts-morph");
-var _sourceMap = require("source-map");
+import { ts, Project, ModuleKind, ScriptTarget, Node, } from "ts-morph";
+import { SourceMapConsumer } from "source-map";
 function compileTypeScript(apiFilePath) {
-  const compilerOptions = {
-    lib: ["dom", "es2020"],
-    sourceMap: true,
-    inlineSourceMap: true,
-    inlineSources: true,
-    declaration: false,
-    noEmit: false,
-    module: _tsMorph.ModuleKind.CommonJS,
-    target: _tsMorph.ScriptTarget.ES2020
-  };
-  const project = new _tsMorph.Project({
-    compilerOptions
-  });
-  const sourceFile = project.addSourceFileAtPath(apiFilePath);
-  const outputJS = project.emitToMemory({
-    targetSourceFile: sourceFile
-  });
-  const outputJSText = outputJS.getFiles()[0].text;
-  return {
-    sourceFile,
-    outputJSText
-  };
+    const compilerOptions = {
+        lib: ["dom", "es2020"],
+        sourceMap: true,
+        inlineSourceMap: true,
+        inlineSources: true,
+        declaration: false,
+        noEmit: false,
+        module: ModuleKind.CommonJS,
+        target: ScriptTarget.ES2020,
+    };
+    const project = new Project({
+        compilerOptions,
+    });
+    const sourceFile = project.addSourceFileAtPath(apiFilePath);
+    const outputJS = project.emitToMemory({ targetSourceFile: sourceFile });
+    const outputJSText = outputJS.getFiles()[0].text;
+    return { sourceFile, outputJSText };
 }
-function findFirstExecutableLine(sourceFile) {
-  var _defaultExportSymbol$;
-  let functionBody;
-  const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
-  const defaultExportDeclaration = defaultExportSymbol === null || defaultExportSymbol === void 0 || (_defaultExportSymbol$ = defaultExportSymbol.getDeclarations()) === null || _defaultExportSymbol$ === void 0 ? void 0 : _defaultExportSymbol$[0];
-  if (defaultExportDeclaration) {
-    if (defaultExportDeclaration.getKind() === _tsMorph.ts.SyntaxKind.FunctionDeclaration) {
-      functionBody = defaultExportDeclaration.getBody();
-    } else {
-      const exportAssignments = sourceFile.getExportAssignments();
-      for (const exportAssignment of exportAssignments) {
-        const expression = exportAssignment.getExpression();
-        if (!expression) continue;
-        if (expression.getKind() === _tsMorph.ts.SyntaxKind.Identifier || expression.getKind() === _tsMorph.ts.SyntaxKind.FunctionExpression || expression.getKind() === _tsMorph.ts.SyntaxKind.ArrowFunction) {
-          var _sourceFile$getVariab;
-          const identifier = expression.getText();
-          const possiblyExportedFunction = sourceFile.getFunction(identifier) || ((_sourceFile$getVariab = sourceFile.getVariableStatement(identifier)) === null || _sourceFile$getVariab === void 0 ? void 0 : _sourceFile$getVariab.getDescendants().find(node => node.getKind() === _tsMorph.ts.SyntaxKind.FunctionExpression || node.getKind() === _tsMorph.ts.SyntaxKind.ArrowFunction));
-          if (possiblyExportedFunction) {
-            functionBody = possiblyExportedFunction.getBody();
-            break;
-          }
+export function findFirstExecutableLine(sourceFile) {
+    let functionBody;
+    // Directly find the default exported function's body
+    const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
+    const defaultExportDeclaration = defaultExportSymbol?.getDeclarations()?.[0];
+    if (defaultExportDeclaration) {
+        // Check if the default export is a function
+        if (defaultExportDeclaration.getKind() === ts.SyntaxKind.FunctionDeclaration) {
+            functionBody = defaultExportDeclaration.getBody();
         }
-        if (_tsMorph.Node.hasBody(expression) && (expression.getKind() === _tsMorph.ts.SyntaxKind.FunctionExpression || expression.getKind() === _tsMorph.ts.SyntaxKind.ArrowFunction)) {
-          functionBody = expression.getBody();
-          break;
+        else {
+            // Handle ExportAssignment specifically for cases like `export default identifier;`
+            const exportAssignments = sourceFile.getExportAssignments();
+            for (const exportAssignment of exportAssignments) {
+                const expression = exportAssignment.getExpression();
+                if (!expression)
+                    continue;
+                if (expression.getKind() === ts.SyntaxKind.Identifier ||
+                    expression.getKind() === ts.SyntaxKind.FunctionExpression ||
+                    expression.getKind() === ts.SyntaxKind.ArrowFunction) {
+                    const identifier = expression.getText();
+                    const possiblyExportedFunction = sourceFile.getFunction(identifier) ||
+                        sourceFile
+                            .getVariableStatement(identifier)
+                            ?.getDescendants()
+                            .find((node) => node.getKind() === ts.SyntaxKind.FunctionExpression ||
+                            node.getKind() === ts.SyntaxKind.ArrowFunction);
+                    if (possiblyExportedFunction) {
+                        functionBody = possiblyExportedFunction.getBody();
+                        break;
+                    }
+                }
+                if (Node.hasBody(expression) &&
+                    (expression.getKind() === ts.SyntaxKind.FunctionExpression ||
+                        expression.getKind() === ts.SyntaxKind.ArrowFunction)) {
+                    // As these are anonymous, we directly access their body
+                    functionBody = expression.getBody();
+                    break;
+                }
+            }
         }
-      }
     }
-  }
-  if (!functionBody || !_tsMorph.Node.isStatemented(functionBody)) {
-    return -1;
-  }
-  if (functionBody.getStatements().length === 0) {
-    return -1;
-  }
-  const position = functionBody.getStatements()[0].getStart();
-  return sourceFile.getLineAndColumnAtPos(position);
+    if (!functionBody || !Node.isStatemented(functionBody)) {
+        return -1;
+    }
+    if (functionBody.getStatements().length === 0) {
+        return -1;
+    }
+    const position = functionBody.getStatements()[0].getStart();
+    return sourceFile.getLineAndColumnAtPos(position);
 }
 async function getSourceMap(jsCode) {
-  const sourceMapBase64 = jsCode.substring(jsCode.lastIndexOf("//# sourceMappingURL=data:application/json;base64,") + "//# sourceMappingURL=data:application/json;base64,".length);
-  const sourceMapText = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
-  const sourceMap = JSON.parse(sourceMapText);
-  return new _sourceMap.SourceMapConsumer(sourceMap);
+    const sourceMapBase64 = jsCode.substring(jsCode.lastIndexOf("//# sourceMappingURL=data:application/json;base64,") +
+        "//# sourceMappingURL=data:application/json;base64,".length);
+    const sourceMapText = Buffer.from(sourceMapBase64, "base64").toString("utf-8");
+    const sourceMap = JSON.parse(sourceMapText);
+    return new SourceMapConsumer(sourceMap);
 }
 async function mapFirstLineNumberBySourceMap(sourceFileName, jsCode, line, column) {
-  const sourceMap = await getSourceMap(jsCode);
-  const generatedLineNumber = sourceMap.generatedPositionFor({
-    source: sourceFileName,
-    line,
-    column
-  }).line;
-  if (!generatedLineNumber) return -1;
-  return generatedLineNumber;
+    const sourceMap = await getSourceMap(jsCode);
+    const generatedLineNumber = sourceMap.generatedPositionFor({
+        source: sourceFileName,
+        line,
+        column,
+    }).line;
+    if (!generatedLineNumber)
+        return -1;
+    return generatedLineNumber;
+}
+export default async function getFirstLineNumber(apiFilePath) {
+    const sourceFileName = apiFilePath.split("/").pop() ?? apiFilePath;
+    // Compile TypeScript to JavaScript and get the Typescript AST
+    const { sourceFile, outputJSText } = compileTypeScript(apiFilePath);
+    // Find the first line of code in the default export ts code
+    const result = findFirstExecutableLine(sourceFile);
+    if (result === -1)
+        return { sourceFileName, lineNumber: -1 };
+    return {
+        sourceFileName,
+        lineNumber: await mapFirstLineNumberBySourceMap(sourceFileName, outputJSText, result.line, result.column),
+    };
 }
-async function getFirstLineNumber(apiFilePath) {
-  const sourceFileName = apiFilePath.split("/").pop() ?? apiFilePath;
-  const {
-    sourceFile,
-    outputJSText
-  } = compileTypeScript(apiFilePath);
-  const result = findFirstExecutableLine(sourceFile);
-  if (result === -1) return {
-    sourceFileName,
-    lineNumber: -1
-  };
-  return {
-    sourceFileName,
-    lineNumber: await mapFirstLineNumberBySourceMap(sourceFileName, outputJSText, result.line, result.column)
-  };
-}