@3sixty/api-processors 0.0.0-stage → 0.20.0-next.1

package/dist/types/identity/contextIdProcessor.d.ts

@@ -0,0 +1,40 @@
+import type { IBaseRoute, IBaseRouteProcessor, IHttpResponse, IHttpServerRequest } from "@3sixty/api-models";
+import { type IContextIds } from "@3sixty/context";
+import type { IContextIdProcessorConstructorOptions } from "../models/IContextIdProcessorConstructorOptions.js";
+/**
+ * Adds an id to the request context ids.
+ */
+export declare class ContextIdProcessor implements IBaseRouteProcessor {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of ContextIdProcessor.
+     * @param options Options for the processor.
+     */
+    constructor(options: IContextIdProcessorConstructorOptions);
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className(): string;
+    /**
+     * The service needs to be started when the application is initialized.
+     * @param nodeLoggingComponentType The node logging component type.
+     * @returns A promise that resolves when the context ID has been loaded from the store.
+     */
+    start(nodeLoggingComponentType?: string): Promise<void>;
+    /**
+     * Pre process the REST request for the specified route.
+     * @param request The incoming request.
+     * @param response The outgoing response.
+     * @param route The route to process.
+     * @param contextIds The context IDs of the request.
+     * @param processorState The state handed through the processors.
+     * @returns A promise that resolves when the context ID has been injected into the request.
+     */
+    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, contextIds: IContextIds, processorState: {
+        [id: string]: unknown;
+    }): Promise<void>;
+}

package/dist/types/identity/staticContextIdProcessor.d.ts

@@ -0,0 +1,34 @@
+import type { IBaseRoute, IBaseRouteProcessor, IHttpResponse, IHttpServerRequest } from "@3sixty/api-models";
+import type { IContextIds } from "@3sixty/context";
+import type { IStaticContextIdProcessorConstructorOptions } from "../models/IStaticContextIdProcessorConstructorOptions.js";
+/**
+ * Adds a static context id to the request context.
+ */
+export declare class StaticContextIdProcessor implements IBaseRouteProcessor {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of StaticContextIdProcessor.
+     * @param options Options for the processor.
+     */
+    constructor(options: IStaticContextIdProcessorConstructorOptions);
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className(): string;
+    /**
+     * Pre process the REST request for the specified route.
+     * @param request The incoming request.
+     * @param response The outgoing response.
+     * @param route The route to process.
+     * @param contextIds The context IDs of the request.
+     * @param processorState The state handed through the processors.
+     * @returns A promise that resolves when the static context ID has been injected into the request.
+     */
+    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, contextIds: IContextIds, processorState: {
+        [id: string]: unknown;
+    }): Promise<void>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./data/restRouteProcessor.js";
+export * from "./data/socketRouteProcessor.js";
+export * from "./identity/contextIdProcessor.js";
+export * from "./identity/staticContextIdProcessor.js";
+export * from "./logging/loggingProcessor.js";
+export * from "./mimeType/jsonLdMimeTypeProcessor.js";
+export * from "./mimeType/jwtMimeTypeProcessor.js";
+export * from "./models/IContextIdProcessorConfig.js";
+export * from "./models/IContextIdProcessorConstructorOptions.js";
+export * from "./models/ILoggingProcessorConfig.js";
+export * from "./models/ILoggingProcessorConstructorOptions.js";
+export * from "./models/IRestRouteProcessorConstructorOptions.js";
+export * from "./models/IRouteProcessorConfig.js";
+export * from "./models/ISocketRouteProcessorConstructorOptions.js";
+export * from "./models/IStaticContextIdProcessorConfig.js";
+export * from "./models/IStaticContextIdProcessorConstructorOptions.js";

package/dist/types/logging/loggingProcessor.d.ts

@@ -0,0 +1,46 @@
+import type { IBaseRoute, IBaseRouteProcessor, IHttpResponse, IHttpServerRequest } from "@3sixty/api-models";
+import type { IContextIds } from "@3sixty/context";
+import type { ILoggingProcessorConstructorOptions } from "../models/ILoggingProcessorConstructorOptions.js";
+/**
+ * Process the REST request and log its information.
+ */
+export declare class LoggingProcessor implements IBaseRouteProcessor {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of LoggingProcessor.
+     * @param options Options for the processor.
+     */
+    constructor(options?: ILoggingProcessorConstructorOptions);
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className(): string;
+    /**
+     * Pre process the REST request for the specified route.
+     * @param request The incoming request.
+     * @param response The outgoing response.
+     * @param route The route to process.
+     * @param contextIds The context IDs of the request.
+     * @param processorState The state handed through the processors.
+     * @returns A promise that resolves when the pre-processing log entry has been written.
+     */
+    pre(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, contextIds: IContextIds, processorState: {
+        [id: string]: unknown;
+    }): Promise<void>;
+    /**
+     * Post process the REST request for the specified route.
+     * @param request The incoming request.
+     * @param response The outgoing response.
+     * @param route The route to process.
+     * @param contextIds The context IDs of the request.
+     * @param processorState The state handed through the processors.
+     * @returns A promise that resolves when the post-processing log entry has been written.
+     */
+    post(request: IHttpServerRequest, response: IHttpResponse, route: IBaseRoute | undefined, contextIds: IContextIds, processorState: {
+        [id: string]: unknown;
+    }): Promise<void>;
+}

package/dist/types/mimeType/jsonLdMimeTypeProcessor.d.ts

@@ -0,0 +1,26 @@
+import type { IMimeTypeProcessor } from "@3sixty/api-models";
+/**
+ * Process the JSON-LD mime type.
+ */
+export declare class JsonLdMimeTypeProcessor implements IMimeTypeProcessor {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className(): string;
+    /**
+     * Get the MIME types that this handler can handle.
+     * @returns The MIME types that this handler can handle.
+     */
+    getTypes(): string[];
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    handle(body: Uint8Array): Promise<unknown>;
+}

package/dist/types/mimeType/jwtMimeTypeProcessor.d.ts

@@ -0,0 +1,26 @@
+import type { IMimeTypeProcessor } from "@3sixty/api-models";
+/**
+ * Process the JWT mime type.
+ */
+export declare class JwtMimeTypeProcessor implements IMimeTypeProcessor {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className(): string;
+    /**
+     * Get the MIME types that this handler can handle.
+     * @returns The MIME types that this handler can handle.
+     */
+    getTypes(): string[];
+    /**
+     * Handle content.
+     * @param body The body to process.
+     * @returns The processed body.
+     */
+    handle(body: Uint8Array): Promise<unknown>;
+}

package/dist/types/models/IContextIdProcessorConfig.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Configuration for the context id processor.
+ */
+export interface IContextIdProcessorConfig {
+    /**
+     * The fixed identity key for request context.
+     */
+    key: string;
+    /**
+     * Only add the identity if the request is authenticated.
+     */
+    authOnly?: boolean;
+}

package/dist/types/models/IContextIdProcessorConstructorOptions.d.ts

@@ -0,0 +1,10 @@
+import type { IContextIdProcessorConfig } from "./IContextIdProcessorConfig.js";
+/**
+ * Options for the ContextIdProcessor constructor.
+ */
+export interface IContextIdProcessorConstructorOptions {
+    /**
+     * The configuration for the processor.
+     */
+    config: IContextIdProcessorConfig;
+}

package/dist/types/models/ILoggingProcessorConfig.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Configuration for the request logging processor.
+ */
+export interface ILoggingProcessorConfig {
+    /**
+     * Include the body objects when logging the information.
+     */
+    includeBody?: boolean;
+    /**
+     * Show the full base64 content for data, default to abbreviate.
+     */
+    fullBase64?: boolean;
+    /**
+     * List of property names to obfuscate, can be regex, defaults to "password".
+     */
+    obfuscateProperties?: string[];
+    /**
+     * Request URL path prefixes to exclude from logging, defaults to ["/logging"].
+     * Use this to prevent the logging endpoint itself from appearing in its own output.
+     */
+    excludePaths?: string[];
+}

package/dist/types/models/ILoggingProcessorConstructorOptions.d.ts

@@ -0,0 +1,14 @@
+import type { ILoggingProcessorConfig } from "./ILoggingProcessorConfig.js";
+/**
+ * Options for the LoggingProcessor constructor.
+ */
+export interface ILoggingProcessorConstructorOptions {
+    /**
+     * The type for the logging component.
+     */
+    loggingComponentType?: string;
+    /**
+     * The configuration for the logging processor.
+     */
+    config?: ILoggingProcessorConfig;
+}

package/dist/types/models/IRestRouteProcessorConstructorOptions.d.ts

@@ -0,0 +1,10 @@
+import type { IRouteProcessorConfig } from "../models/IRouteProcessorConfig.js";
+/**
+ * Options for the RestRouteProcessor constructor.
+ */
+export interface IRestRouteProcessorConstructorOptions {
+    /**
+     * The configuration for the processor.
+     */
+    config?: IRouteProcessorConfig;
+}

package/dist/types/models/IRouteProcessorConfig.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configuration for the route processor.
+ */
+export interface IRouteProcessorConfig {
+    /**
+     * Include the stack with errors.
+     */
+    includeErrorStack?: boolean;
+}

package/dist/types/models/ISocketRouteProcessorConstructorOptions.d.ts

@@ -0,0 +1,10 @@
+import type { IRouteProcessorConfig } from "./IRouteProcessorConfig.js";
+/**
+ * Options for the SocketRouteProcessor constructor.
+ */
+export interface ISocketRouteProcessorConstructorOptions {
+    /**
+     * The configuration for the processor.
+     */
+    config?: IRouteProcessorConfig;
+}

package/dist/types/models/IStaticContextIdProcessorConfig.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration for the static id processor.
+ */
+export interface IStaticContextIdProcessorConfig {
+    /**
+     * The fixed identity key for request context.
+     */
+    key: string;
+    /**
+     * The fixed identity value for request context.
+     */
+    value: string;
+    /**
+     * Only add the identity if the request is authenticated.
+     */
+    authOnly?: boolean;
+}

package/dist/types/models/IStaticContextIdProcessorConstructorOptions.d.ts

@@ -0,0 +1,10 @@
+import type { IStaticContextIdProcessorConfig } from "./IStaticContextIdProcessorConfig.js";
+/**
+ * Options for the StaticContextIdProcessor constructor.
+ */
+export interface IStaticContextIdProcessorConstructorOptions {
+    /**
+     * The configuration for the processor.
+     */
+    config: IStaticContextIdProcessorConfig;
+}

package/docs/changelog.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## [0.20.0-next.1](https://github.com/3sixtyglobal/api/compare/api-processors-v0.20.0-next.0...api-processors-v0.20.0-next.1) (2026-10-23)
+
+
+### Features
+
+* publish packages under the [@3sixty](https://github.com/3sixty) namespace ([91b1822](https://github.com/3sixtyglobal/api/commit/91b1822dba38f70692087ad4643572531d6634dc))
+* updated ts compile ([d9a5c86](https://github.com/3sixtyglobal/api/commit/d9a5c86ec7dd1faf3045b5cd1e0d38a4b331313d))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @3sixty/api-models bumped from 0.20.0-next.0 to 0.20.0-next.1

package/docs/examples.md

@@ -0,0 +1,189 @@
+# 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 '@3sixty/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 '@3sixty/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 '@3sixty/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 '@3sixty/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 '@3sixty/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 '@3sixty/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: '3Sixty API'
+    }
+  })
+};
+
+await restProcessor.process(request, response, route, {});
+console.log(response.statusCode ?? 200); // 200
+```
+
+## StaticContextIdProcessor
+
+```typescript
+import { StaticContextIdProcessor } from '@3sixty/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/docs/reference/classes/ContextIdProcessor.md

@@ -0,0 +1,129 @@
+# Class: ContextIdProcessor
+
+Adds an id to the request context ids.
+
+## Implements
+
+- `IBaseRouteProcessor`
+
+## Constructors
+
+### Constructor
+
+> **new ContextIdProcessor**(`options`): `ContextIdProcessor`
+
+Create a new instance of ContextIdProcessor.
+
+#### Parameters
+
+##### options
+
+[`IContextIdProcessorConstructorOptions`](../interfaces/IContextIdProcessorConstructorOptions.md)
+
+Options for the processor.
+
+#### Returns
+
+`ContextIdProcessor`
+
+## Properties
+
+### CLASS\_NAME {#class_name}
+
+> `readonly` `static` **CLASS\_NAME**: `string`
+
+Runtime name for the class.
+
+## Methods
+
+### className() {#classname}
+
+> **className**(): `string`
+
+Returns the class name of the component.
+
+#### Returns
+
+`string`
+
+The class name of the component.
+
+#### Implementation of
+
+`IBaseRouteProcessor.className`
+
+***
+
+### start() {#start}
+
+> **start**(`nodeLoggingComponentType?`): `Promise`\<`void`\>
+
+The service needs to be started when the application is initialized.
+
+#### Parameters
+
+##### nodeLoggingComponentType?
+
+`string`
+
+The node logging component type.
+
+#### Returns
+
+`Promise`\<`void`\>
+
+A promise that resolves when the context ID has been loaded from the store.
+
+#### Implementation of
+
+`IBaseRouteProcessor.start`
+
+***
+
+### pre() {#pre}
+
+> **pre**(`request`, `response`, `route`, `contextIds`, `processorState`): `Promise`\<`void`\>
+
+Pre process the REST request for the specified route.
+
+#### Parameters
+
+##### request
+
+`IHttpServerRequest`
+
+The incoming request.
+
+##### response
+
+`IHttpResponse`
+
+The outgoing response.
+
+##### route
+
+`IBaseRoute` \| `undefined`
+
+The route to process.
+
+##### contextIds
+
+`IContextIds`
+
+The context IDs of the request.
+
+##### processorState
+
+\{\[`id`: `string`\]: `unknown`; \}
+
+The state handed through the processors.
+
+#### Returns
+
+`Promise`\<`void`\>
+
+A promise that resolves when the context ID has been injected into the request.
+
+#### Implementation of
+
+`IBaseRouteProcessor.pre`