Skip to content
CAI
Software that uses CAICheck a score

thisisagile/easy

54.6

Adequate · 9 November 2026

10.1k

lines of production code

TypeScript

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add NamespaceContext for request-scoped storage in Express

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

Add conditional rendering layout component

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

Add easy-react demo application

A new demo application has been added to the easy-react package, providing a working example of the library's capabilities. This demo is built with Next.js and TypeScript, featuring a domain model for currency exchange rates (Exchange) and a repository layer that fetches EUR/US exchange data. The user interface displays the current exchange rate, demonstrating how to integrate easy-react's state management and domain logic within a standard React/Next.js environment.

packages/easy-react/demo · high confidence

Add new domain value types for DUNS, EAN, Email, IBAN, Postal Code, Slug, URL, and VAT

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

Establishes the main entry point for the easy package

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

Initial package configuration and tooling setup

The easy-domain package has been initialized with standard development tooling configurations. This includes ESLint setup (via .eslintrc.cjs and .eslintignore), Jest testing configuration extending a base config, TypeScript compilation settings targeting the src directory, and SonarQube project properties for code quality analysis.

packages/easy-domain · high confidence

Initial package scaffolding and CI configuration for packages/easy

This change introduces the foundational configuration files for the \packages/easy\ package, establishing its build, test, and quality-gate infrastructure. It adds ESLint configuration (\.eslintrc.cjs\ and \.eslintignore\) to define linting scope, a Jest configuration (\jest.config.cjs\) that extends a shared base, and a TypeScript configuration (\tsconfig.json\) specifying source and output directories. Additionally, it includes a SonarQube configuration (\sonar-project.properties\) that defines source/test paths, points to the JavaScript coverage report, and enables waiting for quality gates, thereby integrating the package into the project's continuous integration and code quality workflows.

packages/easy · high confidence

Initial package scaffolding for easy-test-react

The easy-test-react package is introduced with its foundational configuration files, establishing the environment for development and testing. This includes ESLint settings to manage code quality and ignore generated or irrelevant files, a Jest configuration that extends a base setup and specifically maps the 'uuid' module to resolve compatibility issues, and a TypeScript configuration targeting ES2020 with DOM support. Additionally, SonarQube properties are defined to direct code coverage and test reports to the correct paths, ensuring quality gates are enforced during the build process.

packages/easy-test-react · high confidence

Initial project scaffolding and configuration

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

Initial release of the easy-react UI library

The easy-react library is introduced as a new package providing standard web and app components built with React. The initial distribution exposes layout utilities and general utility functions via the main entry point, establishing the foundation for the library's component set.

packages/easy-react/src · high confidence

Initial setup of easy-test-web package with ESM build and test infrastructure

The new easy-test-web package is introduced, configured to publish ESM-only output built with tsdown. It includes a complete testing environment using Jest and Puppeteer/Playwright, along with SonarQube integration that waits for quality gates and reports coverage via the javascript.lcov property.

packages/easy-test-web · high confidence

Initial setup of the easy-mongo package

A new 'easy-mongo' package has been added to the repository, containing the foundational configuration files required for its development and integration. This includes TypeScript compilation settings that reference the 'easy' package, ESLint rules and ignore patterns, Jest test configuration extending a base setup, and SonarQube properties for code quality analysis. This change establishes the structural scaffolding for the new module but does not yet include the source code or tests themselves.

packages/easy-mongo · high confidence

Introduce BqProvider for Google BigQuery integration

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. The provider accepts a Database instance and automatically configures the BigQuery client using the database's projectId, returning query results as a list of JSON objects and mapping execution errors to the framework's Exception.CouldNotExecute type.

packages/easy-bq · high confidence

Introduce Playwright integration for end-to-end testing

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

Introduce Puppeteer-based E2E testing implementation

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

Introduce SQL query builder and TableGateway for data access

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

Introduce core utility types and helpers for the easy-test package

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

Introduce easy-express package for Express.js integration

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

Introduce easy-express package with ESM build and configuration

Added the new easy-express package, which exports Express-related utilities and types from its source directory. The package is configured to build as ESM-only using tsdown, extends the root TypeScript configuration, and includes standard tooling files such as ESLint, Jest, and SonarQube settings to support development and quality gates.

packages/easy-express · high confidence

Introduce easy-service package with HTTP resource and JWT support

A new \easy-service\ package has been added to the codebase, extracting service-specific logic from the core \easy\ library. This package provides the infrastructure for building HTTP services, including decorators for defining routes (\@route\, \@get\, \@post\, etc.), handling HTTP verbs, and managing resource metadata. It introduces a \Service\ class for bootstrapping applications, an \AppProvider\ interface for wiring resources, and a \Jwt\ class for signing and verifying tokens using environment variables. Additionally, it includes a \HealthResource\ for basic health checks and utilities for error handling (\OriginatedError\) and dependency requirements (\Requires\).

packages/easy-service/src · high confidence

Introduce easy-test package with ESM build and SonarQube integration

The new easy-test package provides test utilities (matchers and mocks) built as ESM-only using tsdown. It includes configuration for ESLint, Jest, and TypeScript, and is integrated with SonarQube to wait for quality gates and report coverage via the javascript.lcov property.

packages/easy-test · high confidence

Introduce new data access abstractions and condition helpers

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

Introduce structured HTTP client primitives and response handling

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

Introduce web testing interfaces for element interaction and navigation

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

Introduces core process-layer classes for application structure and data operations

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

Introduces easy-test mock utilities and asymmetric matchers

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

Introduction of a JWT Value Object for decoding

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

New Jest matchers for HTTP, routing, and validation

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

New React testing utilities for element querying and interaction

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

New React utility hooks and helpers in easy-react

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

New SQL Server provider implementation

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

New domain classes and repository implementations in easy package

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

New domain structs for Money, Address, and physical dimensions

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

New easy-mongo package with MongoDB integration and Atlas Search support

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

New service layer with Api, ApiGateway, and RouteGateway classes

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

New type system and utility classes in the Easy package

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

New utility modules for data mapping, type checking, and object traversal

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

New validation library with decorators and fluent API

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

Behavioural changes

2 commits (0 fixes) modifying scripts

A change to existing behaviour in scripts — 2 commits, 1 file: “feat(packaging)!: publish ESM only, built with tsdown”; “feat(packaging)!: ship a loadable ESM entry with an exports map and a packed-consumer bundle gate”.

scripts · medium confidence · unverified

4 commits (1 fix) modifying .yarn

A change to existing behaviour in .yarn — 4 commits (1 fix), 2 files: “feat: Add 'dir' function to Log and its corresponding test”; “feat: Update easy to use Yarn 4.x”; “feat(easy): move service specific code into a new package”; and 1 more.

.yarn · medium confidence · unverified

4 commits (1 fix) modifying packages/easy-react

A change to existing behaviour in packages/easy-react — 4 commits (1 fix), 3 files: “fix(easy-react): exclude demo dir from Sonar analysis”; “style: Run the formatter”; “feat(packaging)!: publish ESM only, built with tsdown”; and 1 more.

packages/easy-react · medium confidence · unverified

Establishes build and quality configuration for the easy-service package

The easy-service package now includes its own project configuration files, including TypeScript settings, ESLint rules, Jest testing setup, and SonarQube quality gate properties. This provides the service with standardized tooling for compilation, linting, testing, and code quality analysis.

packages/easy-service · high confidence

Expose new value types and restructure public API exports

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

Microsoft SQL Server provider moved to a separate package

The Microsoft SQL Server provider has been extracted into its own standalone package (\packages/easy-mssql\). This change includes the necessary configuration files for the new package, such as ESLint, Jest, SonarQube, and TypeScript settings, establishing the build and testing infrastructure for this isolated module.

packages/easy-mssql · high confidence

New generic Req class with optional pagination and headers

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

Standardized build and quality-gate configuration for Playwright and Puppeteer packages

The \easy-playwright\ and \easy-puppeteer\ packages now include standardized configuration files for linting, testing, and code quality analysis. Users will benefit from consistent ESLint and Jest setups that inherit from shared base configurations, ensuring uniform code style and test execution across both packages. Additionally, SonarQube integration is configured to use the \javascript.lcov\ property for coverage reporting and enforces quality gates, meaning CI pipelines will now wait for SonarQube quality checks to pass before proceeding, improving code quality assurance.

packages/easy-playwright, packages/easy-puppeteer · high confidence

Fixes

1 commit (1 fix) fixing (repo-wide)

A fix in (repo-wide) — 1 commit (1 fix), 63 files: “build: upgrade all dependencies to latest and fix the fallout”. Also in this area: Added snapshot test for form content type encoding.

packages/easy/test/http/\\snapshots\\_ · medium confidence · unverified_

5 commits (3 fixes) fixing packages/easy-domain/src/enums

A fix in packages/easy-domain/src/enums — 5 commits (3 fixs), 9 files: “feat!: make Easy catalogues tree-shakeable”; “fix(catalogues): let catalogue subpaths tree-shake in Next and tsdown consumers”; “fix(easy-domain): Extend country with isEu function”; and 2 more.

packages/easy-domain/src/enums · medium confidence · unverified

Test coverage

2 commits adding/updating tests in packages/easy-playwright/test/ref, packages/easy-puppeteer/test/ref; 5 commits adding/updating tests in packages/easy-domain/test/enums; 7 commits adding/updating tests in test/bundle; Added bundle-size regression tests and packaging validation; Added reference test fixtures for the Easy framework; 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-service core components; Added test coverage for process components; Added test reference files for easy-express Dev resource; Added tests for Jwt validation and serialization; Added tests for defaultExport utility; 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.

Dependencies

Initialize Yarn 4 workspace with updated core dependencies

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 52 → 55 (+2.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 76 → 76 (-0.5)
  • Architecture 71 → 65 (-5.8)
  • Maturity 57 → 64 (+7.1)
  • Readiness 36 → 40 (+3.7)
  • Security 70 → 69 (-1.0)
  • Domain Modelling 79 → 71 (-7.5)
  • Performance 100 → 100 (+0.0)

Resolved (108)

  • ClassTooLong: Locale (packages/easy-domain/src/enums/Locale.ts)
  • Cross-context type Optional (easy → easy-domain) (packages/easy-domain/src/enums/Country.ts)
  • Cross-context type Optional (easy → easy-domain) (packages/easy-domain/src/enums/Locale.ts)
  • Cross-context type Optional (easy → easy-domain) (packages/easy-domain/src/structs/Money.ts)
  • Cross-context type Optional (easy → easy-mongo) (packages/easy-mongo/src/MongoGateway.ts)
  • Cross-context type Optional (easy → easy-mongo) (packages/easy-mongo/src/MongoGateway.ts)
  • Cross-context type Optional (easy → easy-mongo) (packages/easy-mongo/src/Stages.ts)
  • Cross-context type Optional (easy → easy-mongo) (packages/easy-mongo/src/Stages.ts)
  • Cross-context type Optional (easy → easy-react) (packages/easy-react/src/utils/Hooks.ts)
  • Cross-context type Optional (easy → easy-react) (packages/easy-react/src/utils/toClasses.ts)
  • Cross-context type SortDirection (easy → easy-mongo) (packages/easy-mongo/src/Collection.ts)
  • Deprecated: @azure/msal-browser (yarn.lock)
  • Deprecated: @azure/msal-node (yarn.lock)
  • Deprecated: @humanwhocodes/config-array (yarn.lock)
  • Deprecated: @humanwhocodes/object-schema (yarn.lock)
  • Deprecated: abab (yarn.lock)
  • Deprecated: conventional-changelog-atom (yarn.lock)
  • Deprecated: conventional-changelog-codemirror (yarn.lock)
  • Deprecated: conventional-changelog-core (yarn.lock)
  • Deprecated: conventional-changelog-ember (yarn.lock)
  • …and 88 more

New (20)

  • Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (registry.npmjs.org unreachable)
  • Deprecated: @types/uuid (packages/easy-express/package.json)
  • Deprecated: @types/uuid (packages/easy/package.json)
  • Deprecated: glob (yarn.lock)
  • Deprecated: glob (yarn.lock)
  • FileTooLong: enums/Country.ts (packages/easy-domain/src/enums/Country.ts)
  • FunctionTooLong: Country.registry (packages/easy-domain/src/enums/Country.ts)
  • FunctionTooLong: Currency.registry (packages/easy-domain/src/enums/Currency.ts)
  • FunctionTooLong: Locale.registry (packages/easy-domain/src/enums/Locale.ts)
  • High CVE: [GHSA redacted] (yarn.lock)
  • High CVE: [GHSA redacted] (yarn.lock)
  • Low CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • Medium CVE: [GHSA redacted] (yarn.lock)
  • Mock-dominated test: closable browser testers close their browser (packages/easy-test-web/test/Tester.test.ts)
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #1
  • Pass-through layer (packages/easy/src/process/Manage.ts)

Changes since last survey

  • 18 commits — 10 feature/other, 8 fixes

By area

  • packages/easy — 11 commits
  • .github/workflows — 2 commits
  • test/bundle — 2 commits
  • (root) — 1 commit
  • packages/easy-express — 1 commit
  • packages/easy-mongo — 1 commit

Notable commits

  • fix: build: upgrade all dependencies to latest and fix the fallout
  • fix: fix(catalogues): let catalogue subpaths tree-shake in Next and tsdown consumers
  • fix: fix(easy): DateTime toLocale/toFormat no longer read the clock
  • fix: fix(easy): resolve wall times without reading the clock
  • fix: fix(easy): stop choose and tryTo from loading the validation graph
  • fix: fix(easy-test): declare import-time side effects so bundlers keep match…
  • fix: fix(easy-test): import jest from @jest/globals so mocks work under native ESM
  • fix: fix(release): publish with yarn npm publish so workspace: ranges are re…
  • change: build: derive catalogue facade resolution from package manifests
  • change: ci: run the packed artifact consumer tests with --experimental-vm-modul…
  • change: feat!: make Easy catalogues tree-shakeable
  • change: feat(easy): make Try cheap on filter misses (no throw/catch, lazy Error)
  • change: feat(easy-mongo): back off Mongo reconnects per cluster in MongoProvide…
  • change: perf(easy): DateTime reuses one Intl formatter per zone for offsets
  • change: perf(easy): DateTime toLocale/toFormat reuse Intl formatters
  • change: test(bundle): measure choose and tryTo and rebase the baseline on 3971490
  • change: test(easy): match multi-line predicate source in Try filter-miss messag…
  • change: test: cover Sonar branch gaps in web and express packages

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 7b4a86a5ba1b58a2744e668bfba8b9df4b3ead39 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-bb0cb800cd0f.