norn-cli 2.3.0 → 2.4.0

package/out/apiResponseIntellisenseCache.js

@@ -0,0 +1,394 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseApiResponseRequestLine = parseApiResponseRequestLine;
+exports.parseApiResponseRequestText = parseApiResponseRequestText;
+exports.saveApiResponseShapeForRequest = saveApiResponseShapeForRequest;
+exports.getCachedApiResponseShapeForRequest = getCachedApiResponseShapeForRequest;
+exports.getApiResponseShapeNodeAtPath = getApiResponseShapeNodeAtPath;
+exports.getApiResponseShapeProperties = getApiResponseShapeProperties;
+exports.getApiResponseShapeTypeSummary = getApiResponseShapeTypeSummary;
+exports.parseApiResponseBodyPathForCompletion = parseApiResponseBodyPathForCompletion;
+const crypto = __importStar(require("crypto"));
+const path = __importStar(require("path"));
+const cacheDir_1 = require("./cacheDir");
+const stringUtils_1 = require("./stringUtils");
+const CACHE_VERSION = 1;
+const CACHE_FILE = 'api-response-intellisense.json';
+const MAX_DEPTH = 6;
+const MAX_OBJECT_PROPERTIES = 100;
+const MAX_ARRAY_ITEMS = 20;
+function removeRetryOptions(value) {
+    return value
+        .replace(/\bretry\s+\d+\b/ig, '')
+        .replace(/\bbackoff\s+\d+(?:\.\d+)?\s*(?:s|ms|seconds?|milliseconds?)?\b/ig, '')
+        .trim();
+}
+function normalizeQuotedTarget(target) {
+    const trimmed = target.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith('\'') && trimmed.endsWith('\''))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function normalizeTargetForIdentity(target) {
+    return normalizeQuotedTarget(removeRetryOptions(target)).replace(/\s+/g, ' ').trim();
+}
+function hashTarget(target) {
+    return crypto.createHash('sha256').update(target).digest('hex').slice(0, 16);
+}
+function redactSensitiveTargetParts(target) {
+    let redacted = target.replace(/(https?:\/\/)([^/\s:@]+):([^/\s@]+)@/ig, '$1***@');
+    redacted = redacted.replace(/([?&][^=&\s]*(?:token|secret|password|passwd|pwd|key|auth|signature|sig)[^=&\s]*=)[^&\s]+/ig, '$1***');
+    redacted = redacted.replace(/\b(?:bearer|basic)\s+[a-z0-9._~+/=-]+/ig, match => `${match.split(/\s+/)[0]} ***`);
+    return redacted;
+}
+function normalizeEnvironment(environment) {
+    const trimmed = environment?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizeIdentity(identity) {
+    const rootPath = (0, cacheDir_1.findProjectRoot)(identity.sourceFile);
+    const absoluteSourceFile = path.resolve(identity.sourceFile);
+    const relativeSourceFile = path.relative(rootPath, absoluteSourceFile).replace(/\\/g, '/');
+    const target = normalizeTargetForIdentity(identity.target);
+    return {
+        rootPath,
+        sourceFile: relativeSourceFile || path.basename(absoluteSourceFile),
+        sourceLine: identity.sourceLine,
+        method: identity.method.toUpperCase(),
+        target,
+        targetHash: hashTarget(target),
+        environment: normalizeEnvironment(identity.environment)
+    };
+}
+function buildCacheKey(identity) {
+    return [
+        identity.sourceFile,
+        identity.sourceLine === undefined ? '' : String(identity.sourceLine),
+        identity.method,
+        identity.targetHash,
+        identity.environment ?? ''
+    ].map(encodeURIComponent).join('|');
+}
+function getCachePath(rootPath) {
+    return (0, cacheDir_1.getNornCacheFilePath)(rootPath, CACHE_FILE);
+}
+function loadCache(rootPath) {
+    return (0, cacheDir_1.loadVersionedJsonCache)({
+        cachePath: getCachePath(rootPath),
+        version: CACHE_VERSION,
+        createDefault: () => ({ version: CACHE_VERSION, entries: {} }),
+        isValid: cache => typeof cache.entries === 'object' && cache.entries !== null
+    });
+}
+function saveCache(rootPath, cache) {
+    return (0, cacheDir_1.saveVersionedJsonCache)(getCachePath(rootPath), cache, () => !!(0, cacheDir_1.ensureNornCacheDir)(rootPath));
+}
+function parseApiResponseRequestLine(line) {
+    const trimmed = (0, stringUtils_1.stripInlineComment)(line).trim();
+    const varMatch = trimmed.match(/^var\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+    if (varMatch) {
+        return {
+            variableName: varMatch[1],
+            method: varMatch[2].toUpperCase(),
+            target: normalizeTargetForIdentity(varMatch[3])
+        };
+    }
+    const requestMatch = trimmed.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(.+)$/i);
+    if (!requestMatch) {
+        return undefined;
+    }
+    return {
+        method: requestMatch[1].toUpperCase(),
+        target: normalizeTargetForIdentity(requestMatch[2])
+    };
+}
+function parseApiResponseRequestText(requestText) {
+    const lines = requestText.split('\n');
+    for (let lineOffset = 0; lineOffset < lines.length; lineOffset++) {
+        const request = parseApiResponseRequestLine(lines[lineOffset]);
+        if (request) {
+            return { lineOffset, request };
+        }
+    }
+    return undefined;
+}
+function getCacheableJsonRoot(responseBody) {
+    let candidate = responseBody;
+    if (typeof candidate === 'string') {
+        try {
+            candidate = JSON.parse(candidate);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (candidate !== null && typeof candidate === 'object') {
+        return candidate;
+    }
+    return undefined;
+}
+function getPrimitiveShape(value) {
+    if (value === null) {
+        return { type: 'null' };
+    }
+    switch (typeof value) {
+        case 'string':
+            return { type: 'string' };
+        case 'number':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        default:
+            return { type: 'unknown' };
+    }
+}
+function buildShape(value, depth = 0) {
+    if (depth >= MAX_DEPTH) {
+        if (Array.isArray(value)) {
+            return { type: 'array', items: { type: 'unknown' } };
+        }
+        if (value !== null && typeof value === 'object') {
+            return { type: 'object', properties: {} };
+        }
+        return getPrimitiveShape(value);
+    }
+    if (Array.isArray(value)) {
+        const itemShapes = value
+            .slice(0, MAX_ARRAY_ITEMS)
+            .map(item => buildShape(item, depth + 1));
+        return {
+            type: 'array',
+            items: mergeShapes(itemShapes)
+        };
+    }
+    if (value !== null && typeof value === 'object') {
+        const properties = {};
+        const entries = Object.entries(value).slice(0, MAX_OBJECT_PROPERTIES);
+        for (const [name, propertyValue] of entries) {
+            properties[name] = buildShape(propertyValue, depth + 1);
+        }
+        return { type: 'object', properties };
+    }
+    return getPrimitiveShape(value);
+}
+function mergeObjectShapes(nodes) {
+    const propertyNames = new Set();
+    for (const node of nodes) {
+        for (const name of Object.keys(node.properties ?? {})) {
+            propertyNames.add(name);
+        }
+    }
+    const properties = {};
+    for (const name of [...propertyNames].slice(0, MAX_OBJECT_PROPERTIES)) {
+        const propertyShapes = nodes
+            .map(node => node.properties?.[name])
+            .filter((node) => Boolean(node));
+        properties[name] = mergeShapes(propertyShapes);
+    }
+    return { type: 'object', properties };
+}
+function mergeArrayShapes(nodes) {
+    return {
+        type: 'array',
+        items: mergeShapes(nodes
+            .map(node => node.items)
+            .filter((node) => Boolean(node)))
+    };
+}
+function mergeShapes(nodes) {
+    if (nodes.length === 0) {
+        return { type: 'unknown' };
+    }
+    const hasNull = nodes.some(node => node.type === 'null');
+    const nonNullNodes = nodes.filter(node => node.type !== 'null');
+    const effectiveNodes = nonNullNodes.length > 0 ? nonNullNodes : nodes;
+    const firstType = effectiveNodes[0].type;
+    const sameType = effectiveNodes.every(node => node.type === firstType);
+    if (!sameType) {
+        return { type: 'unknown', nullable: hasNull || undefined };
+    }
+    let merged;
+    if (firstType === 'object') {
+        merged = mergeObjectShapes(effectiveNodes);
+    }
+    else if (firstType === 'array') {
+        merged = mergeArrayShapes(effectiveNodes);
+    }
+    else {
+        merged = { type: firstType };
+    }
+    if (hasNull && merged.type !== 'null') {
+        merged.nullable = true;
+    }
+    return merged;
+}
+function saveApiResponseShapeForRequest(identity, responseBody) {
+    const root = getCacheableJsonRoot(responseBody);
+    if (root === undefined) {
+        return false;
+    }
+    const shape = buildShape(root);
+    if (shape.type !== 'object' && shape.type !== 'array') {
+        return false;
+    }
+    const normalizedIdentity = normalizeIdentity(identity);
+    const cache = loadCache(normalizedIdentity.rootPath);
+    const key = buildCacheKey(normalizedIdentity);
+    cache.entries[key] = {
+        method: normalizedIdentity.method,
+        target: redactSensitiveTargetParts(normalizedIdentity.target),
+        targetHash: normalizedIdentity.targetHash,
+        sourceFile: normalizedIdentity.sourceFile,
+        sourceLine: normalizedIdentity.sourceLine,
+        environment: normalizedIdentity.environment,
+        cachedAt: new Date().toISOString(),
+        shape
+    };
+    return saveCache(normalizedIdentity.rootPath, cache);
+}
+function findBestEntry(entries, identity) {
+    const exactLineEntries = entries.filter(entry => entry.sourceLine === identity.sourceLine);
+    const linePreferredEntries = exactLineEntries.length > 0 ? exactLineEntries : entries;
+    const exactEnvironment = identity.environment
+        ? linePreferredEntries.find(entry => entry.environment === identity.environment)
+        : undefined;
+    if (exactEnvironment) {
+        return exactEnvironment;
+    }
+    const noEnvironment = linePreferredEntries.find(entry => !entry.environment);
+    if (noEnvironment) {
+        return noEnvironment;
+    }
+    return linePreferredEntries
+        .slice()
+        .sort((a, b) => b.cachedAt.localeCompare(a.cachedAt))[0];
+}
+function getCachedApiResponseShapeForRequest(identity) {
+    const normalizedIdentity = normalizeIdentity(identity);
+    const cache = loadCache(normalizedIdentity.rootPath);
+    const exactKey = buildCacheKey(normalizedIdentity);
+    const exactEntry = cache.entries[exactKey];
+    if (exactEntry) {
+        return exactEntry;
+    }
+    const candidates = Object.values(cache.entries).filter(entry => entry.sourceFile === normalizedIdentity.sourceFile &&
+        entry.method === normalizedIdentity.method &&
+        entry.targetHash === normalizedIdentity.targetHash);
+    return findBestEntry(candidates, normalizedIdentity);
+}
+function isNumericSegment(segment) {
+    return /^\d+$/.test(segment);
+}
+function getApiResponseShapeNodeAtPath(shape, pathSegments) {
+    let current = shape;
+    for (const segment of pathSegments) {
+        if (!current) {
+            return undefined;
+        }
+        if (current.type === 'array') {
+            current = current.items;
+            if (isNumericSegment(segment)) {
+                continue;
+            }
+        }
+        if (current?.type !== 'object') {
+            return undefined;
+        }
+        current = current.properties?.[segment];
+    }
+    return current;
+}
+function isPathSafePropertyName(name) {
+    return /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name);
+}
+function getApiResponseShapeProperties(node) {
+    if (!node) {
+        return [];
+    }
+    if (node.type === 'array') {
+        const itemProperties = getApiResponseShapeProperties(node.items);
+        return [
+            { name: 'count', shape: { type: 'number' } },
+            ...itemProperties
+        ];
+    }
+    if (node.type !== 'object' || !node.properties) {
+        return [];
+    }
+    return Object.entries(node.properties)
+        .filter(([name]) => isPathSafePropertyName(name))
+        .map(([name, shape]) => ({ name, shape }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+function getApiResponseShapeTypeSummary(node) {
+    let summary;
+    if (node.type === 'array') {
+        const itemSummary = node.items ? getApiResponseShapeTypeSummary(node.items) : 'unknown';
+        summary = `array<${itemSummary}>`;
+    }
+    else {
+        summary = node.type;
+    }
+    return node.nullable ? `${summary} | null` : summary;
+}
+function parseApiResponseBodyPathForCompletion(suffix) {
+    const pathSuffix = suffix.startsWith('[') ? `.${suffix}` : suffix;
+    if (!pathSuffix.startsWith('.')) {
+        return undefined;
+    }
+    const normalized = pathSuffix.replace(/\[(\d+)\]/g, '.$1');
+    if (!normalized.startsWith('.')) {
+        return undefined;
+    }
+    const withoutLeadingDot = normalized.slice(1);
+    const endsAtSeparator = normalized.endsWith('.');
+    const rawParts = withoutLeadingDot.split('.');
+    const nonEmptyParts = rawParts.filter(part => part !== '');
+    if (endsAtSeparator) {
+        return {
+            pathSegments: nonEmptyParts,
+            partial: ''
+        };
+    }
+    const partial = nonEmptyParts.at(-1) ?? '';
+    return {
+        pathSegments: nonEmptyParts.slice(0, -1),
+        partial
+    };
+}
+//# sourceMappingURL=apiResponseIntellisenseCache.js.map