@bigbinary/neeto-playwright-commons 3.0.0 → 3.0.2

package/configs/eslint/common.js

@@ -0,0 +1,128 @@
+import neeto from "@bigbinary/eslint-plugin-neeto";
+import js from "@eslint/js";
+import tsEslint from "@typescript-eslint/eslint-plugin";
+import tsParser from "@typescript-eslint/parser";
+import playwrightPlugin from "eslint-plugin-playwright";
+import importPlugin from "eslint-plugin-import";
+import globals from "globals";
+import path from "path";
+
+const commonEslintConfig = ({
+  ignores = [],
+  extendsOverrides = [],
+  overrideRules = {},
+  tsconfigRootDir = "",
+}) => {
+  const configs = [
+    js.configs.recommended,
+    {
+      ignores: [...ignores],
+    },
+
+    {
+      files: ["**/*.ts", "**/*.spec.ts"],
+      ignores: ["**/*.d.ts"],
+      languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          tsconfigRootDir,
+          project: ["./tsconfig.json"],
+        },
+        globals: {
+          ...globals.browser,
+          ...globals.es2021,
+          ...globals.node,
+        },
+      },
+      plugins: {
+        "@typescript-eslint": tsEslint,
+        playwright: playwrightPlugin,
+        import: importPlugin,
+        "@bigbinary/neeto": neeto,
+      },
+      rules: {
+        ...tsEslint.configs.recommended.rules,
+        ...playwrightPlugin.configs.recommended.rules,
+
+        "@bigbinary/neeto/use-dayjs-from-neeto-commons-fronted": "off",
+        "@bigbinary/neeto/use-array-methods": "off",
+        "@typescript-eslint/no-floating-promises": "error",
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          { destructuredArrayIgnorePattern: "^_" },
+        ],
+        "@typescript-eslint/no-explicit-any": [
+          "error",
+          { ignoreRestArgs: true },
+        ],
+        "@typescript-eslint/no-unused-expressions": [
+          "error",
+          { allowShortCircuit: true, allowTernary: true },
+        ],
+
+        "playwright/expect-expect": "off",
+        "playwright/no-conditional-in-test": "warn",
+        "playwright/no-nth-methods": "error",
+        "playwright/no-page-pause": "error",
+        "playwright/no-raw-locators": "warn",
+        "playwright/no-useless-await": "error",
+        "playwright/no-useless-not": "error",
+        "playwright/no-wait-for-timeout": "error",
+        "playwright/prefer-strict-equal": "warn",
+        "playwright/prefer-to-be": "warn",
+        "playwright/prefer-to-contain": "error",
+        "playwright/prefer-to-have-count": "error",
+        "playwright/prefer-to-have-length": "error",
+        "playwright/prefer-web-first-assertions": "error",
+        "playwright/require-top-level-describe": "error",
+        "playwright/require-soft-assertions": "off",
+        "playwright/valid-expect": "error",
+        "playwright/no-standalone-expect": "warn",
+        "playwright/valid-title": [
+          "warn",
+          { mustMatch: { test: "^(must|should)" }, ignoreTypeOfStepName: true },
+        ],
+        "playwright/prefer-lowercase-title": [
+          "error",
+          { ignoreTopLevelDescribe: true, allowedPrefixes: ["Step"] },
+        ],
+        "import/order": [
+          "error",
+          {
+            "newlines-between": "always",
+            alphabetize: { order: "asc", caseInsensitive: true },
+            warnOnUnassignedImports: true,
+            groups: [
+              "builtin",
+              "external",
+              "internal",
+              "index",
+              "sibling",
+              "parent",
+              "object",
+              "type",
+            ],
+          },
+        ],
+        ...overrideRules,
+      },
+      settings: {
+        "import/resolver": {
+          typescript: {
+            alwaysTryTypes: true,
+            project: path.join(tsconfigRootDir, "tsconfig.json"),
+          },
+        },
+      },
+    },
+
+    ...extendsOverrides,
+  ];
+
+  return configs;
+};
+
+export default commonEslintConfig;

package/configs/eslint/host.js

@@ -0,0 +1,42 @@
+import path from "path";
+import eslintConfig from "./common.js";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const hostEslintConfig = ({ rules = {}, tsconfigRootDir = "", ignores }) => {
+  return eslintConfig({
+    tsconfigRootDir,
+    overrideRules: {
+      "import/named": "off",
+      "react-hooks/rules-of-hooks": "off",
+      "@bigbinary/neeto/no-missing-localization": [
+        "warn",
+        {
+          translationsDir: path.resolve(
+            __dirname,
+            "../../../../../..",
+            "app/javascript/src/translations"
+          ),
+          languages: ["en"],
+          nanosTranslationDir: [
+            path.resolve(
+              __dirname,
+              "../../../../../..",
+              "node_modules/@bigbinary/neeto-commons-frontend/translations"
+            ),
+          ],
+        },
+      ],
+      "@bigbinary/neeto/use-standard-date-time-formats": "warn",
+      "@bigbinary/neeto/no-dangling-constants": "off",
+      "@bigbinary/neeto/use-webpack-alias": "off",
+      ...rules,
+    },
+    ignores,
+  });
+};
+
+export default hostEslintConfig;

package/configs/scripts/jsdoc-builder/constants.mjs

@@ -0,0 +1,41 @@
+import { complement, startsWith } from "ramda";
+
+export const REMARK_NODE_TYPES = {
+  HTML: "html",
+  PARAGRAPH: "paragraph",
+  CODE: "code",
+  HEADING: "heading",
+  TEXT: "text",
+  INLINE_CODE: "inlineCode",
+};
+
+export const BABEL_NODE_TYPES = { IDENTIFIER: "Identifier" };
+
+export const SUBHEADING_PATTERN = { type: REMARK_NODE_TYPES.HEADING, depth: 2 };
+export const HTML_PATTERN = { type: REMARK_NODE_TYPES.HTML };
+export const IMG_PATTERN = {
+  type: REMARK_NODE_TYPES.HTML,
+  value: startsWith("<img"),
+};
+export const CODE_PATTERN = { type: REMARK_NODE_TYPES.CODE };
+export const PARAGRAPH_PATTERN = { type: REMARK_NODE_TYPES.PARAGRAPH };
+export const HTML_EXCEPT_IMG_PATTERN = {
+  type: REMARK_NODE_TYPES.HTML,
+  value: complement(startsWith("<img")),
+};
+export const INLINE_CODE_PATTERN = { type: REMARK_NODE_TYPES.INLINE_CODE };
+export const TEXT_PATTERN = { type: REMARK_NODE_TYPES.TEXT };
+export const DOCS_FOLDER_NAME = "docs";
+export const TYPES_FOLDER_NAME = "typeTemplates";
+export const EXPORTED_TYPES_FOLDER_NAME = "."; // root
+
+export const JSDOC_IMG_HEIGHT = "200";
+export const JSDOC_IMG_WIDTH = "300";
+
+export const DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT = "\n *\n";
+export const LINE_BREAK = "\n";
+export const JSDOC_EXAMPLE_TAG = "@example ";
+export const JSDOC_END_EXAMPLE_TAG = "@endexample";
+export const ASTERISK = "*";
+export const ASTERISK_WITH_SPACES = " * ";
+export const WHITESPACE_PARENTHESIS_REGEX = /[\s()]/g;

package/configs/scripts/jsdoc-builder/utils.mjs

@@ -0,0 +1,257 @@
+import fs from "fs";
+import path from "path";
+
+import * as babelParser from "@babel/parser";
+import { mergeLeft } from "ramda";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+
+import {
+  ASTERISK,
+  ASTERISK_WITH_SPACES,
+  CODE_PATTERN,
+  DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT,
+  HTML_EXCEPT_IMG_PATTERN,
+  IMG_PATTERN,
+  JSDOC_EXAMPLE_TAG,
+  JSDOC_END_EXAMPLE_TAG,
+  JSDOC_IMG_HEIGHT,
+  JSDOC_IMG_WIDTH,
+  LINE_BREAK,
+  PARAGRAPH_PATTERN,
+  SUBHEADING_PATTERN,
+  TYPES_FOLDER_NAME,
+  WHITESPACE_PARENTHESIS_REGEX,
+} from "./constants.mjs";
+import * as babelTypes from "@babel/types";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+
+import { matches } from "@bigbinary/neeto-cist";
+import { endsWith } from "ramda";
+
+const traverse = _traverse.default;
+const generate = _generate.default;
+
+const removeWhiteSpaceAndParentheses = string =>
+  string.replace(WHITESPACE_PARENTHESIS_REGEX, "");
+
+const addLeadingCommentForTextWithLineBreaks = ({
+  text,
+  addCommentForFirstItem = true,
+  addDoubleLineBreaks = true,
+}) => {
+  if (!hasLineBreaks(text)) return addLeadingComment(text);
+  const joinString = addDoubleLineBreaks
+    ? DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT
+    : LINE_BREAK;
+
+  return text
+    .split(LINE_BREAK)
+    .map((item, idx) => {
+      if (!addCommentForFirstItem && idx === 0) return item;
+
+      return addLeadingComment(item);
+    })
+    .join(joinString);
+};
+
+const addLeadingComment = (text, trimWhiteSpace = false) =>
+  (trimWhiteSpace ? ASTERISK : ASTERISK_WITH_SPACES) + text;
+
+const transformCode = node => {
+  let text = "";
+  text += addLeadingComment(JSDOC_EXAMPLE_TAG);
+  text += DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT;
+  text += addLeadingCommentForTextWithLineBreaks({
+    text: removeCommentTags(node.value),
+    addDoubleLineBreaks: false,
+  });
+  text += LINE_BREAK;
+  text += addLeadingComment(JSDOC_END_EXAMPLE_TAG);
+  text += LINE_BREAK;
+
+  return text;
+};
+
+const hasLineBreaks = text => text?.includes(LINE_BREAK);
+
+const getParagraphChildrenText = node => {
+  const children = node.children;
+  if (children.length === 1) return children[0].value;
+
+  return children
+    .map(child => child.value || child.children?.[0]?.value)
+    .join("");
+};
+
+const transformParagraph = node => {
+  let text = "";
+  text += ASTERISK_WITH_SPACES;
+  const childrenText = getParagraphChildrenText(node);
+
+  if (hasLineBreaks(childrenText)) {
+    text += addLeadingCommentForTextWithLineBreaks({
+      text: childrenText,
+      addCommentForFirstItem: false,
+    });
+  } else {
+    text += childrenText;
+  }
+  text += DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT;
+
+  return text;
+};
+
+const transformImg = node => {
+  const { src, alt } = parseImgTag(node.value);
+  let text = ASTERISK_WITH_SPACES;
+  text += `![${alt}](${src}|height=${JSDOC_IMG_HEIGHT}|width=${JSDOC_IMG_WIDTH})`;
+  text += DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT;
+
+  return text;
+};
+
+const transformNodesToText = nodes => {
+  let text = DOUBLE_LINE_BREAK_WITH_LEADING_COMMENT;
+
+  nodes.forEach(node => {
+    if (matches(CODE_PATTERN, node)) {
+      text += transformCode(node);
+    } else if (matches(IMG_PATTERN, node)) {
+      text += transformImg(node);
+    } else if (matches(PARAGRAPH_PATTERN, node)) {
+      text += transformParagraph(node);
+    }
+  });
+
+  return addLeadingComment(text, true);
+};
+
+const parseImgTag = imgTagStr =>
+  imgTagStr.split(" ").reduce((acc, item) => {
+    let [attrName, attrValue] = item.split("=");
+    attrValue = attrValue?.replaceAll(">", "").replaceAll('"', "");
+
+    return mergeLeft({ [attrName]: attrValue }, acc);
+  }, {});
+
+const removeCommentTags = str => str.replaceAll("/*", "").replaceAll("*/", "");
+
+export const parseTypeFile = typeFileContent =>
+  babelParser.parse(typeFileContent, {
+    sourceType: "module",
+    plugins: [["typescript", { dts: true }]],
+  });
+
+export const buildEntityTitleToEntityDescMap = (nodes, map) => {
+  nodes.forEach((node, idx) => {
+    if (!matches(SUBHEADING_PATTERN, node)) return;
+
+    const entityName = removeWhiteSpaceAndParentheses(node.children[0].value);
+    const entityRightSiblings = [];
+
+    for (let i = idx + 1; i < nodes.length; i++) {
+      const siblingNode = nodes[i];
+
+      if (matches(HTML_EXCEPT_IMG_PATTERN, siblingNode)) continue;
+
+      if (matches(SUBHEADING_PATTERN, siblingNode)) break;
+
+      entityRightSiblings.push(siblingNode);
+    }
+    const entityRightSiblingsText = transformNodesToText(entityRightSiblings);
+    map[entityName] = entityRightSiblingsText;
+  });
+};
+
+export const syncTypeFiles = exportedTypesFolderName => {
+  const sourceDir = path.resolve(TYPES_FOLDER_NAME);
+  const destDir = path.resolve(exportedTypesFolderName);
+
+  fs.cpSync(sourceDir, destDir, { recursive: true });
+};
+
+export const getFileNameList = dirPath => {
+  let files = [];
+  const items = fs.readdirSync(dirPath, { withFileTypes: true });
+
+  for (const item of items) {
+    if (item.isDirectory()) {
+      files = [...files, ...getFileNameList(path.join(dirPath, item.name))];
+    } else {
+      files.push(path.join(dirPath, item.name));
+    }
+  }
+
+  return files;
+};
+
+export const getFileContent = fileName =>
+  fs.readFileSync(path.resolve(fileName), "utf8").toString();
+
+export const parseMarkdown = fileContent =>
+  unified().use(remarkParse).parse(fileContent);
+
+export const defaultTypeFileTraverser = options => {
+  traverse(options.typeFileAST, {
+    VariableDeclaration: ({ node }) =>
+      handleNode({
+        node,
+        options,
+        extractEntityName: findVariableDeclarationName,
+      }),
+    ClassProperty: ({ node }) =>
+      handleNode({ node, options, extractEntityName: findClassPropertyName }),
+  });
+};
+
+export const findVariableDeclarationName = node =>
+  node?.declarations?.[0]?.id?.name || node?.declaration?.id?.name;
+
+export const isUtil = entityName => endsWith("Utils", entityName);
+
+export const findClassPropertyName = node => node?.key?.name;
+
+export const handleEntity = (
+  node,
+  entityTitleToDescMapOfAllFiles,
+  entityName
+) => {
+  const entityDesc = entityTitleToDescMapOfAllFiles[entityName];
+
+  if (!entityName || !entityDesc) {
+    return;
+  }
+
+  babelTypes.addComment(node, "leading", entityDesc);
+};
+
+export const handleUtilityMethods = (node, entityTitleToDescMapOfAllFiles) => {
+  const members =
+    node?.declarations?.[0]?.id?.typeAnnotation?.typeAnnotation?.members;
+
+  members?.map(methodNode => {
+    handleEntity(
+      methodNode,
+      entityTitleToDescMapOfAllFiles,
+      methodNode.key.name
+    );
+  });
+};
+
+export const handleNode = ({
+  node,
+  extractEntityName,
+  options: { entityTitleToDescMapOfAllFiles, typeFileName, typeFileAST },
+}) => {
+  const entityName = extractEntityName(node);
+
+  isUtil(entityName)
+    ? handleUtilityMethods(node, entityTitleToDescMapOfAllFiles)
+    : handleEntity(node, entityTitleToDescMapOfAllFiles, entityName);
+
+  const { code } = generate(typeFileAST, {});
+
+  fs.writeFileSync(path.resolve(typeFileName), code);
+};

package/index.cjs.js

@@ -253,12 +253,10 @@ class NeetoEmailDeliveryApi {
     constructor(neetoPlaywrightUtilities) {
         this.neetoPlaywrightUtilities = neetoPlaywrightUtilities;
     }
-    connect = (payload) => this.neetoPlaywrightUtilities.apiRequest({
+    connect = ({ ownerId, ...payload }) => this.neetoPlaywrightUtilities.apiRequest({
         method: "post",
         url: `${NEETO_EMAIL_DELIVERY_TESTING_BASE_URL}/connect`,
-        body: {
-            connect: neetoCist.keysToSnakeCase(payload),
-        },
+        body: neetoCist.keysToSnakeCase({ ownerId, connect: payload }),
     });
     verifyEmail = (params) => this.neetoPlaywrightUtilities.apiRequest({
         url: `${NEETO_EMAIL_DELIVERY_TESTING_BASE_URL}/verify_email`,
@@ -121483,70 +121481,6 @@ class TagsPage {
     };
 }
 
-const REFRESH_TOKEN_ENV_KEYS = {
-    gmail: "EMAIL_DELIVERY_GMAIL_REFRESH_TOKEN",
-    outlook: "EMAIL_DELIVERY_OUTLOOK_REFRESH_TOKEN",
-};
-const FROM_EMAIL_ENV_KEYS = {
-    gmail: "EMAIL_DELIVERY_CONNECTED_GMAIL",
-    outlook: "EMAIL_DELIVERY_CONNECTED_OUTLOOK",
-};
-class EmailDeliveryUtils {
-    neetoPlaywrightUtilities;
-    emailDeliveryApi;
-    constructor(neetoPlaywrightUtilities) {
-        this.neetoPlaywrightUtilities = neetoPlaywrightUtilities;
-        this.emailDeliveryApi = new NeetoEmailDeliveryApi(neetoPlaywrightUtilities);
-    }
-    connectViaRequest = async ({ provider }) => {
-        const refreshTokenEnvKey = REFRESH_TOKEN_ENV_KEYS[provider];
-        const refreshToken = process.env[refreshTokenEnvKey];
-        if (ramda.isNil(refreshToken)) {
-            throw new Error(`ENV variable ${refreshTokenEnvKey} is not properly configured`);
-        }
-        const response = await this.emailDeliveryApi.connect({
-            emailProvider: provider,
-            refreshToken,
-        });
-        test.expect(response?.ok()).toBeTruthy();
-        return response;
-    };
-    verifyEmailViaRequest = async ({ subject, to, partialBody, from }, { provider, timeout = 30 * 1000, shouldThrowErrorOnTimeout = true, }) => {
-        const fromEmail = from ?? process.env[FROM_EMAIL_ENV_KEYS[provider]];
-        if (ramda.isNil(fromEmail)) {
-            throw new Error(`ENV variable ${FROM_EMAIL_ENV_KEYS[provider]} is not properly configured`);
-        }
-        const verifyParams = {
-            emailProvider: provider,
-            subject,
-            to,
-            from: fromEmail,
-            body: partialBody,
-        };
-        let lastResult = null;
-        const fetchEmail = async () => {
-            const response = await this.emailDeliveryApi.verifyEmail(verifyParams);
-            if (!response?.ok()) {
-                lastResult = null;
-                return;
-            }
-            lastResult = (await response.json());
-        };
-        const email = (await this.neetoPlaywrightUtilities.executeRecursively({
-            condition: async () => {
-                await fetchEmail();
-                return Boolean(lastResult?.exists);
-            },
-            callback: async () => lastResult?.exists ? (lastResult.email ?? null) : null,
-            timeout,
-        }));
-        if (!email && shouldThrowErrorOnTimeout) {
-            throw new Error(`Timed out waiting for ${provider} email matching subject "${subject}"`);
-        }
-        return email;
-    };
-}
-
 const USER_AGENTS = {
     windows: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36",
     mac: "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
@@ -125247,6 +125181,72 @@ class NeetoAuthServer {
     };
 }
 
+const REFRESH_TOKEN_ENV_KEYS = {
+    gmail: "EMAIL_DELIVERY_GMAIL_REFRESH_TOKEN",
+    outlook: "EMAIL_DELIVERY_OUTLOOK_REFRESH_TOKEN",
+};
+const FROM_EMAIL_ENV_KEYS = {
+    gmail: "EMAIL_DELIVERY_CONNECTED_GMAIL",
+    outlook: "EMAIL_DELIVERY_CONNECTED_OUTLOOK",
+};
+class EmailDeliveryUtils {
+    neetoPlaywrightUtilities;
+    emailDeliveryApi;
+    constructor(neetoPlaywrightUtilities) {
+        this.neetoPlaywrightUtilities = neetoPlaywrightUtilities;
+        this.emailDeliveryApi = new NeetoEmailDeliveryApi(neetoPlaywrightUtilities);
+    }
+    connectViaRequest = async ({ provider, ownerId }) => {
+        const refreshTokenEnvKey = REFRESH_TOKEN_ENV_KEYS[provider];
+        const refreshToken = process.env[refreshTokenEnvKey];
+        if (ramda.isNil(refreshToken)) {
+            throw new Error(`ENV variable ${refreshTokenEnvKey} is not properly configured`);
+        }
+        const response = await this.emailDeliveryApi.connect({
+            emailProvider: provider,
+            refreshToken,
+            ownerId,
+        });
+        test.expect(response?.ok()).toBeTruthy();
+        return response;
+    };
+    verifyEmailViaRequest = async ({ subject, to, partialBody, from }, { provider, ownerId, timeout = 30 * 1000, shouldThrowErrorOnTimeout = true, }) => {
+        const fromEmail = from ?? process.env[FROM_EMAIL_ENV_KEYS[provider]];
+        if (ramda.isNil(fromEmail)) {
+            throw new Error(`ENV variable ${FROM_EMAIL_ENV_KEYS[provider]} is not properly configured`);
+        }
+        const verifyParams = {
+            emailProvider: provider,
+            subject,
+            to,
+            from: fromEmail,
+            body: partialBody,
+            ownerId,
+        };
+        let lastResult = null;
+        const fetchEmail = async () => {
+            const response = await this.emailDeliveryApi.verifyEmail(verifyParams);
+            if (!response?.ok()) {
+                lastResult = null;
+                return;
+            }
+            lastResult = (await response.json());
+        };
+        const email = (await this.neetoPlaywrightUtilities.executeRecursively({
+            condition: async () => {
+                await fetchEmail();
+                return Boolean(lastResult?.exists);
+            },
+            callback: async () => lastResult?.exists ? (lastResult.email ?? null) : null,
+            timeout,
+        }));
+        if (!email && shouldThrowErrorOnTimeout) {
+            throw new Error(`Timed out waiting for ${provider} email matching subject "${subject}"`);
+        }
+        return email;
+    };
+}
+
 var main$1 = {exports: {}};
 
 var version = "17.3.1";
@@ -126114,6 +126114,7 @@ exports.EmailDeliveryUtils = EmailDeliveryUtils;
 exports.EmbedBase = EmbedBase;
 exports.FILE_FORMATS = FILE_FORMATS;
 exports.FONT_SIZE_SELECTORS = FONT_SIZE_SELECTORS;
+exports.FROM_EMAIL_ENV_KEYS = FROM_EMAIL_ENV_KEYS;
 exports.GLOBAL_TRANSLATIONS_PATTERN = GLOBAL_TRANSLATIONS_PATTERN;
 exports.GOOGLE_ANALYTICS_SELECTORS = GOOGLE_ANALYTICS_SELECTORS;
 exports.GOOGLE_CALENDAR_DATE_FORMAT = GOOGLE_CALENDAR_DATE_FORMAT;