posthog-node 5.8.8 → 5.9.1

package/src/extensions/express.ts

@@ -0,0 +1,40 @@
+import type * as http from 'node:http'
+import { uuidv7 } from '@posthog/core'
+import ErrorTracking from './error-tracking'
+import { PostHogBackendClient } from '../client'
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core'
+
+type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void
+
+type ExpressErrorMiddleware = (
+  error: MiddlewareError,
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  next: (error: MiddlewareError) => void
+) => void
+
+interface MiddlewareError extends Error {
+  status?: number | string
+  statusCode?: number | string
+  status_code?: number | string
+  output?: {
+    statusCode?: number | string
+  }
+}
+
+export function setupExpressErrorHandler(
+  _posthog: PostHogBackendClient,
+  app: {
+    use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown
+  }
+): void {
+  app.use((error: MiddlewareError, _, __, next: (error: MiddlewareError) => void): void => {
+    const hint: CoreErrorTracking.EventHint = { mechanism: { type: 'middleware', handled: false } }
+    // Given stateless nature of Node SDK we capture exceptions using personless processing
+    // when no user can be determined e.g. in the case of exception autocapture
+    ErrorTracking.buildEventMessage(error, hint, uuidv7(), { $process_person_profile: false }).then((msg) =>
+      _posthog.capture(msg)
+    )
+    next(error)
+  })
+}

package/src/extensions/feature-flags/crypto-helpers.ts

@@ -0,0 +1,36 @@
+/// <reference lib="dom" />
+import { Lazy } from './lazy'
+
+const nodeCrypto = new Lazy(async () => {
+  try {
+    return await import('crypto')
+  } catch {
+    return undefined
+  }
+})
+
+export async function getNodeCrypto(): Promise<typeof import('crypto') | undefined> {
+  return await nodeCrypto.getValue()
+}
+
+const webCrypto = new Lazy(async (): Promise<SubtleCrypto | undefined> => {
+  if (typeof globalThis.crypto?.subtle !== 'undefined') {
+    return globalThis.crypto.subtle
+  }
+
+  try {
+    // Node.js: use built-in webcrypto and assign it if needed
+    const crypto = await nodeCrypto.getValue()
+    if (crypto?.webcrypto?.subtle) {
+      return crypto.webcrypto.subtle as SubtleCrypto
+    }
+  } catch {
+    // Ignore if not available
+  }
+
+  return undefined
+})
+
+export async function getWebCrypto(): Promise<SubtleCrypto | undefined> {
+  return await webCrypto.getValue()
+}

package/src/extensions/feature-flags/crypto.ts

@@ -0,0 +1,22 @@
+/// <reference lib="dom" />
+
+import { getNodeCrypto, getWebCrypto } from './crypto-helpers'
+
+export async function hashSHA1(text: string): Promise<string> {
+  // Try Node.js crypto first
+  const nodeCrypto = await getNodeCrypto()
+  if (nodeCrypto) {
+    return nodeCrypto.createHash('sha1').update(text).digest('hex')
+  }
+
+  const webCrypto = await getWebCrypto()
+
+  // Fall back to Web Crypto API
+  if (webCrypto) {
+    const hashBuffer = await webCrypto.digest('SHA-1', new TextEncoder().encode(text))
+    const hashArray = Array.from(new Uint8Array(hashBuffer))
+    return hashArray.map((byte) => byte.toString(16).padStart(2, '0')).join('')
+  }
+
+  throw new Error('No crypto implementation available. Tried Node Crypto API and Web SubtleCrypto API')
+}