serverless-simple-middleware 0.0.74 → 0.0.75

package/src/middleware/trace.ts

@@ -1,265 +1,265 @@
-import { v4 as uuid4 } from 'uuid';
-import {
-  AWSComponent,
-  loadAWSConfig,
-  SimpleAWS,
-  SimpleAWSConfigLoadParam,
-} from '../aws';
-import { getLogger, stringifyError } from '../utils';
-
-import { SQS } from '@aws-sdk/client-sqs';
-import { $enum } from 'ts-enum-util';
-import { HandlerAuxBase, HandlerContext, HandlerPluginBase } from './base';
-
-const logger = getLogger(__filename);
-
-interface ITracerLog {
-  uuid: string;
-  timestamp: number;
-  route: string;
-  key: string;
-  system: string;
-  action: string;
-  attribute: string;
-  body: string;
-  error: boolean;
-  client: string;
-  version: string;
-}
-
-interface ITracerLogInput {
-  route?: string;
-  key?: string;
-  system?: string;
-  action?: string;
-  attribute: string;
-  body: string;
-  error?: boolean;
-  client?: string;
-  version?: string;
-}
-
-export class TracerLog implements ITracerLog {
-  public readonly uuid: string;
-  public readonly timestamp: number;
-
-  constructor(
-    public readonly route: string,
-    public readonly key: string,
-    public readonly system: string,
-    public readonly action: string,
-    public readonly attribute: string,
-    public readonly body: string,
-    public readonly error: boolean,
-    public readonly client: string,
-    public readonly version: string,
-  ) {
-    this.uuid = uuid4();
-    this.timestamp = Date.now();
-  }
-}
-
-export class Tracer {
-  private queueName: string;
-  private sqs: SQS;
-  private buffer: TracerLog[];
-
-  constructor(queueName: string, sqs: SQS) {
-    this.queueName = queueName;
-    this.sqs = sqs;
-    this.buffer = [];
-  }
-
-  public push = (log: TracerLog) => this.buffer.push(log);
-
-  public flush = async () => {
-    if (this.buffer.length === 0) {
-      return;
-    }
-    try {
-      const urlResult = await this.sqs.getQueueUrl({
-        QueueName: this.queueName,
-      });
-      logger.stupid(`urlResult`, urlResult);
-      if (!urlResult.QueueUrl) {
-        throw new Error(`No queue url with name[${this.queueName}]`);
-      }
-      const eventQueueUrl = urlResult.QueueUrl;
-
-      const chunkSize = 10;
-      for (let begin = 0; begin < this.buffer.length; begin += chunkSize) {
-        const end = Math.min(this.buffer.length, begin + chunkSize);
-        const subset = this.buffer.slice(begin, end);
-        const sendBatchResult = await this.sqs.sendMessageBatch({
-          QueueUrl: eventQueueUrl,
-          Entries: subset.map((each) => ({
-            Id: `${each.key}_${each.uuid}`,
-            MessageBody: JSON.stringify(each),
-          })),
-        });
-        logger.stupid(`sendBatchResult`, sendBatchResult);
-      }
-
-      this.buffer = [];
-    } catch (error) {
-      logger.warn(`Error in eventSource: ${error}`);
-    }
-  };
-}
-
-export class TracerWrapper {
-  constructor(
-    private tracer: Tracer,
-    private route: string,
-    private system: string,
-    private key: string,
-    private action: string,
-    private client: string,
-    private version: string,
-  ) {}
-
-  public push = (attribute: string, body: string, error: boolean = false) => {
-    this.tracer.push(
-      new TracerLog(
-        this.route,
-        this.key,
-        this.system,
-        this.action,
-        attribute,
-        body,
-        error,
-        this.client,
-        this.version,
-      ),
-    );
-  };
-
-  public send = (log: ITracerLogInput) => {
-    this.tracer.push(
-      new TracerLog(
-        log.route || this.route,
-        log.key || this.key,
-        log.system || this.system,
-        log.action || this.action,
-        log.attribute,
-        log.body,
-        log.error || false,
-        log.client || this.client,
-        log.version || this.version,
-      ),
-    );
-  };
-}
-
-export interface TracerPluginOptions {
-  route: string;
-  queueName: string;
-  system: string;
-
-  awsConfig?: SimpleAWSConfigLoadParam;
-  region?: string;
-}
-
-export interface TracerPluginAux extends HandlerAuxBase {
-  tracer: (key: string, action: string) => TracerWrapper;
-}
-
-export class TracerPlugin extends HandlerPluginBase<TracerPluginAux> {
-  private tracer: Tracer;
-  private options: TracerPluginOptions;
-  private last: { key: string; action: string };
-  private client: { agent: string; version: string };
-
-  constructor(options: TracerPluginOptions) {
-    super();
-    this.options = options;
-    this.last = {
-      key: 'nothing',
-      action: 'unknown',
-    };
-    this.client = {
-      agent: '',
-      version: '',
-    };
-  }
-
-  public create = async () => {
-    const awsConfig = this.options.awsConfig
-      ? await loadAWSConfig(this.options.awsConfig)
-      : undefined;
-
-    const sqs = (() => {
-      if (!awsConfig) {
-        return new SQS({
-          region: this.options.region,
-        });
-      }
-      $enum(AWSComponent).forEach((eachComponent) => {
-        const config = awsConfig.get(eachComponent);
-        if (config) {
-          config.region = this.options.region;
-        }
-      });
-      return new SimpleAWS(awsConfig).sqs;
-    })();
-
-    this.tracer = new Tracer(this.options.queueName, sqs);
-    const tracer = (key: string, action: string) => {
-      this.last = { key, action };
-      return new TracerWrapper(
-        this.tracer,
-        this.options.route,
-        this.options.system,
-        key,
-        action,
-        this.client.agent,
-        this.client.version,
-      );
-    };
-    return { tracer };
-  };
-
-  public begin = ({ request }: HandlerContext<TracerPluginAux>) => {
-    this.client.version = request.header('X-Version') || '0.0.0';
-    this.client.agent = (() => {
-      const fromHeader = request.header('User-Agent');
-      if (fromHeader) {
-        return fromHeader;
-      }
-      if (
-        request.context &&
-        request.context.identity &&
-        request.context.identity.userAgent
-      ) {
-        return request.context.identity.userAgent;
-      }
-      return '';
-    })();
-  };
-
-  public end = () => this.tracer.flush();
-
-  public error = ({ request, aux }: HandlerContext<TracerPluginAux>) => {
-    if (!aux) {
-      console.warn('Aux is not initialized');
-      return;
-    }
-    if (!request.lastError) {
-      return;
-    }
-
-    const { key, action } = this.last;
-    aux
-      .tracer(key, action)
-      .push(
-        'error',
-        typeof request.lastError === 'string'
-          ? request.lastError
-          : stringifyError(request.lastError),
-        true,
-      );
-  };
-}
-
-const build = (options: TracerPluginOptions) => new TracerPlugin(options);
-export default build;
+import { v4 as uuid4 } from 'uuid';
+import {
+  AWSComponent,
+  loadAWSConfig,
+  SimpleAWS,
+  SimpleAWSConfigLoadParam,
+} from '../aws';
+import { getLogger, stringifyError } from '../utils';
+
+import { SQS } from '@aws-sdk/client-sqs';
+import { $enum } from 'ts-enum-util';
+import { HandlerAuxBase, HandlerContext, HandlerPluginBase } from './base';
+
+const logger = getLogger(__filename);
+
+interface ITracerLog {
+  uuid: string;
+  timestamp: number;
+  route: string;
+  key: string;
+  system: string;
+  action: string;
+  attribute: string;
+  body: string;
+  error: boolean;
+  client: string;
+  version: string;
+}
+
+interface ITracerLogInput {
+  route?: string;
+  key?: string;
+  system?: string;
+  action?: string;
+  attribute: string;
+  body: string;
+  error?: boolean;
+  client?: string;
+  version?: string;
+}
+
+export class TracerLog implements ITracerLog {
+  public readonly uuid: string;
+  public readonly timestamp: number;
+
+  constructor(
+    public readonly route: string,
+    public readonly key: string,
+    public readonly system: string,
+    public readonly action: string,
+    public readonly attribute: string,
+    public readonly body: string,
+    public readonly error: boolean,
+    public readonly client: string,
+    public readonly version: string,
+  ) {
+    this.uuid = uuid4();
+    this.timestamp = Date.now();
+  }
+}
+
+export class Tracer {
+  private queueName: string;
+  private sqs: SQS;
+  private buffer: TracerLog[];
+
+  constructor(queueName: string, sqs: SQS) {
+    this.queueName = queueName;
+    this.sqs = sqs;
+    this.buffer = [];
+  }
+
+  public push = (log: TracerLog) => this.buffer.push(log);
+
+  public flush = async () => {
+    if (this.buffer.length === 0) {
+      return;
+    }
+    try {
+      const urlResult = await this.sqs.getQueueUrl({
+        QueueName: this.queueName,
+      });
+      logger.stupid(`urlResult`, urlResult);
+      if (!urlResult.QueueUrl) {
+        throw new Error(`No queue url with name[${this.queueName}]`);
+      }
+      const eventQueueUrl = urlResult.QueueUrl;
+
+      const chunkSize = 10;
+      for (let begin = 0; begin < this.buffer.length; begin += chunkSize) {
+        const end = Math.min(this.buffer.length, begin + chunkSize);
+        const subset = this.buffer.slice(begin, end);
+        const sendBatchResult = await this.sqs.sendMessageBatch({
+          QueueUrl: eventQueueUrl,
+          Entries: subset.map((each) => ({
+            Id: `${each.key}_${each.uuid}`,
+            MessageBody: JSON.stringify(each),
+          })),
+        });
+        logger.stupid(`sendBatchResult`, sendBatchResult);
+      }
+
+      this.buffer = [];
+    } catch (error) {
+      logger.warn(`Error in eventSource: ${error}`);
+    }
+  };
+}
+
+export class TracerWrapper {
+  constructor(
+    private tracer: Tracer,
+    private route: string,
+    private system: string,
+    private key: string,
+    private action: string,
+    private client: string,
+    private version: string,
+  ) {}
+
+  public push = (attribute: string, body: string, error: boolean = false) => {
+    this.tracer.push(
+      new TracerLog(
+        this.route,
+        this.key,
+        this.system,
+        this.action,
+        attribute,
+        body,
+        error,
+        this.client,
+        this.version,
+      ),
+    );
+  };
+
+  public send = (log: ITracerLogInput) => {
+    this.tracer.push(
+      new TracerLog(
+        log.route || this.route,
+        log.key || this.key,
+        log.system || this.system,
+        log.action || this.action,
+        log.attribute,
+        log.body,
+        log.error || false,
+        log.client || this.client,
+        log.version || this.version,
+      ),
+    );
+  };
+}
+
+export interface TracerPluginOptions {
+  route: string;
+  queueName: string;
+  system: string;
+
+  awsConfig?: SimpleAWSConfigLoadParam;
+  region?: string;
+}
+
+export interface TracerPluginAux extends HandlerAuxBase {
+  tracer: (key: string, action: string) => TracerWrapper;
+}
+
+export class TracerPlugin extends HandlerPluginBase<TracerPluginAux> {
+  private tracer: Tracer;
+  private options: TracerPluginOptions;
+  private last: { key: string; action: string };
+  private client: { agent: string; version: string };
+
+  constructor(options: TracerPluginOptions) {
+    super();
+    this.options = options;
+    this.last = {
+      key: 'nothing',
+      action: 'unknown',
+    };
+    this.client = {
+      agent: '',
+      version: '',
+    };
+  }
+
+  public create = async () => {
+    const awsConfig = this.options.awsConfig
+      ? await loadAWSConfig(this.options.awsConfig)
+      : undefined;
+
+    const sqs = (() => {
+      if (!awsConfig) {
+        return new SQS({
+          region: this.options.region,
+        });
+      }
+      $enum(AWSComponent).forEach((eachComponent) => {
+        const config = awsConfig.get(eachComponent);
+        if (config) {
+          config.region = this.options.region;
+        }
+      });
+      return new SimpleAWS(awsConfig).sqs;
+    })();
+
+    this.tracer = new Tracer(this.options.queueName, sqs);
+    const tracer = (key: string, action: string) => {
+      this.last = { key, action };
+      return new TracerWrapper(
+        this.tracer,
+        this.options.route,
+        this.options.system,
+        key,
+        action,
+        this.client.agent,
+        this.client.version,
+      );
+    };
+    return { tracer };
+  };
+
+  public begin = ({ request }: HandlerContext<TracerPluginAux>) => {
+    this.client.version = request.header('X-Version') || '0.0.0';
+    this.client.agent = (() => {
+      const fromHeader = request.header('User-Agent');
+      if (fromHeader) {
+        return fromHeader;
+      }
+      if (
+        request.context &&
+        request.context.identity &&
+        request.context.identity.userAgent
+      ) {
+        return request.context.identity.userAgent;
+      }
+      return '';
+    })();
+  };
+
+  public end = () => this.tracer.flush();
+
+  public error = ({ request, aux }: HandlerContext<TracerPluginAux>) => {
+    if (!aux) {
+      console.warn('Aux is not initialized');
+      return;
+    }
+    if (!request.lastError) {
+      return;
+    }
+
+    const { key, action } = this.last;
+    aux
+      .tracer(key, action)
+      .push(
+        'error',
+        typeof request.lastError === 'string'
+          ? request.lastError
+          : stringifyError(request.lastError),
+        true,
+      );
+  };
+}
+
+const build = (options: TracerPluginOptions) => new TracerPlugin(options);
+export default build;

package/src/middleware/websocketBase.ts

@@ -0,0 +1,92 @@
+import type { APIGatewayProxyWebsocketEventV2, Context } from 'aws-lambda';
+import { getLogger } from '../utils/logger';
+
+const logger = getLogger(__filename);
+
+export interface WebSocketHandlerAuxBase {
+  [key: string]: any;
+}
+
+export class WebSocketHandlerRequest {
+  public event: APIGatewayProxyWebsocketEventV2;
+  public context: Context;
+  public lastError: Error | string | undefined;
+
+  private lazyBody?: any;
+
+  constructor(event: APIGatewayProxyWebsocketEventV2, context: Context) {
+    this.event = event;
+    this.context = context;
+    this.lastError = undefined;
+
+    const ev = this.event as any;
+    if (ev.headers) {
+      const normalized: Record<string, string | undefined> = {};
+      for (const key of Object.keys(ev.headers)) {
+        normalized[key.toLowerCase()] = ev.headers[key];
+      }
+      ev.headers = normalized;
+    }
+  }
+
+  get body() {
+    if (!this.event.body) {
+      return {};
+    }
+    if (this.lazyBody === undefined) {
+      try {
+        this.lazyBody = JSON.parse(this.event.body);
+      } catch (error) {
+        logger.error(`Failed to parse WebSocket body: ${error}`);
+        this.lazyBody = {};
+      }
+    }
+    return this.lazyBody || {};
+  }
+
+  get connectionId(): string {
+    return this.event.requestContext.connectionId;
+  }
+
+  get routeKey(): string {
+    return this.event.requestContext.routeKey;
+  }
+
+  get domainName(): string {
+    return this.event.requestContext.domainName;
+  }
+
+  get stage(): string {
+    return this.event.requestContext.stage;
+  }
+
+  // HTTP plugin compatibility methods
+
+  /**
+   * For HTTP plugin compatibility (TracerPlugin uses this).
+   * WebSocket events may have headers in $connect route (HTTP handshake),
+   * but typically don't have headers in other routes.
+   */
+  public header(key: string): string | undefined {
+    const event = this.event as any;
+    if (event.headers) {
+      return event.headers[key.toLowerCase()];
+    }
+    return undefined;
+  }
+}
+
+export interface WebSocketHandlerResponse {
+  statusCode: number;
+  body?: string;
+}
+
+export interface WebSocketHandlerContext<A extends WebSocketHandlerAuxBase> {
+  request: WebSocketHandlerRequest;
+  response: undefined; // For HTTP plugin compatibility (not used in WebSocket handlers)
+  aux: A;
+}
+
+export type WebSocketHandler<A extends WebSocketHandlerAuxBase> = (
+  context: WebSocketHandlerContext<A>,
+) => WebSocketHandlerResponse | Promise<WebSocketHandlerResponse> | undefined;

package/src/utils/index.ts

@@ -1,2 +1,2 @@
-export * from './logger';
-export * from './misc';
+export * from './logger';
+export * from './misc';