@zenera/faker 1.1.20 → 1.1.22

package/dist/logger.js

@@ -0,0 +1,273 @@
+import { bold, cyan, dim, green, red, yellow } from '@zenera/cli/lib';
+import { mkdirSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+// ---------------------------------------------------------------------------
+// Formatting Helpers
+// ---------------------------------------------------------------------------
+export function formatTimestamp(d) {
+    const pad = (n, w = 2) => String(n).padStart(w, '0');
+    const yyyy = d.getFullYear();
+    const mm = pad(d.getMonth() + 1);
+    const dd = pad(d.getDate());
+    const hh = pad(d.getHours());
+    const min = pad(d.getMinutes());
+    const ss = pad(d.getSeconds());
+    const ms = pad(d.getMilliseconds(), 3);
+    return `${yyyy}-${mm}-${dd} ${hh}:${min}:${ss}.${ms}`;
+}
+export function statusText(status) {
+    switch (status) {
+        case 200:
+            return 'OK';
+        case 201:
+            return 'Created';
+        case 202:
+            return 'Accepted';
+        case 204:
+            return 'No Content';
+        case 400:
+            return 'Bad Request';
+        case 401:
+            return 'Unauthorized';
+        case 403:
+            return 'Forbidden';
+        case 404:
+            return 'Not Found';
+        case 405:
+            return 'Method Not Allowed';
+        case 413:
+            return 'Payload Too Large';
+        case 500:
+            return 'Internal Server Error';
+        case 501:
+            return 'Not Implemented';
+        case 502:
+            return 'Bad Gateway';
+        case 504:
+            return 'Gateway Timeout';
+        default:
+            return status < 400 ? 'Success' : status < 500 ? 'Client Error' : 'Server Error';
+    }
+}
+export function colorForStatus(status) {
+    if (status < 300)
+        return green;
+    if (status < 400)
+        return cyan;
+    if (status < 500)
+        return yellow;
+    return red;
+}
+export function colorForErrorKind(kind) {
+    if (kind.startsWith('CLIENT_ERROR'))
+        return yellow;
+    if (kind === 'SUCCESS')
+        return green;
+    return (s) => red(bold(s));
+}
+// ---------------------------------------------------------------------------
+// Markdown Request / Response Dump File
+// ---------------------------------------------------------------------------
+/**
+ * Saves a markdown file with all input information and output data for a request.
+ * Returns the absolute path of the generated markdown file.
+ */
+export async function saveRequestDump(dir, data) {
+    mkdirSync(dir, { recursive: true });
+    const safePath = data.pathname.replace(/[^a-zA-Z0-9_-]/g, '_').replace(/^_+|_+$/g, '') || 'root';
+    const isoPrefix = data.timestamp.toISOString().replace(/[:.]/g, '-');
+    const filename = `${isoPrefix}-${data.method.toUpperCase()}-${safePath}-${data.id}.md`;
+    const fullPath = join(dir, filename);
+    const lines = [
+        `# Request: ${data.method.toUpperCase()} ${data.pathname}${data.search}`,
+        '',
+        `- **Request ID**: \`${data.id}\``,
+        `- **Timestamp**: ${data.timestamp.toISOString()}`,
+        `- **Status**: ${data.status} ${statusText(data.status)}`,
+        `- **Duration**: ${data.durationMs}ms`,
+        `- **Operation ID**: ${data.operationId ? `\`${data.operationId}\`` : '_None_'}`,
+        `- **Route Pattern**: ${data.routePath ? `\`${data.routePath}\`` : '_None_'}`,
+        `- **Cache**: ${data.cacheStatus ?? 'n/a'}`,
+    ];
+    if (data.errorKind) {
+        lines.push(`- **Error Kind**: \`${data.errorKind}\``);
+    }
+    if (data.regenerated) {
+        lines.push(`- **Regenerated**: Yes (attempts: ${data.regenAttempts ?? 1})`);
+    }
+    if (data.regenLimitHit) {
+        lines.push(`- **Regeneration Limit**: Hit (limit: ${data.regenLimit})`);
+    }
+    if (data.note) {
+        lines.push(`- **Note**: ${data.note}`);
+    }
+    lines.push('', '---', '', '## Request Info', '');
+    lines.push('### URL & Method', '```http', `${data.method.toUpperCase()} ${data.url}`, '```', '');
+    lines.push('### Path Parameters');
+    if (data.pathParams && Object.keys(data.pathParams).length > 0) {
+        lines.push('```json', JSON.stringify(data.pathParams, null, 2), '```');
+    }
+    else {
+        lines.push('_None_');
+    }
+    lines.push('');
+    lines.push('### Query Parameters');
+    if (data.query && Object.keys(data.query).length > 0) {
+        lines.push('```json', JSON.stringify(data.query, null, 2), '```');
+    }
+    else {
+        lines.push('_None_');
+    }
+    lines.push('');
+    lines.push('### Request Headers');
+    if (data.requestHeaders && Object.keys(data.requestHeaders).length > 0) {
+        lines.push('```json', JSON.stringify(data.requestHeaders, null, 2), '```');
+    }
+    else {
+        lines.push('_None_');
+    }
+    lines.push('');
+    lines.push('### Request Body');
+    if (data.requestBody !== undefined) {
+        lines.push('```json', typeof data.requestBody === 'string'
+            ? data.requestBody
+            : JSON.stringify(data.requestBody, null, 2), '```');
+    }
+    else {
+        lines.push('_Empty_');
+    }
+    lines.push('');
+    lines.push('---', '', '## Response Data', '');
+    lines.push('### Status', '```http', `HTTP/1.1 ${data.status} ${statusText(data.status)}`, '```', '');
+    lines.push('### Response Headers');
+    if (data.responseHeaders && Object.keys(data.responseHeaders).length > 0) {
+        lines.push('```json', JSON.stringify(data.responseHeaders, null, 2), '```');
+    }
+    else {
+        lines.push('_None_');
+    }
+    lines.push('');
+    lines.push('### Response Body');
+    if (data.responseBody !== undefined) {
+        lines.push('```json', typeof data.responseBody === 'string'
+            ? data.responseBody
+            : JSON.stringify(data.responseBody, null, 2), '```');
+    }
+    else {
+        lines.push('_Empty_');
+    }
+    lines.push('');
+    if (data.errorMessage || data.stderr || (data.issues && data.issues.length > 0)) {
+        lines.push('---', '', '## Error & Diagnostics', '');
+        if (data.errorKind) {
+            lines.push(`### Classification`, `\`${data.errorKind}\``, '');
+        }
+        if (data.errorMessage) {
+            lines.push(`### Error Message`, `\`${data.errorMessage}\``, '');
+        }
+        if (data.issues && data.issues.length > 0) {
+            lines.push('### Validation Issues', '```json', JSON.stringify(data.issues, null, 2), '```', '');
+        }
+        if (data.stderr) {
+            lines.push('### Stderr / Traceback', '```', data.stderr, '```', '');
+        }
+    }
+    await writeFile(fullPath, lines.join('\n'), 'utf8');
+    return resolve(fullPath);
+}
+// ---------------------------------------------------------------------------
+// Log Line Formatter
+// ---------------------------------------------------------------------------
+export function formatLogLine(data, dumpPath) {
+    const ts = dim(`[${formatTimestamp(data.timestamp)}]`);
+    const method = cyan(bold(data.method.toUpperCase()));
+    const target = `${data.pathname}${data.search}`;
+    const statusCol = colorForStatus(data.status);
+    const status = statusCol(String(data.status));
+    const duration = dim(`${data.durationMs}ms`);
+    let tag = '';
+    if (data.errorKind) {
+        const tagCol = colorForErrorKind(data.errorKind);
+        tag = ` ${tagCol(`[${data.errorKind}]`)}`;
+    }
+    else if (data.status < 400) {
+        tag = ` ${green('[SUCCESS]')}`;
+    }
+    const note = data.note ? ` ${dim(`· ${data.note}`)}` : '';
+    const errDetail = data.errorMessage ? ` ${dim(`(${data.errorMessage})`)}` : '';
+    const firstLine = `${ts} ${method} ${target} ${status} ${duration}${tag}${note}${errDetail}`;
+    const lines = [firstLine];
+    if (data.stderr && data.stderr.trim()) {
+        const lastStderr = data.stderr.trim().split('\n').slice(-4).join('\n    ');
+        lines.push(`  ${dim('stderr:')} ${red(lastStderr)}`);
+    }
+    if (dumpPath) {
+        const fileUrl = `file://${resolve(dumpPath)}`;
+        lines.push(`  ${dim('↳ dump:')} ${cyan(fileUrl)}`);
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Special Log Messages
+// ---------------------------------------------------------------------------
+export function formatRegenLimitHit(urlPath, limit, operationId) {
+    const ts = dim(`[${formatTimestamp(new Date())}]`);
+    const op = operationId ? ` (${operationId})` : '';
+    return `${ts} ${red(bold('[REGENERATION_LIMIT_HIT]'))} Maximum regeneration limit (${limit}) reached for URL "${urlPath}"${op}. Halting further regeneration attempts.`;
+}
+export function formatRegenerating(urlPath, attempt, limit, operationId, reason) {
+    const ts = dim(`[${formatTimestamp(new Date())}]`);
+    const op = operationId ? ` (${operationId})` : '';
+    const r = reason ? ` [${reason}]` : '';
+    return `${ts} ${yellow(bold('[REGENERATING]'))} Error in generator for "${urlPath}"${op}${r}. Attempting regeneration (${attempt}/${limit})...`;
+}
+export function formatRegenerated(urlPath, attempt, durationMs, operationId) {
+    const ts = dim(`[${formatTimestamp(new Date())}]`);
+    const op = operationId ? ` (${operationId})` : '';
+    return `${ts} ${green(bold('[REGENERATED]'))} Successfully regenerated generator for "${urlPath}"${op} in attempt ${attempt} (${durationMs}ms).`;
+}
+export class RequestHistory {
+    #successful = new Map();
+    #maxExamples;
+    constructor(maxExamples = 5) {
+        this.#maxExamples = maxExamples;
+    }
+    recordSuccess(operationKey, input, output) {
+        let list = this.#successful.get(operationKey);
+        if (!list) {
+            list = [];
+            this.#successful.set(operationKey, list);
+        }
+        list.push({ input, output });
+        if (list.length > this.#maxExamples) {
+            list.shift();
+        }
+    }
+    getSuccessful(operationKey, count = 2) {
+        const list = this.#successful.get(operationKey);
+        if (!list || list.length === 0) {
+            return [];
+        }
+        return list.slice(-count);
+    }
+}
+export class RegenerationLimiter {
+    #counts = new Map();
+    limit;
+    constructor(limit = 3) {
+        this.limit = limit;
+    }
+    countFor(url) {
+        return this.#counts.get(url) ?? 0;
+    }
+    isLimitHit(url) {
+        return (this.#counts.get(url) ?? 0) >= this.limit;
+    }
+    increment(url) {
+        const next = (this.#counts.get(url) ?? 0) + 1;
+        this.#counts.set(url, next);
+        return next;
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/page.d.ts

@@ -0,0 +1,3 @@
+import { type Operation } from './spec.ts';
+export declare function indexPage(operations: readonly Operation[]): string;
+//# sourceMappingURL=page.d.ts.map