@mintlify/prebuild 1.0.996 → 1.0.998

package/dist/prebuild/__tests__/resolveRefs.test.js

@@ -1,9 +1,9 @@
+import { CircularRefError, PathTraversalError, RefInvalidJsonError, RefNotFoundError, resolveRefs, } from '@mintlify/validation';
 import { mkdtemp, writeFile, mkdir, rm } from 'fs/promises';
 import { readFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import path from 'path';
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { resolveRefs, RefNotFoundError, CircularRefError, PathTraversalError, RefInvalidJsonError, } from '../resolveRefs.js';
 describe('resolveRefs', () => {
     let tempDir;
     let reader;
@@ -37,8 +37,8 @@ describe('resolveRefs', () => {
         const input = { tabs: { $ref: './nav/tabs.json' } };
         const { resolved, referencedFiles } = await resolveRefs(input, reader);
         expect(resolved).toEqual({ tabs: { items: ['page1', 'page2'] } });
-        expect(referencedFiles).toContain(path.join('nav', 'tabs.json'));
-        expect(referencedFiles).toContain(path.join('nav', 'items.json'));
+        expect(referencedFiles).toContain('nav/tabs.json');
+        expect(referencedFiles).toContain('nav/items.json');
     });
     it('resolves $ref inside array elements', async () => {
         await writeJson('group1.json', { group: 'API', pages: ['api/get', 'api/post'] });

package/dist/prebuild/resolveRefs.d.ts

@@ -1,18 +1,4 @@
-export declare class RefNotFoundError extends Error {
-    constructor(refPath: string, referencedFrom: string);
-}
-export declare class CircularRefError extends Error {
-    constructor(chain: string[]);
-}
-export declare class PathTraversalError extends Error {
-    constructor(refPath: string);
-}
-export declare class RefInvalidJsonError extends Error {
-    constructor(refPath: string, details: string);
-}
-export interface ResolveRefsResult {
-    resolved: unknown;
-    referencedFiles: string[];
-}
-export declare function resolveRefs(value: unknown, readFile: (relativePath: string) => Promise<string>): Promise<ResolveRefsResult>;
+import { CircularRefError, PathTraversalError, RefInvalidJsonError, RefNotFoundError, resolveRefs, type ResolveRefsResult } from '@mintlify/validation';
+export { CircularRefError, PathTraversalError, RefInvalidJsonError, RefNotFoundError, resolveRefs };
+export type { ResolveRefsResult };
 export declare function resolveFileRefs(value: unknown, contentDirectory: string): Promise<ResolveRefsResult>;

package/dist/prebuild/resolveRefs.js

@@ -1,95 +1,7 @@
+import { CircularRefError, PathTraversalError, RefInvalidJsonError, RefNotFoundError, resolveRefs, } from '@mintlify/validation';
 import { readFile } from 'fs/promises';
 import path from 'path';
-export class RefNotFoundError extends Error {
-    constructor(refPath, referencedFrom) {
-        super(`Referenced config file '${refPath}' does not exist (referenced from ${referencedFrom})`);
-        this.name = 'RefNotFoundError';
-    }
-}
-export class CircularRefError extends Error {
-    constructor(chain) {
-        super(`Circular reference detected: ${chain.join(' → ')}`);
-        this.name = 'CircularRefError';
-    }
-}
-export class PathTraversalError extends Error {
-    constructor(refPath) {
-        super(`Referenced config file '${refPath}' is outside the project directory`);
-        this.name = 'PathTraversalError';
-    }
-}
-export class RefInvalidJsonError extends Error {
-    constructor(refPath, details) {
-        super(`Referenced config file '${refPath}' contains invalid JSON: ${details}`);
-        this.name = 'RefInvalidJsonError';
-    }
-}
-function isJsonObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function getRefPath(value) {
-    if (!isJsonObject(value) || typeof value.$ref !== 'string')
-        return undefined;
-    return value.$ref;
-}
-function resolveRefPath(refPath, fromFile) {
-    if (fromFile)
-        return path.normalize(path.join(path.dirname(fromFile), refPath));
-    return path.normalize(refPath);
-}
-async function loadRefFile(refPath, fullPath, readFile, fromFile) {
-    let content;
-    try {
-        content = await readFile(fullPath);
-    }
-    catch {
-        throw new RefNotFoundError(refPath, fromFile ?? 'project root');
-    }
-    try {
-        return JSON.parse(content);
-    }
-    catch (e) {
-        throw new RefInvalidJsonError(refPath, e instanceof Error ? e.message : String(e));
-    }
-}
-export async function resolveRefs(value, readFile) {
-    const referencedFiles = [];
-    async function resolve(value, visited, fromFile) {
-        const refPath = getRefPath(value);
-        if (refPath != null) {
-            const fullPath = resolveRefPath(refPath, fromFile);
-            if (fullPath.startsWith('..'))
-                throw new PathTraversalError(refPath);
-            if (visited.has(fullPath))
-                throw new CircularRefError([...visited, fullPath]);
-            const parsed = await loadRefFile(refPath, fullPath, readFile, fromFile);
-            referencedFiles.push(fullPath);
-            const resolvedRef = await resolve(parsed, new Set([...visited, fullPath]), fullPath);
-            if (isJsonObject(resolvedRef)) {
-                const siblings = Object.entries(value).filter(([key]) => key !== '$ref');
-                const result = { ...resolvedRef };
-                for (const [key, val] of siblings) {
-                    result[key] = await resolve(val, visited, fromFile);
-                }
-                return result;
-            }
-            return resolvedRef;
-        }
-        if (Array.isArray(value)) {
-            return Promise.all(value.map((item) => resolve(item, visited, fromFile)));
-        }
-        if (isJsonObject(value)) {
-            const result = {};
-            for (const [key, val] of Object.entries(value)) {
-                result[key] = await resolve(val, visited, fromFile);
-            }
-            return result;
-        }
-        return value;
-    }
-    const resolved = await resolve(value, new Set());
-    return { resolved, referencedFiles };
-}
+export { CircularRefError, PathTraversalError, RefInvalidJsonError, RefNotFoundError, resolveRefs };
 export async function resolveFileRefs(value, contentDirectory) {
     return resolveRefs(value, (relativePath) => readFile(path.join(contentDirectory, relativePath), 'utf-8'));
 }