@globisnv/cypress-core 0.0.1

package/README.md

@@ -0,0 +1,255 @@
+# @globisnv/cypress-core
+
+Core building blocks for Globis Cypress E2E tests.
+
+This package holds everything that is *not* customer-specific: the shared Cypress config factory, the custom command library for the Servoy-based Globis solutions, the WebSocket-aware loading detector, the reusable data-entry blueprints, and the lint scripts. Customer repos install it, call `defineGlobisConfig()` in their `cypress.config.ts`, import `@globisnv/cypress-core/register` in their support file, and only keep their own specs and customer-specific commands locally.
+
+---
+
+## Installation
+
+```bash
+npm install @globisnv/cypress-core
+```
+
+Peer dependencies (must be installed in the consumer repo):
+
+| Package | Range |
+| --- | --- |
+| `cypress` | `^15.19.0` |
+| `cypress-real-events` | `^1.15.0` |
+
+---
+
+## Compatibility with Globis Online
+
+Core's own version is plain semver, deliberately **not** tied to globis-online's version numbers — the two release on independent schedules, and forcing them to share digits would mean bumping core every time globis-online ships a release that doesn't touch anything core depends on.
+
+Instead, each core release declares the **minimum** globis-online version it requires — a floor, not a pin. Blueprints and commands are written against a given release's Servoy DOM/behavior; they keep working on every later globis-online release *until* one of them actually changes something a blueprint depends on, at which point core needs a new version anyway, with its floor bumped to that release. There's no meaningful upper bound to declare in advance — you only find out a version broke something by running against it.
+
+| Core version | Minimum globis-online version |
+| --- | --- |
+| `0.0.1` | `11.0.2` |
+
+The floor is recorded in `package.json` under `globisOnline.minVersion` (machine-readable, in case tooling wants to check it later) and here in this table (human-readable, updated on every release alongside `CHANGELOG.md`). `globis-cypress` stays pinned to the latest core version — since it's Globis's own suite, it's the first thing to catch a globis-online release breaking something, before any customer repo would.
+
+---
+
+## Setting up a new customer repo
+
+Starting a brand-new customer test repo from a blank slate — no manual copy-pasting from an existing one:
+
+```bash
+npx -p @globisnv/cypress-core create-globis-customer-repo
+```
+
+It asks two questions — a target folder (e.g. `acme-cypress`) and the customer's 3-letter abbreviation (e.g. `ACM`) — then:
+
+- Copies a minimal template into that folder: `package.json`, `tsconfig.json`, `biome.json`, `cypress.config.ts`, `cypress.env.json.example`, `CODEOWNERS`, `.gitignore`, `cypress/support/{e2e.ts,record.ts}`, and a starter `cypress/e2e/<abbrev>/template.cy.ts.example`.
+- Runs `git init` and `npm install`.
+
+The generated repo has fresh history (nothing cloned or filtered from any other repo) and depends on `@globisnv/cypress-core` like any other consumer — no local customer commands or blueprints are pre-populated, so it can never leak another customer's code. From there:
+
+```bash
+cd acme-cypress
+cp cypress.env.json.example cypress.env.json   # fill in your credentials
+npx cypress open --e2e --browser chrome
+```
+
+---
+
+## Usage
+
+### 1. `cypress.config.ts`
+
+```ts
+import { defineGlobisConfig } from '@globisnv/cypress-core/config';
+
+export default defineGlobisConfig({
+    // Scalar e2e overrides — merged over the core defaults
+    e2e: {
+        specPattern: 'cypress/e2e/**/*.cy.ts',
+        defaultCommandTimeout: 20000,
+        // Optional: runs *after* the core wiring, on the same `on`/`config`
+        setupNodeEvents(on, config) {
+            // customer-specific node events
+        }
+    },
+    // Optional: extra cy.task() handlers alongside the core ones
+    extraTasks: {
+        myTask(arg) {
+            return null;
+        }
+    }
+});
+```
+
+`defineGlobisConfig()` ([src/config.ts](src/config.ts)) sets the shared defaults — 1920×1080 viewport, video on without compression, a 120s response timeout, `experimentalMemoryManagement`, `scrollBehavior: 'center'` — and wires:
+
+- **Env exposure** — every `config.env` key is copied to `config.expose` *except* the sensitive ones (`password`, `password2`, `api_key`, `QLIKURLS`, `S3_KEY`, `S3_SECRET`), which stay node-side.
+- **Core tasks** — `log`, `set`, `get` (a process-scoped key/value store shared across specs), `bufferWsMetrics` and `flushWsMetrics`.
+- **Browser sizing** — a `before:browser:launch` hook forcing 1920×1080 and `--force-device-scale-factor=1` for headless Chrome, plus Firefox/Electron equivalents.
+
+### 2. `cypress/support/e2e.ts`
+
+```ts
+import '@globisnv/cypress-core/register';
+
+// Customer-specific commands stay local:
+import './commands/ACME_commands';
+```
+
+[src/register.ts](src/register.ts) imports all generic command files, the WebSocket detector, and `cypress-real-events`. It also registers a `beforeEach` + `Cypress.on('fail')` pair that flags a failed test through the `set`/`get` task, so cleanup commands like `GLO_closeDashboard` can bail out instead of masking the real error with a secondary failure in the cloud report.
+
+### 3. Blueprints, commands and helpers
+
+Blueprints and generic command files are **not** re-exported from the package root — import them via their subpath:
+
+```ts
+import { GLO_enterEquipment, type objEquipment } from '@globisnv/cypress-core/blueprints/GLO_equipment';
+import { getUUID, getDate, open, close, check } from '@globisnv/cypress-core/tsHelper';
+import { createRequestVariables } from '@globisnv/cypress-core/apiMethods/IGS_request';
+```
+
+Available subpaths:
+
+| Subpath | Contents |
+| --- | --- |
+| `.` | `defineGlobisConfig` only — safe to import from `cypress.config.ts` |
+| `./register` | Side-effect import that registers all commands |
+| `./config` | The config factory on its own |
+| `./tsHelper` | Constants, branded flags and helper functions |
+| `./types` | Ambient/global type declarations |
+| `./blueprints/*` | Per-program data-entry blueprints |
+| `./commands/*` | Individual command files |
+| `./apiMethods/*` | REST request/response helpers |
+
+> Do **not** try to reach these through custom tsconfig path aliases pointing into `node_modules`. `tsconfig-paths-webpack-plugin` (which Cypress's default preprocessor uses) silently ignores mappings that resolve inside `node_modules` — they typecheck but fail to bundle. Real package subpath exports resolve correctly in both `tsc` and webpack.
+
+> `tsHelper` is deliberately **not** re-exported from the package root. Its top-level `Cypress.expose(...)` call only works in a browser-context (spec/support) process — `cypress.config.ts` runs in Node, so the root import (`.`) has to stay safe to use there. Always import `tsHelper` via `@globisnv/cypress-core/tsHelper` explicitly.
+
+---
+
+## What's in the box
+
+```
+src/
+├── config.ts             # defineGlobisConfig() — the shared cypress.config factory
+├── register.ts           # side-effect entrypoint: loads all generic commands
+├── index.ts              # public API (config factory + tsHelper re-export)
+├── tsHelper.ts           # constants, branded boolean flags, date/UUID/number helpers, cleanup formulas
+├── types.ts              # global ambient types (selectors, dialogs, WebSocket protocol, extended filters)
+├── websocketDetector.ts  # WebSocket spy + WS_loadingCheck state machine
+├── blueprints/           # 132 per-program data-entry blueprints
+├── commands/             # 6 generic command files (~128 custom commands)
+├── apiMethods/           # IGS REST request/response helpers
+└── plugins/              # prometheusWriter — SigV4-signed remote write to AWS AMP
+scripts/                  # standalone lint rules (shipped to consumers)
+```
+
+### Command families
+
+Each command file targets one Globis solution. All are loaded by `register.ts`.
+
+| Prefix | Solution | Commands |
+| --- | --- | --- |
+| `GLO_` | Globis Online (the main Servoy client) | 79 |
+| `FOB_` | Form Builder | 17 |
+| `GLT_` | GlobTake (`/solution/globtake`) | 11 |
+| `POR_` | Portal | 10 |
+| `GLS_` | GlobScan (`/solution/globscan`) | 8 |
+| `GLJ_` | GlobJob (`/solution/globjob`) | 3 |
+| `WS_` | WebSocket helpers (from `websocketDetector.ts`) | 3 |
+
+`GLO_commands.ts` is the backbone: login/logout and company/user switching, element lookup (`GLO_getElement`), input/date/checkbox/radio entry, grid interaction (select, sort, filter, row lookup, custom views), dialog handling, datacontrol buttons, extended filters, file upload/read, and value storage between steps. Every command carries a JSDoc block with its parameters — that is the reference documentation.
+
+### Blueprints
+
+A blueprint is a typed object plus a function that fills in one program's detail form. For example [GLO_equipment.ts](src/blueprints/GLO_equipment.ts) exports `objEquipment` and `GLO_enterEquipment(obj, tabName?)`, which walks the fields with `cy.GLO_addInput`, `cy.GLO_checkbox`, `cy.GLO_popupWindow`, and delegates nested blocks to other blueprints (`GLO_enterAddressPopup`). Specs then read as data, not as clicks:
+
+```ts
+GLO_enterEquipment({
+    equipmentCode: `CYP-${getUUID(4)}`,
+    equipmentCategory: 'Trailer',
+    flagIsActive: check
+});
+```
+
+131 blueprints cover Globis Online programs (articles, contracts, transport orders, invoices, consignments, warehouse, customs, …) and 1 covers GlobTake.
+
+### WebSocket detector
+
+Servoy's frontend talks to its backend over a single persistent WebSocket, which `cy.intercept()` cannot observe — historically that meant `cy.wait(N)`. [websocketDetector.ts](src/websocketDetector.ts) replaces those with a semantics-aware idle check:
+
+- `WS_visitWithSpy(url)` — visits a URL with `window.WebSocket` patched so every frame is mirrored into `win.wsMessages`.
+- `WS_loadingCheck(options?)` — resolves only once pending requests, the Sablo loading indicator, pending `svyPush` data syncs, and the DOM loading indicator are all idle for a quiet period. Handles dialogs, popup forms, `closeNode`/`cellClick` bursts, window destroy and navigation.
+- `WS_toggleDialogHandler('enable' | 'disable')` — controls whether plain `Info` dialogs are auto-dismissed or left to the test.
+
+It is opt-in per run: `cypressWebsocketLoader` / `cypressWebsocketDebug` are read from the `extraParams` env object (see below).
+
+### Metrics
+
+`WS_loadingCheck` can emit per-action timing metrics. They are buffered in-memory through the `bufferWsMetrics` task and pushed by `flushWsMetrics`, which SigV4-signs a Snappy-compressed Prometheus remote-write payload with container IMDS credentials ([src/plugins/prometheusWriter.ts](src/plugins/prometheusWriter.ts)). The flush is a **no-op unless `AMP_REMOTE_WRITE_URL` is set**, so consumer repos without an AMP endpoint simply never push.
+
+---
+
+## Environment variables
+
+Set via Cypress env (`config.env`, `CYPRESS_*`, or `--env`) unless noted.
+
+| Key | Purpose |
+| --- | --- |
+| `globisUrl` | Base solution URL. `GLJ/GLS/GLT_login` rewrite the `/solution/<name>` segment off this. |
+| `portalUrl`, `formBuilderUrl`, `oktaUrl` | Entry URLs for the portal, form builder and Okta login flows. |
+| `username`, `username2` | Default and alternate login users. |
+| `password`, `password2`, `api_key` | Secrets — kept node-side, never exposed to the browser. |
+| `loginType`, `ownerName`, `formBuilderStandalone`, `saveData` | Login/flow switches read by the commands. |
+| `BUILD_NUMBER` | Used by `getOrCreateUuid()` to build a stable `CYP<build>` test-data prefix. |
+| `extraParams` | Object of Jenkins-passed extras; `cypressWebsocketLoader` and `cypressWebsocketDebug` (`'true'`) live here. |
+| `AMP_REMOTE_WRITE_URL`, `AMP_REGION` | Node `process.env` — Prometheus remote-write target and region. |
+| `numTestsKeptInMemory` | Node `process.env` — overrides Cypress's default of `0`. |
+
+---
+
+## Development
+
+```bash
+npm run build          # tsc -p tsconfig.build.json  → dist/
+npm run build:watch    # incremental build for local linking
+npm run typescript     # tsc --noEmit --skipLibCheck
+npm run lint           # biome check .
+npm run lint:fix       # biome check . --write
+```
+
+Formatting is Biome ([biome.json](biome.json)): 4-space indent, single quotes, semicolons, no trailing commas, 180-column lines, LF endings. `src/types.ts` has `noUnusedVariables` disabled since it is declaration-only.
+
+### Shipped lint scripts
+
+`scripts/` is published with the package so consumer repos can run the same rule over their specs. It's a standalone Node script (no ESLint) that reads the invoking repo's `tsconfig.json` from `process.cwd()`, using the TypeScript 7 `typescript/unstable/*` preview API — the classic in-process Compiler API that `typescript-eslint` and `ts-morph` depend on was removed in TS7, which is why those tools cap their peer range below it.
+
+| Script | What it does |
+| --- | --- |
+| [check-unnecessary-waiting.mjs](scripts/check-unnecessary-waiting.mjs) | Fails on `cy.wait(<number>)`, including numeric constants/default params aliased in the enclosing scope. Exempt a call with a `// biome-ignore plugin: <reason>` comment on the line directly above — Biome's GritQL plugins have no suppression mechanism, hence the standalone script. |
+
+Wire it into the consumer repo:
+
+```json
+{
+    "scripts": {
+        "lint:waiting": "node node_modules/@globisnv/cypress-core/scripts/check-unnecessary-waiting.mjs"
+    }
+}
+```
+
+`check-deprecated-get-commands.mjs` (the old-positional-API-to-tuple-form codemod) is **not** shipped here — it lives in `globis-cypress`'s own `scripts/`. It only matters for that repo's older version branches (`11.0.1`, `11.0.0`, `10.5.19`), which never adopted the tuple-based API and never will; no customer repo has ever had the old API, so there's nothing for it to do there.
+
+### Conventions
+
+- **ESM only** (`"type": "module"`) — internal imports carry the `.js` extension.
+- Commands are declared on `Cypress.Chainable` inside a `declare global` block in the file that implements them, with JSDoc on every parameter.
+- Boolean arguments use the branded flag constants from `tsHelper.ts` (`open`/`close`, `check`/`unCheck`, `skipCheck`/`noSkipCheck`, …) so a call site reads as intent rather than `true`/`false`.
+- New generic commands, blueprints and helpers belong here; anything customer-specific stays in the consumer repo.
+
+### Review ownership
+
+[CODEOWNERS](CODEOWNERS) protects the shared surface — `package.json`, `tsconfig*.json`, `biome.json`, `src/config.ts`, `src/register.ts`, `src/commands/`, `src/plugins/` and `.github/`. Changes there need a review from the listed owners.

package/bin/create-customer-repo.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// Scaffolds a blank customer test repo: copies template/ into a target
+// directory, fills in the company abbreviation, then runs git init and
+// npm install. No dependencies beyond Node's own stdlib.
+
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = path.resolve(fileURLToPath(import.meta.url), '..', '..');
+const templateDir = path.join(packageRoot, 'template');
+const corePackageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf-8'));
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const ask = async (question) => (await rl.question(question)).trim();
+
+let targetDir = await ask('Target folder (e.g. acme-cypress): ');
+while (!targetDir) {
+    targetDir = await ask('Target folder cannot be empty: ');
+}
+
+let abbrev = await ask('Company abbreviation, 3 letters (e.g. ACM): ');
+while (!/^[A-Za-z]{3}$/.test(abbrev)) {
+    abbrev = await ask('Must be exactly 3 letters (e.g. ACM): ');
+}
+rl.close();
+
+const abbrevUpper = abbrev.toUpperCase();
+const abbrevLower = abbrev.toLowerCase();
+const targetPath = path.resolve(process.cwd(), targetDir);
+const packageName = `${abbrevLower}-cypress`;
+
+if (fs.existsSync(targetPath) && fs.readdirSync(targetPath).length > 0) {
+    console.error(`Error: ${targetPath} already exists and is not empty.`);
+    process.exit(1);
+}
+
+// Resolves child inside root and rejects anything that would escape it
+// (defense in depth — entry names come from our own bundled template/
+// today, but the read/write roots must never be escapable regardless).
+function resolveWithin(root, name) {
+    const resolvedRoot = path.resolve(root);
+    const resolved = path.resolve(resolvedRoot, name);
+    const relative = path.relative(resolvedRoot, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        console.error(`Error: refusing to touch a path outside ${resolvedRoot}: ${name}`);
+        process.exit(1);
+    }
+    return resolved;
+}
+
+function copyTemplate(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = resolveWithin(src, entry.name);
+        const destName = entry.name === '__CUSTOMER__' ? abbrevLower : entry.name;
+        const destPath = resolveWithin(dest, destName);
+        if (entry.isDirectory()) {
+            copyTemplate(srcPath, destPath);
+            continue;
+        }
+        let content = fs.readFileSync(srcPath, 'utf-8');
+        if (entry.name === 'package.json') {
+            content = content.replace('__PACKAGE_NAME__', packageName).replace('__CORE_VERSION__', corePackageJson.version);
+        }
+        if (entry.name === 'e2e.ts') {
+            content = content.replace(/__CUSTOMER_LOWER__/g, abbrevLower).replace(/__CUSTOMER_UPPER__/g, abbrevUpper);
+        }
+        fs.writeFileSync(destPath, content);
+    }
+}
+
+copyTemplate(templateDir, targetPath);
+
+console.log(`\nFiles created at ${targetPath}\n`);
+
+console.log('Running git init...');
+execSync('git init', { cwd: targetPath, stdio: 'inherit' });
+
+console.log('Running npm install...');
+execSync('npm install', { cwd: targetPath, stdio: 'inherit' });
+
+console.log(`\n${packageName} is ready.\n`);
+console.log('Next steps:');
+console.log(`  cd ${targetDir}`);
+console.log('  cp cypress.env.json.example cypress.env.json   # then fill it in');
+console.log('  npx cypress open --e2e --browser chrome');

package/biome.json

@@ -0,0 +1,49 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.5.7/schema.json",
+    "files": {
+        "includes": ["**", "!dist", "!template"]
+    },
+    "formatter": {
+        "enabled": true,
+        "indentStyle": "space",
+        "indentWidth": 4,
+        "lineEnding": "lf",
+        "lineWidth": 180
+    },
+    "javascript": {
+        "formatter": {
+            "quoteStyle": "single",
+            "semicolons": "always",
+            "trailingCommas": "none"
+        }
+    },
+    "linter": {
+        "enabled": true,
+        "rules": {
+            "preset": "recommended",
+            "complexity": {
+                "noUselessTernary": "error"
+            },
+            "style": {
+                "useTemplate": "error",
+                "noNonNullAssertion": "off",
+                "useNamingConvention": "off"
+            },
+            "suspicious": {
+                "noDoubleEquals": "error"
+            }
+        }
+    },
+    "overrides": [
+        {
+            "includes": ["src/types.ts"],
+            "linter": {
+                "rules": {
+                    "correctness": {
+                        "noUnusedVariables": "off"
+                    }
+                }
+            }
+        }
+    ]
+}

package/dist/apiMethods/IGS_request.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Represents the type of the body object for HTTP requests.
+ * @template T - Type of the body.
+ */
+interface BodyType<T> {
+    [key: string]: T;
+}
+/**
+ * Represents the type for the primary key object.
+ */
+type primaryKeyType = {
+    pkName: string;
+    value: string;
+};
+/**
+ * Creates request variables object for HTTP request.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {object} [body] - The body of the request.
+ * @param {number} [timeout] - A custom timeout to override the default
+ * @param {string} [api_key_overide] - An api key to use instead of the `api_key` environment variable.
+ * @returns {object} The request variables object.
+ */
+export declare const createRequestVariables: (apiUrl: string, method: apiMethodType, body?: object, timeout?: number, api_key_overide?: string) => Cypress.Chainable<{
+    url: string;
+    method: string;
+    headers: {
+        [key: string]: string;
+    };
+    body?: object;
+    timeout?: number;
+}>;
+/**
+ * Sends a HTTP request and verifies the response status.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {object} [body] - The body of the request.
+ * @param {number} [status=200] - The expected status code of the response.
+ * @param {number} [timeout] - A custom timeout, overriding the default.
+ * @param
+ * @returns {void}
+ */
+export declare const requestWithResponse: (apiUrl: string, method: apiMethodType, body?: object, status?: number, timeout?: number) => void;
+/**
+ * Represents the primary key object.
+ * @type {primaryKeyType}
+ */
+export declare const primaryKeyObject: primaryKeyType;
+/**
+ * Sends a PATCH request with response verification.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {BodyType<string | number | object>} body - The body of the request.
+ * @param {number} [status=200] - The expected status code of the response.
+ * @returns {void}
+ */
+export declare const requestWithResponsePatch: (apiUrl: string, method: apiMethodType, body: BodyType<string | number | object>, status?: number) => void;
+/**
+ * Sends a HTTP request, verifies the response status, and returns the ID field.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {object} body - The body of the request.
+ * @param {string} idField - The ID field to be returned from the response.
+ * @returns {Promise<string>} The ID field from the response.
+ */
+export declare const requestWithResponseAndReturnId: (apiUrl: string, method: apiMethodType, body: object, idField: string) => Promise<string>;
+/**
+ * Sends a GET request, verifies the response status, and returns the specified field.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {string} nrField - The field to be returned from the response.
+ * @returns {Promise<string>} The specified field from the response.
+ */
+export declare const getRequestAndReturnNr: (apiUrl: string, nrField: string) => Promise<string>;
+/**
+ * Sends a GET request, verifies the response status, and returns the response body.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @returns {Promise<object>} The response body.
+ */
+export declare const getRequestAndReturnBody: (apiUrl: string) => Promise<object>;
+/**
+ * Sends an HTTP request with custom headers and returns the response body.
+ * This is a universal function that supports any HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request (GET, POST, PUT, PATCH, DELETE, etc.).
+ * @param {object} [body] - The body of the request (optional, not used for GET requests).
+ * @param {number} [status=200] - The expected status code of the response.
+ * @param {string} [api_key_overide] - An api key to use instead of the `api_key` environment variable.
+ * @returns {Promise<object>} The response body.
+ */
+export declare const requestAndReturnBody: (apiUrl: string, method: apiMethodType, body?: object, status?: number, api_key_overide?: string) => Promise<object>;
+export {};

package/dist/apiMethods/IGS_request.js

@@ -0,0 +1,161 @@
+/**
+ * Creates request variables object for HTTP request.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {object} [body] - The body of the request.
+ * @param {number} [timeout] - A custom timeout to override the default
+ * @param {string} [api_key_overide] - An api key to use instead of the `api_key` environment variable.
+ * @returns {object} The request variables object.
+ */
+export const createRequestVariables = (apiUrl, method, body, timeout, api_key_overide) => {
+    return cy.env(['api_key']).then(({ api_key }) => {
+        const url = new URL(apiUrl);
+        const executionToken = url.searchParams.get('X-Execution-Token');
+        if (executionToken) {
+            url.searchParams.delete('X-Execution-Token');
+        }
+        const headers = {
+            authorization: (api_key_overide ?? api_key),
+            'Content-Type': 'application/json',
+            ...(executionToken && { 'X-Execution-Token': executionToken })
+        };
+        const requestOptions = {
+            url: url.toString(),
+            method: method,
+            headers: headers,
+            body: body
+        };
+        if (timeout !== undefined) {
+            requestOptions.timeout = timeout;
+        }
+        return requestOptions;
+    });
+};
+/**
+ * Sends a HTTP request and verifies the response status.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {object} [body] - The body of the request.
+ * @param {number} [status=200] - The expected status code of the response.
+ * @param {number} [timeout] - A custom timeout, overriding the default.
+ * @param
+ * @returns {void}
+ */
+export const requestWithResponse = (apiUrl, method, body, status = 200, timeout) => {
+    createRequestVariables(apiUrl, method, body, timeout).then((opts) => {
+        cy.request(opts).then((response) => {
+            expect(response.status).to.eq(status);
+        });
+    });
+};
+/**
+ * Represents the primary key object.
+ * @type {primaryKeyType}
+ */
+export const primaryKeyObject = {
+    pkName: 'somePK',
+    value: 'SomeValue'
+};
+/**
+ * Sends a PATCH request with response verification.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {BodyType<string | number | object>} body - The body of the request.
+ * @param {number} [status=200] - The expected status code of the response.
+ * @returns {void}
+ */
+export const requestWithResponsePatch = (apiUrl, method, body, status = 200) => {
+    // Add primary key to the body
+    body[primaryKeyObject.pkName] = primaryKeyObject.value;
+    cy.GLO_log(`method: ${method} -- body: ${JSON.stringify(body)}`);
+    // Send the request with response verification
+    requestWithResponse(apiUrl, method, body, status);
+};
+/**
+ * Sends a HTTP request, verifies the response status, and returns the ID field.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request.
+ * @param {object} body - The body of the request.
+ * @param {string} idField - The ID field to be returned from the response.
+ * @returns {Promise<string>} The ID field from the response.
+ */
+export const requestWithResponseAndReturnId = (apiUrl, method, body, idField) => {
+    cy.GLO_log(`method: ${method} -- body: ${JSON.stringify(body)}`);
+    return new Cypress.Promise((resolve) => {
+        createRequestVariables(apiUrl, method, body).then((opts) => {
+            cy.request(opts).then((response) => {
+                expect(response.status).to.eq(200);
+                const responsePost = response.body;
+                const responsePostBodyCreate = responsePost.create;
+                resolve(responsePostBodyCreate[0][idField]);
+            });
+        });
+    });
+};
+/**
+ * Sends a GET request, verifies the response status, and returns the specified field.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {string} nrField - The field to be returned from the response.
+ * @returns {Promise<string>} The specified field from the response.
+ */
+export const getRequestAndReturnNr = (apiUrl, nrField) => {
+    cy.GLO_log(`method: GET -- requested field: ${nrField}`);
+    return new Cypress.Promise((resolve) => {
+        createRequestVariables(apiUrl, 'GET').then((opts) => {
+            cy.request(opts).then((response) => {
+                expect(response.status).to.eq(200);
+                const responseBody = response.body;
+                const responseElement = responseBody[0];
+                expect(responseElement).to.have.property(nrField);
+                resolve(responseElement[nrField]);
+            });
+        });
+    });
+};
+/**
+ * Sends a GET request, verifies the response status, and returns the response body.
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @returns {Promise<object>} The response body.
+ */
+export const getRequestAndReturnBody = (apiUrl) => {
+    cy.GLO_log('method: GET');
+    return new Cypress.Promise((resolve) => {
+        createRequestVariables(apiUrl, 'GET').then((opts) => {
+            cy.request(opts).then((response) => {
+                expect(response.status).to.eq(200);
+                const responseBody = response.body;
+                const responseElement = responseBody[0];
+                resolve(responseElement);
+            });
+        });
+    });
+};
+/**
+ * Sends an HTTP request with custom headers and returns the response body.
+ * This is a universal function that supports any HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)
+ *
+ * @param {string} apiUrl - The URL of the API endpoint.
+ * @param {apiMethodType} method - The HTTP method for the request (GET, POST, PUT, PATCH, DELETE, etc.).
+ * @param {object} [body] - The body of the request (optional, not used for GET requests).
+ * @param {number} [status=200] - The expected status code of the response.
+ * @param {string} [api_key_overide] - An api key to use instead of the `api_key` environment variable.
+ * @returns {Promise<object>} The response body.
+ */
+export const requestAndReturnBody = (apiUrl, method, body, status = 200, api_key_overide) => {
+    const bodyLog = body ? ` -- body: ${JSON.stringify(body)}` : '';
+    cy.GLO_log(`method: ${method}${bodyLog}`);
+    return new Cypress.Promise((resolve) => {
+        createRequestVariables(apiUrl, method, body, undefined, api_key_overide).then((opts) => {
+            cy.request(opts).then((response) => {
+                expect(response.status).to.eq(status);
+                resolve(response.body);
+            });
+        });
+    });
+};