@lark-apaas/fullstack-cli 1.1.8 → 1.1.9-alpha.1

package/dist/commands/gen-db-schema.js

@@ -73,16 +73,16 @@ export async function run(options = {}) {
             console.error('[gen-db-schema] schema.ts not generated');
             throw new Error('drizzle-kit introspect failed to generate schema.ts');
         }
-        fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
-        fs.copyFileSync(generatedSchema, SCHEMA_FILE);
-        console.log(`[gen-db-schema] ✓ Copied to ${outputPath}`);
         // 后处理 schema（使用 CommonJS require 方式加载）
         const { postprocessDrizzleSchema } = require('@lark-apaas/devtool-kits');
-        const stats = postprocessDrizzleSchema(SCHEMA_FILE);
+        const stats = postprocessDrizzleSchema(generatedSchema);
         if (stats?.unmatchedUnknown?.length) {
             console.warn('[gen-db-schema] Unmatched custom types detected:', stats.unmatchedUnknown);
         }
         console.log('[gen-db-schema] ✓ Postprocessed schema');
+        fs.mkdirSync(path.dirname(SCHEMA_FILE), { recursive: true });
+        fs.copyFileSync(generatedSchema, SCHEMA_FILE);
+        console.log(`[gen-db-schema] ✓ Copied to ${outputPath}`);
         try {
             if (options.enableNestModuleGenerate) {
                 const { parseAndGenerateNestResourceTemplate } = require('@lark-apaas/devtool-kits');

package/dist/commands/read-logs/client-std.d.ts

@@ -0,0 +1,2 @@
+export declare function readClientStdSegment(filePath: string, maxLines: number): string[];
+export declare function extractClientStdSegment(lines: string[], maxLines: number): string[];

package/dist/commands/read-logs/client-std.js

@@ -0,0 +1,98 @@
+import { readFileTailLines } from './tail.js';
+import { stripPrefixFromStdLine } from './std-utils.js';
+export function readClientStdSegment(filePath, maxLines) {
+    const lines = readFileTailLines(filePath, Math.max(maxLines * 5, 2000));
+    return extractClientStdSegment(lines, maxLines);
+}
+export function extractClientStdSegment(lines, maxLines) {
+    const bodyLines = lines.map(stripPrefixFromStdLine);
+    const hotStartMarkers = [
+        /file change detected\..*incremental compilation/i,
+        /starting incremental compilation/i,
+        /starting compilation/i,
+        /\bcompiling\b/i,
+        /\brecompil/i,
+    ];
+    const hotEndMarkers = [
+        /file change detected\..*incremental compilation/i,
+        /\bwebpack compiled\b/i,
+        /compiled successfully/i,
+        /compiled with warnings/i,
+        /compiled with errors/i,
+        /failed to compile/i,
+        /fast refresh/i,
+        /\bhmr\b/i,
+        /hot update/i,
+        /\bhot reload\b/i,
+        /\bhmr update\b/i,
+    ];
+    const compiledMarkers = [
+        /\bwebpack compiled\b/i,
+        /compiled successfully/i,
+        /compiled with warnings/i,
+        /compiled with errors/i,
+        /failed to compile/i,
+    ];
+    let startIndex = -1;
+    for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+        const line = bodyLines[i];
+        if (!line)
+            continue;
+        if (hotStartMarkers.some((re) => re.test(line))) {
+            startIndex = i;
+            break;
+        }
+    }
+    if (startIndex === -1) {
+        let pivotIndex = -1;
+        for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+            const line = bodyLines[i];
+            if (!line)
+                continue;
+            if (hotEndMarkers.some((re) => re.test(line))) {
+                pivotIndex = i;
+                break;
+            }
+        }
+        if (pivotIndex !== -1) {
+            if (compiledMarkers.some((re) => re.test(bodyLines[pivotIndex] ?? ''))) {
+                startIndex = pivotIndex;
+            }
+            else {
+                const searchLimit = 80;
+                const from = Math.max(0, pivotIndex - searchLimit);
+                for (let i = pivotIndex; i >= from; i -= 1) {
+                    const line = bodyLines[i];
+                    if (!line)
+                        continue;
+                    if (compiledMarkers.some((re) => re.test(line))) {
+                        startIndex = i;
+                        break;
+                    }
+                }
+                if (startIndex === -1) {
+                    startIndex = pivotIndex;
+                }
+            }
+        }
+    }
+    if (startIndex === -1) {
+        for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
+            const line = bodyLines[i];
+            if (!line)
+                continue;
+            if (/\bdev:client\b/.test(line)) {
+                startIndex = i;
+                break;
+            }
+        }
+    }
+    const segment = startIndex === -1 ? bodyLines : bodyLines.slice(startIndex);
+    if (segment.length === 0) {
+        return [];
+    }
+    if (segment.length <= maxLines) {
+        return segment;
+    }
+    return segment.slice(segment.length - maxLines);
+}

package/dist/commands/read-logs/json-lines.d.ts

@@ -0,0 +1,3 @@
+export declare function readJsonLinesLastPid(filePath: string, maxLines: number): string[];
+export declare function readJsonLinesByTraceId(filePath: string, traceId: string, maxLines: number): string[];
+export declare function readJsonLinesTail(lines: string[], maxLines: number): string[];

package/dist/commands/read-logs/json-lines.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+function normalizePid(value) {
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    return 'unknown';
+}
+export function readJsonLinesLastPid(filePath, maxLines) {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return [];
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    let position = stat.size;
+    let remainder = '';
+    let targetPid = null;
+    let finished = false;
+    const collected = [];
+    try {
+        while (position > 0 && !finished) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, position);
+            let chunk = buffer.toString('utf8');
+            if (remainder) {
+                chunk += remainder;
+                remainder = '';
+            }
+            const parts = chunk.split('\n');
+            remainder = parts.shift() ?? '';
+            for (let i = parts.length - 1; i >= 0; i -= 1) {
+                const line = parts[i].trim();
+                if (!line)
+                    continue;
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const pid = normalizePid(parsed?.pid);
+                if (targetPid === null) {
+                    targetPid = pid;
+                }
+                if (pid !== targetPid) {
+                    finished = true;
+                    break;
+                }
+                collected.push(line);
+                if (collected.length >= maxLines * 5) {
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        if (!finished && remainder) {
+            const line = remainder.trim();
+            if (line) {
+                try {
+                    const parsed = JSON.parse(line);
+                    const pid = normalizePid(parsed?.pid);
+                    if (targetPid === null) {
+                        targetPid = pid;
+                    }
+                    if (pid === targetPid) {
+                        collected.push(line);
+                    }
+                }
+                catch {
+                    return [];
+                }
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const reversed = collected.reverse();
+    if (reversed.length <= maxLines) {
+        return reversed;
+    }
+    return reversed.slice(reversed.length - maxLines);
+}
+function normalizeTraceId(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        return trimmed ? trimmed : null;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return String(value);
+    }
+    return null;
+}
+function extractTraceId(obj) {
+    if (!obj || typeof obj !== 'object')
+        return null;
+    const record = obj;
+    const directKeys = ['trace_id', 'traceId', 'traceID', 'traceid'];
+    for (const key of directKeys) {
+        const value = normalizeTraceId(record[key]);
+        if (value)
+            return value;
+    }
+    const meta = record['meta'];
+    if (meta && typeof meta === 'object') {
+        const metaRecord = meta;
+        for (const key of directKeys) {
+            const value = normalizeTraceId(metaRecord[key]);
+            if (value)
+                return value;
+        }
+    }
+    const attributes = record['attributes'];
+    if (attributes && typeof attributes === 'object') {
+        const attrRecord = attributes;
+        for (const key of ['traceID', 'trace_id', 'traceId', 'traceid']) {
+            const value = normalizeTraceId(attrRecord[key]);
+            if (value)
+                return value;
+        }
+    }
+    return null;
+}
+export function readJsonLinesByTraceId(filePath, traceId, maxLines) {
+    const wanted = traceId.trim();
+    if (!wanted)
+        return [];
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return [];
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    let position = stat.size;
+    let remainder = '';
+    let processedNonEmpty = 0;
+    let finished = false;
+    const collected = [];
+    const maxProcessed = Math.max(maxLines * 200, 5000);
+    try {
+        while (position > 0 && !finished) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, position);
+            let chunk = buffer.toString('utf8');
+            if (remainder) {
+                chunk += remainder;
+                remainder = '';
+            }
+            const parts = chunk.split('\n');
+            remainder = parts.shift() ?? '';
+            for (let i = parts.length - 1; i >= 0; i -= 1) {
+                const line = parts[i].trim();
+                if (!line)
+                    continue;
+                processedNonEmpty += 1;
+                try {
+                    const parsed = JSON.parse(line);
+                    const lineTraceId = extractTraceId(parsed);
+                    if (lineTraceId === wanted) {
+                        collected.push(line);
+                        if (collected.length >= maxLines) {
+                            finished = true;
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+                if (processedNonEmpty >= maxProcessed && collected.length > 0) {
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        if (!finished && remainder) {
+            const line = remainder.trim();
+            if (line) {
+                try {
+                    const parsed = JSON.parse(line);
+                    const lineTraceId = extractTraceId(parsed);
+                    if (lineTraceId === wanted) {
+                        collected.push(line);
+                    }
+                }
+                catch {
+                    return [];
+                }
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return collected.reverse();
+}
+export function readJsonLinesTail(lines, maxLines) {
+    const result = [];
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        result.push(line);
+        if (result.length >= maxLines) {
+            break;
+        }
+    }
+    return result.reverse();
+}

package/dist/commands/read-logs/server-std.d.ts

@@ -0,0 +1 @@
+export declare function readServerStdSegment(filePath: string, maxLines: number): string[];

package/dist/commands/read-logs/server-std.js

@@ -0,0 +1,25 @@
+import { readFileTailLines } from './tail.js';
+import { readStdLinesTailFromLastMarker, stripPrefixFromStdLine } from './std-utils.js';
+export function readServerStdSegment(filePath, maxLines) {
+    const marker = (line) => {
+        if (!line)
+            return false;
+        if (/\bdev:server\b/.test(line))
+            return true;
+        if (line.includes('Starting compilation in watch mode'))
+            return true;
+        if (line.includes('File change detected. Starting incremental compilation'))
+            return true;
+        if (line.includes('Starting Nest application'))
+            return true;
+        if (line.includes('Nest application successfully started'))
+            return true;
+        return false;
+    };
+    const segment = readStdLinesTailFromLastMarker(filePath, maxLines, marker);
+    if (segment.markerFound) {
+        return segment.lines;
+    }
+    const lines = readFileTailLines(filePath, maxLines);
+    return lines.map(stripPrefixFromStdLine);
+}

package/dist/commands/read-logs/std-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function stripPrefixFromStdLine(line: string): string;
+export declare function readStdLinesTailFromLastMarker(filePath: string, maxLines: number, isMarker: (line: string) => boolean): {
+    lines: string[];
+    markerFound: boolean;
+};

package/dist/commands/read-logs/std-utils.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+export function stripPrefixFromStdLine(line) {
+    const match = line.match(/^(\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(server|client)\] )(.*)$/);
+    if (!match) {
+        return line;
+    }
+    return match[4] || '';
+}
+export function readStdLinesTailFromLastMarker(filePath, maxLines, isMarker) {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return { lines: [], markerFound: false };
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    let position = stat.size;
+    let remainder = '';
+    let markerFound = false;
+    let finished = false;
+    const collected = [];
+    try {
+        while (position > 0 && !finished) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, position);
+            let chunk = buffer.toString('utf8');
+            if (remainder) {
+                chunk += remainder;
+                remainder = '';
+            }
+            const parts = chunk.split('\n');
+            remainder = parts.shift() ?? '';
+            for (let i = parts.length - 1; i >= 0; i -= 1) {
+                const rawLine = parts[i];
+                const line = stripPrefixFromStdLine(rawLine);
+                if (collected.length < maxLines) {
+                    collected.push(line);
+                }
+                if (isMarker(line)) {
+                    markerFound = true;
+                    finished = true;
+                    break;
+                }
+            }
+        }
+        if (!finished && remainder) {
+            const line = stripPrefixFromStdLine(remainder);
+            if (collected.length < maxLines) {
+                collected.push(line);
+            }
+            if (isMarker(line)) {
+                markerFound = true;
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return { lines: collected.reverse(), markerFound };
+}

package/dist/commands/read-logs/tail.d.ts

@@ -0,0 +1,2 @@
+export declare function fileExists(filePath: string): boolean;
+export declare function readFileTailLines(filePath: string, maxLines: number): string[];

package/dist/commands/read-logs/tail.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+export function fileExists(filePath) {
+    try {
+        fs.accessSync(filePath, fs.constants.F_OK | fs.constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readFileTailLines(filePath, maxLines) {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) {
+        return [];
+    }
+    const fd = fs.openSync(filePath, 'r');
+    const chunkSize = 64 * 1024;
+    const chunks = [];
+    let position = stat.size;
+    let collectedLines = 0;
+    try {
+        while (position > 0 && collectedLines <= maxLines) {
+            const length = Math.min(chunkSize, position);
+            position -= length;
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, position);
+            chunks.unshift(buffer.toString('utf8'));
+            const chunkLines = buffer.toString('utf8').split('\n').length - 1;
+            collectedLines += chunkLines;
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const content = chunks.join('');
+    const allLines = content.split('\n');
+    if (allLines.length === 0) {
+        return [];
+    }
+    if (allLines[allLines.length - 1] === '') {
+        allLines.pop();
+    }
+    if (allLines.length <= maxLines) {
+        return allLines;
+    }
+    return allLines.slice(allLines.length - maxLines);
+}

package/dist/commands/read-logs.d.ts

@@ -1,9 +1,16 @@
-type LogType = 'server' | 'trace' | 'server-std' | 'client-std' | 'browser' | 'client';
+type LogType = 'server' | 'trace' | 'server-std' | 'client-std' | 'browser';
+export interface ReadLogsJsonResult {
+    hasError: boolean;
+    message: string;
+    logs?: unknown[];
+}
 interface ReadLogsOptions {
     logDir: string;
     type: LogType;
     maxLines?: number;
+    traceId?: string;
 }
 export declare function readLatestLogLines(options: ReadLogsOptions): Promise<string[]>;
+export declare function readLogsJsonResult(options: ReadLogsOptions): Promise<ReadLogsJsonResult>;
 export declare function run(options: ReadLogsOptions): Promise<void>;
 export {};