@transcend-io/utils 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,210 @@
+import Bluebird from "bluebird";
+
+//#region src/logger.d.ts
+interface Logger {
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+}
+//#endregion
+//#region src/splitInHalf.d.ts
+/**
+* Split an array roughly in half. Stable for even/odd lengths.
+*
+* @param entries - Items to split
+* @returns A tuple [left, right] halves
+*/
+declare function splitInHalf<T>(entries: T[]): [T[], T[]];
+//#endregion
+//#region src/sleepPromise.d.ts
+/**
+* Sleep in a promise
+*
+* @param sleepTime - The time to sleep in milliseconds.
+* @returns Resolves promise
+*/
+declare function sleepPromise(sleepTime: number): Promise<number>;
+//#endregion
+//#region src/extractErrorMessage.d.ts
+/**
+* Extract a human-readable error message from a thrown error.
+*
+* Tries to parse JSON bodies that follow common REST/GraphQL error patterns:
+*   { error: { message: string } }
+*   { errors: [{ message: string }, ...] }
+*
+* Falls back to `err.message` or 'Unknown error'.
+*
+* @param err - Unknown error thrown by network call
+* @returns A concise error string safe to log/show
+*/
+declare function extractErrorMessage(err: unknown): string;
+//#endregion
+//#region src/getErrorStatus.d.ts
+/**
+* Extract an HTTP status code from a thrown error (got compatible).
+*
+* @param err - Unknown error thrown by network call
+* @returns HTTP status code, if present
+*/
+declare function getErrorStatus(err: unknown): number | undefined;
+//#endregion
+//#region src/limitRecords.d.ts
+/**
+* Limits the number of records in the returned object to a maximum.
+* For entries beyond the max, sets their value to `true`.
+*
+* @param obj - Object
+* @param max - Maximum number of entries to retain original value.
+* @returns Object with keys mapped to their value or `true` if over the limit.
+*/
+declare function limitRecords<T>(obj: Record<string, T>, max: number): Record<string, T | true>;
+//#endregion
+//#region src/RateCounter.d.ts
+/**
+* Tracks counts over time and calculates rates within a specified time window.
+*
+* This class maintains a rolling window of count "buckets" (timestamped values)
+* and provides methods to add new counts and compute the rate of events over a
+* configurable time window.
+*
+* Example usage:
+* ```typescript
+* const counter = new RateCounter();
+* counter.add(5); // Add 5 events
+* const rate = counter.rate(60_000); // Get rate over last 60 seconds
+* ```
+*/
+declare class RateCounter {
+  private buckets;
+  /**
+  * Adds a new count to the counter.
+  *
+  * @param n - The number of events to add to the counter.
+  */
+  add(n: number): void;
+  /**
+  * rate over the last `windowMs` milliseconds
+  *
+  * @param windowMs - The time window in milliseconds to calculate the rate over.
+  * @returns The average rate of events per second over the specified time window.
+  */
+  rate(windowMs: number): number;
+}
+//#endregion
+//#region src/time.d.ts
+declare const DAY_MS: number;
+declare const HOUR_MS: number;
+declare const FIVE_MIN_MS: number;
+/**
+* Clamp 1..50 per API spec
+*
+* @param n - Number
+* @returns Clamped number
+*/
+declare const clampPageSize: (n?: number) => number;
+/**
+* TRUE UTC day start (00:00:00Z)
+*
+* @param d - Date
+* @returns Day start
+*/
+declare const startOfUtcDay: (d: Date) => Date;
+/**
+* TRUE UTC hour start (HH:00:00Z)
+*
+* @param d - Date
+* @returns Hour start
+*/
+declare const startOfHour: (d: Date) => Date;
+/**
+* Add ms safely
+*
+* @param d - Date
+* @param ms - Milliseconds to add
+* @returns New date
+*/
+declare const addMs: (d: Date, ms: number) => Date;
+/**
+* Add whole UTC days (exclusive bound helper)
+*
+* @param d - Date
+* @param n - Number of days to add
+* @returns New date
+*/
+declare const addDaysUtc: (d: Date, n: number) => Date;
+//#endregion
+//#region src/retrySamePromise.d.ts
+interface RetryPolicy {
+  /** Maximum retry attempts (not counting the initial try) */
+  maxAttempts: number;
+  /** Fixed delay between attempts in milliseconds */
+  delayMs: number;
+  /**
+  * Decide whether a given error should be retried.
+  *
+  * @param status - HTTP status code (if known)
+  * @param message - Extracted error message (if known)
+  */
+  shouldRetry(status?: number, message?: string): boolean;
+}
+/**
+* Retry a single async operation according to the provided policy.
+* The operation is executed once initially, then up to `maxAttempts` retries.
+*
+* @param op - Operation to run
+* @param policy - Retry policy
+* @param onBackoff - Observer called before each retry (for logging/metrics)
+* @returns Result of the operation if it eventually succeeds
+* @throws The last error encountered if all retries fail
+*/
+declare function retrySamePromise<T>(op: () => Promise<T>, policy: RetryPolicy, onBackoff: (note: string) => void): Promise<T>;
+//#endregion
+//#region src/chunkOneCsvFile.d.ts
+/**
+* Options for chunking a single CSV file
+*/
+type ChunkOpts = {
+  /** Path to the CSV file to chunk */filePath: string; /** Output directory for chunk files; defaults to the same directory as the input file */
+  outputDir?: string; /** Clear output directory before starting */
+  clearOutputDir: boolean; /** Chunk size in MB */
+  chunkSizeMB: number; /** Optional report interval in milliseconds for progress updates */
+  reportEveryMs?: number; /** Callback for progress updates */
+  onProgress: (processed: number, total?: number) => void; /** Logger instance (required — no default; callers must inject) */
+  logger: Logger;
+};
+/**
+* Stream a single CSV file and write chunk files of roughly chunkSizeMB.
+* - Writes header to each chunk.
+* - Logs periodic progress via onProgress.
+*
+* @param opts - Options for chunking the file
+* @returns Promise that resolves when done
+*/
+declare function chunkOneCsvFile(opts: ChunkOpts): Promise<void>;
+//#endregion
+//#region src/bluebird.d.ts
+/**
+* Concurrent map with configurable concurrency limit.
+* Re-export of Bluebird.map for use across the monorepo.
+*/
+declare const map: typeof Bluebird.map;
+/**
+* Sequential map (concurrency = 1).
+* Re-export of Bluebird.mapSeries for use across the monorepo.
+*/
+declare const mapSeries: typeof Bluebird.mapSeries;
+//#endregion
+//#region src/index.d.ts
+interface DeveloperToolNameParts {
+  displayName: string;
+  slug: string;
+}
+declare function normalizeDeveloperToolName(value: string): string;
+declare function toPackageDisplayName(value: string): string;
+declare function toPackageSlug(value: string): string;
+declare function describePackageName(value: string): DeveloperToolNameParts;
+//#endregion
+export { ChunkOpts, DAY_MS, DeveloperToolNameParts, FIVE_MIN_MS, HOUR_MS, Logger, RateCounter, RetryPolicy, addDaysUtc, addMs, chunkOneCsvFile, clampPageSize, describePackageName, extractErrorMessage, getErrorStatus, limitRecords, map, mapSeries, normalizeDeveloperToolName, retrySamePromise, sleepPromise, splitInHalf, startOfHour, startOfUtcDay, toPackageDisplayName, toPackageSlug };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/logger.ts","../src/splitInHalf.ts","../src/sleepPromise.ts","../src/extractErrorMessage.ts","../src/getErrorStatus.ts","../src/limitRecords.ts","../src/RateCounter.ts","../src/time.ts","../src/retrySamePromise.ts","../src/chunkOneCsvFile.ts","../src/bluebird.ts","../src/index.ts"],"mappings":";;;UAAiB,MAAA;EACf,IAAA,IAAQ,IAAA;EACR,IAAA,IAAQ,IAAA;EACR,KAAA,IAAS,IAAA;EACT,KAAA,IAAS,IAAA;AAAA;;;;;;AAJX;;;iBCMgB,WAAA,GAAA,CAAe,OAAA,EAAS,CAAA,MAAO,CAAA,IAAK,CAAA;;;;;;ADNpD;;;iBEMgB,YAAA,CAAa,SAAA,WAAoB,OAAA;;;;;;AFNjD;;;;;;;;;iBGYgB,mBAAA,CAAoB,GAAA;;;;;;AHZpC;;;iBIMgB,cAAA,CAAe,GAAA;;;;;;AJN/B;;;;;iBKQgB,YAAA,GAAA,CAAgB,GAAA,EAAK,MAAA,SAAe,CAAA,GAAI,GAAA,WAAc,MAAA,SAAe,CAAA;;;;;;ALRrF;;;;;;;;;;;cMca,WAAA;EAAA,QACH,OAAA;ENXC;;;;ACEX;EKqBE,GAAA,CAAI,CAAA;;;;;;;EAgBJ,IAAA,CAAK,QAAA;AAAA;;;cC3CM,MAAA;AAAA,cACA,OAAA;AAAA,cACA,WAAA;APFb;;;;;;AAAA,cOUa,aAAA,GAAiB,CAAA;;;;;;;cAQjB,aAAA,GAAiB,CAAA,EAAG,IAAA,KAAO,IAAA;;;;ANZxC;;;cMqBa,WAAA,GAAe,CAAA,EAAG,IAAA,KAAO,IAAA;;;;;;;;cAUzB,KAAA,GAAS,CAAA,EAAG,IAAA,EAAM,EAAA,aAAa,IAAA;;;;;;;AL/B5C;cKwCa,UAAA,GAAc,CAAA,EAAG,IAAA,EAAM,CAAA,aAAY,IAAA;;;UC1C/B,WAAA;;EAEf,WAAA;ERNF;EQQE,OAAA;;;;;;;EAOA,WAAA,CAAY,MAAA,WAAiB,OAAA;AAAA;;;;;;;;APT/B;;;iBOsBsB,gBAAA,GAAA,CACpB,EAAA,QAAU,OAAA,CAAQ,CAAA,GAClB,MAAA,EAAQ,WAAA,EACR,SAAA,GAAY,IAAA,oBACX,OAAA,CAAQ,CAAA;;;;;ARhCX;KSeY,SAAA;sCAEV,QAAA;EAEA,SAAA;EAEA,cAAA;EAEA,WAAA;EAEA,aAAA;EAEA,UAAA,GAAa,SAAA,UAAmB,KAAA;EAEhC,MAAA,EAAQ,MAAA;AAAA;ARvBV;;;;;;;;AAAA,iBQ4GsB,eAAA,CAAgB,IAAA,EAAM,SAAA,GAAY,OAAA;;;;;ATlHxD;;cUMa,GAAA,SAAY,QAAA,CAAS,GAAA;;;;;cAMrB,SAAA,SAAkB,QAAA,CAAS,SAAA;;;UCVvB,sBAAA;EACf,WAAA;EACA,IAAA;AAAA;AAAA,iBAGc,0BAAA,CAA2B,KAAA;AAAA,iBAI3B,oBAAA,CAAqB,KAAA;AAAA,iBAOrB,aAAA,CAAc,KAAA;AAAA,iBAId,mBAAA,CAAoB,KAAA,WAAgB,sBAAA"}

package/dist/index.mjs

@@ -0,0 +1,377 @@
+import { once } from "node:events";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, readdir, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { Parser } from "csv-parse";
+import * as fastcsv from "fast-csv";
+import Bluebird from "bluebird";
+//#region src/splitInHalf.ts
+/**
+* Split an array roughly in half. Stable for even/odd lengths.
+*
+* @param entries - Items to split
+* @returns A tuple [left, right] halves
+*/
+function splitInHalf(entries) {
+	const mid = Math.floor(entries.length / 2);
+	return [entries.slice(0, mid), entries.slice(mid)];
+}
+//#endregion
+//#region src/sleepPromise.ts
+/**
+* Sleep in a promise
+*
+* @param sleepTime - The time to sleep in milliseconds.
+* @returns Resolves promise
+*/
+function sleepPromise(sleepTime) {
+	return new Promise((resolve) => {
+		setTimeout(() => resolve(sleepTime), sleepTime);
+	});
+}
+//#endregion
+//#region src/extractErrorMessage.ts
+/**
+* Extract a human-readable error message from a thrown error.
+*
+* Tries to parse JSON bodies that follow common REST/GraphQL error patterns:
+*   { error: { message: string } }
+*   { errors: [{ message: string }, ...] }
+*
+* Falls back to `err.message` or 'Unknown error'.
+*
+* @param err - Unknown error thrown by network call
+* @returns A concise error string safe to log/show
+*/
+function extractErrorMessage(err) {
+	const anyErr = err;
+	let errorMsg = anyErr?.response?.body || anyErr?.message || "Unknown error";
+	try {
+		const parsed = JSON.parse(errorMsg);
+		const candidates = parsed.errors || parsed.error?.errors || [parsed.error?.message || parsed.error];
+		errorMsg = (Array.isArray(candidates) ? candidates : [candidates]).filter(Boolean).join(", ");
+	} catch {}
+	return errorMsg;
+}
+//#endregion
+//#region src/getErrorStatus.ts
+/**
+* Extract an HTTP status code from a thrown error (got compatible).
+*
+* @param err - Unknown error thrown by network call
+* @returns HTTP status code, if present
+*/
+function getErrorStatus(err) {
+	const anyErr = err;
+	return anyErr?.response?.statusCode ?? anyErr?.response?.status;
+}
+//#endregion
+//#region src/limitRecords.ts
+/**
+* Limits the number of records in the returned object to a maximum.
+* For entries beyond the max, sets their value to `true`.
+*
+* @param obj - Object
+* @param max - Maximum number of entries to retain original value.
+* @returns Object with keys mapped to their value or `true` if over the limit.
+*/
+function limitRecords(obj, max) {
+	return Object.entries(obj).reduce((acc, [userId, value], i) => {
+		acc[userId] = i < max ? value : true;
+		return acc;
+	}, {});
+}
+//#endregion
+//#region src/RateCounter.ts
+/**
+* Tracks counts over time and calculates rates within a specified time window.
+*
+* This class maintains a rolling window of count "buckets" (timestamped values)
+* and provides methods to add new counts and compute the rate of events over a
+* configurable time window.
+*
+* Example usage:
+* ```typescript
+* const counter = new RateCounter();
+* counter.add(5); // Add 5 events
+* const rate = counter.rate(60_000); // Get rate over last 60 seconds
+* ```
+*/
+var RateCounter = class {
+	buckets = [];
+	/**
+	* Adds a new count to the counter.
+	*
+	* @param n - The number of events to add to the counter.
+	*/
+	add(n) {
+		const now = Date.now();
+		this.buckets.push({
+			t: now,
+			n
+		});
+		const cutoff = now - 12e4;
+		while (this.buckets.length > 0 && this.buckets[0].t < cutoff) this.buckets.shift();
+	}
+	/**
+	* rate over the last `windowMs` milliseconds
+	*
+	* @param windowMs - The time window in milliseconds to calculate the rate over.
+	* @returns The average rate of events per second over the specified time window.
+	*/
+	rate(windowMs) {
+		const cutoff = Date.now() - windowMs;
+		let sum = 0;
+		for (let i = this.buckets.length - 1; i >= 0; i -= 1) {
+			const b = this.buckets[i];
+			if (b.t < cutoff) break;
+			sum += b.n;
+		}
+		return sum / (windowMs / 1e3);
+	}
+};
+//#endregion
+//#region src/time.ts
+const DAY_MS = 1440 * 60 * 1e3;
+const HOUR_MS = 3600 * 1e3;
+const FIVE_MIN_MS = 300 * 1e3;
+/**
+* Clamp 1..50 per API spec
+*
+* @param n - Number
+* @returns Clamped number
+*/
+const clampPageSize = (n) => Math.max(1, Math.min(50, n ?? 50));
+/**
+* TRUE UTC day start (00:00:00Z)
+*
+* @param d - Date
+* @returns Day start
+*/
+const startOfUtcDay = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+/**
+* TRUE UTC hour start (HH:00:00Z)
+*
+* @param d - Date
+* @returns Hour start
+*/
+const startOfHour = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours()));
+/**
+* Add ms safely
+*
+* @param d - Date
+* @param ms - Milliseconds to add
+* @returns New date
+*/
+const addMs = (d, ms) => new Date(d.getTime() + ms);
+/**
+* Add whole UTC days (exclusive bound helper)
+*
+* @param d - Date
+* @param n - Number of days to add
+* @returns New date
+*/
+const addDaysUtc = (d, n) => new Date(d.getTime() + n * DAY_MS);
+//#endregion
+//#region src/retrySamePromise.ts
+/**
+* Retry a single async operation according to the provided policy.
+* The operation is executed once initially, then up to `maxAttempts` retries.
+*
+* @param op - Operation to run
+* @param policy - Retry policy
+* @param onBackoff - Observer called before each retry (for logging/metrics)
+* @returns Result of the operation if it eventually succeeds
+* @throws The last error encountered if all retries fail
+*/
+async function retrySamePromise(op, policy, onBackoff) {
+	let attempt = 0;
+	while (true) try {
+		return await op();
+	} catch (err) {
+		attempt += 1;
+		const status = getErrorStatus(err);
+		const msg = extractErrorMessage(err);
+		if (!(attempt <= policy.maxAttempts && policy.shouldRetry(status, msg))) throw err;
+		onBackoff(`Retrying after status=${status} attempt=${attempt}/${policy.maxAttempts} — ${msg}`);
+		await sleepPromise(policy.delayMs);
+	}
+}
+//#endregion
+//#region src/chunkOneCsvFile.ts
+/**
+* Create a CSV writer (fast-csv formatter piped to a write stream) that writes
+* a header line first, and then accepts object rows. Returns a tiny API to
+* write rows with backpressure handling and to close the file cleanly.
+*
+* @param filePath - The path to the output CSV file
+* @param headers - The headers for the CSV file
+* @returns An object with `write` and `end` methods
+*/
+function createCsvChunkWriter(filePath, headers) {
+	const ws = createWriteStream(filePath);
+	const csv = fastcsv.format({
+		headers,
+		writeHeaders: true,
+		objectMode: true
+	});
+	csv.pipe(ws);
+	return {
+		async write(row) {
+			if (!csv.write(row)) await once(csv, "drain");
+		},
+		async end() {
+			const finished = Promise.all([once(ws, "finish")]);
+			csv.end();
+			await finished;
+		}
+	};
+}
+/**
+* Zero-pad chunk numbers to four digits (e.g., 1 -> "0001").
+*
+* @param n - The chunk number to pad
+* @returns The padded chunk number as a string
+*/
+function pad4(n) {
+	return String(n).padStart(4, "0");
+}
+/**
+* Approximate row size in bytes using comma-joined field values.
+*
+* @param obj - The row object to estimate size for
+* @returns Approximate byte size of the row when serialized as CSV
+*/
+function approxRowBytes(obj) {
+	return Buffer.byteLength(Object.values(obj).map((v) => v == null ? "" : String(v)).join(","), "utf8");
+}
+/**
+* Stream a single CSV file and write chunk files of roughly chunkSizeMB.
+* - Writes header to each chunk.
+* - Logs periodic progress via onProgress.
+*
+* @param opts - Options for chunking the file
+* @returns Promise that resolves when done
+*/
+async function chunkOneCsvFile(opts) {
+	const { filePath, outputDir, clearOutputDir, chunkSizeMB, onProgress, reportEveryMs = 500, logger } = opts;
+	const { size: fileBytes } = await stat(filePath);
+	let lastTick = 0;
+	logger.info(`Chunking ${filePath} into ~${chunkSizeMB}MB files...`);
+	const chunkSizeBytes = Math.floor(chunkSizeMB * 1024 * 1024);
+	const baseName = basename(filePath, ".csv");
+	const outDir = outputDir || dirname(filePath);
+	logger.info(`Output directory: ${outDir}`);
+	await mkdir(outDir, { recursive: true });
+	if (clearOutputDir) {
+		logger.warn(`Clearing output directory: ${outDir}`);
+		const files = await readdir(outDir);
+		await Promise.all(files.filter((f) => f.startsWith(`${baseName}_chunk_`) && f.endsWith(".csv")).map((f) => unlink(join(outDir, f))));
+	}
+	let headerRow = null;
+	let expectedCols = null;
+	let totalLines = 0;
+	let currentChunk = 1;
+	let currentSize = 0;
+	const parser = new Parser({
+		columns: false,
+		skip_empty_lines: true
+	});
+	let sampleBytes = 0;
+	let sampleRows = 0;
+	const emit = () => {
+		const avg = sampleRows > 0 ? sampleBytes / sampleRows : 0;
+		const estTotal = avg > 0 ? Math.max(totalLines, Math.ceil(fileBytes / avg)) : void 0;
+		onProgress(totalLines, estTotal);
+		lastTick = Date.now();
+	};
+	emit();
+	let writer = null;
+	const currentChunkPath = () => join(outDir, `${baseName}_chunk_${pad4(currentChunk)}.csv`);
+	const t = new Transform({
+		objectMode: true,
+		async transform(row, _enc, cb) {
+			try {
+				if (!headerRow) {
+					headerRow = row.slice(0);
+					expectedCols = headerRow.length;
+					writer = createCsvChunkWriter(currentChunkPath(), headerRow);
+					cb();
+					return;
+				}
+				if (expectedCols !== null && row.length !== expectedCols) logger.warn(`Row has ${row.length} cols; expected ${expectedCols}`);
+				totalLines += 1;
+				if (totalLines % 25e4 === 0) onProgress(totalLines);
+				const obj = Object.fromEntries(headerRow.map((h, i) => [h, row[i]]));
+				const rowBytes = approxRowBytes(obj);
+				sampleBytes += rowBytes;
+				sampleRows += 1;
+				if (Date.now() - lastTick >= reportEveryMs) emit();
+				if (writer && currentSize > 0 && currentSize + rowBytes > chunkSizeBytes) {
+					await writer.end();
+					currentChunk += 1;
+					currentSize = 0;
+					logger.info(`Rolling to chunk ${currentChunk} after ${totalLines.toLocaleString()} rows.`);
+					writer = createCsvChunkWriter(currentChunkPath(), headerRow);
+				}
+				if (!writer) writer = createCsvChunkWriter(currentChunkPath(), headerRow);
+				await writer.write(obj);
+				currentSize += rowBytes;
+				cb();
+			} catch (e) {
+				cb(e);
+			}
+		},
+		async flush(cb) {
+			try {
+				if (writer) {
+					await writer.end();
+					writer = null;
+				}
+				emit();
+				cb();
+			} catch (e) {
+				cb(e);
+			}
+		}
+	});
+	await pipeline(createReadStream(filePath), parser, t);
+	onProgress(totalLines);
+	logger.info(`Chunked ${filePath} into ${currentChunk} file(s); processed ${totalLines.toLocaleString()} rows.`);
+}
+//#endregion
+//#region src/bluebird.ts
+/**
+* Concurrent map with configurable concurrency limit.
+* Re-export of Bluebird.map for use across the monorepo.
+*/
+const map = Bluebird.map.bind(Bluebird);
+/**
+* Sequential map (concurrency = 1).
+* Re-export of Bluebird.mapSeries for use across the monorepo.
+*/
+const mapSeries = Bluebird.mapSeries.bind(Bluebird);
+//#endregion
+//#region src/index.ts
+const whitespacePattern = /\s+/g;
+function normalizeDeveloperToolName(value) {
+	return value.trim().replace(whitespacePattern, " ");
+}
+function toPackageDisplayName(value) {
+	return normalizeDeveloperToolName(value).split(" ").map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join(" ");
+}
+function toPackageSlug(value) {
+	return normalizeDeveloperToolName(value).toLowerCase().replace(whitespacePattern, "-");
+}
+function describePackageName(value) {
+	return {
+		displayName: toPackageDisplayName(value),
+		slug: toPackageSlug(value)
+	};
+}
+//#endregion
+export { DAY_MS, FIVE_MIN_MS, HOUR_MS, RateCounter, addDaysUtc, addMs, chunkOneCsvFile, clampPageSize, describePackageName, extractErrorMessage, getErrorStatus, limitRecords, map, mapSeries, normalizeDeveloperToolName, retrySamePromise, sleepPromise, splitInHalf, startOfHour, startOfUtcDay, toPackageDisplayName, toPackageSlug };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/splitInHalf.ts","../src/sleepPromise.ts","../src/extractErrorMessage.ts","../src/getErrorStatus.ts","../src/limitRecords.ts","../src/RateCounter.ts","../src/time.ts","../src/retrySamePromise.ts","../src/chunkOneCsvFile.ts","../src/bluebird.ts","../src/index.ts"],"sourcesContent":["/**\n * Split an array roughly in half. Stable for even/odd lengths.\n *\n * @param entries - Items to split\n * @returns A tuple [left, right] halves\n */\nexport function splitInHalf<T>(entries: T[]): [T[], T[]] {\n  const mid = Math.floor(entries.length / 2);\n  return [entries.slice(0, mid), entries.slice(mid)];\n}\n","/**\n * Sleep in a promise\n *\n * @param sleepTime - The time to sleep in milliseconds.\n * @returns Resolves promise\n */\nexport function sleepPromise(sleepTime: number): Promise<number> {\n  return new Promise((resolve) => {\n    setTimeout(() => resolve(sleepTime), sleepTime);\n  });\n}\n","/**\n * Extract a human-readable error message from a thrown error.\n *\n * Tries to parse JSON bodies that follow common REST/GraphQL error patterns:\n *   { error: { message: string } }\n *   { errors: [{ message: string }, ...] }\n *\n * Falls back to `err.message` or 'Unknown error'.\n *\n * @param err - Unknown error thrown by network call\n * @returns A concise error string safe to log/show\n */\nexport function extractErrorMessage(err: unknown): string {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const anyErr = err as any;\n  let errorMsg = anyErr?.response?.body || anyErr?.message || 'Unknown error';\n\n  // Try to parse as JSON; if not parsable, leave as-is.\n  try {\n    const parsed = JSON.parse(errorMsg);\n    // Typical shapes: errors[], error.errors[], error.message\n    const candidates = parsed.errors ||\n      parsed.error?.errors || [parsed.error?.message || parsed.error];\n\n    const msgs = Array.isArray(candidates) ? candidates : [candidates];\n    errorMsg = msgs.filter(Boolean).join(', ');\n  } catch {\n    // not JSON, ignore\n  }\n  return errorMsg;\n}\n","/**\n * Extract an HTTP status code from a thrown error (got compatible).\n *\n * @param err - Unknown error thrown by network call\n * @returns HTTP status code, if present\n */\nexport function getErrorStatus(err: unknown): number | undefined {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const anyErr = err as any;\n  return anyErr?.response?.statusCode ?? anyErr?.response?.status;\n}\n","/**\n * Limits the number of records in the returned object to a maximum.\n * For entries beyond the max, sets their value to `true`.\n *\n * @param obj - Object\n * @param max - Maximum number of entries to retain original value.\n * @returns Object with keys mapped to their value or `true` if over the limit.\n */\nexport function limitRecords<T>(obj: Record<string, T>, max: number): Record<string, T | true> {\n  return Object.entries(obj).reduce(\n    (acc, [userId, value], i) => {\n      acc[userId] = i < max ? value : true;\n      return acc;\n    },\n    {} as Record<string, T | true>,\n  );\n}\n","/**\n * Tracks counts over time and calculates rates within a specified time window.\n *\n * This class maintains a rolling window of count \"buckets\" (timestamped values)\n * and provides methods to add new counts and compute the rate of events over a\n * configurable time window.\n *\n * Example usage:\n * ```typescript\n * const counter = new RateCounter();\n * counter.add(5); // Add 5 events\n * const rate = counter.rate(60_000); // Get rate over last 60 seconds\n * ```\n */\nexport class RateCounter {\n  private buckets: Array<{\n    /** Timestamp of the bucket */\n    t: number;\n    /** Number of events in the bucket */\n    n: number;\n  }> = [];\n\n  /**\n   * Adds a new count to the counter.\n   *\n   * @param n - The number of events to add to the counter.\n   */\n  add(n: number): void {\n    const now = Date.now();\n    this.buckets.push({ t: now, n });\n    // keep last 2 minutes of buckets\n    const cutoff = now - 120_000;\n    while (this.buckets.length > 0 && this.buckets[0]!.t < cutoff) {\n      this.buckets.shift();\n    }\n  }\n\n  /**\n   * rate over the last `windowMs` milliseconds\n   *\n   * @param windowMs - The time window in milliseconds to calculate the rate over.\n   * @returns The average rate of events per second over the specified time window.\n   */\n  rate(windowMs: number): number {\n    const now = Date.now();\n    const cutoff = now - windowMs;\n    let sum = 0;\n    for (let i = this.buckets.length - 1; i >= 0; i -= 1) {\n      const b = this.buckets[i]!;\n      if (b.t < cutoff) break;\n      sum += b.n;\n    }\n    return sum / (windowMs / 1000);\n  }\n}\n","export const DAY_MS: number = 24 * 60 * 60 * 1000;\nexport const HOUR_MS: number = 60 * 60 * 1000;\nexport const FIVE_MIN_MS: number = 5 * 60 * 1000;\n\n/**\n * Clamp 1..50 per API spec\n *\n * @param n - Number\n * @returns Clamped number\n */\nexport const clampPageSize = (n?: number): number => Math.max(1, Math.min(50, n ?? 50));\n\n/**\n * TRUE UTC day start (00:00:00Z)\n *\n * @param d - Date\n * @returns Day start\n */\nexport const startOfUtcDay = (d: Date): Date =>\n  new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));\n\n/**\n * TRUE UTC hour start (HH:00:00Z)\n *\n * @param d - Date\n * @returns Hour start\n */\nexport const startOfHour = (d: Date): Date =>\n  new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours()));\n\n/**\n * Add ms safely\n *\n * @param d - Date\n * @param ms - Milliseconds to add\n * @returns New date\n */\nexport const addMs = (d: Date, ms: number): Date => new Date(d.getTime() + ms);\n\n/**\n * Add whole UTC days (exclusive bound helper)\n *\n * @param d - Date\n * @param n - Number of days to add\n * @returns New date\n */\nexport const addDaysUtc = (d: Date, n: number): Date => new Date(d.getTime() + n * DAY_MS);\n","import { extractErrorMessage } from './extractErrorMessage.js';\nimport { getErrorStatus } from './getErrorStatus.js';\nimport { sleepPromise } from './sleepPromise.js';\n\nexport interface RetryPolicy {\n  /** Maximum retry attempts (not counting the initial try) */\n  maxAttempts: number;\n  /** Fixed delay between attempts in milliseconds */\n  delayMs: number;\n  /**\n   * Decide whether a given error should be retried.\n   *\n   * @param status - HTTP status code (if known)\n   * @param message - Extracted error message (if known)\n   */\n  shouldRetry(status?: number, message?: string): boolean;\n}\n\n/**\n * Retry a single async operation according to the provided policy.\n * The operation is executed once initially, then up to `maxAttempts` retries.\n *\n * @param op - Operation to run\n * @param policy - Retry policy\n * @param onBackoff - Observer called before each retry (for logging/metrics)\n * @returns Result of the operation if it eventually succeeds\n * @throws The last error encountered if all retries fail\n */\nexport async function retrySamePromise<T>(\n  op: () => Promise<T>,\n  policy: RetryPolicy,\n  onBackoff: (note: string) => void,\n): Promise<T> {\n  let attempt = 0;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    try {\n      // First pass and any subsequent retries run the same op.\n      return await op();\n    } catch (err) {\n      attempt += 1;\n\n      // Use shared helpers for status + human-readable message extraction\n      const status = getErrorStatus(err);\n      const msg = extractErrorMessage(err);\n\n      const canRetry = attempt <= policy.maxAttempts && policy.shouldRetry(status, msg);\n\n      if (!canRetry) {\n        // Surface the final error to the caller, which may then split/fail.\n        throw err;\n      }\n\n      onBackoff(\n        `Retrying after status=${status} attempt=${attempt}/${policy.maxAttempts} — ${msg}`,\n      );\n      await sleepPromise(policy.delayMs);\n      // Loop to retry\n    }\n  }\n}\n","import { once } from 'node:events';\nimport { createReadStream, createWriteStream } from 'node:fs';\nimport { mkdir, readdir, unlink, stat } from 'node:fs/promises';\nimport { basename, dirname, join } from 'node:path';\nimport { Transform } from 'node:stream';\nimport { pipeline } from 'node:stream/promises';\n\nimport { Parser } from 'csv-parse';\nimport * as fastcsv from 'fast-csv';\n\nimport type { Logger } from './logger.js';\n\n/**\n * Options for chunking a single CSV file\n */\nexport type ChunkOpts = {\n  /** Path to the CSV file to chunk */\n  filePath: string;\n  /** Output directory for chunk files; defaults to the same directory as the input file */\n  outputDir?: string;\n  /** Clear output directory before starting */\n  clearOutputDir: boolean;\n  /** Chunk size in MB */\n  chunkSizeMB: number;\n  /** Optional report interval in milliseconds for progress updates */\n  reportEveryMs?: number;\n  /** Callback for progress updates */\n  onProgress: (processed: number, total?: number) => void;\n  /** Logger instance (required — no default; callers must inject) */\n  logger: Logger;\n};\n\n/**\n * Create a CSV writer (fast-csv formatter piped to a write stream) that writes\n * a header line first, and then accepts object rows. Returns a tiny API to\n * write rows with backpressure handling and to close the file cleanly.\n *\n * @param filePath - The path to the output CSV file\n * @param headers - The headers for the CSV file\n * @returns An object with `write` and `end` methods\n */\nfunction createCsvChunkWriter(\n  filePath: string,\n  headers: string[],\n): {\n  /** Write a row object to the CSV file */\n  write: (row: Record<string, unknown>) => Promise<void>;\n  /** Close the CSV file, ensuring all data is flushed */\n  end: () => Promise<void>;\n} {\n  const ws = createWriteStream(filePath);\n  const csv = fastcsv.format({ headers, writeHeaders: true, objectMode: true });\n  // Pipe csv → file stream\n  csv.pipe(ws);\n\n  return {\n    /**\n     * Write a row object to the CSV file.\n     *\n     * @param row - The row data as an object\n     */\n    async write(row) {\n      // Respect backpressure from fast-csv formatter\n      const ok = csv.write(row);\n      if (!ok) {\n        await once(csv, 'drain');\n      }\n    },\n    /**\n     * Close the CSV file, ensuring all data is flushed.\n     */\n    async end() {\n      // End formatter; wait for underlying file stream to finish flush/close\n      const finished = Promise.all([once(ws, 'finish')]);\n      csv.end();\n      await finished;\n    },\n  };\n}\n\n/**\n * Zero-pad chunk numbers to four digits (e.g., 1 -> \"0001\").\n *\n * @param n - The chunk number to pad\n * @returns The padded chunk number as a string\n */\nfunction pad4(n: number): string {\n  return String(n).padStart(4, '0');\n}\n\n/**\n * Approximate row size in bytes using comma-joined field values.\n *\n * @param obj - The row object to estimate size for\n * @returns Approximate byte size of the row when serialized as CSV\n */\nfunction approxRowBytes(obj: Record<string, unknown>): number {\n  // naive but fast; adequate for chunk rollover thresholding\n  return Buffer.byteLength(\n    Object.values(obj)\n      .map((v) => (v == null ? '' : String(v)))\n      .join(','),\n    'utf8',\n  );\n}\n\n/**\n * Stream a single CSV file and write chunk files of roughly chunkSizeMB.\n * - Writes header to each chunk.\n * - Logs periodic progress via onProgress.\n *\n * @param opts - Options for chunking the file\n * @returns Promise that resolves when done\n */\nexport async function chunkOneCsvFile(opts: ChunkOpts): Promise<void> {\n  const {\n    filePath,\n    outputDir,\n    clearOutputDir,\n    chunkSizeMB,\n    onProgress,\n    reportEveryMs = 500,\n    logger,\n  } = opts;\n  const { size: fileBytes } = await stat(filePath); // total bytes on disk\n  let lastTick = 0;\n\n  logger.info(`Chunking ${filePath} into ~${chunkSizeMB}MB files...`);\n\n  const chunkSizeBytes = Math.floor(chunkSizeMB * 1024 * 1024);\n  const baseName = basename(filePath, '.csv');\n  const outDir = outputDir || dirname(filePath);\n  logger.info(`Output directory: ${outDir}`);\n  await mkdir(outDir, { recursive: true });\n\n  // Clear previous chunk files for this base\n  if (clearOutputDir) {\n    logger.warn(`Clearing output directory: ${outDir}`);\n    const files = await readdir(outDir);\n    await Promise.all(\n      files\n        .filter((f) => f.startsWith(`${baseName}_chunk_`) && f.endsWith('.csv'))\n        .map((f) => unlink(join(outDir, f))),\n    );\n  }\n\n  let headerRow: string[] | null = null;\n  let expectedCols: number | null = null;\n  let totalLines = 0;\n  let currentChunk = 1;\n  let currentSize = 0;\n\n  const parser = new Parser({\n    columns: false,\n    skip_empty_lines: true,\n  });\n\n  // running sample to estimate avg row bytes\n  let sampleBytes = 0;\n  let sampleRows = 0;\n\n  const emit = (): void => {\n    const avg = sampleRows > 0 ? sampleBytes / sampleRows : 0;\n    const estTotal = avg > 0 ? Math.max(totalLines, Math.ceil(fileBytes / avg)) : undefined;\n    onProgress(totalLines, estTotal);\n    lastTick = Date.now();\n  };\n\n  // seed an initial 0/N as soon as we start\n  emit();\n\n  // Current active chunk writer; created after we know headers\n  let writer: {\n    /** Write a row object to the current chunk file */\n    write: (row: Record<string, unknown>) => Promise<void>;\n    /** Close the current chunk file */\n    end: () => Promise<void>;\n  } | null = null;\n\n  // Returns current chunk file path -- chunk number is always 4-digit padded\n  const currentChunkPath = (): string =>\n    join(outDir, `${baseName}_chunk_${pad4(currentChunk)}.csv`);\n\n  const t = new Transform({\n    objectMode: true,\n    /**\n     * Transform each row of the CSV file into a chunk.\n     *\n     * @param row - The current row being processed\n     * @param _enc - Encoding (not used)\n     * @param cb - Callback to signal completion or error\n     */\n    async transform(row: string[], _enc, cb) {\n      try {\n        // First row is the header\n        if (!headerRow) {\n          headerRow = row.slice(0);\n          expectedCols = headerRow.length;\n\n          // Open first chunk with header asynchronously\n          writer = createCsvChunkWriter(currentChunkPath(), headerRow);\n          cb();\n          return;\n        }\n\n        // sanity check rows (non-fatal)\n        if (expectedCols !== null && row.length !== expectedCols) {\n          logger.warn(`Row has ${row.length} cols; expected ${expectedCols}`);\n        }\n\n        totalLines += 1;\n        if (totalLines % 250_000 === 0) {\n          onProgress(totalLines);\n        }\n\n        // Build row object using the original header\n        const obj = Object.fromEntries(headerRow!.map((h, i) => [h, row[i]]));\n\n        // Determine the row size up-front\n        const rowBytes = approxRowBytes(obj);\n        sampleBytes += rowBytes;\n        sampleRows += 1;\n\n        // time-based throttle for UI updates\n        if (Date.now() - lastTick >= reportEveryMs) emit();\n\n        // If adding this row would exceed the threshold, roll first,\n        // so this row becomes the first row in the next chunk.\n        if (writer && currentSize > 0 && currentSize + rowBytes > chunkSizeBytes) {\n          await writer.end();\n          currentChunk += 1;\n          currentSize = 0;\n          logger.info(\n            `Rolling to chunk ${currentChunk} after ${totalLines.toLocaleString()} rows.`,\n          );\n          writer = createCsvChunkWriter(currentChunkPath(), headerRow!);\n        }\n\n        // Ensure writer exists (should after header)\n        if (!writer) {\n          writer = createCsvChunkWriter(currentChunkPath(), headerRow!);\n        }\n\n        // Write row and update approximate size\n        await writer.write(obj);\n        currentSize += rowBytes;\n\n        cb();\n      } catch (e) {\n        cb(e as Error);\n      }\n    },\n\n    // Ensure final file is closed\n    /**\n     * Flush is called when the readable has ended; we close any open writer.\n     *\n     * @param cb - Callback to signal completion or error\n     */\n    async flush(cb) {\n      try {\n        if (writer) {\n          await writer.end();\n          writer = null;\n        }\n        emit(); // Final progress tick\n        cb();\n      } catch (e) {\n        cb(e as Error);\n      }\n    },\n  });\n\n  const rs = createReadStream(filePath);\n  await pipeline(rs, parser, t);\n\n  // Final progress tick\n  onProgress(totalLines);\n  logger.info(\n    `Chunked ${filePath} into ${currentChunk} file(s); processed ${totalLines.toLocaleString()} rows.`,\n  );\n}\n","import Bluebird from 'bluebird';\n\n/**\n * Concurrent map with configurable concurrency limit.\n * Re-export of Bluebird.map for use across the monorepo.\n */\nexport const map: typeof Bluebird.map = Bluebird.map.bind(Bluebird);\n\n/**\n * Sequential map (concurrency = 1).\n * Re-export of Bluebird.mapSeries for use across the monorepo.\n */\nexport const mapSeries: typeof Bluebird.mapSeries = Bluebird.mapSeries.bind(Bluebird);\n","const whitespacePattern = /\\s+/g;\n\nexport interface DeveloperToolNameParts {\n  displayName: string;\n  slug: string;\n}\n\nexport function normalizeDeveloperToolName(value: string): string {\n  return value.trim().replace(whitespacePattern, ' ');\n}\n\nexport function toPackageDisplayName(value: string): string {\n  return normalizeDeveloperToolName(value)\n    .split(' ')\n    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase())\n    .join(' ');\n}\n\nexport function toPackageSlug(value: string): string {\n  return normalizeDeveloperToolName(value).toLowerCase().replace(whitespacePattern, '-');\n}\n\nexport function describePackageName(value: string): DeveloperToolNameParts {\n  return {\n    displayName: toPackageDisplayName(value),\n    slug: toPackageSlug(value),\n  };\n}\n\nexport * from './logger.js';\nexport * from './splitInHalf.js';\nexport * from './sleepPromise.js';\nexport * from './extractErrorMessage.js';\nexport * from './getErrorStatus.js';\nexport * from './limitRecords.js';\nexport * from './RateCounter.js';\nexport * from './time.js';\nexport * from './retrySamePromise.js';\nexport * from './chunkOneCsvFile.js';\nexport * from './bluebird.js';\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@transcend-io/utils",
+  "version": "0.0.0",
+  "description": "Shared utilities for the Transcend developer tools monorepo.",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "@transcend-io/source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "check-exports": "attw --pack . --ignore-rules cjs-resolves-to-esm"
+  },
+  "dependencies": {
+    "bluebird": "^3.7.2",
+    "csv-parse": "^5.6.0",
+    "fast-csv": "^4.3.6"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "catalog:",
+    "@types/bluebird": "^3.5.38",
+    "@types/node": "catalog:",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}