puristajs/purista

PURISTA is a TypeScript framework for building event-driven, microservice-based applications with a focus on reliability and observability. It provides a core service builder for defining commands, subscriptions, streams, and queues, backed by pluggable transport bridges for NATS, AMQP, MQTT, and HTTP. The system integrates with major cloud providers for state, configuration, and secret management, and supports complex orchestration via Temporal workflows and multi-agent AI harnesses.

112 changes.

The project underwent a significant architectural overhaul, removing legacy HTTP server and helper modules to establish a cleaner, abstraction-driven core with standardized stores and bridges. This period focused on expanding the framework's connectivity by introducing dedicated event bridges for AMQP, MQTT, and NATS, alongside SDKs for Dapr and Kubernetes. Concurrently, the codebase was modernized with updated dependencies, comprehensive OpenTelemetry integration, and extensive example applications to demonstrate the new capabilities.

52 changes.

This period focused on establishing Hono as the primary HTTP server implementation, complete with OpenAPI generation and comprehensive example applications. It also introduced a robust, type-safe queue and streaming system with native support for Redis and NATS JetStream backends. Additionally, the framework expanded its capabilities with AI agent integration and multi-cloud secret management stores.

Introduces the AWSSecretStore class, allowing applications to retrieve, set, and delete secrets using AWS Secrets Manager. The implementation includes in-memory caching for read operations to reduce AWS API calls, and handles secret creation automatically by retrying with a CreateSecretCommand if an UpdateSecretCommand fails due to a missing resource. It exposes configuration for the AWS SDK client (e.g., region) and exports the store along with its version information.

packages/aws-secret-store/src · high confidence

Introduces the AWSConfigStore class, allowing applications to read, write, and delete configuration values via AWS Systems Manager Parameter Store. The store caches reads in memory by default to reduce AWS API calls, supports tenant-aware and environment-aware parameter paths, and ensures that AWS SDK errors during get, set, or remove operations are wrapped in typed internal server errors for consistent error handling.

packages/aws-config-store/src · high confidence

The ping v1 service now includes a DELETE command, exposing a new HTTP endpoint for deletion operations. This change introduces the command builder, schema definitions (using Zod for input parameters, payloads, and output), and TypeScript types specifically for this delete operation within the examples/hono-example service.

examples/hono-example/src/service/ping/v1/command/delete · high confidence

The Dapr SDK now exposes a \/dapr/config\ endpoint that returns an empty list of entities. This satisfies Dapr's app configuration discovery protocol, allowing the application to register correctly with the Dapr sidecar even though Dapr actors are not utilized in this context.

packages/dapr-sdk/src/DaprEventBridge/routes · high confidence

The examples/dapr-example/deployment directory now includes complete deployment artifacts for the email and user services. This adds Dapr application manifests (dapr.yaml) defining the service endpoints and commands, along with per-service Dapr configuration and component YAML files for local Redis-based state, pub/sub, configuration, and secret stores. The service entry points (index.ts) are also added, wiring the @purista/dapr-sdk clients (DaprEventBridge, DaprSecretStore, DaprStateStore, DaprConfigStore) and OpenTelemetry Zipkin tracing into the email and user services.

examples/dapr-example/deployment · high confidence

Introduces a new \NatsStateStore\ implementation that persists application state to a NATS JetStream key-value bucket. The store lazily establishes a NATS connection and caches the KV bucket handle, automatically reconnecting if the connection becomes stale or closed. It encodes values using the NATS \JSONCodec\, requiring stored data to be JSON-compatible, and provides standard state operations (\getState\, \setState\, \removeState\) along with a \destroy\ method to cleanly drain and close the connection during shutdown.

packages/nats-state-store/src · high confidence

The examples/client-builder/src/service directory now includes a complete PingPong v1 service example. This adds a service definition using the ServiceBuilder, two command builders (ping and pong) that expose HTTP endpoints and define input/output schemas via Zod, and corresponding test files verifying command execution. The example also introduces a ServiceEvent enum for event naming and demonstrates how to wire command definitions into a service instance.

examples/client-builder/src/service · high confidence

The service now defines a ServiceEvent constant object containing a 'Pinged' event, which is emitted by the Service v1 ping command. This provides a structured way to reference this specific event within the application.

examples/kubernetes/src/service · high confidence

The examples/temporal/src/temporal/workflows directory now includes a new onboarding workflow that manages user registration, email verification, and account creation. This workflow integrates OpenTelemetry for distributed tracing by configuring global propagators and applying OpenTelemetry interceptors to capture workflow execution metrics.

examples/temporal/src/temporal/workflows · high confidence

The \packages/dapr-sdk/src/types\ directory now exports a comprehensive set of TypeScript definitions for Pub/Sub interactions. This includes types for configuring bulk subscriptions (e.g., \BulkSubscribeConfig\, \BulkSubscribeOptions\), handling bulk publish requests and responses (e.g., \PubSubBulkPublishEntry\, \PubSubBulkPublishResponse\), and defining subscription routes and rules (e.g., \DaprPubSubRouteType\, \DaprPubSubRuleType\). These types provide strict interfaces for message callbacks, metadata, and status enums, enabling better type safety when implementing Dapr Pub/Sub features.

packages/dapr-sdk/src/types · high confidence

The examples/client-builder/src directory now includes a complete example application that demonstrates how to initialize a Purista service with an EventBridge and HTTP server, as well as how to generate client code from service definitions. The example provides two distinct client-generation workflows: one that builds clients directly from service builder source files (generateClientFromCode.ts) and another that loads pre-exported JSON definitions (generateClientFromFile.ts). It also includes utilities for exporting service definitions to JSON files and a main entry point that orchestrates the server lifecycle with graceful shutdown.

examples/client-builder/src · high confidence

Introduces a new example project demonstrating how to export service definitions to JSON and generate TypeScript client code from those definitions or directly from the backend codebase. The example includes configuration for the Purista framework (v1.12.0), a Biome v2 linter/formatter setup, and an HTTP server configuration using Hono, providing a reference implementation for client generation workflows.

examples/client-builder · high confidence

The example application now includes dedicated configuration modules for its core integrations. A new \temporalConfig.ts\ file defines the connection address, namespace, and task queue settings for the Temporal worker. A \natsBridgeConfig.ts\ file provides a typed, partial configuration object for the NATS bridge. Additionally, a \jaegerExporterOptions.ts\ file configures the OpenTelemetry exporter to send traces to a local Jaeger instance at \http://localhost:4318/v1/traces\.

examples/temporal/src/config · high confidence

A new quickstart example has been added to demonstrate how to set up a PURISTA application using the Hono HTTP server. The example shows how to initialize event and queue bridges, register a ping service, and start the server on port 3000.

examples/quickstart/src · high confidence

The NATS bridge example now includes TypeScript type definitions to support its structure. A new \User\ type is defined with fields for email, name, password, and userId, and a \StateStoreKey\ constant is introduced to manage state store keys (currently only 'users'). These types are re-exported via the types index file to be used by other parts of the example.

examples/nats-bridge/src/types · high confidence

The email service example now includes a versioned v1 implementation that registers a subscription to the NewUserRegistered event. When a new user is registered, this subscription retrieves the user's details and logs a confirmation that a welcome email has been sent to their address, utilizing configured email provider URLs and authentication tokens.

examples/mqtt-bridge/src/service/email · high confidence

The Hono example project now includes a new 'delay' service located in the service/delay directory. This addition introduces a service info definition that registers a 'Delay' service, described as an example of a service that starts after the webserver and registers commands, along with an accompanying README file to document the example.

examples/hono-example/src/service/delay · high confidence

The examples/nats-bridge/src/service/email directory now includes a v1 email service implementation. This adds a service definition for sending emails, a configuration schema using Zod, and a subscription that triggers on the NewUserRegistered event to send a welcome email. The subscription retrieves user details via the User service, uses configured email provider credentials, and logs the action. Tests are included to verify the subscription's behavior.

examples/fullexample/src/service/email, examples/nats-bridge/src/service/email · high confidence

The examples/hono-example/src/service/ping/v1/command/foo directory now includes a complete implementation of a 'foo' command, featuring Zod v4 schemas for input parameters, payloads, and output, along with a command builder that exposes the command as a public GET HTTP endpoint. A corresponding test file verifies the command's execution using mocked dependencies, ensuring the example demonstrates proper integration with the Purista core framework.

examples/hono-example/src/service/ping/v1/command/foo · high confidence

The Delay v1 service example now includes a new 'fooBar' command, exposing it as an HTTP GET endpoint at 'foo-bar/:p/:q?'. This command accepts a string parameter 'p' and an optional 'q', uses unknown schemas for its payload, and returns a simple object containing the parameter. The implementation includes the command builder, Zod-based validation schemas, TypeScript types, and a corresponding unit test to verify execution.

examples/hono-example/src/service/delay/v1/command · high confidence

A new DefaultSecretStore implementation has been added to the core package, providing a process-local, in-memory secret store intended exclusively for development and testing environments. The store allows users to initialize it with pre-defined secret values and supports get, set, and remove operations. By default, write and removal operations are disabled to prevent accidental modification during tests, but these can be enabled via configuration flags. The implementation includes a warning log to alert users that this store is not secure for production use.

packages/core/src/DefaultConfigStore, packages/core/src/DefaultSecretStore · high confidence

The ping service now includes a subscription that logs incoming ping events. This new component defines a payload schema for the 'pong' string, binds the subscription to the 'Pinged' service event, and implements a handler that records the received pong value via the logger. A corresponding test verifies the subscription function executes without errors.

examples/hono-example/src/service/ping/v1/subscription · high confidence

The examples/hono-example now includes a new 'paramTest' command within the ping v1 service, demonstrating how to handle HTTP GET endpoints with both path parameters (required and optional) and query parameters (required and optional). This addition includes the command builder configuration, Zod-based input/output schemas, TypeScript type definitions, and a corresponding unit test to verify correct parameter handling.

examples/hono-example/src/service/ping/v1/command/paramTest · high confidence

The Hono example service now includes a new 'ping' command that exposes a POST endpoint at 'ping'. This command accepts a JSON payload containing a 'ping' string and an optional 'query' query parameter, validates them using Zod schemas, and returns a 'pong' response. The implementation includes a command builder that configures the HTTP endpoint, disables security for the example, and tracks request metrics.

examples/hono-example/src/service/ping/v1/command/ping · high confidence

The Hono example now includes a dedicated module defining the metadata for the ping service, specifying its name as 'Ping' and description as 'Example ping service' while conforming to the core ServiceInfoType interface.

examples/hono-example/src/service/ping · high confidence

The Hono example now serves a static HTML welcome page at the root path. This page confirms that the PURISTA project is running and provides quick links to the OpenAPI UI, as well as local instances of Grafana, Uptrace, Jaeger, and Zipkin for tracing and observability.

examples/hono-example/public · high confidence

The NATS bridge example now includes a dedicated HTTP server configuration file that sets up a Hono-based service on port 8080. This configuration enables dynamic routes, sets the log level to debug, mounts the API at /api, and activates OpenAPI documentation generation with version 1.0.0.

examples/nats-bridge/src/config · high confidence

The core helper module has been reorganized into a dedicated \packages/core/src/core/helper\ directory, with files renamed to use the \.impl.ts\ extension and imports updated to explicit \.js\ paths for ESM compatibility. This change introduces several new capabilities: proxies for chained invocation (\createInvokeFunctionProxy\), streaming (\createOpenStreamFunctionProxy\), and queue operations (\createQueueEnqueueProxy\, \createQueueScheduleProxy\); new message creation helpers for success responses (\createSuccessResponse\), error responses (\createErrorResponse\), and info messages (\createInfoMessage\); and a new utility to sanitize logs by stripping sensitive payload data (\getCleanedMessage\). Additionally, unique ID generation now relies on OpenTelemetry's \RandomIdGenerator\ via \getUniqueId\, and a new assertion helper (\assertNonArrowFunction\) ensures hooks use standard function syntax to preserve \this\ context.

packages/core/src/core/helper · high confidence

The in-memory DefaultEventBridge implementation has been updated to support more granular message routing. Subscriptions can now filter messages based on \tenantId\ and \principalId\ in addition to existing sender and receiver service identifiers. The bridge also enforces \instanceId\ matching for both senders and receivers, ensuring that messages are only delivered to subscriptions that explicitly match the specific service instance. This allows for multi-tenant isolation and precise instance-level routing within the same process.

packages/core/src/DefaultEventBridge · high confidence

The service example now includes a ServiceEvent constant object that defines specific event strings for user registration (NewUserRegistered) and welcome email delivery (WelcomeEmailSent), providing a centralized reference for these service-level events.

examples/fullexample/src/service · high confidence

The EventBridge base class now includes built-in support for streaming, allowing callers to receive incremental frames via an async iterator with automatic timeout and late-frame handling. Command invocations are tracked in a registry that enforces configurable timeouts, rejecting pending calls with a GatewayTimeout error if no response arrives, and classifying late responses. Additionally, an in-flight execution tracker monitors active commands, subscriptions, streams, and generic tasks, enabling graceful shutdown by waiting for in-flight work to complete within a specified grace period.

packages/core/src/core/EventBridge · high confidence

The base-http-bridge package now explicitly exports the \HttpEventBridge\ class and a \puristaVersion\ constant (set to 3.2.4) from its main entry point. This allows consumers to programmatically check the library version and access the bridge implementation directly, supported by new unit tests verifying these exports are defined.

packages/base-http-bridge/src · high confidence

The MQTT bridge example now includes a dedicated HTTP server configuration file that sets up a Hono-based service on port 8080 with dynamic routes enabled, debug logging, and an OpenAPI definition for the /api endpoint.

examples/mqtt-bridge/src/config · high confidence

The NATS bridge now constructs NATS subject paths for publishing messages and subscribing to events by combining a configurable topic prefix with snake-cased message attributes (such as message type, tenant ID, sender/receiver details, and event name). Undefined fields are handled as wildcards for subscriptions or replaced with a configured empty string for published messages, ensuring stable and predictable broker routing.

packages/natsbridge/src/topic · high confidence

Introduces the \@purista/hono-http-server\ package, providing a web server implementation built on Hono. The package exports \honoV1Service\ for registering and managing services, along with configuration options such as \enableDynamicRoutes\. It is designed to integrate with the Purista event bridge, allowing users to start the server and expose registered services via a standard HTTP interface.

packages/hono-http-server/src · high confidence

The \@purista/dapr-sdk\ package is now available, providing adapters to integrate PURISTA services with the Dapr sidecar. This release exposes a \DaprClient\, \DaprEventBridge\, \DaprSecretStore\, \DaprStateStore\, and \DaprConfigStore\ via the main entry point, allowing users to wire their services to Dapr's eventing, secret, state, and configuration capabilities. The package is currently at version 3.2.4.

packages/dapr-sdk/src · high confidence

Adds the \AmqpBridge\ class to enable using RabbitMQ as the underlying transport for the Purista event bridge. The implementation manages AMQP connections, channels, and queues for both command routing and event subscriptions, including support for durable queues, consumer pause/resume, and dead-letter routing. It handles payload encoding (JSON) and encryption (configurable, defaulting to no-op) and integrates OpenTelemetry for distributed tracing by injecting and extracting trace context via AMQP headers.

packages/amqpbridge/src · high confidence

The core package now includes an AgentQueueBuilder that allows services to define and attach AI agents directly to their queue, worker, command, and stream infrastructure. This builder handles the full lifecycle of an attached agent, including model binding, skill resolution, durable workspace policies, and scoped runtime execution. It provides a fluent API for declaring schemas, metrics, and execution policies, and integrates with the Purista harness to manage agent runs, streaming, and telemetry. The implementation includes runtime context creation, identity derivation, and scoped runtime management to ensure agents are properly isolated and initialized within the service instance.

packages/core/src/AgentQueueBuilder · high confidence

Added a new \AzureSecretStore\ class that integrates with Azure Key Vault for managing secrets. The implementation uses \DefaultAzureCredential\ for authentication and includes an in-memory cache for secret reads to reduce API calls. It handles missing secrets (404) by returning \undefined\ and maps other Azure client errors to internal server errors, providing a robust interface for retrieving and managing secrets in Azure environments.

packages/azure-secret-store/src · high confidence

A new ClientBuilder component has been added to the core package to generate TypeScript client libraries from service definitions. It reads configuration from \purista.client.json\ (or a custom path) and outputs ESM modules containing HTTP and EventBridge client functions, along with their corresponding TypeScript types. The builder supports merging multiple service definitions, handles both HTTP-exposed and event-bridge services, and allows customization of client names (defaulting to \HttpClient\ and \EventBridgeClient\) and output paths. It also includes utilities for writing code blocks and managing the output directory structure.

packages/core/src/ClientBuilder · high confidence

The \packages/dapr-sdk/src/DaprConfigStore\ and \packages/dapr-sdk/src/DaprStateStore\ directories now contain the implementation and tests for Dapr integration. The \DaprConfigStore\ adapter reads configuration values from the local Dapr sidecar via the \v1.0-alpha1\ configuration API, explicitly returning \undefined\ for missing keys, while write and remove operations are disabled. The \DaprStateStore\ adapter provides full read, write, and remove capabilities for JSON state values using the \v1.0\ state API. Both adapters support optional API tokens and configurable store names, with tests verifying correct HTTP path construction and error handling for disabled operations.

packages/dapr-sdk/src/DaprConfigStore · high confidence

Added a new DaprSecretStore implementation that retrieves secrets from a Dapr sidecar via its local HTTP API. The adapter supports fetching individual or multiple secrets, explicitly returning undefined for any keys that are not found in the store, and includes optional namespace metadata for Kubernetes deployments. Write operations (set/remove) are intentionally unsupported and will throw a NotImplemented error, ensuring users only rely on the read-only capability provided by this component.

packages/dapr-sdk/src/DaprSecretStore · high confidence

The Dapr SDK now exposes a new \DaprEventBridgeConfig\ type that extends the base HTTP event bridge configuration with optional Dapr sidecar client settings. This allows users to configure invocation, Pub/Sub, and health check parameters specifically for the Dapr Event Bridge component.

packages/dapr-sdk/src/DaprEventBridge/types · high confidence

Added a new DaprEventBridge component that connects PURISTA services to the local Dapr sidecar. This bridge hosts HTTP endpoints for Dapr command invocation and Pub/Sub subscription delivery, publishes events via the Dapr Pub/Sub API, and invokes commands in other services through Dapr service invocation. It automatically registers discovery routes at \/dapr/subscribe\ and \/dapr/config\, converts service and event names to kebab-case, and uses Hono for HTTP handling. The implementation supports only event-name subscriptions for Pub/Sub routing and exposes REST endpoints under \/api\ while keeping internal routes under \/purista\.

packages/dapr-sdk/src/DaprClient, packages/dapr-sdk/src/DaprEventBridge · high confidence

The core package now includes a new DefaultLogger implementation that wraps the Pino logging library. This change adds a factory function, initLogger, which creates a logger instance pre-configured with the application name 'PURISTA' and automatically injects the current version into log entries via a mixin. The default log level is determined by the runtime environment: it sets to 'debug' in development mode and 'info' in production, accessible via the new getDefaultLogLevel helper. The entry also includes the DefaultLogger class implementation and its corresponding unit tests.

packages/core/src/DefaultLogger · high confidence

Added a new \GoogleSecretStore\ implementation that integrates with Google Cloud Secret Manager for retrieving and managing secrets. The store supports in-memory caching of secret values (configurable via \enableCache\ and \cacheTtl\), handles missing secrets by returning \undefined\ (gRPC code 5), and automatically creates the secret resource in Google Cloud if it does not exist when setting a new value. It also includes unit tests verifying correct behavior for missing secrets, internal server errors, and secret creation flows.

packages/gcloud-secret-store/src · high confidence

This change adds the core TypeScript type definitions for the HTTP event bridge, establishing the contract for interacting with sidecar or platform HTTP APIs. It introduces \HttpEventBridgeClient\ to define methods for generating internal and public API paths, invoking commands, publishing events, and checking sidecar availability. It also defines \HttpEventBridgeConfig\ to specify server settings (host, port, prefixes), enable REST API exposure, support CloudEvent payloads, and toggle HTTP compression. Additionally, \IHttpEventBridge\ and \RouterFunction\ types are added to support Hono-based route handlers and bridge instance binding.

packages/base-http-bridge/src/HttpEventBridge/types · high confidence

This change introduces the HttpEventBridge component, which enables running PURISTA services in environments like Dapr or Knative by exposing internal HTTP endpoints for commands and subscriptions. The bridge uses the Hono framework to handle incoming requests, supporting both standard JSON and CloudEvents (structured and binary) for command and subscription payloads. It provides a REST projection handler that translates HTTP query and route parameters into command envelopes, enforces required query parameters, and returns typed command responses or error envelopes. The bridge also includes lifecycle management (start/destroy), health check endpoints, and OpenTelemetry tracing for all incoming requests.

packages/base-http-bridge/src/HttpEventBridge · high confidence

The Hono HTTP server now provides a versioned v1 service implementation that exposes PURISTA commands as HTTP endpoints. This service supports dynamic route registration, allowing endpoints to be automatically added when services announce their command definitions via InfoMessages. It includes configurable request body size limits (defaulting to 1 MiB), health check endpoints, and OpenAPI documentation generation. The implementation uses Zod for configuration validation and supports both synchronous and asynchronous command execution patterns.

packages/hono-http-server/src/service/hono · high confidence

The \packages/core/src/HttpClient/types\ directory now contains the foundational type definitions for the HTTP client, including \HttpClientConfig\ (with optional \baseUrl\, auth credentials, and OpenTelemetry settings), \AuthCredentials\, \HttpClientRequestOptions\, and the \RestClient\ interface. This interface exposes standard HTTP methods (GET, POST, PUT, PATCH, DELETE) that return JSON-parsed results or raw text, establishing the contract for the new HTTP client capability.

packages/core/src/HttpClient/types · high confidence

A new HttpClient implementation is available in the core package, providing a standardized way to make HTTP requests with built-in OpenTelemetry tracing and metrics. The client automatically records request duration and status codes as low-cardinality metrics, creates spans for observability, and normalizes errors into HandledError or UnhandledError types. It supports standard HTTP methods (GET, POST, PUT, PATCH, DELETE), JSON serialization, basic and bearer authentication, and configurable timeouts.

packages/core/src/HttpClient · high confidence

The InfisicalClient implementation now validates the bearer token upon construction, throwing a typed InvalidToken error if the token is missing or lacks the required secret segment. When writing secrets via setSecret, the client attempts a PATCH request first and falls back to creating the secret with a POST request only if the API returns a NotFound error; other errors are propagated without fallback. The client uses AES-256-GCM for encrypting and decrypting secret values and names, and writes secrets with the 'shared' type.

packages/infisical-secret-store/src/InfisicalClient · high confidence

Users can now store and retrieve secrets using the Infisical service by instantiating the new InfisicalSecretStore. The store caches secret values in memory by default to reduce API calls, with the ability to disable caching or configure the TTL via the enableCache and cacheTtl options. It requires a bearer token for authentication and exposes standard get, set, and remove secret operations backed by the Infisical HTTP client.

packages/infisical-secret-store/src · high confidence

The \@purista/nats-queue-bridge\ package now provides a \NatsQueueBridge\ implementation backed by NATS JetStream, enabling strict queue capabilities including delayed delivery, FIFO ordering, and dead-letter inspection. The bridge enforces strict startup validation and idempotent enqueue operations using a Key-Value store, while managing job lifecycles through configurable lease timeouts and retry attempts. Users can configure connection options, subject prefixes, and storage types (file or memory) to integrate with their existing NATS infrastructure.

packages/nats-queue-bridge/src · high confidence

Adds a new \NatsConfigStore\ implementation that persists configuration values in a NATS JetStream key-value bucket. The store lazily establishes a NATS connection, verifies JetStream is enabled, and caches the KV bucket handle; it automatically reconnects if the connection closes or drains. Values are encoded/decoded using the NATS \JSONCodec\, requiring JSON-compatible data. The component exposes standard config operations (\getConfig\, \setConfig\, \removeConfig\) and a \destroy\ method to cleanly drain and close the connection. Tests verify reconnection behavior on stale KV handles and proper cleanup of cached handles on destroy.

packages/nats-config-store/src · high confidence

The \packages/natsbridge/src\ package now provides a \NatsBridge\ implementation of the \EventBridge\ interface, enabling services to use NATS as their message broker. The bridge supports both core NATS for low-latency communication and JetStream for durable subscriptions, manual acknowledgements, and dead-lettering. It handles OpenTelemetry context propagation via NATS headers, manages subscription lifecycle (register/unregister), and includes configuration defaults for retry policies and topic naming. Tests verify subscription persistence, JetStream consumer usage, and proper error handling when JetStream is unavailable.

packages/natsbridge/src · high confidence

The NATS bridge now includes dedicated handlers for processing incoming commands and subscriptions. Command handlers decode messages, invoke registered callbacks, and reply via NATS request/reply, while also optionally republishing responses as events based on the \commandResponsePublishTwice\ configuration. Subscription handlers process incoming events and republish returned custom messages to the appropriate topics. Both handlers integrate OpenTelemetry tracing, serialize/deserialize OTP contexts via NATS headers, and include instance identification in message metadata.

packages/natsbridge/src/handler · high confidence

The ServiceBaseClass now integrates OpenTelemetry for distributed tracing, automatically initializing a NodeTracerProvider with service name and version attributes, and exposing methods like getTracer and startActiveSpan to create and manage spans. It also introduces a ServiceInfoValidator that enforces strict formatting rules for service names (alphanumeric, hyphens, underscores) and versions (numeric only) via a Proxy, ensuring consistent service identification across the platform.

packages/core/src/core/Service/ServiceBaseClass · high confidence

PURISTA now includes a Queue Bridge transport adapter contract and a comprehensive metrics recording system. The Queue Bridge defines the interface for durable or in-memory queue operations—including enqueueing, leasing, acknowledgement, retry, and dead-letter handling—along with a capability matrix that allows services to validate delivery guarantees (such as FIFO ordering, idempotency, and dead-letter support) at startup. The metrics subsystem provides a framework for recording operational data via OpenTelemetry, featuring a catalog of framework metrics (for commands, subscriptions, streams, queues, and agents), a typed metric context for custom application metrics, and strict attribute policies to ensure low cardinality and prevent sensitive data leakage.

packages/core/src/core/types · high confidence

A new RedisConfigStore implementation is available in the redis-config-store package, allowing applications to persist configuration values in a Redis instance. The store serializes values as JSON strings, uses tenant-aware key prefixes to avoid collisions, and manages the Redis connection lifecycle (lazy connection on first use, explicit destroy for cleanup). It extends the standard ConfigStore interface, providing getConfig, setConfig, and removeConfig operations backed directly by Redis without a local in-memory cache.

packages/redis-config-store/src · high confidence

Added the \RedisQueueBridge\ implementation in \packages/redis-queue-bridge/src\, providing a new capability to use Redis as the underlying store for the PURISTA queue system. This bridge supports delayed delivery, FIFO ordering, idempotent enqueueing, dead-letter handling, and lease inspection, allowing users to configure a Redis connection and key prefix for queue operations.

packages/redis-queue-bridge/src · high confidence

A new Redis state store implementation is now available, allowing applications to persist state values as JSON strings in a Redis database. The store uses the \@redis/client\ library, supports tenant-aware key prefixes to avoid collisions, and handles serialization/deserialization automatically. It provides methods to get, set, and remove state, with lazy connection management and a destroy method for clean shutdown. The implementation includes configuration options for the Redis client, such as URL and authentication settings, and is designed to be used in shared environments with TLS and authenticated endpoints.

packages/redis-state-store/src · high confidence

The core package now includes a \StreamDefinitionBuilder\ that allows developers to define streaming endpoints with full type safety and composability. This builder supports declaring input/output schemas for payloads, chunks, and final results, as well as configuring HTTP exposure (including SSE and aggregate modes), OpenAPI metadata, and security settings. It also enables streams to invoke other services, consume other streams, enqueue queues, and emit custom events, all while supporting guard hooks for pre- and post-processing. This provides a unified, type-safe API for building complex streaming interactions within the PURISTA framework.

packages/core/src/StreamDefinitionBuilder · high confidence

The Kubernetes example now includes a new 'TheService' (v1) demonstrating a basic service structure. This example features a 'ping' command that returns a boolean status, exposed as an HTTP GET endpoint. The implementation uses Zod for schema validation and follows the framework's builder pattern for service and command definition, providing a reference for how to structure services and commands within the Kubernetes deployment context.

examples/kubernetes/src/service/theService · high confidence

This change adds a new \VaultSecretStore\ implementation that enables PURISTA applications to retrieve and manage secrets from a HashiCorp Vault KV v2 engine. The store caches secret values in memory by default (configurable via \enableCache\ and \cacheTtl\) and normalizes the configured mount path by stripping leading and trailing slashes, falling back to the default \secret\ mount if the path is empty. Users can now configure the Vault endpoint and authentication token to securely access tenant-aware secret paths, with automatic handling of 404 errors for missing secrets.

packages/vault-secret-store/src · high confidence

PURISTA core now includes a \DefaultQueueBridge\ for local development and testing, providing an in-memory implementation of the queue contract with support for delayed delivery, FIFO ordering, and lease management, alongside a \ScheduleDefinitionBuilder\ that allows services to define provider-neutral schedules for emitting events, enqueuing jobs, or invoking commands.

packages/core/src · high confidence

This change adds the core TypeScript type definitions for the DefaultEventBridge, establishing the shape of its configuration and internal state management. It defines \DefaultEventBridgeConfig\ to allow users to optionally enable warning logs for messages that fail to reach any receiver. It introduces \PendingInvocations\ to manage asynchronous request-response patterns within the bridge. Most significantly, it defines \SubscriptionStorageEntry\, which formalizes how event subscriptions are stored and matched; this type includes specific matching logic for sender and receiver attributes (service name, version, target, instance ID), event names, principal IDs, and now includes support for \TenantId\ matching, reflecting the addition of tenant-awareness to the event routing logic.

packages/core/src/DefaultEventBridge/types · high confidence

The v1 delay service implementation is now available in the Hono example, providing a structured way to define and configure the service. This change introduces a \ServiceBuilder\ pattern that combines service metadata, a Zod v4-based configuration schema, and command definitions (currently including a \fooBar\ command) into a single service instance. The module exports the service builder, the final service instance, and the configuration types, allowing users to instantiate and register the delay service with explicit schema validation.

examples/hono-example/src/service/delay/v1 · high confidence

This change adds the foundational TypeScript types for the new NATS message broker integration within the \natsbridge\ package. It defines \NatsBridgeConfig\ to manage connection settings, including JetStream durability modes, message expiry, and failure handling defaults. It also introduces \INatsBridge\ to represent the internal bridge state and \IncomingMessageFunction\ to type the message handlers, ensuring that topic and handler helpers are bound with the correct context for NATS and JetStream message processing.

packages/natsbridge/src/types · high confidence

This change adds the \QueueDefinitionBuilder\ and \QueueWorkerBuilder\ classes to the core package, providing a fluent API for defining durable queues and their associated workers. The \QueueDefinitionBuilder\ allows users to configure queue schemas, lifecycle policies (including a new 'longRunning' execution profile with automatic heartbeat and lease extension logic), result emission policies, and scheduling targets. The \QueueWorkerBuilder\ complements this by defining worker execution behavior, such as concurrency limits, handler implementations, and guard hooks, while also declaring the worker's capabilities to invoke other services, consume streams, enqueue other queues, emit events, and invoke agents. These builders generate typed definitions that integrate with the system's service proxy and bridge infrastructure.

packages/core/src/QueueDefinitionBuilder, packages/core/src/QueueWorkerBuilder · high confidence

This change adds the foundational TypeScript types and runtime guards for the new streaming feature within the core package. It defines the streaming message protocol, including types for open requests, control frames (such as cancellation), and data frames (chunks and final results). It also introduces the \StreamDefinition\ structure, allowing developers to configure stream handlers with before/after guard hooks, validation schemas, and metadata for HTTP exposure. Additionally, it provides utility functions to safely discriminate between different stream message types at runtime.

packages/core/src/core/types/stream · high confidence

This change adds the foundational TypeScript types and configuration for the new queue handling capability in the core package. It defines the contract for queue operations, including \QueueDefinition\ for declaring queues with schemas, lifecycle policies, and workers, and \QueueEnqueueOptions\ for specifying delivery details like idempotency keys and delays. It also introduces \QueueJobContext\ and \QueueJobControls\ to provide workers with runtime capabilities such as explicit retry, fail, lease extension, and cancellation handling. Additionally, it provides \defaultQueueLifecycleConfig\ with opinionated defaults (e.g., 15-minute visibility timeout, 24-hour retry window) and utility types like \QueueJobStore\ for tracking job status.

packages/core/src/core/types/queue · high confidence

This change adds a new set of TypeScript type definitions in the core helper types module to formally describe the structure of service definitions and application instances. Users can now rely on explicit types for full application definitions (including versioning and REST API paths), detailed service definitions (covering commands, subscriptions, streams, queues, queue workers, schedules, and event-to-queue bindings), and utility types for constructor inference and instance resolution. These types provide a standardized, type-safe contract for defining and interacting with services and their components within the application.

packages/core/src/helper/types · high confidence

The StateStore module now exposes a formal \StateStore\ interface along with specific type definitions for its core operations (\StateGetterFunction\, \StateSetterFunction\, and \StateDeleteFunction\). This change provides a clear contract for state management, defining how to get, set, and remove state values, as well as how to destroy the store instance, improving type safety and clarity for developers implementing or using the store.

packages/core/src/core/StateStore/types · high confidence

This change adds the foundational TypeScript type definitions for the AmqpBridge package, establishing the contract for configuration and data serialization. It defines \AmqpBridgeConfig\ to specify connection details (URL, socket options), exchange settings (name, assertions, dead-letter routing), and consumer behavior (prefetch counts). Additionally, it introduces \Encoder\ and \Encrypter\ type maps alongside their respective function interfaces (\EncoderFunctions\, \EncryptFunctions\), allowing users to configure custom content-type codecs and payload encryption handlers for AMQP messages.

packages/amqpbridge/src/types · high confidence

The Hono HTTP server now exposes a set of TypeScript types to help users define secure, typed endpoints. \VariablesBase\ defines the standard context variables available to generated handlers, including \principalId\, \tenantId\, \traceId\, and \instanceId\. \EndpointProtectMiddleware\ provides a type signature for middleware that authenticates requests and sets these variables, while \HealthFunction\ defines the callback structure for health checks. \BindingsBase\ serves as the foundation for Hono bindings, defaulting to an empty object.

packages/hono-http-server/src/types · high confidence

This change introduces a new Dapr example application located in \examples/dapr-example\. The example demonstrates a multi-service architecture using the Purista framework, featuring a User service (with commands for signing up, retrieving users, and pinging) and an Email service (with a subscription that sends welcome emails upon user registration). It includes configuration for Node 20, a Purista schema definition, and a Postman collection for testing the HTTP endpoints.

examples/dapr-example · high confidence

The EventBridge types module now exposes a comprehensive interface and configuration schema for PURISTA services, including the main EventBridge contract, a detailed EventBridgeCapabilities matrix, and specific capability types for commands, streams, and consumer failures. This change introduces structured support for streaming (incremental delivery, cancellation, late frame handling), command transport strategies (request-reply, reply-queue, topic-correlation, HTTP, in-memory), and robust failure handling (bounded/delayed retries, dead-lettering, pause/resume). Configuration is standardized via EventBridgeConfig, which now supports optional instance IDs, log levels, and OpenTelemetry integration, enabling strict capability validation at startup to ensure adapters meet reliability requirements.

packages/core/src/core/EventBridge/types · high confidence

The core package now exposes a dedicated \HttpServer\ module containing type definitions for HTTP service metadata, including support for standard HTTP methods, query parameters, and streaming configurations. This location introduces the \HttpExposedServiceMeta\ type structure and a corresponding \isHttpExposedServiceMeta\ runtime validation function to ensure correct metadata shapes, alongside re-exported constants for compression settings.

packages/core/src/core/HttpServer · high confidence

The examples/hono-example/src directory now contains a complete Hono-based web server entry point. This example demonstrates how to initialize the Purista core event bridge, register services (such as ping and delayed services), and expose them via a Hono app. It includes built-in support for OpenAPI documentation using Scalar's API Reference, static file serving from the ./public directory, compression, and basic authentication middleware. The server also sets up OpenTelemetry metrics and a custom health check, providing a reference implementation for integrating Purista with a Hono HTTP server.

examples/hono-example/src · high confidence

The Hono example now includes a new ping service (v1) that demonstrates command handling (ping, foo, paramTest, delete) and log subscriptions. This service is built using the core ServiceBuilder, includes a Zod-based configuration schema, and exposes OpenTelemetry metrics for request counting with route attributes.

examples/hono-example/src/service/ping/v1 · high confidence

Added a new entry-point file (index.ts) for the Kubernetes example that demonstrates how to initialize a service using the Purista core and k8s-sdk packages. The example configures an AMQP event bridge, sets up default stores for configuration, secrets, and state, and exposes an HTTP server via Hono with health-check and API-mount capabilities.

examples/kubernetes/src · high confidence

Introduces the MqttBridge class, an EventBridge implementation that enables PURISTA services to communicate via MQTT 5 brokers. This new component handles command registration, subscription management, and message emission using MQTT QoS semantics, while integrating OpenTelemetry tracing through MQTT user properties. The package includes default configuration for local broker connections and comprehensive test coverage for the subscription lifecycle and error handling.

packages/mqttbridge/src · high confidence

Added a new example project in the \examples/mqtt-bridge\ directory that demonstrates how to use the Purista framework with an MQTT event bridge. The example includes configuration for a Mosquitto broker, TypeScript type definitions for user data, and a README with instructions to start the MQTT broker and run the application via npm scripts.

examples/mqtt-bridge · high confidence

The MQTT bridge now includes dedicated handlers for processing incoming commands and subscriptions, and for handling command responses. The command handler (\getCommandHandler\) decodes incoming JSON commands, invokes the registered callback, and publishes a correlated response back to the MQTT topic, ensuring the response sender includes the specific \instanceId\ of the bridge instance. It also supports optional \tenantId\ and \principalId\ propagation in message user properties. The subscription handler (\getSubscriptionHandler\) processes subscription messages and republishes returned events, while the command response handler (\handleCommandResponse\) resolves or rejects pending invocations based on correlation data, ignoring late responses. All handlers integrate OpenTelemetry tracing for visibility into command reception, processing, and response sending.

packages/mqttbridge/src/handler · high confidence

This change introduces a new \TopicRouter\ class and a suite of topic-generation utilities within the MQTT bridge. The router enables dispatching incoming MQTT messages to handlers using either MQTT 5 subscription identifiers for fast lookup or wildcard topic matching. Additionally, new functions are provided to construct specific MQTT topic filters: \getTopicName\ builds publish topics from PURISTA messages, \getSubscriptionTopic\ creates subscription filters from PURISTA subscription definitions (using \+\ wildcards for unspecified fields), \getCommandSubscriptionTopic\ and \getCommandResponseSubscriptionTopic\ handle command-related topic patterns, and \getSharedTopicName\ wraps topics for shared subscriptions. The \isMatchingTopic\ utility supports standard MQTT \+\ and \\#\ wildcards for pattern matching.

packages/mqttbridge/src/topic · high confidence

Added a new example in the examples/nats-bridge directory that demonstrates using PURISTA with the NATS event bridge and state store. The example includes configuration for a local NATS broker (via npm scripts), a Mosquitto configuration file, and project setup files (tsconfig, purista.json) targeting Node 20. Users can now run this example to interact with the OpenAPI UI at localhost:8080/api.

examples/nats-bridge · high confidence

The \packages/hono-http-server/src/helper\ directory now includes a suite of utilities that enhance API documentation and error reporting. \addPathToOpenApi\ generates OpenAPI 3.1 operation definitions for commands and streams, including support for SSE and aggregate streaming modes, trace headers, and security schemes. Error responses now follow RFC 9457 Problem Details, with helpers in \problemDetails.ts\ to normalize errors into JSON or Markdown representations and generate corresponding OpenAPI schemas. Path and query parameter definitions are now explicitly extracted from route metadata via \getParameterDefinition\ and \getQueryDefinition\. Additionally, \streamTransport.ts\ provides logic for handling SSE protocol events and aggregating stream results, while \logging.ts\ integrates OpenTelemetry span context into HTTP logs.

packages/hono-http-server/src/helper · high confidence

The quickstart example now includes a complete Ping service (v1) demonstrating core framework features. It exposes a synchronous HTTP command that returns a pong, an asynchronous HTTP command that enqueues jobs to a 'pingJob' queue for background processing, and a subscription that logs events when the synchronous command succeeds. The example also includes the corresponding queue worker and comprehensive unit tests for all components.

examples/quickstart/src/service/ping · high confidence

The core package now includes a dedicated SubscriptionDefinitionBuilder that enforces strict input and output schema validation for subscriptions. This builder allows developers to define payload and parameter schemas that are validated before execution, throwing a HandledError (400) on failure, and validates the subscription function's return value against an output schema, throwing an UnhandledError (500) if it fails. It also supports configurable before-guard hooks that run prior to the main subscription logic, and provides a typed API for declaring invocations, stream invokes, emits, and queue operations, ensuring type safety and robust error handling for subscription definitions.

packages/core/src/SubscriptionDefinitionBuilder · high confidence

The examples/temporal/src/service directory now includes complete v1 service definitions for four domains: User, Email, Account, and Card. Each domain provides a service builder, configuration schema (using Zod), command definitions with input/output schemas, and unit tests. The User service exposes createUser and register commands, with register starting a Temporal workflow via @temporalio/client. The Email service exposes confirmEmail (signaling an existing Temporal workflow) and sendVerificationEmail. The Account service exposes createAccount, and the Card service is scaffolded with no commands yet. A shared ServiceEvent enum centralizes event names (e.g., UserCreated, EmailAddressConfirmed, BankAccountCreated, UserRegistrationStarted).

examples/temporal/src/service · high confidence

Added a new example application in examples/temporal/src that demonstrates integrating Purista services with Temporal, NATS, and Hono. The example initializes a NatsBridge for event handling, starts multiple domain services (user, email, account, card) using the new async getInstance pattern, and exposes a Hono-based HTTP server with Swagger UI and static file serving. It also includes OpenTelemetry tracing via OTLP exporter for observability.

examples/temporal/src · high confidence

Added a new example demonstrating PURISTA integration with Temporal, including a Docker Compose setup for local development that provisions NATS, PostgreSQL, Temporal, Jaeger Tracing, and the Temporal UI. The example provides a starter project structure with configuration files (purista.json, tsconfig.json, vite.config.ts) and a landing page with links to the OpenAPI, Jaeger, NATS, and Temporal UIs, along with documentation on starting the worker and application services.

examples/temporal · high confidence

The Temporal example now includes a dedicated worker entry point (worker.ts) and a helper utility (getInvoke.ts) that enable Temporal workflows to invoke Purista services via the EventBridge. The worker sets up OpenTelemetry tracing with a Jaeger exporter and registers both standard activities and Purista-based activities (createAccount, createUser, sendEmailVerification) that route through the NatsBridge. This provides a concrete implementation of how Temporal workers can interact with the Purista core event system.

examples/temporal/src/temporal · high confidence

The core package now exposes a suite of helper functions in the \packages/core/src/helper\ directory to support service definition management and runtime stability. Users can now merge multiple service definitions into a single full definition structure via \mergeServiceDefinition\, and export the aggregated result using \exportServiceDefinitions\. To support OpenAPI generation, new utilities \convertEmitValidationsToSchema\ and \convertInvokeValidationsToSchema\ transform internal validation schemas into OpenAPI SchemaObjects. Runtime reliability is improved with \gracefulShutdown\, which handles sequential teardown of services and event bridges on process signals, and \getTimeoutPromise\, which enforces invocation timeouts. Additionally, \throwIfNotValidMessage\ provides strict validation for incoming Event Bridge messages, and \safeBind\ offers a type-safe alternative to standard function binding.

packages/core/src/helper · high confidence

The \packages/core/src/mocks\ directory now exports a suite of unit-test helpers that provide mock implementations for the core runtime context. Developers can use \getCommandTransformContextMock\ and \getSubscriptionTransformContextMock\ to simulate command and subscription execution environments, including stubbed logging, metrics, secrets, configs, states, and queue operations (enqueue/schedule). A \getEventBridgeMock\ is available to simulate the event bridge with configurable capabilities, and \getQueueBridgeMock\ provides a mock queue bridge with default capabilities and stubbed lifecycle and message-handling methods. These helpers simplify writing isolated tests for core logic by removing the need for real infrastructure or complex setup.

packages/core/src/mocks · high confidence

This change introduces a suite of new scripts in the \scripts/\ directory to support the framework's development workflow and quality assurance. Key additions include \api-docs-audit.mjs\ and \knowledge-audit.mjs\ to enforce documentation standards (summaries, examples, and spec boundaries) across packages and markdown files, and \skills-audit.mjs\ to validate the structure and content of user-facing skills. Operational tooling includes \releasePrepare.sh\ and \commitVersion.sh\ to automate version bumping and build steps, \packageImportSmoke.mjs\ to verify public package integrity, and \runWithDockerHost.mjs\ to simplify Docker command execution by auto-detecting the host environment.

scripts · high confidence

Added a new example in the \examples/enterprise-billing-cycle\ directory that illustrates an enterprise interoperability pattern using default in-memory infrastructure. The example defines a monthly billing schedule that triggers an event, which is bound to a long-running queue job to close the billing cycle. It includes a queue worker that processes the job and emits a completion event, which is then recorded by a subscription. The example highlights the use of \idempotencyMode: 'advisory'\ for local development and notes that \idempotencyMode: 'strict'\ can be used with Redis or NATS bridges to prevent duplicate job creation.

examples/enterprise-billing-cycle · high confidence

The examples/fullexample/src directory now contains a complete, runnable example application. It uses the Hono HTTP server framework and integrates OpenTelemetry for distributed tracing, supporting exporters for Jaeger, Teletrace, Uptrace, and Zipkin via OTLP. The example demonstrates wiring together core services (AMQP event bridge, user and email services) with state, config, and secret stores, and provides multiple entry points (index.ts, indexConsole.ts, etc.) to select different tracing backends.

examples/fullexample/src · high confidence

The examples/fullexample directory now includes a complete, ready-to-run setup for local development and testing, featuring pre-configured Docker Compose files and infrastructure for multiple observability backends. Users can now spin up Grafana (with Tempo, Loki, and Prometheus), Jaeger, Uptrace, Teletrace, or SigNoz environments directly alongside the example application. The example also provides a public landing page with direct links to the respective UIs (e.g., Grafana at localhost:3000, Jaeger at localhost:16686) and includes configuration files for RabbitMQ, ClickHouse, and alerting, simplifying the process of tracing, logging, and metrics visualization for the PURISTA framework.

examples/fullexample · high confidence

The \packages/k8s-sdk/src\ directory now provides a new helper package to run PURISTA services in Kubernetes. It introduces \getHttpServer\, which creates a Hono-based web server with a \/healthz\ endpoint and automatic HTTP compression. The \addServiceEndpoints\ function registers routes for commands marked with \HttpExposedServiceMeta\, handling query parameter validation, request body parsing, and OpenTelemetry tracing. This allows services to expose their commands as REST endpoints without manual route configuration.

packages/k8s-sdk/src · high confidence

Added new test helper functions in the core package to generate mocked command and custom messages for unit testing. The new \getCommandMessageMock\, \getCommandSuccessMessageMock\, \getCommandErrorMessageMock\, and \getCustomMessageMessageMock\ functions provide standardized, frozen message structures with generated IDs, timestamps, and sender/receiver details, simplifying the creation of test fixtures for command and event handling logic.

packages/core/src/mocks/messages · high confidence

The \examples/agent-example\ directory now contains a complete demo of a PURISTA multi-agent workflow for incident response. It exposes a \POST /api/v1/incident-response\ HTTP endpoint (via Hono/OpenAPI) that orchestrates a coordinator agent delegating to specialist agents (\analyzeSignals\ and \assessRollbackRisk\) and a triage agent. The example demonstrates agent skills, sandbox policies for risk assessment, deterministic command tools for evidence retrieval, and OpenAI integration via \@purista/harness-openai\, alongside the necessary service builders, schemas, and tests.

examples/agent-example · high confidence

The \packages/core/src/zodOpenApi\ module now provides \validationToSchema\, an asynchronous utility that converts Standard Schema-compatible validators (such as Zod or Yup) into OpenAPI 3.1 schema objects, and \extendApi\, which allows attaching OpenAPI metadata directly to Zod schemas. This enables users to generate API documentation from validation schemas and augment them with specific OpenAPI descriptions.

packages/core/src/zodOpenApi · high confidence

Added four new utility functions to the core string helper module: convertToCamelCase, convertToKebabCase, convertToPascalCase, and convertToSnakeCase. These functions allow users to easily convert strings between common naming conventions (camelCase, kebab-case, PascalCase, and snake\_case), handling mixed inputs with spaces, underscores, and hyphens. Each function is accompanied by comprehensive tests covering various input formats.

packages/core/src/helper/string · high confidence

The subscription module now exposes a comprehensive set of TypeScript types that define the subscription lifecycle and message handling. This includes the core \Subscription\ and \SubscriptionDefinition\ types, which structure how subscriptions are declared and configured. A new hook system is introduced via \SubscriptionBeforeGuardHook\, \SubscriptionAfterGuardHook\, \SubscriptionTransformInputHook\, and \SubscriptionTransformOutputHook\, allowing users to intercept and transform messages before and after execution. Additionally, \SubscriptionConsumerControlError\ and \SubscriptionHandlerResult\ provide explicit control over message outcomes, supporting statuses such as retry, dead-letter, drop, and stop-consumer.

packages/core/src/core/types/subscription · high confidence

The MQTT bridge package now exposes specific TypeScript types to define its configuration and internal structures. Users can now rely on \MqttBridgeConfig\ for typed setup options, which extends standard MQTT client options with bridge-specific settings like topic prefixes, QoS levels for commands and subscriptions, and session/message expiry intervals. Additionally, \IMqttBridge\ defines the internal receiver shape including the active MQTT client and pending invocation registry, while \IncomingMessageFunction\ provides a typed signature for message handlers that receive both the decoded event and the raw MQTT publish packet.

packages/mqttbridge/src/types · high confidence

The MQTT bridge example now includes a v1 user service that exposes three new HTTP endpoints: POST /user/signup to register new users (validating for duplicates), GET /user to list all registered users, and GET /user/:userId to retrieve a specific user by ID. The service uses Zod schemas for input/output validation and persists user data in the state store, providing a complete user management capability within the example application.

examples/mqtt-bridge/src/service/user · high confidence

The full example now includes a v1 user service that exposes three HTTP commands: sign-up (POST /user/signup), get all users (GET /user), and get user by ID (GET /user/:userId). Input and output schemas are defined with Zod and extended with API metadata, and command types are derived from these schemas. The sign-up command validates for duplicate emails, stores new users in state, and emits a NewUserRegistered event while recording a signup counter metric. Tests verify successful registration, duplicate-email rejection, listing users, and retrieving a user by ID (including a 404 when not found).

examples/fullexample/src/service/user, examples/nats-bridge/src/service/user · high confidence

The website now includes a new handbook section and a redesigned landing page. The handbook is supported by new \HandbookCard\ and \HandbookIcon\ components that display guide entries with custom SVG icons and featured styling. The landing page has been rebuilt with new components including \Hero\, \Capabilities\ (listing framework features like AI Harness and HTTP Server), \EnterprisePillars\ (visualizing provider-agnosticism, observability, and approval workflows), \CodePreview\ (for syntax-highlighted code snippets), \CTA\, and \Footer\. Additionally, new \Harness\-specific components (\HarnessFlow\, \HarnessHero\, \HarnessRedirect\, \HarnessStory\, \SecurityBoundary\) have been added to support the AI Harness documentation and marketing content.

web/src · high confidence

The repository has been initialized with standard governance and configuration files, including an Apache 2.0 LICENSE, a Code of Conduct, a Security policy, and a CONTRIBUTING guide. It also introduces a new .env.example file defining environment variables for integration tests (AWS, NATS, Infisical, Azure, GCloud) and a .dcignore file to exclude docs, tests, scripts, and website directories from Docker context.

(repo-wide) · high confidence

The \SecretStoreBaseClass\ in \packages/core/src/core/SecretStore\ has been updated to include an optional in-memory cache for secret values. When the \enableCache\ configuration option is set to true, the \getSecret\ method will check the local cache before fetching from the underlying store, respecting an optional \cacheTtl\ (time-to-live) for expiration. Additionally, \setSecret\ and \removeSecret\ operations now automatically update or clear the cache to ensure consistency. This change allows applications to reduce external store calls for frequently accessed secrets, improving performance while maintaining the existing security and configuration toggles for get, set, and remove operations.

packages/core/src/core/SecretStore · high confidence

The SecretStore module now exposes a formal interface (SecretStore) defining methods for getting, setting, and removing secrets, along with a destroy method for cleanup. To support performance, a new SecretStoreCacheMap type has been added to track cached secret values with timestamps, and specific function types (SecretGetterFunction, SecretSetterFunction, SecretDeleteFunction) are now exported for type safety.

packages/core/src/core/SecretStore/types · high confidence

The quickstart example now includes a ServiceEvent definition that exposes a 'Pinged' event, emitted by the ping v1 command's HTTP endpoint.

examples/quickstart/src/service · high confidence

The configuration module for the HTTP server has been removed, deleting the files that previously provided default settings (such as port 9090, logging levels, and OpenAPI metadata) and the service information object. Consequently, the main entry point no longer exports the HTTP server or its related middleware, effectively stripping these components from the public API.

src/http-server/config · high confidence

The internal error (500), not-found (404), and OpenAPI handlers, along with the HTTP server creation and context generation helpers, have been removed from the codebase. This eliminates the specific logic for generating standard error responses, serving OpenAPI documentation, and initializing the HTTP/2 secure server context within this module.

src/http-server/handler · high confidence

The \HttpServerService\ implementation and all associated public exports (config, handlers, middleware, types) have been removed from the \src/http-server\ module. This deletion eliminates the HTTP server functionality, including route handling, middleware execution, and OpenAPI integration, from this package.

src/http-server · high confidence

The entire \src/http-server/types\ module has been removed, deleting all TypeScript type definitions and exports related to the HTTP server implementation. This includes the removal of core types such as \Context\, \Handler\, \Middleware\, and \HttpServerConfig\, as well as supporting types like \StatusCode\, \SuccessStatusCode\, \QueryParameter\, and \HttpExposedServiceMeta\. Consequently, the public API surface previously exposed via \src/http-server/types/index.ts\ is no longer available.

src/http-server/types · high confidence

The automatic subscription mechanism that exposed service commands as REST API endpoints has been removed. Specifically, the \ServiceCommandsToRestApi\ module (including its configuration, implementation, and index exports) and its registration in the main subscriptions index have been deleted. Users will no longer have service commands automatically registered as HTTP routes based on \InfoServiceFunctionAdded\ messages.

src/http-server/subscriptions · high confidence

The \compressionMiddleware\ and \responseToJsonMiddleware\ modules have been removed from the \src/http-server/onAfterMiddleware\ directory. This deletion eliminates the automatic handling of HTTP response compression (based on request headers) and the automatic conversion of non-JSON payloads to JSON strings with appropriate content-type headers, meaning these behaviors are no longer applied by default in this middleware layer.

src/http-server/onAfterMiddleware · high confidence

The entire \src/core\ module has been removed, eliminating the library's built-in event bridge, service base class, and associated types. This deletes the \DefaultEventBridge\ implementation, the \Service\ class used for command handling and subscriptions, and all supporting utilities (such as error creation, ID generation, and logging). Additionally, the \src/middleware-static\ module for serving static files with compression has been removed. Users relying on this framework for service-to-service communication or static file serving must migrate to alternative implementations.

src/core · high confidence

The \getRoutes\ command, which previously exposed an endpoint to retrieve HTTP route definitions, has been removed from the HTTP server. This change deletes the command's configuration, implementation, schema definitions, and its registration in the main commands index, effectively eliminating the ability to query the server's route map via this specific command interface.

src/http-server/commands · high confidence

The \src/helper\ module has been completely removed, deleting all associated implementation files and type definitions. This includes the \FunctionDefinitionBuilder\ and \SubscriptionDefinitionBuilder\ classes used for constructing command and subscription definitions, the \getFunctionWithValidation\ utility for input/output validation, and the compression helpers (\getCompressionMethod\ and \getCompressionStream\). The public exports in \src/helper/index.ts\ and the type definitions in \src/helper/types\ are also gone, meaning any code depending on these helpers must be updated to use alternative implementations or remove the functionality.

src/helper · high confidence

The \extractPayloadMiddleware\, \helmetMiddleware\, and \requestBodyToJson\ middleware implementations have been removed from the \src/http-server/onBeforeMiddleware\ directory. This deletion eliminates the previous logic for raw payload extraction, security header injection via \helmet\, and automatic JSON parsing of request bodies, indicating a shift in how the server handles incoming HTTP requests.

src/http-server/onBeforeMiddleware · high confidence

The command message payload is now nested under a \payload\ object (containing \parameter\ and \payload\ fields) rather than being flat, and the command definition system now supports a comprehensive lifecycle of hooks: \transformInput\ and \transformOutput\ for data conversion, \beforeGuard\ for pre-execution checks (like auth), and \afterGuard\ for post-execution logic. This change also introduces dedicated types for command success and error responses, along with type guards to identify them, and moves the command type definitions into the \packages/core\ directory.

packages/core/src/core/types/commandType · high confidence

The CommandDefinitionBuilder now uses a unified Standard Schema abstraction for input and output validation, replacing previous type-handling approaches. This change introduces a new \getCommandFunctionWithValidation\ helper that wraps command execution with explicit payload and parameter validation before guard hooks run, and output validation after execution, ensuring stricter type safety and consistent error reporting. The builder also exposes new capabilities for declaring queue enqueuing (\canEnqueue\), stream invokes, and emit schemas, while maintaining support for transform hooks and guard hooks. Under the hood, schema validation and JSON Schema conversion are handled via the new \standardSchema\ module, which supports Zod, Yup, and native Standard Schema vendors, improving interoperability and documentation generation.

packages/core/src/CommandDefinitionBuilder · high confidence

The ConfigStore and StateStore base classes now support enabling or disabling individual operations (get, set, remove) through configuration flags (enableGet, enableSet, enableRemove). When an operation is disabled, the store throws an UnhandledError with a StatusCode of Unauthorized instead of attempting the operation. This allows applications to restrict specific store capabilities at runtime. The ConfigStore also includes an optional local cache mechanism controlled by an enableCache flag.

packages/core/src/core/ConfigStore · high confidence

The core package has been restructured to expose a consolidated set of abstractions and utilities. Users can now import directly from the core index to access the ConfigStore, StateStore, SecretStore, EventBridge, QueueBridge, HttpServer, Service, and Logger components, alongside helper utilities and type definitions. This change centralizes the public API for these core infrastructure elements, simplifying imports for consumers of the library.

packages/core/src/core · high confidence

The DefaultStateStore implementation has been updated to accept an initial configuration object, allowing users to pre-populate state values at startup. Additionally, the store now respects enable/disable flags (enableGet, enableSet, enableRemove) in its configuration, throwing specific errors when operations are disabled, which improves safety for test environments. A warning is also logged on initialization to remind users that this in-memory store is not secure for production use.

packages/core/src/DefaultStateStore · high confidence

The service layer now exposes a ServiceEvent object containing specific string constants for events emitted during the user lifecycle, specifically NewUserRegistered for new sign-ups and WelcomeEmailSent for the subsequent welcome email. This change replaces previous enum-based definitions with a const object structure, providing explicit, typed event names for the NATS bridge example to consume.

examples/nats-bridge/src/service · high confidence

HandledError and UnhandledError now accept and store an optional traceId, which is included in error responses (getErrorResponse), preserved when converting between error types (fromError, intoHandledError), and exposed in JSON serialization (toJSON). This ensures trace context is maintained across error handling and conversion paths.

packages/core/src/core/Error · high confidence

The core type definitions for service information messages have been updated to include two new message variants: \InfoInvokeTimeout\ and \InfoSubscriptionError\, allowing the system to report invocation timeouts and subscription errors. Additionally, the \ServiceInfoType\ now enforces that \serviceName\ and \serviceVersion\ are non-empty strings, preventing empty identifiers in service metadata.

packages/core/src/core/types/infoType · high confidence

The type definitions for the ConfigStore interface and its associated functions (get, set, delete) have been moved from a single file into individual, dedicated TypeScript modules. This change introduces specific types for configuration operations (ConfigGetterFunction, ConfigSetterFunction, ConfigDeleteFunction) and a cache map structure (ConfigStoreCacheMap), while re-exporting them via an updated index file to maintain the public API surface.

packages/core/src/core/ConfigStore/types · high confidence

The onboarding workflow activities now include a dedicated validation step that enforces strict input schemas using Zod. Specifically, the \validate\ function ensures that incoming data contains a valid string \name\ and a lowercase, well-formed \email\ address, throwing an internal server error if the data does not conform to these requirements.

examples/temporal/src/temporal/activities · high confidence

The service layer now defines a \ServiceEvent\ object containing a \Pinged\ constant, replacing the previous enum-based approach. This change provides a structured way to reference the 'pinged' event emitted by the ping v1 command, ensuring consistent string values for this specific HTTP endpoint interaction within the Hono-based example.

examples/hono-example/src/service · medium confidence

The MQTT bridge example has been refactored to use the Hono web framework (via @hono/node-server) instead of its previous implementation. The application entry point now uses ES modules (import/export) and explicitly awaits asynchronous initialization calls for the event bridge, state store, and services (user, email) to ensure proper startup sequencing. The server now serves static files from the ./public directory and manages graceful shutdown for all components.

examples/mqtt-bridge/src · high confidence

The internal helper responsible for converting OpenAPI schema objects to TypeScript types has been refactored to use standardschema instead of the previous typeschema library. This change updates the core transformation logic in the schemaObjectToTsType module, ensuring that generated TypeScript definitions are produced using the new standardschema conventions while maintaining existing configuration options such as immutable types, array length support, and discriminator handling.

packages/core/src/helper/schemaObjectToTsType · high confidence

The NATS bridge example has been refactored to use the Hono web framework (via @hono/node-server) instead of the previous server implementation. The application entry point now explicitly initializes the NatsBridge and NatsStateStore, and starts the HTTP server and services (user, email) using async/await patterns, ensuring proper startup and graceful shutdown sequences.

examples/nats-bridge/src · high confidence

The MQTT bridge service now exposes a ServiceEvent object containing specific string constants for 'newUserRegistered' and 'send a welcome mail to new registered users'. This allows consumers of the service to reliably reference these event types when handling user registration and welcome email flows, replacing any previous ad-hoc string usage or enum definitions.

examples/mqtt-bridge/src/service · high confidence

The PURISTA CLI has been rewritten to use a new internal API structure for scaffolding. This change introduces dedicated functions for generating services, commands, subscriptions, streams, queues, queue workers, and AI agents, which automatically create the necessary TypeScript files, schemas, and service composition wiring. It also adds a new adapter layer for interactive prompts (supporting terminal, scripted, and non-interactive modes) and terminal output rendering, replacing the previous CommonJS scaffolding with a modern ESM-based approach.

packages/cli/src · high confidence

The Service class implementation now includes built-in validation for service metadata (enforcing alphanumeric service names and numeric-only versions via ServiceInfoValidator) and enforces reliability constraints at startup by rejecting configurations that require capabilities the event bridge does not support, such as manual acknowledgement for commands or stream registration on bridges without stream support. Additionally, command and subscription input transformation hooks now perform schema validation with OpenTelemetry tracing, throwing HandledError for validation failures and UnhandledError for transform function errors.

packages/core/src/core/Service · high confidence

The ServiceEvent definitions in the Hono HTTP server service layer have been converted from TypeScript enums to plain object constants. This change updates the internal representation of reserved service events, ensuring compatibility with the new object-based structure while maintaining the same set of available event identifiers for the service.

packages/hono-http-server/src/service · medium confidence

The ServiceBuilder in packages/core/src/ServiceBuilder has been significantly refactored to support a more robust service definition lifecycle. The most notable breaking change is that getInstance() is now asynchronous, requiring users to await the service instance creation. The builder now supports defining custom resources via defineResource() and injecting them at runtime, as well as defining metrics via defineMetric() that cascade into command, subscription, stream, and queue contexts for typed telemetry. Additionally, services can now be marked as deprecated using markAsDeprecated(), and the builder enforces a strict definition resolution phase via resolveDefinitions() before allowing access to command, subscription, schedule, and event-to-queue bindings. The implementation also introduces support for agent runtimes, queue handling, and streaming, with comprehensive type safety for all definition lists and runtime configurations.

packages/core/src/ServiceBuilder · high confidence

The website has been rebuilt using the Astro static site generator, replacing the previous Vite-based setup. This change introduces a new dark-first, flat design system defined in DESIGN.md, featuring specific color tokens, typography scales, and layout constraints for a more technical editorial look. The Astro configuration (astro.config.mjs) integrates React and MDX, applies Tailwind CSS via Vite, and sets up Shiki for syntax highlighting. Additionally, a redirect is configured to map /ai-harness to /harness, and CI workflows have been updated to build the Astro site. Developer guidance is provided via AGENTS.md and CLAUDE.md to ensure consistency with the new design contract.

web · high confidence

The website deployment files in \web/public\ have been restored to ensure the site builds and deploys correctly to GitHub Pages. This includes adding the \.nojekyll\ file to prevent Jekyll processing, setting the \CNAME\ to \purista.dev\, and adding a collection of AWS 3D SVG icons (such as \ami\, \application\, \cloudfront\, and \elastic-load-balancing\) to the public assets directory.

web/public · high confidence

Added integration test for DaprEventBridge; Added integration tests for AMQP bridge connectivity and command handling; Added integration tests for Google Cloud Secret Manager; Added integration tests for NATS queue bridge idempotency; Added integration tests for Redis queue bridge contract and behavior; Added integration tests for RedisConfigStore; Added integration tests for VaultSecretStore; Added integration tests for the Hono HTTP server; Added integration tests for the K8s SDK HTTP server; Added integration tests for the MQTT bridge; Added reliability contract test suites for core primitives; Added test coverage for core client builder, command invocation, and service resources; Added test fixtures for TheService v1 command definitions; Added test fixtures for the Hono HTTP service builder; Added test fixtures for theService v1 commands; Added tests for event subscription matching logic; Integration tests for NATS bridge added; New testing utilities for commands, streams, and queue workers.

The PURISTA framework and its examples have been upgraded to version 3.2.4, requiring Node.js 24.15.0 or later and migrating to TypeScript 7 (via the \@typescript/native\ package). The schema validation library has been updated from Zod 3 to Zod 4, and the HTTP server implementation now relies on Hono 4 with \@hono/node-server\ 2.1.0. The project structure is now a monorepo using Biome for linting and Vitest for testing, with the root package.json managing workspace scripts for building, releasing, and testing across all packages.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 45.

• Code Health 78
• Architecture 92
• Maturity 75
• Readiness 35
• Security 37
• Accessibility 76
• Performance 60

• 300 commits — 227 feature/other, 73 fixes

• packages/core — 62 commits
• website/doc — 55 commits
• (root) — 43 commits
• packages/cli — 21 commits
• packages/amqpbridge — 14 commits
• packages/hono-http-server — 11 commits
• .github/workflows — 10 commits
• docs/assets — 10 commits
• (repo) — 6 commits
• examples/temporal — 6 commits
• examples/client-builder — 5 commits
• packages/base-http-bridge — 5 commits
• packages/mqttbridge — 5 commits
• web/src — 5 commits
• packages/dapr-sdk — 4 commits
• packages/httpserver — 4 commits
• packages/infisical-secret-store — 4 commits
• examples/dapr-example — 3 commits
• examples/hono-example — 3 commits
• packages/vault-secret-store — 3 commits

• fix: Merge pull request #231 from puristajs/codex/fix-typedoc-cli-regex-target
• fix: Merge pull request #232 from puristajs/codex/fix-release-prepare-build-order
• fix: Revert "Prepare PURISTA 3.0.0 release"
• fix: chore: apply biome formatting and import ordering fixes
• fix: chore: cleanup and fix type refactoring
• fix: chore: cleanup cli and fix build
• fix: chore: fix type and add error logging
• fix: chore: minor fix for client-builder
• fix: fix(amqpbridge): harden delivery lifecycle and unregister semantics
• fix: fix(amqpbridge): use typed unavailable errors when disconnected
• fix: fix(aws-config-store): wrap set and remove failures with typed errors
• fix: fix(aws-secret-store): surface update failures when setting secrets
• fix: fix(base-http-bridge): correct rest command query and response handling
• fix: fix(base-http-bridge): return typed command envelopes and guard invoke responses
• fix: fix(ci): handle release PR creation permission restrictions (#235)
• fix: fix(ci): harden release workflows and use npm trusted publishing (#237)
• fix: fix(ci): make publish rerun-safe and normalize repository urls (#239)
• fix: fix(ci): make release version read step shell-safe (#233)
• fix: fix(ci): split release prepare and publish workflows (#234)
• fix: fix(cli): avoid false duplicate detection for builder definitions
• …and 280 more

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

puristajs/purista 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.