CellixJs/cellixjs

This system is a monorepo-based platform called CellixJS that provides a reusable framework for building multi-tenant community management applications. It combines a Node.js API backend with Azure Functions, Cosmos DB, and GraphQL, alongside React-based frontends for community and staff portals. The architecture emphasizes Domain-Driven Design, offering shared infrastructure for authentication, storage, and event handling to accelerate the development of secure, scalable web services.

38 changes.

The project established the CellixJS monorepo foundation, migrating from legacy Azure Functions structures to a new framework-based architecture with DDD seedwork and standardized CI/CD pipelines. Simultaneously, comprehensive Infrastructure as Code modules were developed to provision Azure services, while initial implementations for the API and UI Community applications were introduced.

28 changes.

This period focused on the initial release of the Staff UI application, implementing role-based access control and GraphQL integration. It also expanded the Cellix framework with new packages for Azure Blob and Queue storage, standardized testing configurations, and enhanced local development mock services for MongoDB and OIDC.

The application now includes a dedicated OpenID Connect (OIDC) configuration file that defines the authentication settings for the community end-user portal. This configuration is driven by environment variables (such as authority, client ID, and scopes) with sensible mock defaults for local development, and includes a sign-in callback handler that manages post-login redirection using session storage.

apps/ui-community/src/config · high confidence

A new OpenTelemetry starter module has been added to the API service configuration. It initializes the Otel service with environment-specific settings, enabling console export and simple processors when the NODE\_ENV is set to development.

apps/api/src/service-config · high confidence

Introduced a new AuthLanding component that redirects users to the community accounts page, along with its corresponding Storybook story file to facilitate visual testing and documentation within the UI community application.

apps/ui-community/src/components/ui/molecules · high confidence

The new cellix-tdd agent skill is available under .agents/skills/cellix-tdd, providing a set of TypeScript fixture packages that demonstrate common utility patterns and testing scenarios. These fixtures include functions for parsing host and port values, reading required and optional environment variables, parsing boolean flags and comma-separated string lists, generating slugs with configurable separators, merging HTTP headers with case-insensitive normalization, building deterministic retry policies with exponential backoff, and dispatching commands via a normalized router. Each fixture package contains both the implementation and corresponding Vitest tests, serving as examples for TDD workflows.

(repo-wide) · high confidence

The ui-community app now includes a ThemeContext provider that manages application-wide theme state, supporting light, dark, and custom themes via Ant Design. Users can toggle between light and dark modes using a button in the UI or by pressing Cmd+Shift+K, and their preference is automatically saved and restored on subsequent visits.

apps/ui-community/src/contexts · high confidence

The API service now includes a dedicated Mongoose configuration module that sets up connection options for Azure Cosmos DB. This configuration enables TLS for non-development environments, sets a minimum connection pool size of 10, and enables auto-indexing and auto-creation of collections. It also configures debug logging for development and test environments and provides a context builder to initialize the persistence layer using the Cosmos DB connection string and database name from environment variables.

apps/api/src/service-config/mongoose · high confidence

New integration event handlers have been added to automatically provision members and default roles when a community is created. The \community-created--provision-member-and-default-role.ts\ file registers a listener for the \CommunityCreatedEvent\ that triggers the \CommunityProvisioningService\. These handlers are exposed via new \RegisterDomainEventHandlers\ and \RegisterIntegrationEventHandlers\ functions in the domain and integration index files, allowing the system to react to community creation events.

packages/ocom/event-handler/src/handlers/domain, packages/ocom/event-handler/src/handlers/integration · high confidence

A new token validation configuration file has been introduced that maps specific portal identifiers (AccountPortal and StaffPortal) to their corresponding token keys (ACCOUNT\_PORTAL and STAFF\_PORTAL). This provides a centralized lookup for portal-specific token validation within the API service configuration.

apps/api/src/service-config/token-validation · high confidence

The .agents/skills directory now includes new structured guidance for AI coding assistants to work with Ant Design (antd) v6, the Ant Design CLI tool, and Apollo Client 4.x. The ant-design skill provides decision guidance for component selection, theming, SSR, and migration using the @ant-design/cli for offline API lookups. The antd skill offers a comprehensive workflow for writing, debugging, and migrating antd components using the same CLI. The apollo-client skill guides developers through setting up Apollo Client 4.x, covering integration with React, Next.js, and other frameworks, with detailed references on caching, error handling, fragments, and best practices.

.agents · high confidence

Added Bicep templates (main.bicep and dev.bicepparam) to define the Azure infrastructure for the API application. This configuration provisions an App Service Plan (SKU B1), a Function App (Node.js 22), Azure Cosmos DB (MongoDB API), Application Insights, and a Storage Account with Blob, Queue, and Table services. It also includes configuration for Azure Cognitive Search and sets up CORS policies and RBAC role assignments for the function app identity.

apps/api/iac · high confidence

The search-service location now includes the core Bicep module (main.bicep) and its configuration (bicepconfig.json) for deploying an Azure Cognitive Search resource. This module allows users to provision a search service with configurable replicas, partitions, and SKU tiers (including storage-optimized options), while enforcing specific authentication settings (HTTP 401 with bearer challenge) and supporting role-based access control assignments. The configuration also enables a linter rule to warn when outdated module versions are used.

iac/search-service · high confidence

The \apps/ui-community/.storybook\ directory now contains the foundational Storybook setup, including \main.ts\ for framework and addon configuration, \preview.tsx\ for global decorators, and \apollo-mocks.ts\ for GraphQL data simulation. This configuration enables developers to view and interact with community components and pages in isolation, wrapping stories with Ant Design styles, a React Helmet provider, an OIDC authentication mock, and a mocked Apollo Client to handle GraphQL queries without a live backend.

apps/ui-community/.storybook · high confidence

The \apps/ui-community/src\ directory now contains the foundational entry point and layout for the community application. This includes the main \App.tsx\ component which establishes the React Router structure, defining routes for the root, authentication redirects, and the community section (which further routes to Accounts and Admin views). The application is bootstrapped via \main.tsx\, integrating Ant Design for UI components, React Helmet for document head management, and \react-oidc-context\ for authentication flows. Styling is handled through Tailwind CSS and Ant Design reset styles, with specific CSS modules for layout and component customization.

apps/ui-community/src · high confidence

Added Bicep templates to provision the storage account and static website hosting for the UI Staff portal. The configuration supports multiple environments (dev, qa, uat, prd, etc.) and allows customization of storage SKU, location, and CORS settings.

apps/ui-staff/iac · high confidence

This change introduces the foundational Infrastructure as Code (Bicep) and supporting scripts to deploy static websites on Azure. It defines a storage account with the static website feature enabled (including index and 404 error documents), configures CORS settings, and provisions a CDN endpoint with an origin group pointing to the storage account's primary and secondary web endpoints. A PowerShell deployment script is included to initialize the static website content, and a content-types JSON file is provided to optimize CDN compression for common web assets.

iac/static-website · high confidence

The repository has been initialized as a CellixJS monorepo using pnpm workspaces and Turborepo, establishing a structured layout with \apps/\ (api, ui-community, ui-staff, docs) and \packages/\ directories. This change introduces the foundational build and development infrastructure, including a centralized \turbo.json\ for task orchestration, \pnpm-workspace.yaml\ with a dependency catalog, and \biome.json\ for linting and formatting. It also sets up the continuous integration pipeline via \azure-pipelines.yml\ with stages for building, deploying to Azure, and running EdgeScan security checks, alongside configuration for SonarCloud code quality analysis, GraphQL code generation, and local development tools like Azurite and Portless.

(repo-wide) · high confidence

The new api-services-spec package introduces TypeScript interfaces for service lifecycle management, defining ServiceBase and SyncServiceBase to standardize startUp and shutDown operations. It includes configuration for TypeScript compilation and Turborepo tagging, establishing the foundational types for backend service specifications within the cellix workspace.

packages/cellix/api-services-spec · high confidence

This change introduces the new \ui-staff\ application, a standalone Vite-based React interface for staff users. It includes the core infrastructure for local development and testing, such as mock OIDC configuration files (\mock-oidc.json\, \mock-oidc.users.json\) defining staff roles like \Staff.CaseManager\ and \Staff.TechAdmin\, and environment variables for connecting to the mock authentication authority. The app is configured to run on port 3001, uses Tailwind CSS for styling, and includes a dedicated CI/CD deployment pipeline (\deploy-ui-staff.yml\) and IaC templates for Azure deployment.

apps/ui-staff · high confidence

The new \ui-staff\ application provides a staff portal that authenticates users via OIDC and dynamically routes them to specific management sections based on their assigned permissions. The app integrates with Apollo Client for data fetching and uses a \useStaffPermissions\ hook to evaluate role-based access control (RBAC) flags such as \canManageCommunities\, \canManageFinance\, and \canManageTechAdmin\. Depending on these permissions, authenticated staff members are directed to the appropriate sub-routes (e.g., \/staff/finance\, \/staff/community-management\, \/staff/user-management\), while unauthorized access attempts are redirected to a dedicated error page. The entry point configures the React tree with Ant Design theming, Helmet, and the necessary authentication providers.

apps/ui-staff/src · high confidence

A new framework-level package, @cellix/service-queue-storage, is available to provide a typed, schema-validated interface for Azure Queue Storage. It allows developers to define queues using JSON Schemas, automatically generating TypeScript types for payloads to ensure type safety during send and receive operations. The package supports both outbound sending and inbound receiving (including Azure Functions trigger integration) with built-in validation via Ajv. It also features optional blob-backed message logging, where message payloads and metadata can be persisted to Azure Blob Storage with configurable tags and metadata. The service supports both connection string and managed identity authentication, and includes auto-provisioning for development environments.

packages/cellix/service-queue-storage · high confidence

The staff portal now includes a dedicated Apollo Client setup that manages GraphQL and REST data fetching. This component automatically attaches authentication tokens (via react-oidc-context) and contextual headers (such as community and member IDs derived from the URL) to outgoing requests. It also implements request batching for GraphQL operations and routes specific queries (like CountryDetails) to a separate REST endpoint, ensuring the staff UI can reliably communicate with backend services.

apps/ui-staff/src/components/ui/organisms · high confidence

The community UI now includes an ApolloConnection wrapper component that manages the Apollo Client link chain, automatically injecting authentication headers via react-oidc-context (with a storage fallback in development) and appending x-community-id and x-member-id headers based on the current route. It supports splitting requests to a separate REST link for country data, and is accompanied by Storybook stories to verify rendering and link behavior.

apps/ui-community/src/components/ui/organisms · high confidence

The API application now includes dedicated configuration modules for Azure services. The new \azure-storage\ module exposes environment-based settings for blob storage, supporting managed identity in production and SharedKey signing for local development with Azurite. Additionally, the \queue-storage\ module provides a default logging configuration for the queue service, enabling containerized logging to the 'queue-logs' container.

apps/api/src/service-config/azure-storage, apps/api/src/service-config/queue-storage · high confidence

The API application now uses the new Cellix framework to manage its lifecycle and dependency injection. This change introduces a phased initialization process (infrastructure, context, application services, handlers) that registers core services such as Mongoose, Apollo Server, Token Validation, and Blob Storage (with production/development differentiation for storage credentials). It also wires up GraphQL and REST HTTP handlers via Azure Functions and includes unit tests for the Cellix framework itself and the API bootstrap configuration.

apps/api/src · high confidence

This change adds the \@cellix/mongoose-seedwork\ package, providing concrete infrastructure adapters for MongoDB using Mongoose. It introduces \MongoRepositoryBase\ for CRUD operations with domain event dispatching, \MongoUnitOfWork\ for managing database transactions and integration events, and \MongoTypeConverter\ for mapping between Mongoose documents and domain objects. The package also includes \MongooseDomainAdapter\ and \MongoosePropArray\ to bridge Mongoose document structures with domain entities, along with base types like \Base\ and \SubdocumentBase\. Comprehensive Cucumber-style feature tests and unit tests are included to verify repository, unit of work, and type conversion behaviors.

packages/cellix/mongoose-seedwork/src · high confidence

The \apps/ui-community\ directory now contains the foundational structure for the new UI Community application, including Vite and TypeScript configurations, Tailwind CSS setup, and environment variable definitions for local and E2E testing. This change adds a mock OIDC configuration to support local authentication flows and introduces a deployment pipeline (\deploy-ui-community.yml\) alongside Infrastructure as Code (Bicep) templates to enable automated deployment to Azure. Additionally, a \start-dev.ts\ script is provided to bootstrap the local development server with the correct URL mappings.

apps/ui-community · high confidence

The \@cellix/domain-seedwork\ package now provides the core building blocks for implementing Domain-Driven Design within the Cellix monorepo. It introduces framework-agnostic base classes and interfaces for key DDD concepts, including \AggregateRoot\ (with support for domain and integration events, soft deletes, and a \passport\ for context), \DomainEntity\, \ValueObject\, and \ChildEntity\. The package also standardizes event handling through \DomainEvent\, \EventBus\, \EventPublisher\, and \HandleEvent\ contracts, as well as data access patterns via \Repository\, \UnitOfWork\, and \TypeConverter\ interfaces. Additionally, it includes specific error types like \PermissionError\ and \NotFoundError\, and a \Visa\ interface for permission checking, all accompanied by comprehensive Cucumber-style test coverage.

packages/cellix/domain-seedwork/src · high confidence

The \@cellix/graphql-codegen\ package now provides build-time plugins (\static-type-defs\ and \resolver-manifest\) that generate static TypeScript files from \.graphql\ SDLs and resolver directories. This replaces previous runtime glob-based file discovery, enabling the rolldown bundler to statically analyze and bundle the API without dynamic imports at startup. The package also exports \buildCellixSchema\, which constructs the executable GraphQL schema by merging these generated static artifacts with base Cellix types and scalars. Additionally, \@cellix/graphql-core\ now exposes \baseCellixTypeDefs\ as a generated static array and includes a \getRequestedFieldPaths\ utility for extracting field paths from GraphQL resolve info.

packages/cellix/graphql-core · high confidence

The staff portal now includes a ThemeContext provider that manages light, dark, and custom theme states. This context persists the user's theme preference to localStorage and restores it on load, ensuring consistent appearance across sessions. Additionally, users can toggle the visibility of the theme UI controls using the keyboard shortcut Meta+Shift+K.

apps/ui-staff/src/contexts · high confidence

The ui-core package now includes a \theme-storage.ts\ module that enables saving and loading user theme preferences (light, dark, or custom) to the browser's local storage. This allows theme selections to persist across page reloads and browser sessions, with the core library exposing this functionality alongside its component exports.

packages/cellix/ui-core/src · high confidence

This change adds the \NodeEventBus\ and \InProcEventBus\ implementations for the Cellix event bus seedwork, providing both asynchronous and in-process event dispatching capabilities. The \NodeEventBus\ integrates with OpenTelemetry to automatically create and manage distributed traces for event publishing and processing, ensuring that context propagation is maintained across handlers. It also implements robust error handling where handler exceptions are caught, recorded in spans, and do not propagate to disrupt the dispatch flow. The \InProcEventBus\ offers a simpler, synchronous-in-memory alternative for local development or testing. Both implementations are accompanied by comprehensive Cucumber-style feature tests and unit tests to verify handler registration, dispatch order, and error isolation.

packages/cellix/event-bus-seedwork-node/src · high confidence

The mock OAuth2 seedwork package has been refactored to allow a single frontend application (e.g., \ui-community\) to define and use multiple distinct OIDC configurations (e.g., \end-user\, \admin\). This is achieved by introducing \oidcConfigName\ filtering in the file-based user store, which now isolates users to their specific configuration, and by updating the portal discovery logic to generate unique registration names based on both the app directory and the config name. The manager now registers these as separate named routes, enabling detached login/signup flows and scoped user management for different identity contexts within the same application.

packages/cellix/server-oauth2-mock-seedwork/src · high confidence

This change introduces the \@cellix/config-rolldown\ package, which provides a standardized Rolldown configuration factory for Cellix Azure Functions applications and a CLI tool to prepare the deployment artifact. The package automatically resolves workspace dependencies, configures ESM output with sourcemaps, and handles the final step of copying \host.json\ and generating a \package.json\ for the \deploy/\ directory. It includes a CLI script (\cellix-prepare-azure-functions-deploy\) and comprehensive tests to ensure correct bundling and deployment preparation.

packages/cellix/config-rolldown · high confidence

A new \@cellix/local-dev\ package has been introduced to provide reusable, policy-free mechanics for local development across the monorepo. It centralizes worktree-aware port math (MongoDB and Azurite), URL helpers, dotenv and JSON file utilities, and generic dev runners for Vite, Docusaurus, Azure Functions, Node, and Azurite. This allows app-owned wrapper scripts to manage project-specific environment variables, hostnames, and local settings without hardcoding these details into shared infrastructure.

packages/cellix/serenity-framework · high confidence

A new Bicep module has been added to define an Azure App Service Plan, allowing users to specify the SKU (including Basic, Standard, Premium, and Isolated tiers) and operating system (Linux). The module implements a consistent resource naming convention based on application prefix, environment, and instance name, and includes a bicepconfig.json to enforce module versioning standards.

iac/app-service-plan · high confidence

This change introduces new Infrastructure as Code (Bicep) modules for deploying an Azure Function App and a Cosmos DB MongoDB account. The Function App module provisions a Node.js 20 runtime with system-assigned managed identity, configuring RBAC role assignments for Key Vault access, Storage Blob Data Contributor, and Storage Queue Data Contributor roles. It also sets up Application Insights integration and restricts access via IP security rules to allow only Azure Front Door. The Cosmos DB module defines the MongoDB account with analytical storage and backup policies, including a custom role for connection string access.

iac/function-app · high confidence

The .claude directory now includes symlinks to a new set of agent skills, making them available for use within Claude Code. This update introduces a dedicated 'serenity-tests' skill for Serenity BDD test authoring, alongside new skills for GraphQL operations and schema design, Ant Design and Vercel React best practices, MongoDB connection and schema optimization, Turborepo and Turbo graph optimization, and various development workflow tools like plan-feature, review-diff, and run-validation. These additions expand the available context and guidance for developers working with these specific technologies and workflows.

.claude · high confidence

The \@ocom/application-services\ package now exposes structured application services for the Community and Member contexts. Community services support creating communities (including logging to blob storage and queueing events), querying by ID or external user ID, and updating settings. Member services provide a comprehensive API for managing community members, including creating members with default roles, inviting single or bulk members with configurable expiry, updating roles, activating/deactivating, and removing members, along with queries by ID, community, or external user ID. These services are backed by persistence data sources and include architectural convention tests to enforce service patterns.

packages/ocom · high confidence

The \@cellix/archunit-tests\ package has been introduced to enforce architectural conventions across the reusable Cellix framework layer. This package runs automated checks to ensure the framework maintains its intended structure, including verifying that the domain layer does not depend on persistence or application services, that UI core remains isolated from application UI code, and that specific layer boundaries (such as GraphQL and REST) do not leak into infrastructure. It also validates code-level conventions, such as requiring application service mutations to use scoped transactions, enforcing factory patterns for actions, ensuring GraphQL resolvers are typed correctly, and mandating that Mongoose model files export specific interfaces and constants. These tests are designed to run as part of the repository-wide validation flow to prevent architectural drift in the core framework packages.

packages/cellix/archunit-tests · high confidence

The \@cellix/service-blob-storage\ package introduces a new framework for Azure Blob Storage that separates server-side operations from client-signing capabilities. \ServiceBlobStorage\ provides managed-identity-backed server-side operations (upload, list, delete) and no longer accepts connection strings, while the new \ServiceClientBlobStorage\ subclass adds SharedKey signing for direct client uploads and downloads via \createBlobWriteAuthorizationHeader\, \createBlobReadAuthorizationHeader\, and \generateReadSasToken\. This change isolates the signing logic and connection-string requirements to the client-signing service, allowing applications to choose the appropriate service based on whether they need backend-only access or direct client upload/download support.

packages/cellix/service-blob-storage · high confidence

Added several new scripts to the build-pipeline to enhance CI/CD capabilities. The \build-bicep.js\ script automates the compilation of Bicep infrastructure files to JSON, while \check-sonar-quality-gate.cjs\ allows local verification of SonarCloud quality gate status by polling the API. A new \merge-coverage.js\ script consolidates LCOV coverage reports from the monorepo into a single file, and \get-pr-number.cjs\ securely retrieves the Pull Request number using the GitHub API. These additions support more robust infrastructure management, code quality enforcement, and coverage reporting within the pipeline.

build-pipeline/scripts · high confidence

A new local development service has been added to spin up an in-memory MongoDB instance pre-seeded with realistic data for the 'Riverside' community, including users, members, properties, roles, and services. The service runs on port 50000 by default and is designed to support local development and E2E testing by providing a consistent, reproducible database state without requiring an external MongoDB deployment.

apps/server-mongodb-memory-mock · high confidence

The \@cellix/ui-core\ package now exports two new molecule components: \ComponentQueryLoader\ and \RequireAuth\. \ComponentQueryLoader\ simplifies handling Apollo Client query states by rendering custom content for success, Ant Design skeletons for loading and empty states, and error notifications via Ant Design's message API. \RequireAuth\ guards routes using \react-oidc-context\, displaying a loading spinner while authentication initializes, redirecting unauthenticated users to the login flow (with optional \forceLogin\ to preserve the current route in session storage), and navigating to the home page on auth errors. Both components include Storybook stories demonstrating their various states.

packages/cellix/ui-core/src/components/molecules · high confidence

A new \@cellix/server-mongodb-memory-mock-seedwork\ package has been added to provide reusable startup logic for spinning up a local, single-node MongoDB replica set in memory. This package exports programmatic functions to start the replica set (pinned to MongoDB binary version 7.0.14) and optionally seed the database using Mongoose, supporting configuration for port, database name, and replica set name. It is designed to be consumed by the \@apps/server-mongodb-memory-mock\ app package for development and testing environments, ensuring transaction-ready mocks with ephemeral data.

packages/cellix/server-mongodb-memory-mock-seedwork · high confidence

The \packages/cellix/config-vitest\ package introduces a centralized set of Vitest configurations to standardize testing across the monorepo. It provides distinct presets for Node.js environments (\nodeConfig\), Storybook integration with Playwright browser testing (\createStorybookVitestConfig\), and architecture unit tests (\archConfig\), all built upon a common base (\baseConfig\) that includes Istanbul code coverage and type-checking via tsgo. This allows consumers to easily enable consistent test setups, including specific coverage exclusions and browser instance management, without duplicating configuration logic.

packages/cellix/config-vitest · high confidence

The iac/storage-account module now provides a comprehensive Bicep implementation for Azure Storage Accounts, introducing dedicated sub-modules for Blob, Queue, and Table services. Users can now enable and configure specific storage services (Blob, Queue, Table) independently via boolean flags, allowing for granular control over infrastructure components. The Blob service module adds support for CORS rules (origins, methods, headers, caching), blob versioning, and container creation. The storage account itself supports lifecycle management policies for automatic blob deletion after a specified number of days, configurable SKUs (Standard/Premium with various redundancy options), and enforces TLS 1.2 minimum. The module also outputs the storage account name and ID for use by other infrastructure components.

iac/storage-account · high confidence

The infrastructure-as-code library now includes a new Bicep module and supporting JSON files to enforce consistent Azure resource naming. The \resource-naming-convention.bicep\ module accepts environment and application prefix parameters to generate standardized resource prefixes (e.g., \{app}-{env}-\), while \resource-types.json\ and \location-codes.json\ provide mappings for common resource abbreviations and region codes, ensuring compliance with Microsoft's cloud adoption best practices across deployments.

iac/global · high confidence

The Storybook setup for the cellix/ui-core package has been configured to support React with Vite. The configuration includes essential addons for documentation, accessibility testing, Vitest integration, and onboarding. Additionally, a global decorator has been added to wrap stories in a React Router MemoryRouter, ensuring that components relying on routing context (such as Link or useLocation) function correctly during development and testing.

packages/cellix/ui-core/.storybook · high confidence

The main entry point file for the API package has been deleted, removing the registration of HTTP triggers for both REST and GraphQL endpoints as well as the application start and terminate hooks that managed the service lifecycle.

packages/api/src · high confidence

The \packages/api-graphql/src\ directory has been cleared of its previous implementation files. The \index.ts\ file, which previously exported the \graphHandlerCreator\ function to initialize an Apollo Server instance and wire it to Azure Functions, has been deleted. Additionally, the \context.ts\ file containing the empty \Context\ class has been removed. This change eliminates the local GraphQL server setup and context definition from this package.

packages/api-graphql/src · high confidence

The \api-services-spec\ and \api-services\ packages have been removed from the repository. This deletion eliminates the \StartupObject\ interface and its concrete implementation, along with their associated TypeScript configuration and Prettier formatting rules, effectively stripping these components from the project structure.

packages/api-services-spec · high confidence

The \packages/api-rest/src/index.ts\ file, which previously served as the entry point for Azure Functions HTTP handlers, has been removed. This file contained the \restHandlerCreator\ function and associated type definitions for handling HTTP requests and responses within the API REST package.

packages/api-rest/src · high confidence

The API application has been moved from packages/api to apps/api, bringing with it a complete set of configuration and tooling files. A new Azure Pipelines deployment definition (deploy-api.yml) handles infrastructure setup, Azure Function App deployment, and application settings injection. Local development is supported via new entry points (start-dev.ts, start-azurite.ts, sync-local-settings.ts) and a dedicated e2e local settings file (local-settings.e2e.json) that configures mock OIDC, Cosmos DB, and Azure Storage endpoints. The build pipeline now uses a Rolldown bundler (rolldown.config.ts) to produce a single optimized ESM file for deployment, while TypeScript is configured with project references to internal Cellix and OCOM packages. The Azure Functions host configuration (host.json) has been updated to enable console logging and OpenTelemetry telemetry mode.

apps/api · high confidence

This change introduces two patch files to resolve compatibility issues with specific dependencies. The patch for @azure/functions (v4.11.0) adds the undici-types dependency and updates type imports to support modern web standards. The patch for storybook-addon-apollo-client (v10.0.0) provides an empty preset export, reflecting that the addon's functionality is now handled by manager and preview modules rather than a preset.

patches · high confidence

The mock OAuth2 server has been refactored to support multiple distinct OIDC configurations, allowing different frontend portals to be served with their own specific settings. The server now automatically discovers portal configurations from \mock-oidc.json\ files located in application directories and registers each as a named OIDC provider. This enables testing scenarios where multiple applications or tenants require separate identity configurations, with user stores and subject resolution handled per portal rather than globally.

apps/server-oauth2-mock/src · high confidence

The mock OAuth2 server has been refactored to expose multiple named OpenID Connect portals via a single HTTP server, where each portal is accessible at a distinct path (e.g., \/{name}/.well-known/openid-configuration\). Configuration is now driven by \mock-oidc.json\ files located in each UI app directory, which map environment variable names for client IDs and redirect URIs rather than containing hardcoded values. This change introduces support for multiple login configurations per portal and per-user overlay files for local development, while removing support for the previous \mock-oidc.local.json\ claim overrides. The server automatically discovers these portals by scanning for UI app directories, allowing developers to manage distinct OIDC identities for different parts of the application through a unified mock service.

apps/server-oauth2-mock · high confidence

The pre-commit hook in .husky has been updated to automatically format staged files using the \format:staged\ script before running the \verify\ command. This ensures that code formatting is applied consistently to changes before they are committed, followed by a verification step to catch potential issues early in the development workflow.

.husky · high confidence

API acceptance tests for staff role management and staff landing pages; Added architecture test for API dependency rules; Added integration tests for MongoUnitOfWork; Added tests for the server-oauth2-mock-seedwork package; Added tests for ui-core public components; Archunit test suite ported to OCom verification package; Established E2E test infrastructure for ocom-verification; New E2E test coverage for authentication, community creation, and staff role management.

This change introduces the foundational package.json definitions for the new CellixJS monorepo, establishing the build, test, and dependency configurations for the entire workspace. It defines the core application apps (\@apps/api\, \@apps/docs\, \@apps/ui-community\, \@apps/ui-staff\, and mock servers) and the shared library packages under \packages/cellix\ (including domain seedwork, GraphQL core/codegen, UI core, and storage services) as well as the OCom application packages and verification test suites. The configuration standardizes the use of \tsgo\ for TypeScript compilation, \vitest\ for testing, \biome\ for linting/formatting, and \catalog:\ specifiers for centralized dependency management across all 72 manifests.

(dependencies) · high confidence

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

• CAI 59 → 54 (-4.5)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 88 → 85 (-2.6)
• Architecture 82 → 92 (+10.5)
• Maturity 84 → 92 (+7.9)
• Readiness 51 → 45 (-6.0)
• Security 67 → 65 (-1.5)
• Accessibility 53 → 47 (-6.6)

• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dependency hygiene not measured — no supported dependency manifest was read
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Hotspot: apps/ui-staff/src/App.tsx (apps/ui-staff/src/App.tsx)
• Hotspot: apps/ui-staff/src/contexts/theme-context.tsx (apps/ui-staff/src/contexts/theme-context.tsx)
• Hotspot: apps/ui-staff/src/hooks/use-staff-permissions.ts (apps/ui-staff/src/hooks/use-staff-permissions.ts)
• Hotspot: packages/cellix/server-oauth2-mock-seedwork/src/helpers.ts (packages/cellix/server-oauth2-mock-seedwork/src/helpers.ts)
• Hotspot: packages/cellix/server-oauth2-mock-seedwork/src/login-handlers.ts (packages/cellix/server-oauth2-mock-seedwork/src/login-handlers.ts)
• Hotspot: packages/cellix/server-oauth2-mock-seedwork/src/router.ts (packages/cellix/server-oauth2-mock-seedwork/src/router.ts)
• LLM evaluation failed
• …and 15 more

• App.StaffRoutes (cyclomatic 18) (apps/ui-staff/src/App.tsx)
• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Documentation: no installation or build instructions (packages/cellix/server-mongodb-memory-mock-seedwork/README.md)
• Documentation: written for insiders (packages/ocom/local-dev-config/readme.md)
• FunctionTooLong: community-list.CommunityList (packages/ocom/ui-community-route-accounts/src/components/community-list.tsx)
• FunctionTooLong: file-user-store.createFileUserStore (packages/cellix/server-oauth2-mock-seedwork/src/file-user-store.ts)
• FunctionTooLong: login-handlers.createLoginHandlers (packages/cellix/server-oauth2-mock-seedwork/src/login-handlers.ts)
• FunctionTooLong: member-profile.MemberProfile (packages/ocom/ui-community-shared/src/components/member-profile.tsx)
• FunctionTooLong: members-invite-modal.MembersInviteModal (packages/ocom/ui-community-route-admin/src/components/members-invite-modal.tsx)
• FunctionTooLong: members-list.MemberList (packages/ocom/ui-community-route-admin/src/components/members-list.tsx)
• FunctionTooLong: members-list.container.MemberListContainer (packages/ocom/ui-community-route-admin/src/components/members-list.container.tsx)
• FunctionTooLong: router.buildOidcRouter (packages/cellix/server-oauth2-mock-seedwork/src/router.ts)
• FunctionTooLong: section-layout.SectionLayout (packages/ocom/ui-staff-shared/src/section-layout.tsx)
• FunctionTooLong: staff-role-edit.container.StaffRoleEditContainer (packages/ocom/ui-staff-route-user-management/src/components/staff-role-edit.container.tsx)
• FunctionTooLong: theme-context.ThemeProvider (apps/ui-staff/src/contexts/theme-context.tsx)
• Further orphaned files (smaller)
• HackComment (packages/cellix/event-bus-seedwork-node/src/node-event-bus.ts)
• HackComment (packages/cellix/event-bus-seedwork-node/src/node-event-bus.ts)
• HackComment (packages/cellix/event-bus-seedwork-node/src/node-event-bus.ts)
• HackComment (packages/cellix/event-bus-seedwork-node/src/node-event-bus.ts)
• …and 107 more

• 3 commits — 1 feature/other, 2 fixes

• (root) — 3 commits

• fix: Fix failing Azure Functions Core Tools installation step on build pipeline (#323)
• fix: fix: resolve E2E test dependency graph failures (#307)
• change: feat: use tsgo --lsp for VS Code and Grok TypeScript intelligence (#327)

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

CellixJs/cellixjs 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.