@hypertestco/node-sdk-v3 0.0.1-8

package/Date/DateMock.d.ts

@@ -0,0 +1,27 @@
+import type { Tracer } from '@opentelemetry/api';
+import { HtInstrumentationMockAbstract } from '../instrumentation/core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = EmptyObject;
+type ProcessedInput = EmptyObject;
+type ProcessedInputSchema = EmptyObject;
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    dateIsoString: string;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = {
+    dateIsoString: 'dateIsoString';
+};
+export declare class DateMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ tracer, }: {
+        tracer: Tracer;
+    });
+    generateProcessedInput(): {};
+    generateProcessedInputSchema(): {};
+    generateReadableOutput(realOutput: RealOutput): RealOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export {};

package/Date/HtDate.d.ts

@@ -0,0 +1,3 @@
+import type { TracerProvider } from '@opentelemetry/api';
+export declare const setDateMockTracer: (tracerProvider: TracerProvider) => void;
+export declare const HtDate: DateConstructor;

package/helpers/appCrashHandlers.d.ts

@@ -0,0 +1 @@
+export declare function registerAppCrashHandlers(): void;

package/helpers/backendClient.d.ts

@@ -0,0 +1,22 @@
+declare const createBackendClient: ({ backendBaseUrl, htExtraHeaders, }: {
+    backendBaseUrl: string;
+    htExtraHeaders?: Record<string, string>;
+}) => void;
+type SetContinuousCoverageParams = {
+    serviceIdentifier: string;
+    buildId: string;
+    instanceJobId: string;
+    commitHash?: string;
+    coverage: Record<string, {
+        covered: number;
+        total: number;
+        lineNumbers: string[];
+    }>;
+};
+declare const httpRequests: {
+    IS_CONTINUOUS_COVERAGE_ACTIVE({ serviceIdentifier, }: {
+        serviceIdentifier: string;
+    }): Promise<import("axios").AxiosResponse<any, any>>;
+    SET_CONTINUOUS_COVERAGE({ serviceIdentifier, buildId, instanceJobId, commitHash, coverage, }: SetContinuousCoverageParams): Promise<import("axios").AxiosResponse<any, any>>;
+};
+export { createBackendClient, httpRequests };

package/helpers/cliClient.d.ts

@@ -0,0 +1,21 @@
+import type { AxiosResponse } from 'axios';
+import type { AppErrorObj } from '../../../ht-cli/src/server';
+export declare function createCliClient({ HT_CLI_SERVER_HOST, HT_CLI_SERVER_PORT, }: {
+    HT_CLI_SERVER_HOST: string;
+    HT_CLI_SERVER_PORT: number;
+}): void;
+export type CliRequestResult<RequestBodyType, ResponseBodyType, CustomError> = {
+    err: null;
+    response: AxiosResponse<ResponseBodyType, RequestBodyType>;
+} | {
+    err: CustomError;
+    response: null;
+};
+export declare const cliClient: {
+    SEND_UNCAUGHT_ERROR({ requestId, errorObj, }: {
+        requestId: string;
+        errorObj: AppErrorObj;
+    }): Promise<CliRequestResult<{
+        errorObj: typeof errorObj;
+    }, undefined, Error>>;
+};

package/helpers/coverageProxy.d.ts

@@ -0,0 +1 @@
+export declare function applyCoverageProxy(): void;

package/helpers/discardRequest.d.ts

@@ -0,0 +1,2 @@
+export declare const discardRequest: () => void;
+export declare const isRequestDiscarded: (htRequestId: string) => boolean;

package/helpers/generateMockMapForMemoryStore.d.ts

@@ -0,0 +1,4 @@
+import { type HtMockMemoryMap } from '../../../utils/types';
+import type { MockPayload } from '../server/zodSchemaAndTypes';
+declare const generateMockMapForMemoryStore: (mockArr: MockPayload[]) => HtMockMemoryMap;
+export default generateMockMapForMemoryStore;

package/helpers/getRequestAttributes.d.ts

@@ -0,0 +1,6 @@
+import type { ClientRequest, IncomingMessage } from 'http';
+export declare const getRequestAttributes: (req: IncomingMessage | ClientRequest) => {
+    path: any;
+    query: any;
+    host: any;
+};

package/helpers/getRootMocks.d.ts

@@ -0,0 +1,6 @@
+declare const getRootMocks: ({ serviceId, HT_CLI_SERVER_HOST, HT_CLI_SERVER_PORT, }: {
+    serviceId: string;
+    HT_CLI_SERVER_HOST: string;
+    HT_CLI_SERVER_PORT: number;
+}) => void;
+export default getRootMocks;

package/helpers/htConfigHelper.d.ts

@@ -0,0 +1,25 @@
+import { HT_MODES } from '../../../utils/types';
+import type { HtInstrumentations } from '../instrumentation/core/types/HtInstrumentationEnums';
+type HtConfig = {
+    htMode: HT_MODES;
+    apiKey: string;
+    serviceId: string;
+    filterDuplicateMocksInInstrumentations: HtInstrumentations[];
+    config: {
+        discardReqsOnNodeSqlParserError: boolean;
+        enableHtNodeCacheInstrumentation: boolean;
+    };
+    /**
+     * Config for proper context propagation for frameworks like sailsjs.
+     * For sails If we don't use otel api's ROOT_CONTEXT and use context.active()
+     * then the incoming request spans become child of some root context span of some other library e.g., mysql, pg.
+     *
+     * In case of sailsjs when creating server span context.active() !== ROOT_CONTEXT
+     *
+     * WARNING!!: Using this option will mess up otels own spans and context propagation
+     */
+    useRootContextForServerMocks?: boolean;
+};
+export declare const getConfig: () => HtConfig;
+export declare const setConfig: (config: HtConfig) => void;
+export {};

package/helpers/htTraceExporter.d.ts

@@ -0,0 +1,2 @@
+import type { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+export declare function getHtTraceExporter(ExporterClass: typeof OTLPTraceExporter, loggerUrl?: string): typeof OTLPTraceExporter;

package/helpers/inMemorySpanExporter.d.ts

@@ -0,0 +1,3 @@
+import type { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base';
+export declare const setInMemorySpanExporter: (_inMemorySpanExporter: InMemorySpanExporter) => void;
+export declare const getInMemorySpanExporter: () => InMemorySpanExporter | undefined;

package/helpers/isContinuousCoverageActive.d.ts

@@ -0,0 +1 @@
+export declare const isContinuousCoverageActive: (backendBaseUrl: string, serviceIdentifier: string) => Promise<boolean>;

package/helpers/isValidUuidV4.d.ts

@@ -0,0 +1 @@
+export declare function isValidUuidV4(uuid: string): boolean;

package/helpers/killAppUnderTest.d.ts

@@ -0,0 +1 @@
+export declare const killAppAfterTimeout: (timeoutInMinutes: number) => void;

package/helpers/markAppAsReady.d.ts

@@ -0,0 +1 @@
+export declare function markAppAsReady(): void;

package/helpers/pingOtelCollector.d.ts

@@ -0,0 +1,7 @@
+interface CollectorStatus {
+    accessible: boolean;
+    latency?: number;
+    error?: string;
+}
+export declare function pingOtelCollector(collectorUrl: string, timeoutMs?: number): Promise<CollectorStatus>;
+export {};

package/helpers/posthog.d.ts

@@ -0,0 +1,2 @@
+import { PostHog } from 'posthog-node';
+export declare function getPostHogClient(): PostHog;

package/helpers/removeUnicodeFromReplayResult.d.ts

@@ -0,0 +1,7 @@
+import type { AmqpRequestReplayResult, AmqpRequestReplayResultV2, GRPCRequestReplayResult, GRPCRequestReplayResultV2, GraphqlRequestReplayResult, GraphqlRequestReplayResultV2, HTTPRequestReplayResult, HTTPRequestReplayResultV2, KafkaRequestReplayResult, KafkaRequestReplayResultV2, ManualRequestReplayResult, ManualRequestReplayResultV2, ReplayMockSchemaMap } from '../../../utils/types';
+export declare function removeUnicodeFromReplayResultHelper(value: unknown): unknown;
+type ReplayResult = HTTPRequestReplayResult | GRPCRequestReplayResult | KafkaRequestReplayResult | AmqpRequestReplayResult | ManualRequestReplayResult | GraphqlRequestReplayResult;
+type ReplayResultV2 = HTTPRequestReplayResultV2 | GRPCRequestReplayResultV2 | KafkaRequestReplayResultV2 | AmqpRequestReplayResultV2 | ManualRequestReplayResultV2 | GraphqlRequestReplayResultV2;
+export declare function removeInvalidUnicodeFromReplayResult<T extends ReplayResult | ReplayResultV2>(replayResult: T): T;
+export declare function removeInvalidUnicodeFromRootReplayMock(rootReplayMockObj: ReplayMockSchemaMap): ReplayMockSchemaMap;
+export {};

package/helpers/requestFilter.d.ts

@@ -0,0 +1,3 @@
+import type { HttpReqType } from '../../../utils/types';
+export declare const blockedUserAgents: RegExp;
+export declare const shouldFilterRequest: (httpReqObj: Omit<HttpReqType, "bodyType" | "bodyValue">) => boolean;

package/helpers/syncWaitPort.d.ts

@@ -0,0 +1,6 @@
+type SyncWaitPortRes = {
+    open: boolean;
+    err: string | null;
+};
+declare function syncWaitPort(host: string, port: number): SyncWaitPortRes;
+export default syncWaitPort;

package/helpers/synchronousHttpCall.d.ts

@@ -0,0 +1,15 @@
+type RequestOptions = {
+    url: string;
+    headers?: Record<string, string>;
+    method: string;
+    data?: string | Record<string, unknown>;
+    query?: Record<string, string>;
+    bufferSizeMb?: number;
+};
+type Response = {
+    data: unknown;
+    status: number;
+    headers: unknown;
+};
+export declare function makeSyncHttpRequest({ url, headers, method, data, query, bufferSizeMb, }: RequestOptions): Response;
+export {};

package/helpers/transformDbObjToReadableInputHelpers.d.ts

@@ -0,0 +1,15 @@
+import type { HttpMeta, HttpReqType, HttpRequestInputAndMeta, KafkaReqTypeMinimal } from '../../../utils/types';
+import type { UserMeta as HttpUserMeta } from '../instrumentation/libraries/http/mocks/HttpServerRequestMock';
+import type { InputMeta as KafkaConsumerInputMeta, ReadableInput as KafkaConsumerReadableInput, UserMeta as KafkaUserMeta } from '../instrumentation/libraries/kafka/mocks/KafkaServerMock';
+export declare function createHttpReadableInputAndMeta(request: HttpRequestInputAndMeta): {
+    readableInput: HttpReqType;
+    inputMeta: HttpMeta;
+    userMeta: HttpUserMeta;
+};
+export declare function createHttpDbRowObj(readableInputAndMeta: ReturnType<typeof createHttpReadableInputAndMeta>): HttpRequestInputAndMeta;
+export declare function createKafkaReadableInputAndMeta(request: KafkaReqTypeMinimal): {
+    readableInput: KafkaConsumerReadableInput;
+    inputMeta: KafkaConsumerInputMeta;
+    userMeta: KafkaUserMeta;
+};
+export declare function createKafkaDbRowObj(readableInputAndMeta: ReturnType<typeof createKafkaReadableInputAndMeta>): KafkaReqTypeMinimal;

package/hooks/index.d.ts

@@ -0,0 +1,140 @@
+import type { InputMeta as HttpServerInputMeta, OutputMeta as HttpServerOutputMeta, ReadableInput as HttpServerReadableInput, RealOutput as HttpServerRealOutput, UserMeta as HttpUserMeta } from '../instrumentation/libraries/http/mocks/HttpServerRequestMock';
+import type { InputMeta as KafkaConsumerInputMeta, ReadableInput as KafkaConsumerReadableInput, UserMeta as KafkaUserMeta } from '../instrumentation/libraries/kafka/mocks/KafkaServerMock';
+export declare const hooksMap: {
+    kafkaConsumer: {
+        input: {
+            beforeRecord?: ({ readableInput, inputMeta, userMeta, }: {
+                readableInput: KafkaConsumerReadableInput;
+                inputMeta: KafkaConsumerInputMeta;
+                userMeta: KafkaUserMeta;
+            }) => {
+                readableInput: KafkaConsumerReadableInput;
+                inputMeta: KafkaConsumerInputMeta;
+                userMeta: KafkaUserMeta;
+            };
+            beforeReplay?: ({ readableInput, inputMeta, userMeta, }: {
+                readableInput: KafkaConsumerReadableInput;
+                inputMeta: KafkaConsumerInputMeta;
+                userMeta: KafkaUserMeta;
+            }) => {
+                readableInput: KafkaConsumerReadableInput;
+                inputMeta: KafkaConsumerInputMeta;
+                userMeta: KafkaUserMeta;
+            };
+        };
+    };
+    httpServer: {
+        request: {
+            beforeRecord?: ({ readableInput, inputMeta, userMeta, }: {
+                readableInput: HttpServerReadableInput;
+                inputMeta: HttpServerInputMeta;
+                userMeta: HttpUserMeta;
+            }) => {
+                readableInput: HttpServerReadableInput;
+                inputMeta: HttpServerInputMeta;
+                userMeta: HttpUserMeta;
+            };
+            beforeReplay?: ({ readableInput, inputMeta, userMeta, }: {
+                readableInput: HttpServerReadableInput;
+                inputMeta: HttpServerInputMeta;
+                userMeta: HttpUserMeta;
+            }) => {
+                readableInput: HttpServerReadableInput;
+                inputMeta: HttpServerInputMeta;
+                userMeta: HttpUserMeta;
+            };
+        };
+        response: {
+            beforeRecord?: ({ realOutput, outputMeta, userMeta, }: {
+                realOutput: HttpServerRealOutput;
+                outputMeta: HttpServerOutputMeta;
+                userMeta: HttpUserMeta;
+            }) => {
+                realOutput: HttpServerRealOutput;
+                outputMeta: HttpServerOutputMeta;
+                userMeta: HttpUserMeta;
+            };
+            beforeReplay?: ({ realOutput, outputMeta, userMeta, }: {
+                realOutput: HttpServerRealOutput;
+                outputMeta: HttpServerOutputMeta;
+                userMeta: HttpUserMeta;
+            }) => {
+                realOutput: HttpServerRealOutput;
+                outputMeta: HttpServerOutputMeta;
+                userMeta: HttpUserMeta;
+            };
+        };
+    };
+};
+export declare const hooks: {
+    kafkaConsumer: {
+        input: {
+            v1: ({ beforeRecord, beforeReplay, }: {
+                beforeRecord?: ({ readableInput, inputMeta, userMeta, }: {
+                    readableInput: KafkaConsumerReadableInput;
+                    inputMeta: KafkaConsumerInputMeta;
+                    userMeta: KafkaUserMeta;
+                }) => {
+                    readableInput: KafkaConsumerReadableInput;
+                    inputMeta: KafkaConsumerInputMeta;
+                    userMeta: KafkaUserMeta;
+                };
+                beforeReplay?: ({ readableInput, inputMeta, userMeta, }: {
+                    readableInput: KafkaConsumerReadableInput;
+                    inputMeta: KafkaConsumerInputMeta;
+                    userMeta: KafkaUserMeta;
+                }) => {
+                    readableInput: KafkaConsumerReadableInput;
+                    inputMeta: KafkaConsumerInputMeta;
+                    userMeta: KafkaUserMeta;
+                };
+            }) => void;
+        };
+    };
+    httpServer: {
+        request: {
+            v1: ({ beforeRecord, beforeReplay, }: {
+                beforeRecord?: ({ readableInput, inputMeta, userMeta, }: {
+                    readableInput: HttpServerReadableInput;
+                    inputMeta: HttpServerInputMeta;
+                    userMeta: HttpUserMeta;
+                }) => {
+                    readableInput: HttpServerReadableInput;
+                    inputMeta: HttpServerInputMeta;
+                    userMeta: HttpUserMeta;
+                };
+                beforeReplay?: ({ readableInput, inputMeta, userMeta, }: {
+                    readableInput: HttpServerReadableInput;
+                    inputMeta: HttpServerInputMeta;
+                    userMeta: HttpUserMeta;
+                }) => {
+                    readableInput: HttpServerReadableInput;
+                    inputMeta: HttpServerInputMeta;
+                    userMeta: HttpUserMeta;
+                };
+            }) => void;
+        };
+        response: {
+            v1: ({ beforeRecord, beforeReplay, }: {
+                beforeRecord?: ({ realOutput, outputMeta, userMeta, }: {
+                    realOutput: HttpServerRealOutput;
+                    outputMeta: HttpServerOutputMeta;
+                    userMeta: HttpUserMeta;
+                }) => {
+                    realOutput: HttpServerRealOutput;
+                    outputMeta: HttpServerOutputMeta;
+                    userMeta: HttpUserMeta;
+                };
+                beforeReplay?: ({ realOutput, outputMeta, userMeta, }: {
+                    realOutput: HttpServerRealOutput;
+                    outputMeta: HttpServerOutputMeta;
+                    userMeta: HttpUserMeta;
+                }) => {
+                    realOutput: HttpServerRealOutput;
+                    outputMeta: HttpServerOutputMeta;
+                    userMeta: HttpUserMeta;
+                };
+            }) => void;
+        };
+    };
+};

package/hooks.mjs

@@ -0,0 +1,3 @@
+import { getFormat, getSource, load, resolve } from './index.mjs';
+
+export { getFormat, getSource, load, resolve };

package/htKvStore/env-proxy.d.ts

@@ -0,0 +1 @@
+export declare function setImportantEnvVariables(envVars?: string[]): void;

package/htKvStore/index.d.ts

@@ -0,0 +1,6 @@
+import type { Tracer, TracerProvider } from '@opentelemetry/api';
+export declare function setKvTracerProvider(tracerProvider: TracerProvider): void;
+export declare function getKvTracerProvider(): Tracer;
+export declare function set(identifier: string, value: unknown): void;
+export declare function get(identifier: string): unknown;
+export declare function delete1(identifier: string): void;

package/htKvStore/kvMock.d.ts

@@ -0,0 +1,32 @@
+import { type Tracer } from '@opentelemetry/api';
+import type { JsonSchemaWithoutValues } from '../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import type { Jsonable } from '../../../utils/types/jsonableTypes';
+import { HtInstrumentationMockAbstract } from '../instrumentation/core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    key: string;
+};
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    value: Jsonable;
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = JsonSchemaWithoutValues;
+export declare class KVMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ tracer, submoduleName, isImportantMock, }: {
+        tracer: Tracer;
+        submoduleName?: string;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ReadableInput;
+    generateProcessedInputSchema(): ReadableInput;
+    generateReadableOutput(realOutput: RealOutput): RealOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    save(): void;
+}
+export {};