@hypertestco/node-sdk-v3 0.0.1-8

package/instrumentation/libraries/sqlite3/mocks/sqlite3EachMock.d.ts

@@ -0,0 +1,41 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { type HT_AST } from '../../../helpers/sqlParser';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    queryText?: string;
+    values: string[] | number[];
+    fileName?: string;
+};
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: ReadableInput['values'];
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+};
+type RealOutput = {
+    rows: Record<string, Jsonable>[];
+    rowCount: number;
+};
+type OutputMeta = EmptyObject;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = Jsonable;
+export default class Sqlite3EachMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+}
+export {};

package/instrumentation/libraries/sqlite3/mocks/sqlite3MapMock.d.ts

@@ -0,0 +1,38 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { type HT_AST } from '../../../helpers/sqlParser';
+type ReadableInput = {
+    queryText: string;
+    fileName?: string;
+};
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    fileName?: string;
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+    fileName?: string;
+};
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class Sqlite3MapMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/sqlite3/mocks/sqlite3StatementMock.d.ts

@@ -0,0 +1,40 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import { type HT_AST } from '../../../helpers/sqlParser';
+type ReadableInput = {
+    queryText: string;
+    values: string[] | number[];
+    fileName?: string;
+};
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: string[] | number[];
+    fileName?: string;
+};
+type ProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+    fileName?: string;
+};
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class Sqlite3StatementMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/typeorm/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { RawQueryProcessedInput, RawQueryProcessedInputSchema, RawQueryReadableInput } from './internalTypes';
+export declare const generateRawQueryProcessedInput: (readableInput: RawQueryReadableInput) => RawQueryProcessedInput;
+export declare const generateRawQueryProcessedInputSchema: (readableInput: RawQueryReadableInput, processedInput: RawQueryProcessedInput) => RawQueryProcessedInputSchema;
+export declare const generateReadableInputFromProcessedInput: (processedInput: RawQueryProcessedInput) => RawQueryReadableInput;

package/instrumentation/libraries/typeorm/instrumentation.d.ts

@@ -0,0 +1,68 @@
+import type * as typeorm from 'typeorm';
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtTypeormInstrumentation extends HtInstrumentationBase {
+    _HTDataSourceOriginal: typeof typeorm.DataSource;
+    _HTConnectionOriginal: typeof typeorm.Connection;
+    constructor(options?: {
+        enabled: boolean;
+    });
+    protected init(): HtInstrumentationNodeModule<any>;
+    private patchAsyncFunction;
+    private _patchDataSourceInitializeFunction;
+    private _patchConnectionClassConnectFunction;
+    private _patchDataSourceCreateQueryRunner;
+    private _patchTransactionFns;
+    private _patchDataSourceVoidReturningFunction;
+    private _patchDataSourceShowMigration;
+    private _patchDataSourceRunMigration;
+    private _patchConnectionRunMigration;
+    /**
+     * Typeorm's Transaction patch only exists to prevent recording child mocks of underlying packages.
+     * e.g. mysql2, pg, etc. rawQuery - START TRANSACTION, COMMIT
+     *
+     * During replay it wont call the original function, it will just call the callback with the current entityManager
+     * to prevent queryRunner calls made from original function
+     */
+    private _getPatchedTransactionFn;
+    private _getPatchedRawQueryFn;
+    private _getEntityManagerFind;
+    private _getEntityManagerFindBy;
+    private _getEntityManagerFindAndCount;
+    private _getEntityManagerFindAndCountBy;
+    private _getEntityManagerFindByIds;
+    private _getEntityManagerFindOne;
+    private _getEntityManagerFindOneBy;
+    private _getEntityManagerFindOneById;
+    private _getEntityManagerFindOneOrFail;
+    private _getEntityManagerFindOneByOrFail;
+    private _updateEntityReferenceForProducingSideEffects;
+    private _getSaveAndRemoveFnReadbleInput;
+    private _patchEntityManagerSave;
+    private _patchEntityManagerRemove;
+    private _patchEntityManagerSoftRemove;
+    private _patchEntityManagerRecover;
+    private patchInsertUpsertWithEntitySideEffects;
+    private _patchEntityManagerInsert;
+    private _patchEntityManagerUpsert;
+    private _patchEntityManagerUpdate;
+    private _patchEntityManagerDelete;
+    private _patchEntityManagerSoftDelete;
+    private _patchEntityManagerRestore;
+    private _patchEntityManagerExists;
+    private _patchEntityManagerExistsBy;
+    private _patchEntityManagerCountBy;
+    private _patchEntityManagerCallAggregateFun;
+    private _patchEntityManagerClear;
+    private _patchEntityManagerIncrement;
+    private _patchEntityManagerDecrement;
+    private _patchEntityManagerRelease;
+    private _patchQueryRunnerRelease;
+    private _patchSelectQueryBuilderGetRawMany;
+    private _patchSelectQueryBuilderGetRawAndEntities;
+    private _patchSelectQueryBuilderGetCount;
+    private _patchSelectQueryBuilderGetExists;
+    private _patchSelectQueryBuilderGetManyAndCount;
+    private _patchQueryBuilderExecute;
+    private _patchSelectQueryBuilderStream;
+}

package/instrumentation/libraries/typeorm/internalTypes.d.ts

@@ -0,0 +1,71 @@
+import type * as typeorm from 'typeorm';
+import type { AnyFunction } from '../../../../../utils/types';
+import type { Jsonable } from '../../../../../utils/types/jsonableTypes';
+import type { HT_AST } from '../../helpers/sqlParser';
+import type { HtTypeormInstrumentation } from './instrumentation';
+export type AsyncPatchParams = {
+    plugin: HtTypeormInstrumentation;
+    submoduleName: string;
+    readableInput: RawQueryReadableInput | Record<string, unknown>;
+    originalFn: AnyFunction;
+    thisValue: Record<string, unknown>;
+    inputArgs: unknown[];
+    isQueryMock?: boolean;
+    nonCallbackFuncIndexes?: number[];
+    stopRecordingChildSpans?: boolean;
+    isImportant?: boolean;
+};
+export type QueryDeepPartialEntity<T> = _QueryDeepPartialEntity<typeorm.ObjectLiteral extends T ? unknown : T>;
+type _QueryDeepPartialEntity<T> = {
+    [P in keyof T]?: (T[P] extends Array<infer U> ? _QueryDeepPartialEntity<U>[] : T[P] extends ReadonlyArray<infer U> ? readonly _QueryDeepPartialEntity<U>[] : _QueryDeepPartialEntity<T[P]>) | (() => string);
+};
+export type UpsertType = 'on-conflict-do-update' | 'on-duplicate-key-update' | 'primary-key';
+export type InsertOrUpdateOptions = {
+    /**
+     * If true, postgres will skip the update if no values would be changed (reduces writes)
+     */
+    skipUpdateIfNoValuesChanged?: boolean;
+    /**
+     * If included, postgres will apply the index predicate to a conflict target (partial index)
+     */
+    indexPredicate?: string;
+    upsertType?: UpsertType;
+};
+export type UpsertOptions<Entity> = {
+    conflictPaths: string[] | {
+        [P in keyof Entity]?: true;
+    };
+    /**
+     * If true, postgres will skip the update if no values would be changed (reduces writes)
+     */
+    skipUpdateIfNoValuesChanged?: boolean;
+    /**
+     * Define the type of upsert to use (currently, CockroachDB only).
+     *
+     * If none provided, it will use the default for the database (first one in the list)
+     */
+    upsertType?: UpsertType;
+} & InsertOrUpdateOptions;
+export type PickKeysByType<T, U> = string & keyof {
+    [P in keyof T as T[P] extends U ? P : never]: T[P];
+};
+export type RawQueryReadableInput = {
+    sql: string;
+    parameters: unknown[];
+    dialect: string;
+};
+export type RawQueryProcessedInput = {
+    parsedSql: HT_AST | HT_AST[];
+    values: unknown[];
+    dialect?: string;
+    model?: string;
+};
+export type RawQueryProcessedInputSchema = {
+    parsedSqlSchema: HT_AST | HT_AST[];
+};
+export type RawQueryRealOutput = Jsonable;
+export type RawQueryReadableOutput = RawQueryRealOutput;
+export type RawQueryProcessedOutputSchema = {
+    consistentKeysAndTypesMap: Record<string, string>;
+};
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormEntityUpdateMock.d.ts

@@ -0,0 +1,46 @@
+import type { JsonSchema } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type AnyObject = Record<string, Jsonable>;
+type InputMeta = EmptyObject;
+export type ReadableInput = {
+    dialect: string;
+    tableName: string;
+    entityOrEntities: AnyObject | AnyObject[];
+    options?: AnyObject;
+};
+type ProcessedInputSchema = {
+    dialect: string;
+    tableName: string;
+    consistentEntityKeysAndTypesMap: Record<string, string>;
+    isEntityArray: boolean;
+};
+type ProcessedInput = Omit<ReadableInput, 'options' | 'entityOrEntities'> & {
+    entityOrEntities: JsonSchema;
+};
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    entityOrEntities: AnyObject | AnyObject[];
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = {
+    consistentEntityKeysAndTypesMap: Record<string, string>;
+};
+export default class TypeormEntityUpdateMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormGetManyAndCountMock.d.ts

@@ -0,0 +1,36 @@
+import type * as typeorm from 'typeorm';
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { RawQueryProcessedInput as ProcessedInput, RawQueryProcessedInputSchema as ProcessedInputSchema, RawQueryReadableInput as ReadableInput, RawQueryReadableOutput as ReadableOutput } from '../internalTypes';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    entities: typeorm.ObjectLiteral[];
+    count: number;
+};
+type ProcessedOutputSchema = {
+    entities: {
+        consistentEntityKeysAndTypesMap: Record<string, string>;
+    };
+};
+export default class TypeormGetManyAndCountMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+/**
+ * The readable input generated here would have different formatting for the SQL string than the original one.
+ * Always compare the two re-generated inputs from this function to get accurate results
+ */
+export declare const generateReadableInputFromTypeormGetManyAndCountMock: (processedInput: ProcessedInput) => ReadableInput;
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormGetRawAndEntitiesMock.d.ts

@@ -0,0 +1,39 @@
+import type * as typeorm from 'typeorm';
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { RawQueryProcessedInput as ProcessedInput, RawQueryProcessedInputSchema as ProcessedInputSchema, RawQueryReadableInput as ReadableInput, RawQueryReadableOutput as ReadableOutput } from '../internalTypes';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    entities: typeorm.ObjectLiteral[];
+    raw: unknown[];
+};
+type ProcessedOutputSchema = {
+    entities: {
+        consistentEntityKeysAndTypesMap: Record<string, string>;
+    };
+    raw: {
+        consistentEntityKeysAndTypesMap: Record<string, string>;
+    };
+};
+export default class TypeormGetRawAndEntitiesMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+/**
+ * The readable input generated here would have different formatting for the SQL string than the original one.
+ * Always compare the two re-generated inputs from this function to get accurate results
+ */
+export declare const generateReadableInputFromTypeormGetRawAndEntitiesMock: (processedInput: ProcessedInput) => ReadableInput;
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormInsertUpsertMock.d.ts

@@ -0,0 +1,52 @@
+import type * as typeorm from 'typeorm';
+import type { JsonSchema } from '../../../../../../utils/jsonSchemaDiffGenerator/jsonSchemaTypes';
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { UpsertOptions } from '../internalTypes';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+export type ReadableInput = {
+    dialect: string;
+    tableName: string;
+    entityOrEntities: typeorm.ObjectLiteral | typeorm.ObjectLiteral[];
+    conflictPathsOrOptions?: string[] | UpsertOptions<typeorm.ObjectLiteral>;
+};
+type ProcessedInputSchema = {
+    dialect: string;
+    tableName: string;
+    consistentEntityKeysAndTypesMap: Record<string, string>;
+    isEntityArray: boolean;
+};
+type ProcessedInput = Omit<ReadableInput, 'conflictPathsOrOptions' | 'entityOrEntities'> & {
+    entityOrEntities: JsonSchema;
+};
+type OutputMeta = EmptyObject;
+type RealOutput = {
+    returnValue: typeorm.InsertResult;
+    updatedEntityOrEntities: typeorm.ObjectLiteral | typeorm.ObjectLiteral[];
+};
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = {
+    identifiers: {
+        consistentEntityKeysAndTypesMap: Record<string, string>;
+    };
+    generatedMaps: {
+        consistentEntityKeysAndTypesMap: Record<string, string>;
+    };
+};
+export default class TypeormInsertUpsertMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormMock.d.ts

@@ -0,0 +1,28 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = Record<string, Jsonable>;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject;
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class TypeormMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormQueryBuilderStreamMock.d.ts

@@ -0,0 +1,30 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { RawQueryProcessedInput as ProcessedInput, RawQueryProcessedInputSchema as ProcessedInputSchema, RawQueryReadableInput as ReadableInput, RawQueryReadableOutput as ReadableOutput } from '../internalTypes';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type OutputMeta = EmptyObject;
+type RealOutput = unknown[];
+type ProcessedOutputSchema = {
+    consistentKeysAndTypesMap: Record<string, string>;
+};
+export default class TypeormQueryBuilderStreamMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+/**
+ * The readable input generated here would have different formatting for the SQL string than the original one.
+ * Always compare the two re-generated inputs from this function to get accurate results
+ */
+export declare const generateReadableInputFromTypeormQueryBuilderStreamMock: (processedInput: ProcessedInput) => ReadableInput;
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormRawQueryMock.d.ts

@@ -0,0 +1,26 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+import type { RawQueryProcessedInput as ProcessedInput, RawQueryProcessedInputSchema as ProcessedInputSchema, RawQueryProcessedOutputSchema as ProcessedOutputSchema, RawQueryReadableInput as ReadableInput, RawQueryReadableOutput as ReadableOutput, RawQueryRealOutput as RealOutput } from '../internalTypes';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type OutputMeta = EmptyObject;
+export default class TypeormRawQueryMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+/**
+ * The readable input generated here would have different formatting for the SQL string than the original one.
+ * Always compare the two re-generated inputs from this function to get accurate results
+ */
+export declare const generateReadableInputFromTypeormRawQueryMock: (processedInput: ProcessedInput) => ReadableInput;
+export {};

package/instrumentation/libraries/typeorm/mocks/TypeormRunMigrationMock.d.ts

@@ -0,0 +1,37 @@
+import type { Migration } from 'typeorm';
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject;
+type ReadableInput = {
+    dialect: string;
+    options?: {
+        transaction?: 'all' | 'none' | 'each';
+        fake?: boolean;
+    };
+};
+type ProcessedInput = Omit<ReadableInput, 'options'>;
+type ProcessedInputSchema = ProcessedInput;
+type OutputMeta = EmptyObject;
+type RealOutput = Migration[];
+type ReadableOutput = {
+    migrations: Migration[];
+};
+type ProcessedOutputSchema = {
+    consitentMigrationKeysAndTypes: Record<string, string>;
+};
+export default class TypeormRunMigrationMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, submoduleName, functionType, }: {
+        plugin: HtInstrumentationBase;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(realOutput: RealOutput): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/zookeeper/instrumentation.d.ts

@@ -0,0 +1,30 @@
+import { HtInstrumentationBase } from '../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationNodeModule } from '../../core/baseClasses/HtInstrumentationNodeModule';
+export declare class HtNodeZookeeperClientInstrumentation extends HtInstrumentationBase {
+    _HtNodeZookeeperClientProtocol: unknown;
+    _HtNodeZookeeperClientACL: unknown;
+    _HtNodeZookeeperClientId: unknown;
+    _HtNodeZookeeperClientException: unknown;
+    _HtNodeZookeeperClientState: unknown;
+    constructor(config?: {});
+    protected init(): HtInstrumentationNodeModule<any>[];
+    private getCreateClientPatch;
+    private getPatchedTransaction;
+    private getPatchedClientConnect;
+    private getPatchedClientClose;
+    private getPatchedClientExists;
+    private getPatchedClientCreate;
+    private getPatchedGetData;
+    private getPatchedSetData;
+    private getPatchedGetState;
+    private getPatchedGetChildren;
+    private getPatchedListSubTreeBFS;
+    private getPatchedGetACL;
+    private getPatchedSetACL;
+    private getPatchedMkdirp;
+    private getPatchedAddAuthInfo;
+    private getPatchedGetSessionIdOrPwd;
+    private getPatchedGetSessionTimeout;
+    private getPatchedRemove;
+    private getPatchedTransactionCommit;
+}

package/instrumentation/libraries/zookeeper/mocks/NodeZookeeperClientMock.d.ts

@@ -0,0 +1,35 @@
+import { type FunctionTypeEnum } from '../../../../../../utils/types';
+import type { Jsonable } from '../../../../../../utils/types/jsonableTypes';
+import type { HtInstrumentationBase } from '../../../core/baseClasses/HtInstrumentationBase';
+import { HtInstrumentationMockAbstract } from '../../../core/baseClasses/HtInstrumentationMockAbstract';
+type EmptyObject = Record<string, never>;
+type InputMeta = EmptyObject | {
+    valueString: string | null;
+    valueStringEncoding: string;
+};
+type ReadableInput = Record<string, Jsonable>;
+type ProcessedInput = ReadableInput;
+type ProcessedInputSchema = ReadableInput;
+type OutputMeta = EmptyObject | {
+    valueString: string | null;
+    valueStringEncoding: string;
+};
+type RealOutput = Jsonable;
+type ReadableOutput = RealOutput;
+type ProcessedOutputSchema = RealOutput;
+export default class NodeZookeeperClientMock extends HtInstrumentationMockAbstract<InputMeta, ReadableInput, ProcessedInput, ProcessedInputSchema, OutputMeta, RealOutput, ReadableOutput, ProcessedOutputSchema> {
+    static mockSymbol: symbol;
+    static get mockVersion(): number;
+    constructor({ plugin, packageName, submoduleName, functionType, isImportantMock, }: {
+        plugin: HtInstrumentationBase;
+        packageName: string;
+        submoduleName: string;
+        functionType: FunctionTypeEnum;
+        isImportantMock: boolean;
+    });
+    generateProcessedInput(): ProcessedInput;
+    generateProcessedInputSchema(): ProcessedInputSchema;
+    generateReadableOutput(realOutput: RealOutput): ReadableOutput;
+    generateProcessedOutputSchema(): ProcessedOutputSchema;
+}
+export {};

package/instrumentation/libraries/zookeeper/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const getBufferParsedParams: (inputValueBuffer: Buffer | null, isPwdorId?: boolean) => {
+    jsonValue: Record<string, unknown>;
+    valueString: string;
+    valueStringEncoding: string;
+} | {
+    jsonValue: string;
+    valueString: string;
+    valueStringEncoding: string;
+};