@arkebcacy/beacon-cli-temp 0.1.1

package/src/cs/api/ContentstackError.ts

@@ -0,0 +1,103 @@
+import HandledError from '#cli/ui/HandledError.js';
+import isRecord from '#cli/util/isRecord.js';
+import { inspect, styleText } from 'node:util';
+
+export default class ContentstackError extends HandledError {
+	public constructor(
+		message: string,
+		public readonly code: number,
+		public readonly details: Record<string, readonly string[]>,
+		public readonly context?: string,
+	) {
+		super([...humanize(message, code, details, context)].join(''));
+	}
+
+	public static throwIfError(error: unknown, context?: string) {
+		if (isErrorResponse(error)) {
+			throw new ContentstackError(
+				error.error_message ?? '',
+				error.error_code ?? -1,
+				error.errors ?? {},
+				context,
+			);
+		}
+	}
+}
+
+interface ErrorResponse {
+	readonly error_message?: string;
+	readonly error_code?: number;
+	readonly errors?: Record<string, string[]>;
+}
+
+function isErrorResponse(o: unknown): o is ErrorResponse {
+	if (!isRecord(o)) {
+		return false;
+	}
+
+	if ('error_message' in o && typeof o.error_message !== 'string') {
+		return false;
+	}
+
+	if ('error_code' in o && typeof o.error_code !== 'number') {
+		return false;
+	}
+
+	if (!('errors' in o)) {
+		return true;
+	}
+
+	const { errors } = o;
+
+	if (!isRecord(errors)) {
+		return false;
+	}
+
+	for (const values of Object.values(errors)) {
+		if (!Array.isArray(values)) {
+			return false;
+		}
+
+		if (!values.every((v) => typeof v === 'string')) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function* humanize(
+	message: string,
+	code: number,
+	details: Record<string, readonly string[]>,
+	context: string | undefined,
+) {
+	if (context) {
+		yield styleText('redBright', '⚠');
+		yield ' ';
+		yield context;
+		yield '\n';
+	}
+
+	yield 'The Contentstack API reported an error';
+
+	if (code > 0) {
+		yield ' (';
+		yield styleText('yellowBright', code.toString());
+		yield '): ';
+	} else {
+		yield ': ';
+	}
+
+	yield styleText('redBright', message);
+
+	if (!message.endsWith('.')) {
+		yield '.';
+	}
+
+	if (Object.keys(details).length) {
+		yield '\nDetails: ';
+		yield inspect(details, { colors: true, depth: Infinity });
+		yield '\n';
+	}
+}

package/src/cs/api/MetricMiddleware.ts

@@ -0,0 +1,24 @@
+import type { Histogram } from 'node:perf_hooks';
+import { createHistogram, performance } from 'node:perf_hooks';
+import type { MiddlewareCallbackParams } from 'openapi-fetch';
+
+export default class MetricMiddleware {
+	readonly #histogram = createHistogram();
+
+	public get histogram(): Histogram {
+		return this.#histogram;
+	}
+
+	// Justification: This method is required by the openapi-fetch middleware API.
+	// eslint-disable-next-line @typescript-eslint/class-methods-use-this
+	public onRequest(o: MiddlewareCallbackParams) {
+		performance.mark(o.id);
+	}
+
+	public onResponse(o: MiddlewareCallbackParams & { response: Response }) {
+		const measure = performance.measure(o.id, o.id);
+		performance.clearMeasures(o.id);
+		performance.clearMarks(o.id);
+		this.#histogram.record(Math.round(measure.duration));
+	}
+}

package/src/cs/api/attachMetricCollector.ts

@@ -0,0 +1,16 @@
+import type { Histogram } from 'node:perf_hooks';
+import type createOpenApiClient from 'openapi-fetch';
+import MetricMiddleware from './MetricMiddleware.js';
+
+export default function attachMetricCollector<
+	TClient extends ReturnType<typeof createOpenApiClient>,
+>(client: TClient) {
+	const middleware = new MetricMiddleware();
+	client.use(middleware);
+
+	Object.defineProperty(client, 'performance', {
+		get: () => middleware.histogram,
+	});
+
+	return client as TClient & { readonly performance: Histogram };
+}

package/src/cs/api/attachRateLimiter.ts

@@ -0,0 +1,30 @@
+import type UiContext from '#cli/ui/UiContext.js';
+import RateLimitMiddleware from '@arke-systems/cs-rate-limit-middleware';
+import type createOpenApiClient from 'openapi-fetch';
+import { styleText } from 'util';
+
+export default function attachRateLimiter<
+	TClient extends ReturnType<typeof createOpenApiClient>,
+>(ui: UiContext, client: TClient) {
+	const rateLimiter = new RateLimitMiddleware();
+
+	rateLimiter.on('rate-limit-exceeded', () => {
+		const icon = styleText('redBright', '⚠');
+		ui.error(icon, 'Rate limit exceeded. Giving up.');
+	});
+
+	if (ui.options.verbose) {
+		rateLimiter.on('rate-limit-encountered', () => {
+			const icon = styleText('yellowBright', '⚠');
+			ui.warn(icon, 'Rate limit encountered. Waiting...');
+		});
+	}
+
+	client.use(rateLimiter);
+
+	Object.defineProperty(client, Symbol.asyncDispose, {
+		value: rateLimiter[Symbol.asyncDispose].bind(rateLimiter),
+	});
+
+	return client as AsyncDisposable & TClient;
+}