@twin.org/api-processors 0.0.3-next.20 → 0.0.3-next.21

package/README.md

@@ -1,6 +1,6 @@
 # TWIN API Processors
 
-Route processors for use with API servers.
+This package provides reusable request and route processors for logging, context handling, and content negotiation.
 
 ## Installation
 

package/docs/changelog.md

@@ -1,4 +1,18 @@
-# @twin.org/api-processors - Changelog
+# Changelog
+
+## [0.0.3-next.21](https://github.com/twinfoundation/api/compare/api-processors-v0.0.3-next.20...api-processors-v0.0.3-next.21) (2026-03-11)
+
+
+### Miscellaneous Chores
+
+* **api-processors:** Synchronize repo versions
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @twin.org/api-models bumped from 0.0.3-next.20 to 0.0.3-next.21
 
 ## [0.0.3-next.20](https://github.com/twinfoundation/api/compare/api-processors-v0.0.3-next.19...api-processors-v0.0.3-next.20) (2026-02-09)
 

package/docs/examples.md

@@ -1 +1,189 @@
-# @twin.org/api-processors - Examples
+# Processors Examples
+
+These snippets demonstrate request and response processors that can be composed into REST, socket, and MIME handling pipelines.
+
+## SocketRouteProcessor
+
+```typescript
+import { SocketRouteProcessor } from '@twin.org/api-processors';
+
+const socketProcessor = new SocketRouteProcessor();
+
+console.log(socketProcessor.className()); // SocketRouteProcessor
+
+const socketRoute = {
+  event: 'tenant.updated',
+  handler: async () => ({
+    body: {
+      ok: true
+    }
+  })
+};
+
+const socketRequest = {
+  socketId: 'conn-1',
+  url: '/tenant.updated',
+  pathParams: {},
+  query: {},
+  body: {
+    tenantId: '0123456789abcdef0123456789abcdef'
+  }
+};
+
+const socketResponse = {};
+const socketProcessorState = {};
+
+await socketProcessor.connected(socketRequest, socketRoute);
+
+await socketProcessor.process(
+  socketRequest,
+  socketResponse,
+  socketRoute,
+  socketProcessorState,
+  async (topic, response) => {
+    console.log(topic); // tenant.updated
+    console.log(response.statusCode ?? 200); // 200
+  }
+);
+
+await socketProcessor.disconnected(socketRequest, socketRoute);
+```
+
+## ContextIdProcessor
+
+```typescript
+import { ContextIdProcessor } from '@twin.org/api-processors';
+
+const contextProcessor = new ContextIdProcessor({
+  config: {
+    key: 'node'
+  }
+});
+
+await contextProcessor.start('default');
+console.log(contextProcessor.className()); // ContextIdProcessor
+
+const contextIds = {};
+await contextProcessor.pre(
+  { method: 'get', url: '/health', headers: {} },
+  {},
+  undefined,
+  contextIds,
+  {}
+);
+console.log(typeof contextIds.node); // string
+```
+
+## LoggingProcessor
+
+```typescript
+import { LoggingProcessor } from '@twin.org/api-processors';
+
+const logging = new LoggingProcessor();
+
+console.log(logging.className()); // LoggingProcessor
+
+const request = {
+  method: 'get',
+  url: 'http://localhost:3000/health',
+  headers: {}
+};
+
+const response = {
+  statusCode: 200,
+  headers: {}
+};
+
+const processorState: { [id: string]: unknown } = {};
+
+await logging.pre(request, response, undefined, {}, processorState);
+await logging.post(request, response, undefined, {}, processorState);
+```
+
+## JsonLdMimeTypeProcessor
+
+```typescript
+import { JsonLdMimeTypeProcessor } from '@twin.org/api-processors';
+
+const jsonLd = new JsonLdMimeTypeProcessor();
+
+const mediaTypes = jsonLd.getTypes();
+const body = new TextEncoder().encode('{"@context":"https://schema.org","name":"Tenant"}');
+const handled = await jsonLd.handle(body);
+
+console.log(mediaTypes[0]); // application/ld+json
+console.log(typeof handled); // object
+```
+
+## JwtMimeTypeProcessor
+
+```typescript
+import { JwtMimeTypeProcessor } from '@twin.org/api-processors';
+
+const jwt = new JwtMimeTypeProcessor();
+
+const mediaTypes = jwt.getTypes();
+const body = new TextEncoder().encode('eyJhbGciOiJIUzI1NiJ9.payload.signature');
+const handled = await jwt.handle(body);
+
+console.log(mediaTypes[0]); // application/jwt
+console.log(typeof handled); // string
+```
+
+## RestRouteProcessor
+
+```typescript
+import { RestRouteProcessor } from '@twin.org/api-processors';
+
+const restProcessor = new RestRouteProcessor();
+
+console.log(restProcessor.className()); // RestRouteProcessor
+
+const request = {
+  method: 'get',
+  url: '/info',
+  headers: {},
+  pathParams: {},
+  query: {}
+};
+
+const response = {};
+
+const route = {
+  method: 'get',
+  path: '/info',
+  handler: async () => ({
+    body: {
+      name: 'Twin API'
+    }
+  })
+};
+
+await restProcessor.process(request, response, route, {});
+console.log(response.statusCode ?? 200); // 200
+```
+
+## StaticContextIdProcessor
+
+```typescript
+import { StaticContextIdProcessor } from '@twin.org/api-processors';
+
+const staticContext = new StaticContextIdProcessor({
+  config: {
+    key: 'environment',
+    value: 'test'
+  }
+});
+
+console.log(staticContext.className()); // StaticContextIdProcessor
+
+const contextIds = {};
+await staticContext.pre(
+  { method: 'get', url: '/health', headers: {} },
+  {},
+  undefined,
+  contextIds,
+  {}
+);
+console.log(contextIds.environment); // test
+```

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@twin.org/api-processors",
-	"version": "0.0.3-next.20",
-	"description": "Route processors for use with API servers",
+	"version": "0.0.3-next.21",
+	"description": "Reusable request and route processors for logging, context handling, and content negotiation.",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/twinfoundation/api.git",
@@ -14,7 +14,7 @@
 		"node": ">=20.0.0"
 	},
 	"dependencies": {
-		"@twin.org/api-models": "0.0.3-next.20",
+		"@twin.org/api-models": "0.0.3-next.21",
 		"@twin.org/context": "next",
 		"@twin.org/core": "next",
 		"@twin.org/logging-models": "next",