posthog-node 4.17.0 → 4.17.1

package/src/extensions/error-tracking/types.ts

@@ -1,69 +0,0 @@
-// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-// Licensed under the MIT License
-
-// levels originally copied from Sentry to work with the sentry integration
-// and to avoid relying on a frequently changing @sentry/types dependency
-// but provided as an array of literal types, so we can constrain the level below
-export const severityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'] as const
-export declare type SeverityLevel = (typeof severityLevels)[number]
-
-export interface PolymorphicEvent {
-  [key: string]: unknown
-  readonly type: string
-  readonly target?: unknown
-  readonly currentTarget?: unknown
-}
-
-export interface EventHint {
-  mechanism?: Partial<Mechanism>
-  syntheticException?: Error | null
-}
-
-export interface ErrorProperties {
-  $exception_list: Exception[]
-  $exception_level?: SeverityLevel
-  $exception_DOMException_code?: string
-  $exception_personURL?: string
-}
-
-export interface Exception {
-  type?: string
-  value?: string
-  mechanism?: Mechanism
-  module?: string
-  thread_id?: number
-  stacktrace?: { frames?: StackFrame[]; type: 'raw' }
-}
-
-export interface Mechanism {
-  handled?: boolean
-  type?: string
-  source?: string
-  synthetic?: boolean
-}
-
-export type GetModuleFn = (filename: string | undefined) => string | undefined
-
-export type StackParser = (stack: string, skipFirstLines?: number) => StackFrame[]
-export type StackLineParserFn = (line: string) => StackFrame | undefined
-export type StackLineParser = [number, StackLineParserFn]
-
-export type StackFrameModifierFn = (frames: StackFrame[]) => Promise<StackFrame[]>
-
-export interface StackFrame {
-  platform: string
-  filename?: string
-  function?: string
-  module?: string
-  lineno?: number
-  colno?: number
-  abs_path?: string
-  context_line?: string
-  pre_context?: string[]
-  post_context?: string[]
-  in_app?: boolean
-  instruction_addr?: string
-  addr_mode?: string
-  vars?: { [key: string]: any }
-  debug_id?: string
-}

package/src/extensions/express.ts

@@ -1,37 +0,0 @@
-import type * as http from 'node:http'
-import { uuidv7 } from 'posthog-core/src/vendor/uuidv7'
-import ErrorTracking from './error-tracking'
-import { PostHogBackendClient } from '../client'
-
-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 = { 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.captureException(_posthog, error, hint, uuidv7(), { $process_person_profile: false })
-    next(error)
-  })
-}

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

@@ -1,36 +0,0 @@
-/// <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

@@ -1,22 +0,0 @@
-/// <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')
-}