@tomerh2001/israeli-bank-scrapers 6.3.11

package/lib/scrapers/base-scraper-with-browser.js

@@ -0,0 +1,291 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LoginResults = exports.BaseScraperWithBrowser = void 0;
+var _puppeteer = _interopRequireDefault(require("puppeteer"));
+var _definitions = require("../definitions");
+var _debug = require("../helpers/debug");
+var _elementsInteractions = require("../helpers/elements-interactions");
+var _navigation = require("../helpers/navigation");
+var _baseScraper = require("./base-scraper");
+var _errors = require("./errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.getDebug)('base-scraper-with-browser');
+var LoginBaseResults = /*#__PURE__*/function (LoginBaseResults) {
+  LoginBaseResults["Success"] = "SUCCESS";
+  LoginBaseResults["UnknownError"] = "UNKNOWN_ERROR";
+  return LoginBaseResults;
+}(LoginBaseResults || {});
+const {
+  Timeout,
+  Generic,
+  General,
+  ...rest
+} = _errors.ScraperErrorTypes;
+const LoginResults = exports.LoginResults = {
+  ...rest,
+  ...LoginBaseResults
+};
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+
+async function getKeyByValue(object, value, page) {
+  const keys = Object.keys(object);
+  for (const key of keys) {
+    // @ts-ignore
+    const conditions = object[key];
+    for (const condition of conditions) {
+      let result = false;
+      if (condition instanceof RegExp) {
+        result = condition.test(value);
+      } else if (typeof condition === 'function') {
+        result = await condition({
+          page,
+          value
+        });
+      } else {
+        result = value.toLowerCase() === condition.toLowerCase();
+      }
+      if (result) {
+        // @ts-ignore
+        return Promise.resolve(key);
+      }
+    }
+  }
+  return Promise.resolve(LoginResults.UnknownError);
+}
+function createGeneralError() {
+  return {
+    success: false,
+    errorType: _errors.ScraperErrorTypes.General
+  };
+}
+async function safeCleanup(cleanup) {
+  try {
+    await cleanup();
+  } catch (e) {
+    debug(`Cleanup function failed: ${e.message}`);
+  }
+}
+class BaseScraperWithBrowser extends _baseScraper.BaseScraper {
+  cleanups = [];
+  defaultViewportSize = {
+    width: 1024,
+    height: 768
+  };
+
+  // NOTICE - it is discouraged to use bang (!) in general. It is used here because
+  // all the classes that inherit from this base assume is it mandatory.
+
+  getViewPort() {
+    return this.options.viewportSize ?? this.defaultViewportSize;
+  }
+  async initialize() {
+    await super.initialize();
+    debug('initialize scraper');
+    this.emitProgress(_definitions.ScraperProgressTypes.Initializing);
+    const page = await this.initializePage();
+    await page.setCacheEnabled(false); // Clear cache and avoid 300's response status
+
+    if (!page) {
+      debug('failed to initiate a browser page, exit');
+      return;
+    }
+    this.page = page;
+    this.cleanups.push(() => page.close());
+    if (this.options.defaultTimeout) {
+      this.page.setDefaultTimeout(this.options.defaultTimeout);
+    }
+    if (this.options.preparePage) {
+      debug("execute 'preparePage' interceptor provided in options");
+      await this.options.preparePage(this.page);
+    }
+    const viewport = this.getViewPort();
+    debug(`set viewport to width ${viewport.width}, height ${viewport.height}`);
+    await this.page.setViewport({
+      width: viewport.width,
+      height: viewport.height
+    });
+    this.page.on('requestfailed', request => {
+      debug('Request failed: %s %s', request.failure()?.errorText, request.url());
+    });
+  }
+  async initializePage() {
+    debug('initialize browser page');
+    if ('browserContext' in this.options) {
+      debug('Using the browser context provided in options');
+      return this.options.browserContext.newPage();
+    }
+    if ('browser' in this.options) {
+      debug('Using the browser instance provided in options');
+      const {
+        browser
+      } = this.options;
+
+      /**
+       * For backward compatibility, we will close the browser even if we didn't create it
+       */
+      if (!this.options.skipCloseBrowser) {
+        this.cleanups.push(async () => {
+          debug('closing the browser');
+          await browser.close();
+        });
+      }
+      return browser.newPage();
+    }
+    const {
+      timeout,
+      args,
+      executablePath,
+      showBrowser
+    } = this.options;
+    const headless = !showBrowser;
+    debug(`launch a browser with headless mode = ${headless}`);
+    const browser = await _puppeteer.default.launch({
+      env: this.options.verbose ? {
+        DEBUG: '*',
+        ...process.env
+      } : undefined,
+      headless,
+      executablePath,
+      args,
+      timeout
+    });
+    this.cleanups.push(async () => {
+      debug('closing the browser');
+      await browser.close();
+    });
+    if (this.options.prepareBrowser) {
+      debug("execute 'prepareBrowser' interceptor provided in options");
+      await this.options.prepareBrowser(browser);
+    }
+    debug('create a new browser page');
+    return browser.newPage();
+  }
+  async navigateTo(url, waitUntil = 'load', retries = this.options.navigationRetryCount ?? 0) {
+    const response = await this.page?.goto(url, {
+      waitUntil
+    });
+    if (response === null) {
+      // note: response will be null when navigating to same url while changing the hash part.
+      // the condition below will always accept null as valid result.
+      return;
+    }
+    if (!response) {
+      throw new Error(`Error while trying to navigate to url ${url}, response is undefined`);
+    }
+    if (!response.ok()) {
+      const status = response.status();
+      if (retries > 0) {
+        debug(`Failed to navigate to url ${url}, status code: ${status}, retrying ${retries} more times`);
+        await this.navigateTo(url, waitUntil, retries - 1);
+      } else {
+        throw new Error(`Failed to navigate to url ${url}, status code: ${status}`);
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getLoginOptions(_credentials) {
+    throw new Error(`getLoginOptions() is not created in ${this.options.companyId}`);
+  }
+  async fillInputs(pageOrFrame, fields) {
+    const modified = [...fields];
+    const input = modified.shift();
+    if (!input) {
+      return;
+    }
+    await (0, _elementsInteractions.fillInput)(pageOrFrame, input.selector, input.value);
+    if (modified.length) {
+      await this.fillInputs(pageOrFrame, modified);
+    }
+  }
+  async login(credentials) {
+    if (!credentials || !this.page) {
+      return createGeneralError();
+    }
+    debug('execute login process');
+    const loginOptions = this.getLoginOptions(credentials);
+    if (loginOptions.userAgent) {
+      debug('set custom user agent provided in options');
+      await this.page.setUserAgent(loginOptions.userAgent);
+    }
+    debug('navigate to login url');
+    await this.navigateTo(loginOptions.loginUrl, loginOptions.waitUntil);
+    if (loginOptions.checkReadiness) {
+      debug("execute 'checkReadiness' interceptor provided in login options");
+      await loginOptions.checkReadiness();
+    } else if (typeof loginOptions.submitButtonSelector === 'string') {
+      debug('wait until submit button is available');
+      await (0, _elementsInteractions.waitUntilElementFound)(this.page, loginOptions.submitButtonSelector);
+    }
+    let loginFrameOrPage = this.page;
+    if (loginOptions.preAction) {
+      debug("execute 'preAction' interceptor provided in login options");
+      loginFrameOrPage = (await loginOptions.preAction()) || this.page;
+    }
+    debug('fill login components input with relevant values');
+    await this.fillInputs(loginFrameOrPage, loginOptions.fields);
+    debug('click on login submit button');
+    if (typeof loginOptions.submitButtonSelector === 'string') {
+      await (0, _elementsInteractions.clickButton)(loginFrameOrPage, loginOptions.submitButtonSelector);
+    } else {
+      await loginOptions.submitButtonSelector();
+    }
+    this.emitProgress(_definitions.ScraperProgressTypes.LoggingIn);
+    if (loginOptions.postAction) {
+      debug("execute 'postAction' interceptor provided in login options");
+      await loginOptions.postAction();
+    } else {
+      debug('wait for page navigation');
+      await (0, _navigation.waitForNavigation)(this.page);
+    }
+    debug('check login result');
+    const current = await (0, _navigation.getCurrentUrl)(this.page, true);
+    const loginResult = await getKeyByValue(loginOptions.possibleResults, current, this.page);
+    debug(`handle login results ${loginResult}`);
+    return this.handleLoginResult(loginResult);
+  }
+  async terminate(_success) {
+    debug(`terminating browser with success = ${_success}`);
+    this.emitProgress(_definitions.ScraperProgressTypes.Terminating);
+    if (!_success && !!this.options.storeFailureScreenShotPath) {
+      debug(`create a snapshot before terminated in ${this.options.storeFailureScreenShotPath}`);
+      await this.page.screenshot({
+        path: this.options.storeFailureScreenShotPath,
+        fullPage: true
+      });
+    }
+    await Promise.all(this.cleanups.reverse().map(safeCleanup));
+    this.cleanups = [];
+  }
+  handleLoginResult(loginResult) {
+    switch (loginResult) {
+      case LoginResults.Success:
+        this.emitProgress(_definitions.ScraperProgressTypes.LoginSuccess);
+        return {
+          success: true
+        };
+      case LoginResults.InvalidPassword:
+      case LoginResults.UnknownError:
+        this.emitProgress(_definitions.ScraperProgressTypes.LoginFailed);
+        return {
+          success: false,
+          errorType: loginResult === LoginResults.InvalidPassword ? _errors.ScraperErrorTypes.InvalidPassword : _errors.ScraperErrorTypes.General,
+          errorMessage: `Login failed with ${loginResult} error`
+        };
+      case LoginResults.ChangePassword:
+        this.emitProgress(_definitions.ScraperProgressTypes.ChangePassword);
+        return {
+          success: false,
+          errorType: _errors.ScraperErrorTypes.ChangePassword
+        };
+      default:
+        throw new Error(`unexpected login result "${loginResult}"`);
+    }
+  }
+}
+exports.BaseScraperWithBrowser = BaseScraperWithBrowser;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_puppeteer","_interopRequireDefault","require","_definitions","_debug","_elementsInteractions","_navigation","_baseScraper","_errors","e","__esModule","default","debug","getDebug","LoginBaseResults","Timeout","Generic","General","rest","ScraperErrorTypes","LoginResults","exports","getKeyByValue","object","value","page","keys","Object","key","conditions","condition","result","RegExp","test","toLowerCase","Promise","resolve","UnknownError","createGeneralError","success","errorType","safeCleanup","cleanup","message","BaseScraperWithBrowser","BaseScraper","cleanups","defaultViewportSize","width","height","getViewPort","options","viewportSize","initialize","emitProgress","ScraperProgressTypes","Initializing","initializePage","setCacheEnabled","push","close","defaultTimeout","setDefaultTimeout","preparePage","viewport","setViewport","on","request","failure","errorText","url","browserContext","newPage","browser","skipCloseBrowser","timeout","args","executablePath","showBrowser","headless","puppeteer","launch","env","verbose","DEBUG","process","undefined","prepareBrowser","navigateTo","waitUntil","retries","navigationRetryCount","response","goto","Error","ok","status","getLoginOptions","_credentials","companyId","fillInputs","pageOrFrame","fields","modified","input","shift","fillInput","selector","length","login","credentials","loginOptions","userAgent","setUserAgent","loginUrl","checkReadiness","submitButtonSelector","waitUntilElementFound","loginFrameOrPage","preAction","clickButton","LoggingIn","postAction","waitForNavigation","current","getCurrentUrl","loginResult","possibleResults","handleLoginResult","terminate","_success","Terminating","storeFailureScreenShotPath","screenshot","path","fullPage","all","reverse","map","Success","LoginSuccess","InvalidPassword","LoginFailed","errorMessage","ChangePassword"],"sources":["../../src/scrapers/base-scraper-with-browser.ts"],"sourcesContent":["import puppeteer, { type Frame, type Page, type PuppeteerLifeCycleEvent } from 'puppeteer';\nimport { ScraperProgressTypes } from '../definitions';\nimport { getDebug } from '../helpers/debug';\nimport { clickButton, fillInput, waitUntilElementFound } from '../helpers/elements-interactions';\nimport { getCurrentUrl, waitForNavigation } from '../helpers/navigation';\nimport { BaseScraper } from './base-scraper';\nimport { ScraperErrorTypes } from './errors';\nimport { type ScraperCredentials, type ScraperScrapingResult } from './interface';\n\nconst debug = getDebug('base-scraper-with-browser');\n\nenum LoginBaseResults {\n  Success = 'SUCCESS',\n  UnknownError = 'UNKNOWN_ERROR',\n}\n\nconst { Timeout, Generic, General, ...rest } = ScraperErrorTypes;\nexport const LoginResults = {\n  ...rest,\n  ...LoginBaseResults,\n};\n\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport type LoginResults =\n  | Exclude<ScraperErrorTypes, ScraperErrorTypes.Timeout | ScraperErrorTypes.Generic | ScraperErrorTypes.General>\n  | LoginBaseResults;\n\nexport type PossibleLoginResults = {\n  [key in LoginResults]?: (string | RegExp | ((options?: { page?: Page }) => Promise<boolean>))[];\n};\n\nexport interface LoginOptions {\n  loginUrl: string;\n  checkReadiness?: () => Promise<void>;\n  fields: { selector: string; value: string }[];\n  submitButtonSelector: string | (() => Promise<void>);\n  preAction?: () => Promise<Frame | void>;\n  postAction?: () => Promise<void>;\n  possibleResults: PossibleLoginResults;\n  userAgent?: string;\n  waitUntil?: PuppeteerLifeCycleEvent;\n}\n\nasync function getKeyByValue(object: PossibleLoginResults, value: string, page: Page): Promise<LoginResults> {\n  const keys = Object.keys(object);\n  for (const key of keys) {\n    // @ts-ignore\n    const conditions = object[key];\n\n    for (const condition of conditions) {\n      let result = false;\n\n      if (condition instanceof RegExp) {\n        result = condition.test(value);\n      } else if (typeof condition === 'function') {\n        result = await condition({ page, value });\n      } else {\n        result = value.toLowerCase() === condition.toLowerCase();\n      }\n\n      if (result) {\n        // @ts-ignore\n        return Promise.resolve(key);\n      }\n    }\n  }\n\n  return Promise.resolve(LoginResults.UnknownError);\n}\n\nfunction createGeneralError(): ScraperScrapingResult {\n  return {\n    success: false,\n    errorType: ScraperErrorTypes.General,\n  };\n}\n\nasync function safeCleanup(cleanup: () => Promise<void>) {\n  try {\n    await cleanup();\n  } catch (e) {\n    debug(`Cleanup function failed: ${(e as Error).message}`);\n  }\n}\n\nclass BaseScraperWithBrowser<TCredentials extends ScraperCredentials> extends BaseScraper<TCredentials> {\n  private cleanups: Array<() => Promise<void>> = [];\n\n  private defaultViewportSize = {\n    width: 1024,\n    height: 768,\n  };\n\n  // NOTICE - it is discouraged to use bang (!) in general. It is used here because\n  // all the classes that inherit from this base assume is it mandatory.\n  protected page!: Page;\n\n  protected getViewPort() {\n    return this.options.viewportSize ?? this.defaultViewportSize;\n  }\n\n  async initialize() {\n    await super.initialize();\n    debug('initialize scraper');\n    this.emitProgress(ScraperProgressTypes.Initializing);\n\n    const page = await this.initializePage();\n    await page.setCacheEnabled(false); // Clear cache and avoid 300's response status\n\n    if (!page) {\n      debug('failed to initiate a browser page, exit');\n      return;\n    }\n\n    this.page = page;\n\n    this.cleanups.push(() => page.close());\n\n    if (this.options.defaultTimeout) {\n      this.page.setDefaultTimeout(this.options.defaultTimeout);\n    }\n\n    if (this.options.preparePage) {\n      debug(\"execute 'preparePage' interceptor provided in options\");\n      await this.options.preparePage(this.page);\n    }\n\n    const viewport = this.getViewPort();\n    debug(`set viewport to width ${viewport.width}, height ${viewport.height}`);\n    await this.page.setViewport({\n      width: viewport.width,\n      height: viewport.height,\n    });\n\n    this.page.on('requestfailed', request => {\n      debug('Request failed: %s %s', request.failure()?.errorText, request.url());\n    });\n  }\n\n  private async initializePage() {\n    debug('initialize browser page');\n    if ('browserContext' in this.options) {\n      debug('Using the browser context provided in options');\n      return this.options.browserContext.newPage();\n    }\n\n    if ('browser' in this.options) {\n      debug('Using the browser instance provided in options');\n      const { browser } = this.options;\n\n      /**\n       * For backward compatibility, we will close the browser even if we didn't create it\n       */\n      if (!this.options.skipCloseBrowser) {\n        this.cleanups.push(async () => {\n          debug('closing the browser');\n          await browser.close();\n        });\n      }\n\n      return browser.newPage();\n    }\n\n    const { timeout, args, executablePath, showBrowser } = this.options;\n\n    const headless = !showBrowser;\n    debug(`launch a browser with headless mode = ${headless}`);\n\n    const browser = await puppeteer.launch({\n      env: this.options.verbose ? { DEBUG: '*', ...process.env } : undefined,\n      headless,\n      executablePath,\n      args,\n      timeout,\n    });\n\n    this.cleanups.push(async () => {\n      debug('closing the browser');\n      await browser.close();\n    });\n\n    if (this.options.prepareBrowser) {\n      debug(\"execute 'prepareBrowser' interceptor provided in options\");\n      await this.options.prepareBrowser(browser);\n    }\n\n    debug('create a new browser page');\n    return browser.newPage();\n  }\n\n  async navigateTo(\n    url: string,\n    waitUntil: PuppeteerLifeCycleEvent | undefined = 'load',\n    retries = this.options.navigationRetryCount ?? 0,\n  ): Promise<void> {\n    const response = await this.page?.goto(url, { waitUntil });\n    if (response === null) {\n      // note: response will be null when navigating to same url while changing the hash part.\n      // the condition below will always accept null as valid result.\n      return;\n    }\n\n    if (!response) {\n      throw new Error(`Error while trying to navigate to url ${url}, response is undefined`);\n    }\n\n    if (!response.ok()) {\n      const status = response.status();\n      if (retries > 0) {\n        debug(`Failed to navigate to url ${url}, status code: ${status}, retrying ${retries} more times`);\n        await this.navigateTo(url, waitUntil, retries - 1);\n      } else {\n        throw new Error(`Failed to navigate to url ${url}, status code: ${status}`);\n      }\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  getLoginOptions(_credentials: ScraperCredentials): LoginOptions {\n    throw new Error(`getLoginOptions() is not created in ${this.options.companyId}`);\n  }\n\n  async fillInputs(pageOrFrame: Page | Frame, fields: { selector: string; value: string }[]): Promise<void> {\n    const modified = [...fields];\n    const input = modified.shift();\n\n    if (!input) {\n      return;\n    }\n    await fillInput(pageOrFrame, input.selector, input.value);\n    if (modified.length) {\n      await this.fillInputs(pageOrFrame, modified);\n    }\n  }\n\n  async login(credentials: ScraperCredentials): Promise<ScraperScrapingResult> {\n    if (!credentials || !this.page) {\n      return createGeneralError();\n    }\n\n    debug('execute login process');\n    const loginOptions = this.getLoginOptions(credentials);\n\n    if (loginOptions.userAgent) {\n      debug('set custom user agent provided in options');\n      await this.page.setUserAgent(loginOptions.userAgent);\n    }\n\n    debug('navigate to login url');\n    await this.navigateTo(loginOptions.loginUrl, loginOptions.waitUntil);\n    if (loginOptions.checkReadiness) {\n      debug(\"execute 'checkReadiness' interceptor provided in login options\");\n      await loginOptions.checkReadiness();\n    } else if (typeof loginOptions.submitButtonSelector === 'string') {\n      debug('wait until submit button is available');\n      await waitUntilElementFound(this.page, loginOptions.submitButtonSelector);\n    }\n\n    let loginFrameOrPage: Page | Frame | null = this.page;\n    if (loginOptions.preAction) {\n      debug(\"execute 'preAction' interceptor provided in login options\");\n      loginFrameOrPage = (await loginOptions.preAction()) || this.page;\n    }\n\n    debug('fill login components input with relevant values');\n    await this.fillInputs(loginFrameOrPage, loginOptions.fields);\n    debug('click on login submit button');\n    if (typeof loginOptions.submitButtonSelector === 'string') {\n      await clickButton(loginFrameOrPage, loginOptions.submitButtonSelector);\n    } else {\n      await loginOptions.submitButtonSelector();\n    }\n    this.emitProgress(ScraperProgressTypes.LoggingIn);\n\n    if (loginOptions.postAction) {\n      debug(\"execute 'postAction' interceptor provided in login options\");\n      await loginOptions.postAction();\n    } else {\n      debug('wait for page navigation');\n      await waitForNavigation(this.page);\n    }\n\n    debug('check login result');\n    const current = await getCurrentUrl(this.page, true);\n    const loginResult = await getKeyByValue(loginOptions.possibleResults, current, this.page);\n    debug(`handle login results ${loginResult}`);\n    return this.handleLoginResult(loginResult);\n  }\n\n  async terminate(_success: boolean) {\n    debug(`terminating browser with success = ${_success}`);\n    this.emitProgress(ScraperProgressTypes.Terminating);\n\n    if (!_success && !!this.options.storeFailureScreenShotPath) {\n      debug(`create a snapshot before terminated in ${this.options.storeFailureScreenShotPath}`);\n      await this.page.screenshot({\n        path: this.options.storeFailureScreenShotPath,\n        fullPage: true,\n      });\n    }\n\n    await Promise.all(this.cleanups.reverse().map(safeCleanup));\n    this.cleanups = [];\n  }\n\n  private handleLoginResult(loginResult: LoginResults) {\n    switch (loginResult) {\n      case LoginResults.Success:\n        this.emitProgress(ScraperProgressTypes.LoginSuccess);\n        return { success: true };\n      case LoginResults.InvalidPassword:\n      case LoginResults.UnknownError:\n        this.emitProgress(ScraperProgressTypes.LoginFailed);\n        return {\n          success: false,\n          errorType:\n            loginResult === LoginResults.InvalidPassword\n              ? ScraperErrorTypes.InvalidPassword\n              : ScraperErrorTypes.General,\n          errorMessage: `Login failed with ${loginResult} error`,\n        };\n      case LoginResults.ChangePassword:\n        this.emitProgress(ScraperProgressTypes.ChangePassword);\n        return {\n          success: false,\n          errorType: ScraperErrorTypes.ChangePassword,\n        };\n      default:\n        throw new Error(`unexpected login result \"${loginResult}\"`);\n    }\n  }\n}\n\nexport { BaseScraperWithBrowser };\n"],"mappings":"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","ignoreList":[]}

package/lib/scrapers/base-scraper-with-browser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scrapers/base-scraper-with-browser.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _testsUtils = require("../tests/tests-utils");
+var _baseScraperWithBrowser = require("./base-scraper-with-browser");
+const testsConfig = (0, _testsUtils.getTestsConfig)();
+function isNoSandbox(browser) {
+  // eslint-disable-next-line no-underscore-dangle
+  const args = browser._process.spawnargs;
+  return args.includes('--no-sandbox');
+}
+describe('Base scraper with browser', () => {
+  beforeAll(() => {
+    (0, _testsUtils.extendAsyncTimeout)(); // The default timeout is 5 seconds per async test, this function extends the timeout value
+  });
+  xtest('should pass custom args to scraper if provided', async () => {
+    const options = {
+      ...testsConfig.options,
+      companyId: 'test',
+      showBrowser: false,
+      args: []
+    };
+
+    // avoid false-positive result by confirming that --no-sandbox is not a default flag provided by puppeteer
+    let baseScraperWithBrowser = new _baseScraperWithBrowser.BaseScraperWithBrowser(options);
+    try {
+      await baseScraperWithBrowser.initialize();
+      // @ts-ignore
+      expect(baseScraperWithBrowser.browser).toBeDefined();
+      // @ts-ignore
+      expect(isNoSandbox(baseScraperWithBrowser.browser)).toBe(false);
+      await baseScraperWithBrowser.terminate(true);
+    } catch (e) {
+      await baseScraperWithBrowser.terminate(false);
+      throw e;
+    }
+
+    // set --no-sandbox flag and expect it to be passed by puppeteer.lunch to the new created browser instance
+    options.args = ['--no-sandbox', '--disable-gpu', '--window-size=1920x1080'];
+    baseScraperWithBrowser = new _baseScraperWithBrowser.BaseScraperWithBrowser(options);
+    try {
+      await baseScraperWithBrowser.initialize();
+      // @ts-ignore
+      expect(baseScraperWithBrowser.browser).toBeDefined();
+      // @ts-ignore
+      expect(isNoSandbox(baseScraperWithBrowser.browser)).toBe(true);
+      await baseScraperWithBrowser.terminate(true);
+    } catch (e) {
+      await baseScraperWithBrowser.terminate(false);
+      throw e;
+    }
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/scrapers/base-scraper.d.ts

@@ -0,0 +1,19 @@
+import { type CompanyTypes, ScraperProgressTypes } from '../definitions';
+import { type Scraper, type ScraperCredentials, type ScraperGetLongTermTwoFactorTokenResult, type ScraperLoginResult, type ScraperOptions, type ScraperScrapingResult, type ScraperTwoFactorAuthTriggerResult } from './interface';
+export declare class BaseScraper<TCredentials extends ScraperCredentials> implements Scraper<TCredentials> {
+    options: ScraperOptions;
+    private eventEmitter;
+    constructor(options: ScraperOptions);
+    initialize(): Promise<void>;
+    scrape(credentials: TCredentials): Promise<ScraperScrapingResult>;
+    triggerTwoFactorAuth(_phoneNumber: string): Promise<ScraperTwoFactorAuthTriggerResult>;
+    getLongTermTwoFactorToken(_otpCode: string): Promise<ScraperGetLongTermTwoFactorTokenResult>;
+    protected login(_credentials: TCredentials): Promise<ScraperLoginResult>;
+    protected fetchData(): Promise<ScraperScrapingResult>;
+    protected terminate(_success: boolean): Promise<void>;
+    protected emitProgress(type: ScraperProgressTypes): void;
+    protected emit(eventName: string, payload: Record<string, any>): void;
+    onProgress(func: (companyId: CompanyTypes, payload: {
+        type: ScraperProgressTypes;
+    }) => void): void;
+}

package/lib/scrapers/base-scraper.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseScraper = void 0;
+var _events = require("events");
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _definitions = require("../definitions");
+var _waiting = require("../helpers/waiting");
+var _errors = require("./errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const SCRAPE_PROGRESS = 'SCRAPE_PROGRESS';
+class BaseScraper {
+  eventEmitter = new _events.EventEmitter();
+  constructor(options) {
+    this.options = options;
+  }
+
+  // eslint-disable-next-line  @typescript-eslint/require-await
+  async initialize() {
+    this.emitProgress(_definitions.ScraperProgressTypes.Initializing);
+    _momentTimezone.default.tz.setDefault('Asia/Jerusalem');
+  }
+  async scrape(credentials) {
+    this.emitProgress(_definitions.ScraperProgressTypes.StartScraping);
+    await this.initialize();
+    let loginResult;
+    try {
+      loginResult = await this.login(credentials);
+    } catch (e) {
+      loginResult = e instanceof _waiting.TimeoutError ? (0, _errors.createTimeoutError)(e.message) : (0, _errors.createGenericError)(e.message);
+    }
+    let scrapeResult;
+    if (loginResult.success) {
+      try {
+        scrapeResult = await this.fetchData();
+      } catch (e) {
+        scrapeResult = e instanceof _waiting.TimeoutError ? (0, _errors.createTimeoutError)(e.message) : (0, _errors.createGenericError)(e.message);
+      }
+    } else {
+      scrapeResult = loginResult;
+    }
+    try {
+      const success = scrapeResult && scrapeResult.success === true;
+      await this.terminate(success);
+    } catch (e) {
+      scrapeResult = (0, _errors.createGenericError)(e.message);
+    }
+    this.emitProgress(_definitions.ScraperProgressTypes.EndScraping);
+    return scrapeResult;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  triggerTwoFactorAuth(_phoneNumber) {
+    throw new Error(`triggerOtp() is not created in ${this.options.companyId}`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  getLongTermTwoFactorToken(_otpCode) {
+    throw new Error(`getPermanentOtpToken() is not created in ${this.options.companyId}`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  async login(_credentials) {
+    throw new Error(`login() is not created in ${this.options.companyId}`);
+  }
+
+  // eslint-disable-next-line  @typescript-eslint/require-await
+  async fetchData() {
+    throw new Error(`fetchData() is not created in ${this.options.companyId}`);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  async terminate(_success) {
+    this.emitProgress(_definitions.ScraperProgressTypes.Terminating);
+  }
+  emitProgress(type) {
+    this.emit(SCRAPE_PROGRESS, {
+      type
+    });
+  }
+  emit(eventName, payload) {
+    this.eventEmitter.emit(eventName, this.options.companyId, payload);
+  }
+  onProgress(func) {
+    this.eventEmitter.on(SCRAPE_PROGRESS, func);
+  }
+}
+exports.BaseScraper = BaseScraper;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_events","require","_momentTimezone","_interopRequireDefault","_definitions","_waiting","_errors","e","__esModule","default","SCRAPE_PROGRESS","BaseScraper","eventEmitter","EventEmitter","constructor","options","initialize","emitProgress","ScraperProgressTypes","Initializing","moment","tz","setDefault","scrape","credentials","StartScraping","loginResult","login","TimeoutError","createTimeoutError","message","createGenericError","scrapeResult","success","fetchData","terminate","EndScraping","triggerTwoFactorAuth","_phoneNumber","Error","companyId","getLongTermTwoFactorToken","_otpCode","_credentials","_success","Terminating","type","emit","eventName","payload","onProgress","func","on","exports"],"sources":["../../src/scrapers/base-scraper.ts"],"sourcesContent":["import { EventEmitter } from 'events';\nimport moment from 'moment-timezone';\nimport { type CompanyTypes, ScraperProgressTypes } from '../definitions';\nimport { TimeoutError } from '../helpers/waiting';\nimport { createGenericError, createTimeoutError } from './errors';\nimport {\n  type Scraper,\n  type ScraperCredentials,\n  type ScraperGetLongTermTwoFactorTokenResult,\n  type ScraperLoginResult,\n  type ScraperOptions,\n  type ScraperScrapingResult,\n  type ScraperTwoFactorAuthTriggerResult,\n} from './interface';\n\nconst SCRAPE_PROGRESS = 'SCRAPE_PROGRESS';\n\nexport class BaseScraper<TCredentials extends ScraperCredentials> implements Scraper<TCredentials> {\n  private eventEmitter = new EventEmitter();\n\n  constructor(public options: ScraperOptions) {}\n\n  // eslint-disable-next-line  @typescript-eslint/require-await\n  async initialize() {\n    this.emitProgress(ScraperProgressTypes.Initializing);\n    moment.tz.setDefault('Asia/Jerusalem');\n  }\n\n  async scrape(credentials: TCredentials): Promise<ScraperScrapingResult> {\n    this.emitProgress(ScraperProgressTypes.StartScraping);\n    await this.initialize();\n\n    let loginResult;\n    try {\n      loginResult = await this.login(credentials);\n    } catch (e) {\n      loginResult =\n        e instanceof TimeoutError ? createTimeoutError((e as Error).message) : createGenericError((e as Error).message);\n    }\n\n    let scrapeResult;\n    if (loginResult.success) {\n      try {\n        scrapeResult = await this.fetchData();\n      } catch (e) {\n        scrapeResult =\n          e instanceof TimeoutError\n            ? createTimeoutError((e as Error).message)\n            : createGenericError((e as Error).message);\n      }\n    } else {\n      scrapeResult = loginResult;\n    }\n\n    try {\n      const success = scrapeResult && scrapeResult.success === true;\n      await this.terminate(success);\n    } catch (e) {\n      scrapeResult = createGenericError((e as Error).message);\n    }\n    this.emitProgress(ScraperProgressTypes.EndScraping);\n\n    return scrapeResult;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  triggerTwoFactorAuth(_phoneNumber: string): Promise<ScraperTwoFactorAuthTriggerResult> {\n    throw new Error(`triggerOtp() is not created in ${this.options.companyId}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  getLongTermTwoFactorToken(_otpCode: string): Promise<ScraperGetLongTermTwoFactorTokenResult> {\n    throw new Error(`getPermanentOtpToken() is not created in ${this.options.companyId}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  protected async login(_credentials: TCredentials): Promise<ScraperLoginResult> {\n    throw new Error(`login() is not created in ${this.options.companyId}`);\n  }\n\n  // eslint-disable-next-line  @typescript-eslint/require-await\n  protected async fetchData(): Promise<ScraperScrapingResult> {\n    throw new Error(`fetchData() is not created in ${this.options.companyId}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  protected async terminate(_success: boolean) {\n    this.emitProgress(ScraperProgressTypes.Terminating);\n  }\n\n  protected emitProgress(type: ScraperProgressTypes) {\n    this.emit(SCRAPE_PROGRESS, { type });\n  }\n\n  protected emit(eventName: string, payload: Record<string, any>) {\n    this.eventEmitter.emit(eventName, this.options.companyId, payload);\n  }\n\n  onProgress(func: (companyId: CompanyTypes, payload: { type: ScraperProgressTypes }) => void) {\n    this.eventEmitter.on(SCRAPE_PROGRESS, func);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/scrapers/behatsdaa.d.ts

@@ -0,0 +1,11 @@
+import { BaseScraperWithBrowser, type LoginOptions } from './base-scraper-with-browser';
+import { type ScraperScrapingResult } from './interface';
+type ScraperSpecificCredentials = {
+    id: string;
+    password: string;
+};
+declare class BehatsdaaScraper extends BaseScraperWithBrowser<ScraperSpecificCredentials> {
+    getLoginOptions(credentials: ScraperSpecificCredentials): LoginOptions;
+    fetchData(): Promise<ScraperScrapingResult>;
+}
+export default BehatsdaaScraper;