@nsshunt/ststestrunner 1.1.6 → 1.1.8

package/dist/ststestrunner.mjs

@@ -7,6 +7,7 @@ import http from "node:http";
 import https from "node:https";
 import { randomUUID } from "node:crypto";
 import { parentPort } from "node:worker_threads";
+import { createClient } from "redis";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -482,6 +483,38 @@ var TestCaseFhirBase = class {
 		this.#accesssToken = retVal;
 		return retVal;
 	};
+	GetPersonRecord_ZZ = async (prefix, index, version) => {
+		const { workerIndex, runnerIndex, runId } = this.#options;
+		const useId = `${prefix}-${index}`;
+		let firstName;
+		let lastName;
+		if (this.#options.useRedisForNames === true) {
+			const loaded = await (await this.runnerExecutionWorker.GetStore()).getRecord(runId, `${workerIndex}_${runnerIndex}_${this.runner.iteration}`);
+			firstName = loaded.givenName;
+			lastName = loaded.familyName;
+		} else {
+			const name = this.runnerExecutionWorker.GetFakerName(this.runner.iteration);
+			firstName = name.firstName;
+			lastName = name.lastName;
+		}
+		return {
+			id: useId,
+			resourceType: "Person",
+			name: [{
+				family: lastName,
+				given: [firstName],
+				use: `usual`
+			}],
+			text: {
+				div: `New Record ${this.runner.iteration}`,
+				status: "generated"
+			},
+			meta: {
+				versionId: version,
+				lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		};
+	};
 	GetPersonRecord = async (prefix, index, version) => {
 		const useId = `${prefix}-${index}`;
 		let name;
@@ -35405,14 +35438,245 @@ var TestShutDown = class {
 	};
 };
 //#endregion
+//#region src/redisTestRunStore.ts
+var RedisTestRunStore = class {
+	client;
+	keyPrefix;
+	defaultTtlSeconds;
+	batchSize;
+	maxDeleteBatchSize;
+	connected = false;
+	constructor(options) {
+		this.options = options;
+		this.keyPrefix = options.keyPrefix ?? "testrun";
+		this.defaultTtlSeconds = options.defaultTtlSeconds ?? 3600;
+		this.batchSize = options.batchSize ?? 1e3;
+		this.maxDeleteBatchSize = options.maxDeleteBatchSize ?? 1e3;
+		this.client = createClient({ url: options.redisUrl });
+		this.client.on("error", (err) => {
+			console.error("[RedisTestRunStore] Redis error:", err);
+		});
+	}
+	async connect() {
+		if (this.connected) return;
+		await this.client.connect();
+		this.connected = true;
+	}
+	async disconnect() {
+		if (!this.connected) return;
+		await this.client.quit();
+		this.connected = false;
+	}
+	async ping() {
+		await this.ensureConnected();
+		return this.client.ping();
+	}
+	createRunId(prefix = "run") {
+		return `${prefix}_${Date.now()}_${randomUUID()}`;
+	}
+	async seedRun(runId, records, options) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		if (!Array.isArray(records)) throw new Error("records must be an array");
+		const ttlSeconds = options?.ttlSeconds ?? this.defaultTtlSeconds;
+		const batchSize = options?.batchSize ?? this.batchSize;
+		const storeMetadata = options?.storeMetadata ?? true;
+		if (records.length === 0) {
+			if (storeMetadata) await this.writeRunMetadata(runId, {
+				runId,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				recordCount: 0,
+				ttlSeconds
+			}, ttlSeconds);
+			return;
+		}
+		for (const record of records) this.validateRecord(record);
+		const trackingKey = this.getTrackingKey(runId);
+		const recordChunks = this.chunk(records, batchSize);
+		for (const chunk of recordChunks) {
+			const multi = this.client.multi();
+			for (const record of chunk) {
+				const recordKey = this.getRecordKey(runId, record.id);
+				const flatHash = this.toRedisHash(record);
+				multi.hSet(recordKey, flatHash);
+				multi.sAdd(trackingKey, recordKey);
+				multi.expire(recordKey, ttlSeconds);
+			}
+			multi.expire(trackingKey, ttlSeconds);
+			await multi.exec();
+		}
+		if (storeMetadata) await this.writeRunMetadata(runId, {
+			runId,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			recordCount: records.length,
+			ttlSeconds
+		}, ttlSeconds);
+	}
+	async getRecord(runId, recordId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		this.validateRecordId(recordId);
+		const recordKey = this.getRecordKey(runId, recordId);
+		const data = await this.client.hGetAll(recordKey);
+		return Object.keys(data).length === 0 ? null : data;
+	}
+	async hasRecord(runId, recordId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		this.validateRecordId(recordId);
+		const recordKey = this.getRecordKey(runId, recordId);
+		return await this.client.exists(recordKey) === 1;
+	}
+	async deleteRecord(runId, recordId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		this.validateRecordId(recordId);
+		const recordKey = this.getRecordKey(runId, recordId);
+		const trackingKey = this.getTrackingKey(runId);
+		const multi = this.client.multi();
+		multi.del(recordKey);
+		multi.sRem(trackingKey, recordKey);
+		const delResult = (await multi.exec())?.[0];
+		return Number(delResult) > 0;
+	}
+	async countRunRecords(runId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		const trackingKey = this.getTrackingKey(runId);
+		return this.client.sCard(trackingKey);
+	}
+	async getRunMetadata(runId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		const metadataKey = this.getMetadataKey(runId);
+		const data = await this.client.hGetAll(metadataKey);
+		return Object.keys(data).length === 0 ? null : data;
+	}
+	async cleanupRun(runId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		const trackingKey = this.getTrackingKey(runId);
+		const metadataKey = this.getMetadataKey(runId);
+		const recordKeys = await this.client.sMembers(trackingKey);
+		let deletedRecordKeys = 0;
+		for (const chunk of this.chunk(recordKeys, this.maxDeleteBatchSize)) {
+			if (chunk.length === 0) continue;
+			deletedRecordKeys += await this.client.del(chunk);
+		}
+		const deletedTrackingKey = await this.client.del(trackingKey) > 0;
+		const deletedMetadataKey = await this.client.del(metadataKey) > 0;
+		return {
+			runId,
+			deletedRecordKeys,
+			deletedTrackingKey,
+			deletedMetadataKey
+		};
+	}
+	async extendRunTtl(runId, ttlSeconds) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		const trackingKey = this.getTrackingKey(runId);
+		const metadataKey = this.getMetadataKey(runId);
+		const recordKeys = await this.client.sMembers(trackingKey);
+		for (const chunk of this.chunk(recordKeys, this.batchSize)) {
+			const multi = this.client.multi();
+			for (const key of chunk) multi.expire(key, ttlSeconds);
+			await multi.exec();
+		}
+		await this.client.expire(trackingKey, ttlSeconds);
+		await this.client.expire(metadataKey, ttlSeconds);
+	}
+	async listRunRecordKeys(runId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		return this.client.sMembers(this.getTrackingKey(runId));
+	}
+	async getRunTtl(runId) {
+		await this.ensureConnected();
+		this.validateRunId(runId);
+		const trackingKey = this.getTrackingKey(runId);
+		const metadataKey = this.getMetadataKey(runId);
+		const [trackingKeyTtl, metadataKeyTtl] = await Promise.all([this.client.ttl(trackingKey), this.client.ttl(metadataKey)]);
+		return {
+			trackingKeyTtl,
+			metadataKeyTtl
+		};
+	}
+	async writeRunMetadata(runId, metadata, ttlSeconds) {
+		const metadataKey = this.getMetadataKey(runId);
+		const multi = this.client.multi();
+		multi.hSet(metadataKey, {
+			runId: metadata.runId,
+			createdAt: metadata.createdAt,
+			recordCount: String(metadata.recordCount),
+			ttlSeconds: String(metadata.ttlSeconds)
+		});
+		multi.expire(metadataKey, ttlSeconds);
+		await multi.exec();
+	}
+	getRecordKey(runId, recordId) {
+		return `${this.keyPrefix}:${runId}:record:${recordId}`;
+	}
+	getTrackingKey(runId) {
+		return `${this.keyPrefix}:${runId}:keys`;
+	}
+	getMetadataKey(runId) {
+		return `${this.keyPrefix}:${runId}:meta`;
+	}
+	toRedisHash(record) {
+		const out = {};
+		for (const [key, value] of Object.entries(record)) {
+			if (value === void 0) continue;
+			out[key] = String(value);
+		}
+		return out;
+	}
+	chunk(items, size) {
+		if (size <= 0) throw new Error("Chunk size must be > 0");
+		const result = [];
+		for (let i = 0; i < items.length; i += size) result.push(items.slice(i, i + size));
+		return result;
+	}
+	validateRunId(runId) {
+		if (!runId || typeof runId !== "string") throw new Error("runId must be a non-empty string");
+	}
+	validateRecordId(recordId) {
+		if (!recordId || typeof recordId !== "string") throw new Error("recordId must be a non-empty string");
+	}
+	validateRecord(record) {
+		if (!record || typeof record !== "object") throw new Error("record must be an object");
+		if (!record.id || typeof record.id !== "string") throw new Error("record.id must be a non-empty string");
+		if (typeof record.givenName !== "string") throw new Error(`record ${record.id}: givenName must be a string`);
+		if (typeof record.familyName !== "string") throw new Error(`record ${record.id}: familyName must be a string`);
+		if (typeof record.worker !== "number") throw new Error(`record ${record.id}: worker must be a number`);
+		if (typeof record.runner !== "number") throw new Error(`record ${record.id}: runner must be a number`);
+		if (typeof record.iteration !== "number") throw new Error(`record ${record.id}: iteration must be a number`);
+	}
+	async ensureConnected() {
+		if (!this.connected) await this.connect();
+	}
+};
+//#endregion
 //#region src/workerTestCases.ts
 var WorkerTestCases = class extends AbstractRunnerExecutionWorker {
 	#port;
 	#randomNameList = {};
+	_store;
 	constructor() {
 		super();
 		f.seed(123);
 	}
+	GetStore = async () => {
+		if (!this._store) this._store = new RedisTestRunStore({
+			redisUrl: this.Options.userData.redisStoreConnection,
+			keyPrefix: "testrun",
+			defaultTtlSeconds: 3600,
+			batchSize: 1e3,
+			maxDeleteBatchSize: 1e3
+		});
+		await this._store.ensureConnected();
+		return this._store;
+	};
 	GetFakerName = (index) => {
 		if (this.#randomNameList[index.toString()]) return this.#randomNameList[index.toString()];
 		const fakerNameTuple = {