thisisagile/easy

This system is a comprehensive TypeScript framework designed to accelerate the development of enterprise-grade applications by providing a unified architecture for domain modeling, data access, and service layers. It offers robust abstractions for HTTP APIs, SQL and NoSQL database interactions, and JWT-based security, alongside a dedicated React UI library and a versatile testing suite supporting both unit and end-to-end browser automation.

61 changes.

The project established its foundational architecture by initializing a Yarn 4 monorepo and building the core 'easy' library, which includes domain models, data access abstractions, HTTP handling, and validation utilities. This period also saw the creation of specialized integration packages for Express, MongoDB, and SQL Server, alongside the development of a comprehensive testing ecosystem covering unit, integration, and end-to-end scenarios for React and web browsers.

13 changes.

This period focused on expanding the framework's core capabilities by introducing the easy-domain package for standardized business data types and enums, alongside the new easy-service package for HTTP resource definitions. Significant effort was also dedicated to strengthening test coverage across these new modules and the existing easy-react utilities, while refining release automation and BigQuery integration.

The easy-express package now includes a NamespaceContext class that extends BaseRequestContext to provide request-scoped storage using the cls-hooked library. This allows developers to store and retrieve context data (via get/set methods) that is automatically isolated per request, with a create method to execute functions within a specific namespace context.

packages/easy-express/src/types · high confidence

The easy-react library now includes an If component in the layout module, allowing users to conditionally render child elements based on a boolean or truthy condition. This component is exported via the layout index for easy import.

packages/easy-react/src/layout · high confidence

A new demo application has been added to the easy-react package, providing a concrete example of the library in action. This demo is built with Next.js and TypeScript, featuring a page that displays the current EUR/USD exchange rate. It demonstrates core easy-react concepts by defining an Exchange domain model, an ExchangeRepo for data retrieval, and a ViewRate process to manage the view logic, all wired together in a React component.

packages/easy-react/demo · high confidence

The \packages/easy-domain/src/values\ directory now includes new value types for DUNS numbers, EANs, emails, IBANs, postal codes, slugs, URLs, and VAT identifiers. These types provide standardized validation and normalization for common business data: DUNS numbers are validated as 9-digit numeric strings; EANs use the validator.js checksum; emails are normalized to lowercase and expose a derived name; IBANs are validated via checksum; postal codes are validated against specific country locales (defaulting to Netherlands); slugs are normalized and validated; URLs support configurable validation options (protocols, TLDs, hosts, etc.); and VAT numbers are validated against specific country codes with input cleaning. All types extend the base \Value\ class and use specific sub-path imports from the \validator\ library for tree-shaking.

packages/easy-domain/src/values · high confidence

The \packages/easy/src/index.ts\ file is created to serve as the central export hub for the \easy\ package. It aggregates and re-exports types, utilities, and services from various internal modules, including data access (Condition, Database, Query), domain models (Entity, Struct), HTTP handling (Request, Response, CacheControl), process management (UseCase, Scope), SQL operations (Select, Insert, Update), and utility functions (IfType, Period, Base64). This change consolidates the public API surface, allowing consumers to import all necessary components from a single entry point.

packages/easy/src · high confidence

The repository has been initialized with the core configuration files required to build and maintain the 'easy' framework. This includes a TypeScript configuration targeting ESNext with React JSX support, a tsup build setup for generating both ESM and CJS outputs, and a Jest testing configuration for workspace packages. Development tooling is standardized with ESLint (including security and SonarJS plugins), Prettier, and a release-it setup for automated publishing. The project also adopts Yarn 4.6.0 with node-modules linker and includes a Code of Conduct.

(repo-wide) · high confidence

Introduces the new easy-test-web package, providing the foundational configuration for a web-based testing library. This includes setup for ESLint, TypeScript compilation, and Jest testing, along with integration for SonarQube quality gates and code coverage reporting.

packages/easy-test, packages/easy-test-web · high confidence

Introduces the easy-react package, a new React-based UI library providing standard web and app components. This addition includes the necessary build configuration using tsup for bundling, TypeScript settings, Jest test configuration, and SonarQube analysis rules to support the new component library.

packages/easy-react, packages/easy-react/src · high confidence

The new easy-bq package provides a BqProvider class that wraps the @google-cloud/bigquery client, allowing users to execute SQL queries against BigQuery databases within the Easy framework. This provider handles query execution with parameter support and maps results to the framework's List\<Json\> type, while also integrating with existing test infrastructure and build configurations.

packages/easy-bq · high confidence

Added a new Playwright-based implementation of the testing interface, allowing users to run end-to-end tests using Chromium, Firefox, or Webkit browsers. The new PlaywrightTester supports launching browsers with custom properties, navigating via URLs or use cases, and interacting with elements through standard locators (by ID, class, name, data-testid, XPath) as well as new capabilities like checking element existence and retrieving DOM properties.

packages/easy-playwright/src · high confidence

This change adds the \easy-puppeteer\ package, providing a concrete implementation of the testing interface using Puppeteer. It introduces \PuppeteerTester\ for managing browser sessions (including configurable launch options and viewport settings) and locating elements via CSS selectors, attributes, or XPath, as well as \PuppeteerElement\ to expose element interactions like clicking, typing, and checking existence. This allows users to run end-to-end tests against a real browser environment using the standard Agile Easy testing abstractions.

packages/easy-puppeteer/src · high confidence

This change introduces a new SQL query builder within the easy package, providing classes for constructing Select, Insert, Update, and Delete statements with support for clauses, joins, ordering, and grouping. It adds a TableGateway class that serves as the primary interface for database operations, offering methods to retrieve, add, update, and remove records by ID or in bulk, with optional support for custom query providers to facilitate usage in contexts like transactions.

packages/easy/src/sql · high confidence

Added a new set of utility files (Utils.ts, Types.ts, Eq.ts, Req.ts, Response.ts) to the easy-test package. These provide foundational type definitions (such as Id, Json, Text, UseCase, Tester), helper functions for type checking and conversion (isDefined, asNumber, asString, isArray), and utility classes for handling request objects (Req) and equality comparisons (Eq). This establishes the internal infrastructure for the easy-test testing framework.

packages/easy-test/src/utils · high confidence

A new easy-express package has been added to the repository, providing a dedicated module for Express.js integration. This package exports core Express utilities and type definitions from its source directory, configured to build against the existing 'easy' package via TypeScript project references. It includes standard tooling configurations for linting, testing with Jest, code quality analysis with SonarQube, and bundling via tsup to support both CommonJS and ESM outputs.

packages/easy-express · high confidence

The new \easy-express\ package provides the \ExpressProvider\ to wire service endpoints to an Express application, including support for route-level middleware, security checks (lab coat, JWT token, scope, use case), and content-type handling (JSON, raw JSON, text, stream). It adds an \ErrorHandler\ that maps service errors to HTTP responses and stores server error details in the request context, a \SecurityHandler\ for JWT authentication and environment-based access control, and middleware for request context and correlation IDs.

packages/easy-express/src/express · high confidence

The new \easy-service\ package provides the core building blocks for defining HTTP services, including decorators for HTTP verbs (GET, POST, PUT, PATCH, DELETE, STREAM), resource routing, and security requirements (token, scope, use case). It includes a \Service\ class for managing application lifecycle and port configuration, a \Jwt\ class for signing and verifying tokens using environment variables, and a \HealthResource\ for basic health checks. This package also sets up the necessary build, linting, and testing infrastructure (Jest, ESLint, SonarQube) for the service layer.

packages/easy-service · high confidence

This change adds new core data-layer components to the easy package, including the Condition, Field, and SortCondition classes to facilitate building query filters and sort orders, as well as the InMemoryGateway to provide an in-memory implementation of the data gateway interface. It also introduces the Database class for managing provider instances and options, and defines the QueryProvider interface for executing raw queries and commands.

packages/easy/src/data · high confidence

The \packages/easy/src/http\ module now provides a comprehensive set of types and utilities for building HTTP requests and handling responses. This includes a \CacheControl\ class for managing cache headers, a \ContentType\ enum with support for raw JSON, and a full \HttpStatus\ enum with error classification helpers. Request configuration is handled via \RequestOptions\, which now supports setting headers (including API keys and basic auth), timeouts, max redirects, and status validation. The \RestResult\ type and its \rest\ utility simplify the creation of standardized API responses, while \toResponse\ and \LocalRequestStore\ provide helpers for converting payloads and managing request context.

packages/easy/src/http · high confidence

Added the \easy-test-web\ package, which defines the \Tester\ and \TestElement\ interfaces to enable web-based test execution. The \TestElement\ interface provides methods for interacting with UI elements, including \click\, \type\, \press\ (for keyboard input), \property\, and \exists\. The \Tester\ interface exposes navigation and selection capabilities, such as locating elements by ID, class, name, or data-test-id, submitting forms, waiting for renders, and redirecting. It also includes a \goto\ method for navigating to use cases and a \toUrl\ helper that constructs URLs using a configurable host (defaulting to the \WEB\_HOST\ environment variable) and use case identifiers.

packages/easy-test-web/src · high confidence

This change adds new TypeScript classes to the \packages/easy/src/process\ directory that define the structural and operational backbone of the application. \App\ and \Scope\ classes provide a hierarchical naming and scoping mechanism, allowing use cases to be organized and expanded dynamically. \UseCase\ serves as the base for business logic, supporting scope attachment and identification. \Search\ and \Manage\ classes implement standard data access patterns, with \Search\ handling retrieval (by ID, key, query, etc.) and \Manage\ extending it with CRUD operations (add, update, upsert, remove) against the underlying repository.

packages/easy/src/process · high confidence

Adds the \easy-test\ package with a \mock\ object providing helpers for creating Jest mocks (including \resolveWith\, \rejectWith\, and \returnWith\ for typed values), retrieving mock arguments via \getArg\, and managing mock state. It also introduces a \fits\ namespace with asymmetric matchers for testing text (substring and exact), JSON subsets, URIs, and array items, alongside utilities for generating structured request and response objects.

packages/easy-test/src/mock · high confidence

A new Jwt class has been added to the security module, implementing the Value object pattern to encapsulate JWT strings. This component provides a dedicated method to decode JWT payloads into JSON objects, leveraging the jwt-decode library, and includes serialization support via toJSON.

packages/easy/src/security · high confidence

The \packages/easy-test/src/matchers\ directory now provides a comprehensive suite of custom Jest matchers to simplify testing. HTTP response assertions are available via \toHaveStatus\, \toBeOk\, \toBeCreated\, \toBeNotFound\, and others. Routing and navigation can be verified with \toBeAt\ (partial URL matching) and \toBeExactlyAt\ (exact URL matching), while \toBeRoutedTo\ checks specific URI calls. Validation logic is supported by \toBeValid\, \toFail\, and \toFailWith\ for result objects. Additional utilities include \toBeArrayOf\ and \toBeArrayOfWithLength\ for type and length checks, \toMatchJson\ and \toMatchExactJson\ for object comparison, \toMatchText\ for string equality, and \toBeQueriedWith\ for verifying mock query calls.

packages/easy-test/src/matchers · high confidence

The \packages/easy-test-react/src\ package now provides a new \Tester\ class and \ElementTester\ class to simplify React component testing. The \Tester\ class offers a fluent API for querying rendered components using various selectors (by ID, label, placeholder, role, text, title, alt, href, field, and custom queries), with support for selecting specific instances via an optional index parameter. It also includes methods for submitting forms and debugging. The \ElementTester\ class wraps individual DOM elements, providing methods for common interactions such as clicking, typing, clearing, blurring, and waiting for element removal or presence. The package also exports a \waitForRender\ utility for asynchronous rendering and automatically mocks the timezone to UTC in tests to ensure consistent behavior.

packages/easy-test-react/src · high confidence

The \packages/easy-react/src/utils\ module now exports a suite of new React utilities. This includes state management hooks such as \useState\ (with added reset functionality), \useToggle\ (supporting a \flip\ async action), \useRev\ (for revalidation), and \useOnce\ (for one-time async initialization). It also introduces data-fetching hooks like \useGet\, \useGetList\, \useList\, \usePageList\, and \usePaging\ to simplify list and pagination state. Additionally, new helper functions \toChildren\ and \toClasses\ are provided to assist with rendering and styling.

packages/easy-react/src/utils · high confidence

A new SqlServerProvider class has been added to the easy-mssql package, implementing the QueryProvider interface to handle database connections and query execution using the mssql library. The provider manages connection pooling and ensures connections are established only when necessary, exposing execute, query, and command methods for interacting with Microsoft SQL Server databases.

packages/easy-mssql/src · high confidence

The \packages/easy/src/domain\ directory now contains a set of new domain models and repository implementations. This includes \Struct\, \Entity\, \Child\, \Audit\, and \DateTime\ classes, alongside \Repo\ and \Typo\ repository base classes. The \DateTime\ class has been implemented using Luxon, providing timezone handling and formatting capabilities. The \Repo\ class introduces a generic repository pattern with support for actions like add, update, and upsert, while \Typo\ and \Agent\ provide alternative repository interfaces for different data access needs.

packages/easy/src/domain · high confidence

The \easy-domain\ package now includes structured enum classes and corresponding JSON data files for Countries, Currencies, Locales, Units of Measurement, and Units of Weight. This provides a standardized, type-safe way to access global reference data, including ISO country codes, currency symbols and decimal digits, locale identifiers, and metric conversion multipliers for length and weight.

packages/easy-domain/src/enums · high confidence

The easy-domain package now includes new domain structs for Money, Address, Box, Dimension, Name, and Weight. Money parsing has been extended to support formatted strings (including currency codes and locale-specific decimal/grouping separators) and raw numbers, defaulting to EUR when only a number is provided. Address, Box, Dimension, and Weight structs provide validation and utility methods for handling physical quantities and addresses, while Name supports structured first/middle/last name handling.

packages/easy-domain/src/structs · high confidence

This change introduces the \easy-mongo\ package, extracting MongoDB-specific logic from the core \easy\ library. It provides a \Collection\ class for defining schemas and a \MongoProvider\ for managing database connections and executing CRUD operations. The package includes a \MongoGateway\ that maps these operations to the \easy\ domain model, supporting features like pagination, sorting, and filtering. Additionally, it introduces \AtlasSearchGateway\ and a \Lucene\ module, enabling full-text search capabilities via MongoDB Atlas Search, including support for facets, fuzzy matching, and complex compound queries.

packages/easy-mongo/src · high confidence

The \packages/easy/src/services\ directory now contains a new set of service classes: \Api\, \ApiGateway\, \RouteGateway\, \MappedRouteGateway\, \ViewRouteGateway\, and \AxiosProvider\. \Api\ provides a low-level HTTP client interface with support for GET, POST, PUT, PATCH, and DELETE operations, including request transformation and error handling. \ApiGateway\ extends this to provide a higher-level API for interacting with RESTful endpoints, returning structured data like \PageList\ and \Optional\ types. \RouteGateway\ builds on \ApiGateway\ to offer CRUD operations (all, byId, byIds, search, add, update, upsert, remove, filter, exists) for specific resource routes. \MappedRouteGateway\ and \ViewRouteGateway\ provide additional layers for data transformation and view-based mapping, respectively. \AxiosProvider\ implements the underlying HTTP request execution using Axios, handling headers, timeouts, and redirects.

packages/easy/src/services · high confidence

The \packages/easy/src/types\ directory has been populated with a comprehensive set of new TypeScript types and utility classes. This includes a robust \List\ and \PageList\ class extending native arrays with methods for sorting, filtering, and aggregation, alongside a \Case\ class for fluent conditional logic. New foundational types such as \AnyKey\ for recursive key traversal, \Enum\ for type-safe enumerations, and \Context\ for managing environment and request state have been introduced. Additionally, utility modules for JSON manipulation, text transformation, caching, and error handling have been added to support the broader Easy framework.

packages/easy/src/types · high confidence

Added a suite of new utility modules in \packages/easy/src/utils\ to enhance data handling and type safety. The \View\ and \Mapper\ classes provide robust object transformation, mapping, and traversal capabilities with support for dot notation, JSON handling, and list operations. New type-checking utilities (\IfType\, \If\) allow for safe conditional branching based on value types and presence. Additional helpers include \Base64\ for encoding/decoding, \Convert\ for type conversions, \Period\ for date range calculations, \Promise\ utilities for tuple and settled operations, and \Sentence\ for building structured text.

packages/easy/src/utils · high confidence

Introduces a new validation system in \packages/easy/src/validation\ featuring property decorators (e.g., \@defined\, \@required\, \@inUnion\, \@minLength\) for declarative constraint checking, a \validate\ function for runtime validation of objects and arrays, and a \when\ fluent API for conditional logic and promise-based rejection/recovery.

packages/easy/src/validation · high confidence

A change to existing behaviour in .yarn — 4 commits, 2 files.

.yarn · medium confidence · unverified

The easy-playwright and easy-puppeteer packages now use tsup for building, producing both CommonJS and ESM outputs in the dist folder. SonarQube analysis has been updated to use the javascript.lcov report path and waits for quality gates to complete. Standardized ESLint, Jest, and TypeScript configuration files have been added to both packages to support the new build and test setup.

packages/easy-playwright · high confidence

The easy package is now configured as an independent workspace unit, featuring its own ESLint rules, TypeScript configuration, and Jest test setup. It utilizes tsup for bundling, inheriting the shared configuration to support both CommonJS and ESM outputs, and includes specific SonarQube properties to enable code quality gate monitoring for this package.

packages/easy · high confidence

The package's public API now explicitly exports the newly introduced DunsNumber and VAT value types alongside existing enums and structs. This change also establishes a centralized index file that aggregates all domain exports, effectively untangling previous circular dependencies and providing a cleaner entry point for consumers to import these domain primitives.

packages/easy-domain/src · high confidence

The Microsoft SQL Server provider has been extracted into its own standalone package (\packages/easy-mssql\). This change includes the addition of necessary build and configuration files (such as \tsup.config.ts\, \tsconfig.json\, and \jest.config.js\) to support independent development, testing, and bundling of the provider, separating it from the core library.

packages/easy-mssql · high confidence

The \packages/easy-mongo\ directory has been introduced to house MongoDB-specific logic, separated from the core library. This change establishes the package's build and development infrastructure, including a \tsup\ configuration for bundling, a \tsconfig\ that references the parent \easy\ package, and standard tooling files for ESLint, Jest, and SonarQube quality gates.

packages/easy-mongo · medium confidence

A new generic \Req\<T\>\ class has been introduced in the resources module to standardize request handling. It now includes optional \skip\ and \take\ properties derived from query parameters, returning \undefined\ instead of \NaN\ when absent, and supports passing HTTP headers. The class is generic, allowing the request body to be strongly typed as \T\, and provides convenient getters for \id\ and \q\.

packages/easy/src/resources · high confidence

The easy-test-react package now uses a standardized project structure with dedicated configuration files for ESLint, Jest, TypeScript, and SonarQube. Users benefit from consistent linting rules via a new .eslintrc.js and .eslintignore, a Jest setup that extends the base configuration with jsdom environment support and a temporary workaround for the uuid module, and TypeScript compilation targeting ES2020 with output to the dist directory. Additionally, SonarQube integration is configured to monitor JavaScript code coverage and wait for quality gates, ensuring code quality standards are enforced during development.

packages/easy-test-react · high confidence

A new release-it plugin has been added to automatically resolve 'workspace:' protocol references in internal dependencies to their actual version numbers during the release process. This ensures that published packages contain valid, non-workspace dependency versions, preventing installation errors for end users.

scripts · high confidence

Added reference test fixtures for the Easy framework; Added snapshot test for form content type encoding; Added snapshot tests for React utility hooks; Added test coverage for HTTP utilities; Added test coverage for domain classes and repositories; Added test coverage for domain structs; Added test coverage for domain value types; Added test coverage for easy-express middleware and handlers; Added test coverage for easy-mongo core components; Added test coverage for process components; Added test initialization script for environment setup; Added test reference files for easy-express Dev resource; Added tests for Jwt validation and serialization; Added tests for domain enum types; Added tests for easy-test mock utilities and asymmetric matchers; Added tests for the If layout component; Added type tests for NamespaceContext; Added unit tests for PlaywrightTester; Added unit tests for PuppeteerElement and PuppeteerTester; Added unit tests for React testing utilities; Added unit tests for React utility hooks; Added unit tests for Req resource handling; Added unit tests for SQL query builder and TableGateway; Added unit tests for SqlServerProvider; Added unit tests for core type utilities and domain models; Added unit tests for data-layer components; Added unit tests for easy-test utility functions; Added unit tests for service layer components; Added unit tests for the Tester toUrl utility; Added unit tests for validation constraints and conditional logic.

The project is initialized as a Yarn 4 workspace (packageManager: yarn@4.6.0) containing 15 packages. This change establishes the foundational dependency graph, including the core @thisisagile/easy library, service integrations (MongoDB v6.17.0, MSSQL v9.1.1, BigQuery v8.3.1, Express v4.21.2), testing utilities (Jest v30.4.2, Playwright v1.41.2, Puppeteer v22.2.0), and UI components (React v18.3.1). It also sets up the build toolchain with TypeScript v5.7.3, tsup v7.2.0, and ESLint v8.57.1.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 49 → 59 (+10.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 96 → 96 (+0.2)
• Architecture 49 → 59 (+10.4)
• Maturity 57 → 57 (-0.3)
• Readiness 50 → 58 (+8.2)
• Security 41 → 58 (+17.3)

• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• …and 49 more

• ClassTooLong: Locale (packages/easy-domain/src/enums/Locale.ts)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical vulnerability: [GHSA redacted] (yarn.lock)
• Documentation: no architecture or design documentation (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Further orphaned files (smaller)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• …and 71 more

• 12 commits — 10 feature/other, 2 fixes

• (root) — 3 commits
• packages/easy-test-react — 3 commits
• (repo) — 2 commits
• packages/easy — 1 commit
• packages/easy-domain — 1 commit
• packages/easy-puppeteer — 1 commit
• packages/easy-react — 1 commit

• fix: fix(domain): derive VAT country code type from isVAT to compile with newer validator types
• fix: fix(easy-puppeteer): let row() build valid xpath
• change: Merge remote-tracking branch 'origin/main'
• change: Merge remote-tracking branch 'origin/main' into HEAD
• change: chore(ci): Use npm trusted publishing
• change: chore(deps): bump @google-cloud/bigquery to ^8.3.1
• change: chore(test): skip dot-directories when collecting jest projects
• change: feat(types): let kebab accept non-string input and add ErrorOrigin tests
• change: feat(utils): add given to read a property only when the key is there
• change: test: add blur method to ElementTester with unit tests
• change: test: add byField and atField methods to Tester with unit tests
• change: test: add byName and atName as aliases of byField and atField

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

thisisagile/easy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.