@sdods/core 0.3.2 → 0.5.2

package/dist/steps/ui.steps.js

@@ -1,9 +1,16 @@
 import { expect } from '@playwright/test';
 import './params.js';
 import { Given, Then, When } from '../fixtures/test.js';
-import { render, renderJson } from '../api/template.js';
+import { render, renderJson, renderStrict } from '../api/template.js';
+import { withActionRole } from '../heal/strategies.js';
 import { SdodsError } from '../errors.js';
-const scopesOf = (apiContext, env) => [apiContext.vars.toObject(), env.vars];
+const scopesOf = (apiContext, env) => [
+    apiContext.vars.toObject(),
+    env.vars,
+];
+/** Render one step argument strictly. */
+const arg = ({ apiContext, env }, value) => renderStrict(value, ...scopesOf(apiContext, env));
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 function routePath(config, nameOrPath) {
     const routes = config.project.routes;
     if (nameOrPath in routes)
@@ -14,9 +21,21 @@ function routePath(config, nameOrPath) {
         hint: `Known routes: ${Object.keys(routes).join(', ') || '(none)'}.`,
     });
 }
+/**
+ * The control a label names, for `action`. An exact label beats a partial one, and a control
+ * whose role fits the action beats anything else the label also reaches: `getByLabel('Password')`
+ * on its own also matches a "Show password" toggle, and the fill then dies on a strict-mode
+ * violation. The unfiltered forms stay as the last resort, for controls with no role at all such
+ * as a contenteditable editor.
+ */
+function labelled(page, heal, label, action) {
+    const exact = page.getByLabel(label, { exact: true });
+    const loose = page.getByLabel(label);
+    return heal.prefer(withActionRole(page, exact, action), withActionRole(page, loose, action), exact, loose);
+}
 /* ── navigation ───────────────────────────────────────────────────────── */
 Given('I navigate to the {string} page', async ({ page, config, apiContext, env }, route) => {
-    await page.goto(routePath(config, render(route, ...scopesOf(apiContext, env))), {
+    await page.goto(routePath(config, arg({ apiContext, env }, route)), {
         waitUntil: 'domcontentloaded',
     });
 });
@@ -25,7 +44,7 @@ Given('I reload the page', async ({ page }) => {
 });
 /* ── interactions (heal-aware) ────────────────────────────────────────── */
 When('I click the {string} {role}', async ({ page, heal, apiContext, env }, name, role) => {
-    const n = render(name, ...scopesOf(apiContext, env));
+    const n = arg({ apiContext, env }, name);
     await heal.click(page.getByRole(role, { name: n }), {
         role: role,
         name: n,
@@ -33,89 +52,119 @@ When('I click the {string} {role}', async ({ page, heal, apiContext, env }, name
         description: `${role} "${n}"`,
     });
 });
-When('I click the element with test id {string}', async ({ page, heal }, id) => {
-    await heal.click(page.getByTestId(id), { testId: id, description: `test id "${id}"` });
+When('I click the element with test id {string}', async ({ page, heal, apiContext, env }, id) => {
+    const testId = arg({ apiContext, env }, id);
+    await heal.click(page.getByTestId(testId), { testId, description: `test id "${testId}"` });
 });
 When('I click the text {string}', async ({ page, heal, apiContext, env }, text) => {
-    const t = render(text, ...scopesOf(apiContext, env));
+    const t = arg({ apiContext, env }, text);
     await heal.click(page.getByText(t, { exact: true }), { text: t, description: `text "${t}"` });
 });
 When('I fill the {string} field with {string}', async ({ page, heal, apiContext, env }, label, value) => {
-    const v = render(value, ...scopesOf(apiContext, env));
-    await heal.fill(page.getByLabel(label), { label, placeholder: label, description: `${label} field` }, v);
+    const l = arg({ apiContext, env }, label);
+    await heal.fill(await labelled(page, heal, l, 'fill'), { label: l, placeholder: l, description: `${l} field` }, arg({ apiContext, env }, value));
 });
 When('I fill the element with test id {string} with {string}', async ({ page, heal, apiContext, env }, id, value) => {
-    await heal.fill(page.getByTestId(id), { testId: id, description: `test id "${id}"` }, render(value, ...scopesOf(apiContext, env)));
+    const testId = arg({ apiContext, env }, id);
+    await heal.fill(page.getByTestId(testId), { testId, description: `test id "${testId}"` }, arg({ apiContext, env }, value));
 });
 When('I fill the form:', async ({ page, heal, apiContext, env }, table) => {
     for (const row of table.hashes()) {
-        const field = row.field ?? row.label ?? Object.values(row)[0];
-        const value = render(row.value ?? Object.values(row)[1] ?? '', ...scopesOf(apiContext, env));
-        await heal.fill(page.getByLabel(field), { label: field, placeholder: field, description: `${field} field` }, value);
+        const field = arg({ apiContext, env }, row.field ?? row.label ?? Object.values(row)[0]);
+        const value = arg({ apiContext, env }, row.value ?? Object.values(row)[1] ?? '');
+        await heal.fill(await labelled(page, heal, field, 'fill'), { label: field, placeholder: field, description: `${field} field` }, value);
     }
 });
-When('I select {string} in the {string} dropdown', async ({ page, heal }, option, label) => {
-    await heal.select(page.getByLabel(label), { label, description: `${label} dropdown` }, option);
+When('I select {string} in the {string} dropdown', async ({ page, heal, apiContext, env }, option, label) => {
+    const l = arg({ apiContext, env }, label);
+    await heal.select(await labelled(page, heal, l, 'select'), { label: l, description: `${l} dropdown` }, arg({ apiContext, env }, option));
 });
-When('I check the {string} checkbox', async ({ page, heal }, label) => {
-    const loc = await heal.resolve(page.getByLabel(label), { label, role: 'checkbox', name: label, description: `${label} checkbox` }, 'check');
+When('I check the {string} checkbox', async ({ page, heal, apiContext, env }, label) => {
+    const l = arg({ apiContext, env }, label);
+    const loc = await heal.resolve(await labelled(page, heal, l, 'check'), { label: l, role: 'checkbox', name: l, description: `${l} checkbox` }, 'check');
     await loc.check();
 });
-When('I press {string}', async ({ page }, key) => {
-    await page.keyboard.press(key);
+When('I press {string}', async ({ page, apiContext, env }, key) => {
+    await page.keyboard.press(arg({ apiContext, env }, key));
 });
-When('I upload {string} to the {string} field', async ({ page, config }, file, label) => {
+When('I upload {string} to the {string} field', async ({ page, heal, config, apiContext, env }, file, label) => {
     const { resolve, isAbsolute } = await import('node:path');
-    await page
-        .getByLabel(label)
-        .setInputFiles(isAbsolute(file) ? file : resolve(config.project.root, file));
+    const l = arg({ apiContext, env }, label);
+    const f = arg({ apiContext, env }, file);
+    // A file input has no role to filter on, so only the exact-label preference applies.
+    const input = await heal.prefer(page.getByLabel(l, { exact: true }), page.getByLabel(l));
+    await input.setInputFiles(isAbsolute(f) ? f : resolve(config.project.root, f));
 });
 When('I wait for {int} seconds', async ({ page }, seconds) => {
     await page.waitForTimeout(seconds * 1000);
 });
 /* ── assertions ───────────────────────────────────────────────────────── */
+/*
+ * The text pair means "a visible element carries this text" / "no visible element does". A closed
+ * FAQ answer or a collapsed panel stays in the DOM, so the negative step filters on visibility
+ * rather than counting DOM matches, and the positive step looks past hidden matches instead of
+ * taking whichever comes first. `.filter({ visible: true })` + `toHaveCount(0)` is strict-mode
+ * safe and retries until the text is gone. The `exact` variants match the whole text of an
+ * element (whitespace-normalised, case-sensitive), so "already" does not collide with "you already
+ * serve". `the page should not contain the text` keeps the DOM-absence check for hidden text.
+ */
+const visibleText = (page, text, exact) => page.getByText(text, { exact }).filter({ visible: true });
 Then('I should see the text {string}', async ({ page, apiContext, env }, text) => {
-    const t = render(text, ...scopesOf(apiContext, env));
-    await expect(page.getByText(t, { exact: false }).first()).toBeVisible();
+    await expect(visibleText(page, arg({ apiContext, env }, text), false).first()).toBeVisible();
 });
 Then('I should not see the text {string}', async ({ page, apiContext, env }, text) => {
-    await expect(page.getByText(render(text, ...scopesOf(apiContext, env)), { exact: false })).toHaveCount(0);
+    await expect(visibleText(page, arg({ apiContext, env }, text), false)).toHaveCount(0);
+});
+Then('I should see the exact text {string}', async ({ page, apiContext, env }, text) => {
+    await expect(visibleText(page, arg({ apiContext, env }, text), true).first()).toBeVisible();
+});
+Then('I should not see the exact text {string}', async ({ page, apiContext, env }, text) => {
+    await expect(visibleText(page, arg({ apiContext, env }, text), true)).toHaveCount(0);
+});
+Then('the page should not contain the text {string}', async ({ page, apiContext, env }, text) => {
+    await expect(page.getByText(arg({ apiContext, env }, text), { exact: false })).toHaveCount(0);
 });
-Then('the {string} {role} should be visible', async ({ page, heal }, name, role) => {
-    await heal.expectVisible(page.getByRole(role, { name }), {
+Then('the {string} {role} should be visible', async ({ page, heal, apiContext, env }, name, role) => {
+    const n = arg({ apiContext, env }, name);
+    await heal.expectVisible(page.getByRole(role, { name: n }), {
         role: role,
-        name,
-        description: `${role} "${name}"`,
+        name: n,
+        description: `${role} "${n}"`,
     });
 });
-Then('the element with test id {string} should be visible', async ({ page, heal }, id) => {
-    await heal.expectVisible(page.getByTestId(id), { testId: id, description: `test id "${id}"` });
+Then('the element with test id {string} should be visible', async ({ page, heal, apiContext, env }, id) => {
+    const testId = arg({ apiContext, env }, id);
+    await heal.expectVisible(page.getByTestId(testId), {
+        testId,
+        description: `test id "${testId}"`,
+    });
 });
 Then('the element with test id {string} should contain {string}', async ({ page, heal, apiContext, env }, id, text) => {
-    await heal.expectText(page.getByTestId(id), { testId: id, description: `test id "${id}"` }, render(text, ...scopesOf(apiContext, env)));
+    const testId = arg({ apiContext, env }, id);
+    await heal.expectText(page.getByTestId(testId), { testId, description: `test id "${testId}"` }, arg({ apiContext, env }, text));
 });
-Then('the page URL should contain {string}', async ({ page }, part) => {
-    await expect(page).toHaveURL(new RegExp(part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+Then('the page URL should contain {string}', async ({ page, apiContext, env }, part) => {
+    await expect(page).toHaveURL(new RegExp(escapeRegExp(arg({ apiContext, env }, part))));
 });
-Then('the page title should contain {string}', async ({ page }, part) => {
-    await expect(page).toHaveTitle(new RegExp(part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+Then('the page title should contain {string}', async ({ page, apiContext, env }, part) => {
+    await expect(page).toHaveTitle(new RegExp(escapeRegExp(arg({ apiContext, env }, part))));
 });
-Then('the page should match the visual baseline {string}', async ({ shots, $bddContext }, name) => {
-    await shots.visual(name, $bddContext.stepIndex);
+Then('the page should match the visual baseline {string}', async ({ shots, $bddContext, apiContext, env }, name) => {
+    await shots.visual(arg({ apiContext, env }, name), $bddContext.stepIndex);
 });
 /* ── network mocking ──────────────────────────────────────────────────── */
 When('I mock {string} with JSON:', async ({ page, apiContext, env }, urlGlob, json) => {
     const body = renderJson(json, ...scopesOf(apiContext, env));
-    await page.route(urlGlob, (route) => route.fulfill({ json: body }));
+    await page.route(arg({ apiContext, env }, urlGlob), (route) => route.fulfill({ json: body }));
 });
 When('I mock {string} with HTML:', async ({ page, apiContext, env }, urlGlob, html) => {
     const body = render(html, ...scopesOf(apiContext, env));
-    await page.route(urlGlob, (route) => route.fulfill({ status: 200, contentType: 'text/html', body }));
+    await page.route(arg({ apiContext, env }, urlGlob), (route) => route.fulfill({ status: 200, contentType: 'text/html', body }));
 });
-When('I mock {string} with status {int}', async ({ page }, urlGlob, status) => {
-    await page.route(urlGlob, (route) => route.fulfill({ status, body: '' }));
+When('I mock {string} with status {int}', async ({ page, apiContext, env }, urlGlob, status) => {
+    await page.route(arg({ apiContext, env }, urlGlob), (route) => route.fulfill({ status, body: '' }));
 });
-When('I abort requests to {string}', async ({ page }, urlGlob) => {
-    await page.route(urlGlob, (route) => route.abort());
+When('I abort requests to {string}', async ({ page, apiContext, env }, urlGlob) => {
+    await page.route(arg({ apiContext, env }, urlGlob), (route) => route.abort());
 });
 //# sourceMappingURL=ui.steps.js.map

package/dist/steps/webhook.steps.js

@@ -2,7 +2,7 @@ import { createServer } from 'node:http';
 import { expect } from '@playwright/test';
 import './params.js';
 import { AfterScenario, Given, Then, When } from '../fixtures/test.js';
-import { render } from '../api/template.js';
+import { renderStrict } from '../api/template.js';
 import { SdodsError } from '../errors.js';
 const receivers = new Map();
 function key(apiContext) {
@@ -93,7 +93,7 @@ Then('the callback receiver should receive a delivery', async ({ apiContext }) =
 });
 Then('the callback receiver should receive a delivery containing {string}', async ({ apiContext, env }, text) => {
     const r = requireReceiver(key(apiContext));
-    const needle = render(text, apiContext.vars.toObject(), env.vars);
+    const needle = renderStrict(text, apiContext.vars.toObject(), env.vars);
     await expect
         .poll(() => r.deliveries.some((d) => d.body.includes(needle)), {
         message: `no callback delivery contained "${needle}"`,
@@ -110,7 +110,7 @@ Then('the last callback delivery should have the header {string} set to {string}
         env.vars,
     ];
     const last = r.deliveries[r.deliveries.length - 1];
-    expect(last.headers[render(header, ...scopes).toLowerCase()]).toBe(render(value, ...scopes));
+    expect(last.headers[renderStrict(header, ...scopes).toLowerCase()]).toBe(renderStrict(value, ...scopes));
 });
 /**
  * Torn down after EVERY scenario, including a failing one — hence a hook rather

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.2.2";
+export declare const VERSION: string;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,2 +1,16 @@
-export const VERSION = '0.2.2';
+import { createRequire } from 'node:module';
+/**
+ * The SDODS version, read from this package's own manifest.
+ *
+ * Hand-maintaining this constant drifted: it said 0.2.2 while every publishable package was at
+ * 0.3.2. That is load-bearing rather than cosmetic — `sdods init` writes `^${VERSION}` into every
+ * scaffolded workspace, and a caret on a 0.x version does not cross the minor, so `^0.2.2` pinned
+ * those workspaces (the desktop app's included) to a 0.2.x CLI that predated the commands the web
+ * UI calls.
+ *
+ * Resolves to `packages/core/package.json` from both `src/version.ts` and `dist/version.js`, since
+ * `dist` sits one level below the package root.
+ */
+const manifest = createRequire(import.meta.url)('../package.json');
+export const VERSION = manifest.version;
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/core",
-  "version": "0.3.2",
+  "version": "0.5.2",
   "description": "SDODS runtime: configuration, project registry, fixtures, step libraries, data providers, screenshot narratives and self-healing locators.",
   "license": "Apache-2.0",
   "author": "SDODS <admin@sdods.com>",
@@ -38,11 +38,12 @@
     "node": ">=22"
   },
   "peerDependencies": {
-    "@playwright/test": ">=1.58",
+    "@playwright/test": ">=1.63",
     "playwright-bdd": ">=9"
   },
   "dependencies": {
-    "@sdods/contracts": "0.3.2",
+    "@sdods/contracts": "0.5.2",
+    "@cucumber/cucumber-expressions": "19.0.0",
     "@cucumber/gherkin": "^42.0.1",
     "@cucumber/messages": "^34.2.1",
     "@faker-js/faker": "^10.6.0",
@@ -56,9 +57,10 @@
     "jsonpath-plus": "^10.4.0",
     "picocolors": "^1.1.1",
     "ts-morph": "^28.0.0",
+    "tsx": "^4.23.0",
     "yaml": "^2.9.0",
     "zod": "^4.5.4",
-    "@sdods/db": "0.3.2"
+    "@sdods/db": "0.5.2"
   },
   "homepage": "https://sdods.com",
   "bugs": {