@abbacchio/transport 0.1.1 → 0.1.3

package/src/encrypt.ts

@@ -1,112 +1,112 @@
-import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
-
-/**
- * Generate a cryptographically secure random key for encryption.
- * Use this on the server/producer side to create a key for each channel.
- *
- * @param length - Length of the key in bytes (default: 32 for 256-bit key)
- * @returns A hex-encoded random key
- *
- * @example
- * ```typescript
- * import { generateKey } from "@abbacchio/client";
- *
- * // Generate a key for a channel
- * const key = generateKey();
- *
- * // Use in pino transport
- * const logger = pino({
- *   transport: {
- *     target: "@abbacchio/client/transports/pino",
- *     options: {
- *       url: "http://localhost:4000/api/logs",
- *       channel: "my-app",
- *       secretKey: key,
- *     },
- *   },
- * });
- *
- * // Share the dashboard URL with the key
- * console.log(`Dashboard: http://localhost:4000?channel=my-app&key=${key}`);
- * ```
- */
-export function generateKey(length: number = 32): string {
-  return randomBytes(length).toString("hex");
-}
-
-const ALGORITHM = "aes-256-gcm";
-const IV_LENGTH = 16;
-const AUTH_TAG_LENGTH = 16;
-const SALT_LENGTH = 32;
-const PBKDF2_ITERATIONS = 100000;
-
-/**
- * Derive a key from a password using PBKDF2 (browser-compatible)
- */
-function deriveKey(password: string, salt: Buffer): Buffer {
-  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, 32, "sha256");
-}
-
-/**
- * Encrypt data with AES-256-GCM
- * Returns base64 encoded string: salt:iv:authTag:ciphertext
- */
-export function encrypt(data: string, secretKey: string): string {
-  const salt = randomBytes(SALT_LENGTH);
-  const key = deriveKey(secretKey, salt);
-  const iv = randomBytes(IV_LENGTH);
-
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  const encrypted = Buffer.concat([
-    cipher.update(data, "utf8"),
-    cipher.final(),
-  ]);
-  const authTag = cipher.getAuthTag();
-
-  // Combine: salt + iv + authTag + ciphertext
-  const combined = Buffer.concat([salt, iv, authTag, encrypted]);
-  return combined.toString("base64");
-}
-
-/**
- * Decrypt data encrypted with encrypt()
- */
-export function decrypt(encryptedData: string, secretKey: string): string {
-  const combined = Buffer.from(encryptedData, "base64");
-
-  // Extract components
-  const salt = combined.subarray(0, SALT_LENGTH);
-  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
-  const authTag = combined.subarray(
-    SALT_LENGTH + IV_LENGTH,
-    SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
-  );
-  const ciphertext = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
-
-  const key = deriveKey(secretKey, salt);
-  const decipher = createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(authTag);
-
-  const decrypted = Buffer.concat([
-    decipher.update(ciphertext),
-    decipher.final(),
-  ]);
-
-  return decrypted.toString("utf8");
-}
-
-/**
- * Encrypt a log object
- */
-export function encryptLog(log: unknown, secretKey: string): { encrypted: string } {
-  const jsonStr = JSON.stringify(log);
-  return { encrypted: encrypt(jsonStr, secretKey) };
-}
-
-/**
- * Decrypt an encrypted log
- */
-export function decryptLog<T = unknown>(encryptedLog: { encrypted: string }, secretKey: string): T {
-  const jsonStr = decrypt(encryptedLog.encrypted, secretKey);
-  return JSON.parse(jsonStr);
-}
+import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
+
+/**
+ * Generate a cryptographically secure random key for encryption.
+ * Use this on the server/producer side to create a key for each channel.
+ *
+ * @param length - Length of the key in bytes (default: 32 for 256-bit key)
+ * @returns A hex-encoded random key
+ *
+ * @example
+ * ```typescript
+ * import { generateKey } from "@abbacchio/client";
+ *
+ * // Generate a key for a channel
+ * const key = generateKey();
+ *
+ * // Use in pino transport
+ * const logger = pino({
+ *   transport: {
+ *     target: "@abbacchio/client/transports/pino",
+ *     options: {
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: key,
+ *     },
+ *   },
+ * });
+ *
+ * // Share the dashboard URL with the key
+ * console.log(`Dashboard: http://localhost:4000?channel=my-app&key=${key}`);
+ * ```
+ */
+export function generateKey(length: number = 32): string {
+  return randomBytes(length).toString("hex");
+}
+
+const ALGORITHM = "aes-256-gcm";
+const IV_LENGTH = 16;
+const AUTH_TAG_LENGTH = 16;
+const SALT_LENGTH = 32;
+const PBKDF2_ITERATIONS = 100000;
+
+/**
+ * Derive a key from a password using PBKDF2 (browser-compatible)
+ */
+function deriveKey(password: string, salt: Buffer): Buffer {
+  return pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, 32, "sha256");
+}
+
+/**
+ * Encrypt data with AES-256-GCM
+ * Returns base64 encoded string: salt:iv:authTag:ciphertext
+ */
+export function encrypt(data: string, secretKey: string): string {
+  const salt = randomBytes(SALT_LENGTH);
+  const key = deriveKey(secretKey, salt);
+  const iv = randomBytes(IV_LENGTH);
+
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(data, "utf8"),
+    cipher.final(),
+  ]);
+  const authTag = cipher.getAuthTag();
+
+  // Combine: salt + iv + authTag + ciphertext
+  const combined = Buffer.concat([salt, iv, authTag, encrypted]);
+  return combined.toString("base64");
+}
+
+/**
+ * Decrypt data encrypted with encrypt()
+ */
+export function decrypt(encryptedData: string, secretKey: string): string {
+  const combined = Buffer.from(encryptedData, "base64");
+
+  // Extract components
+  const salt = combined.subarray(0, SALT_LENGTH);
+  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = combined.subarray(
+    SALT_LENGTH + IV_LENGTH,
+    SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH
+  );
+  const ciphertext = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+
+  const key = deriveKey(secretKey, salt);
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+
+  const decrypted = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final(),
+  ]);
+
+  return decrypted.toString("utf8");
+}
+
+/**
+ * Encrypt a log object
+ */
+export function encryptLog(log: unknown, secretKey: string): { encrypted: string } {
+  const jsonStr = JSON.stringify(log);
+  return { encrypted: encrypt(jsonStr, secretKey) };
+}
+
+/**
+ * Decrypt an encrypted log
+ */
+export function decryptLog<T = unknown>(encryptedLog: { encrypted: string }, secretKey: string): T {
+  const jsonStr = decrypt(encryptedLog.encrypted, secretKey);
+  return JSON.parse(jsonStr);
+}

package/src/index.ts

@@ -1,19 +1,19 @@
-// Core client
-export { AbbacchioClient, createClient } from "./client.js";
-export type { AbbacchioClientOptions } from "./client.js";
-
-// Encryption utilities
-export { generateKey, encrypt, decrypt, encryptLog, decryptLog } from "./encrypt.js";
-
-// Re-export transports for convenience
-export { default as pinoTransport } from "./transports/pino.js";
-export type { PinoTransportOptions } from "./transports/pino.js";
-
-export { winstonTransport, AbbacchioWinstonTransport } from "./transports/winston.js";
-export type { WinstonTransportOptions } from "./transports/winston.js";
-
-export { bunyanStream, AbbacchioBunyanStream } from "./transports/bunyan.js";
-export type { BunyanStreamOptions } from "./transports/bunyan.js";
-
-export { interceptConsole, restoreConsole, getActiveClient } from "./transports/console.js";
-export type { ConsoleInterceptorOptions } from "./transports/console.js";
+// Core client
+export { AbbacchioClient, createClient } from "./client.js";
+export type { AbbacchioClientOptions } from "./client.js";
+
+// Encryption utilities
+export { generateKey, encrypt, decrypt, encryptLog, decryptLog } from "./encrypt.js";
+
+// Re-export transports for convenience
+export { default as pinoTransport } from "./transports/pino.js";
+export type { PinoTransportOptions } from "./transports/pino.js";
+
+export { winstonTransport, AbbacchioWinstonTransport } from "./transports/winston.js";
+export type { WinstonTransportOptions } from "./transports/winston.js";
+
+export { bunyanStream, AbbacchioBunyanStream } from "./transports/bunyan.js";
+export type { BunyanStreamOptions } from "./transports/bunyan.js";
+
+export { interceptConsole, restoreConsole, getActiveClient } from "./transports/console.js";
+export type { ConsoleInterceptorOptions } from "./transports/console.js";

package/src/transports/bunyan.ts

@@ -1,99 +1,99 @@
-import { Writable } from "stream";
-import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
-
-export interface BunyanStreamOptions extends AbbacchioClientOptions {
-  /** Bunyan log level (optional) */
-  level?: number | string;
-}
-
-/**
- * Bunyan stream for Abbacchio.
- * Implements the Node.js Writable stream interface for Bunyan.
- *
- * @example
- * ```typescript
- * import bunyan from "bunyan";
- * import { bunyanStream } from "@abbacchio/client/transports/bunyan";
- *
- * const logger = bunyan.createLogger({
- *   name: "myapp",
- *   streams: [
- *     { stream: process.stdout },
- *     bunyanStream({
- *       url: "http://localhost:4000/api/logs",
- *       channel: "my-app",
- *       secretKey: "optional-encryption-key",
- *     }),
- *   ],
- * });
- *
- * logger.info("Hello from Bunyan!");
- * ```
- */
-export class AbbacchioBunyanStream extends Writable {
-  private client: AbbacchioClient;
-  public level?: number | string;
-
-  constructor(opts: BunyanStreamOptions = {}) {
-    super({ objectMode: true });
-    this.client = new AbbacchioClient(opts);
-    this.level = opts.level;
-  }
-
-  /**
-   * Writable stream _write method - called for each log entry
-   */
-  _write(
-    chunk: Record<string, unknown>,
-    _encoding: BufferEncoding,
-    callback: (error?: Error | null) => void
-  ): void {
-    try {
-      // Transform Bunyan format to Abbacchio format
-      const log = this.transformLog(chunk);
-      this.client.add(log);
-      callback();
-    } catch (err) {
-      callback(err as Error);
-    }
-  }
-
-  /**
-   * Transform Bunyan log format to a normalized format
-   */
-  private transformLog(record: Record<string, unknown>): Record<string, unknown> {
-    const { name, hostname, pid, level, msg, time, v, ...rest } = record;
-
-    return {
-      level: level as number,
-      msg,
-      time: time ? new Date(time as string).getTime() : Date.now(),
-      name,
-      hostname,
-      pid,
-      ...rest,
-    };
-  }
-
-  /**
-   * Close the stream
-   */
-  _final(callback: (error?: Error | null) => void): void {
-    this.client.close().then(() => callback()).catch(callback);
-  }
-}
-
-/**
- * Factory function to create a Bunyan stream
- * Returns an object with stream and optional level for Bunyan's streams array
- */
-export function bunyanStream(opts?: BunyanStreamOptions): { stream: AbbacchioBunyanStream; level?: number | string; type: "raw" } {
-  const stream = new AbbacchioBunyanStream(opts);
-  return {
-    stream,
-    level: opts?.level,
-    type: "raw",
-  };
-}
-
-export default bunyanStream;
+import { Writable } from "stream";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface BunyanStreamOptions extends AbbacchioClientOptions {
+  /** Bunyan log level (optional) */
+  level?: number | string;
+}
+
+/**
+ * Bunyan stream for Abbacchio.
+ * Implements the Node.js Writable stream interface for Bunyan.
+ *
+ * @example
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { bunyanStream } from "@abbacchio/client/transports/bunyan";
+ *
+ * const logger = bunyan.createLogger({
+ *   name: "myapp",
+ *   streams: [
+ *     { stream: process.stdout },
+ *     bunyanStream({
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Hello from Bunyan!");
+ * ```
+ */
+export class AbbacchioBunyanStream extends Writable {
+  private client: AbbacchioClient;
+  public level?: number | string;
+
+  constructor(opts: BunyanStreamOptions = {}) {
+    super({ objectMode: true });
+    this.client = new AbbacchioClient(opts);
+    this.level = opts.level;
+  }
+
+  /**
+   * Writable stream _write method - called for each log entry
+   */
+  _write(
+    chunk: Record<string, unknown>,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null) => void
+  ): void {
+    try {
+      // Transform Bunyan format to Abbacchio format
+      const log = this.transformLog(chunk);
+      this.client.add(log);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
+  }
+
+  /**
+   * Transform Bunyan log format to a normalized format
+   */
+  private transformLog(record: Record<string, unknown>): Record<string, unknown> {
+    const { name, hostname, pid, level, msg, time, v, ...rest } = record;
+
+    return {
+      level: level as number,
+      msg,
+      time: time ? new Date(time as string).getTime() : Date.now(),
+      name,
+      hostname,
+      pid,
+      ...rest,
+    };
+  }
+
+  /**
+   * Close the stream
+   */
+  _final(callback: (error?: Error | null) => void): void {
+    this.client.close().then(() => callback()).catch(callback);
+  }
+}
+
+/**
+ * Factory function to create a Bunyan stream
+ * Returns an object with stream and optional level for Bunyan's streams array
+ */
+export function bunyanStream(opts?: BunyanStreamOptions): { stream: AbbacchioBunyanStream; level?: number | string; type: "raw" } {
+  const stream = new AbbacchioBunyanStream(opts);
+  return {
+    stream,
+    level: opts?.level,
+    type: "raw",
+  };
+}
+
+export default bunyanStream;