vovk-cli 0.0.1-draft.39 → 0.0.1-draft.392

package/dist/utils/compileTs.mjs

@@ -0,0 +1,261 @@
+import upperFirst from 'lodash/upperFirst.js';
+import camelCase from 'lodash/camelCase.js';
+export function compileTs(options) {
+    const context = {
+        refs: options.refs || new Map(),
+        compiledRefs: new Map(),
+        refsInProgress: new Set(),
+    };
+    // Collect all definitions from the schema
+    collectDefinitions(options.schema, context.refs);
+    // Ensure the main type name is valid
+    const mainTypeName = sanitizeTypeName(options.name);
+    const mainType = compileSchema(options.schema, mainTypeName, context);
+    // Compile all referenced types, unless dontCreateRefTypes is set
+    const compiledRefs = options.dontCreateRefTypes
+        ? ''
+        : Array.from(context.compiledRefs.entries())
+            .map(([, typeDecl]) => typeDecl)
+            .join('\n\n');
+    return compiledRefs
+        ? `${compiledRefs}\n\n${options.schema.description ? `/** ${escapeJSDocComment(options.schema.description)} */\n` : ''}export type ${mainTypeName} = ${mainType};`
+        : `${options.schema.description ? `/** ${escapeJSDocComment(options.schema.description)} */\n` : ''}export type ${mainTypeName} = ${mainType};`;
+}
+function collectDefinitions(schema, refs) {
+    // Collect from $defs
+    if (schema.$defs) {
+        Object.entries(schema.$defs).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/$defs/${key}`, def);
+            }
+        });
+    }
+    // Collect from definitions (older spec)
+    if (schema.definitions) {
+        Object.entries(schema.definitions).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/definitions/${key}`, def);
+            }
+        });
+    }
+    // Collect from components/schemas (OpenAPI spec)
+    if (schema?.components?.schemas) {
+        Object.entries(schema?.components?.schemas ?? {}).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/components/schemas/${key}`, def);
+            }
+        });
+    }
+    // Recursively collect from nested schemas
+    const schemasToProcess = [];
+    if (schema.properties) {
+        schemasToProcess.push(...Object.values(schema.properties).filter(isSchema));
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schemasToProcess.push(...schema.items.filter(isSchema));
+        }
+        else if (isSchema(schema.items)) {
+            schemasToProcess.push(schema.items);
+        }
+    }
+    if (schema.additionalProperties && isSchema(schema.additionalProperties)) {
+        schemasToProcess.push(schema.additionalProperties);
+    }
+    if (schema.allOf)
+        schemasToProcess.push(...schema.allOf.filter(isSchema));
+    if (schema.anyOf)
+        schemasToProcess.push(...schema.anyOf.filter(isSchema));
+    if (schema.oneOf)
+        schemasToProcess.push(...schema.oneOf.filter(isSchema));
+    schemasToProcess.forEach((s) => collectDefinitions(s, refs));
+}
+function isSchema(value) {
+    return typeof value === 'object' && !Array.isArray(value);
+}
+function compileSchema(schema, name, context) {
+    if (typeof schema === 'boolean') {
+        return schema ? 'any' : 'never';
+    }
+    // Handle x-tsType extension
+    if ('x-tsType' in schema && typeof schema['x-tsType'] === 'string') {
+        return schema['x-tsType'];
+    }
+    // Handle $ref
+    if (schema.$ref) {
+        return handleRef(schema.$ref, context);
+    }
+    // Handle combinators
+    if (schema.allOf) {
+        return handleAllOf(schema.allOf, name, context);
+    }
+    if (schema.anyOf) {
+        return handleAnyOf(schema.anyOf, name, context);
+    }
+    if (schema.oneOf) {
+        return handleOneOf(schema.oneOf, name, context);
+    }
+    // Handle type-specific compilation
+    if (schema.enum) {
+        return handleEnum(schema.enum);
+    }
+    if (schema.const !== undefined) {
+        return handleConst(schema.const);
+    }
+    if (!schema.type) {
+        // No type specified, could be object
+        if (schema.properties || schema.additionalProperties) {
+            return handleObject(schema, name, context);
+        }
+        return 'any';
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.map((t) => compileSchemaWithType({ ...schema, type: t }, name, context)).join(' | ');
+    }
+    return compileSchemaWithType(schema, name, context);
+}
+function compileSchemaWithType(schema, name, context) {
+    switch (schema.type) {
+        case 'null':
+            return 'null';
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'integer':
+            return 'number';
+        case 'array':
+            return handleArray(schema, name, context);
+        case 'object':
+            return handleObject(schema, name, context);
+        default:
+            return 'any';
+    }
+}
+function handleRef(ref, context) {
+    const typeName = refToTypeName(ref);
+    // Check if we're already compiling this ref (circular reference)
+    if (context.refsInProgress.has(ref)) {
+        return typeName;
+    }
+    // Check if already compiled
+    if (context.compiledRefs.has(ref)) {
+        return typeName;
+    }
+    // Find the referenced schema
+    const referencedSchema = context.refs.get(ref);
+    if (!referencedSchema) {
+        return 'any'; // Reference not found
+    }
+    // Mark as in progress
+    context.refsInProgress.add(ref);
+    // Compile the referenced schema
+    const compiledType = compileSchema(referencedSchema, typeName, context);
+    const description = referencedSchema.description
+        ? `/** ${escapeJSDocComment(referencedSchema.description)} */\n`
+        : '';
+    context.compiledRefs.set(ref, `${description}export type ${typeName} = ${compiledType};`);
+    // Mark as completed
+    context.refsInProgress.delete(ref);
+    return typeName;
+}
+function handleAllOf(schemas, name, context) {
+    const types = schemas.map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-all-of-${i}`), context));
+    // For allOf, we need to intersect types
+    // If they're all objects, we can merge them properly
+    const objectTypes = types.filter((t) => t.startsWith('{') && t.endsWith('}'));
+    if (objectTypes.length === types.length) {
+        // Merge object types
+        const merged = objectTypes.map((t) => t.slice(1, -1).trim()).filter((t) => t.length > 0);
+        return merged.length > 0 ? `{ ${merged.join('; ')} }` : '{}';
+    }
+    return types.join(' & ');
+}
+function handleAnyOf(schemas, name, context) {
+    const types = schemas.map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-any-of-${i}`), context));
+    return types.join(' | ');
+}
+function handleOneOf(schemas, name, context) {
+    // For TypeScript, oneOf behaves like anyOf
+    const types = schemas.map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-one-of-${i}`), context));
+    return types.join(' | ');
+}
+function handleEnum(enumValues) {
+    return enumValues.map((v) => JSON.stringify(v)).join(' | ');
+}
+function handleConst(value) {
+    return JSON.stringify(value);
+}
+function handleArray(schema, name, context) {
+    if (!schema.items) {
+        return 'any[]';
+    }
+    if (Array.isArray(schema.items)) {
+        // Tuple (ignoring min/max as requested)
+        const types = schema.items.map((item, i) => compileSchema(item, `${name}Item${i}`, context));
+        return `[${types.join(', ')}]`;
+    }
+    const itemType = compileSchema(schema.items, `${name}Item`, context);
+    return `${wrapUnionType(itemType)}[]`;
+}
+function handleObject(schema, name, context) {
+    const props = [];
+    // Handle known properties
+    if (schema.properties) {
+        const required = new Set(schema.required || []);
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            if (!isSchema(propSchema))
+                continue;
+            const isRequired = required.has(propName);
+            // Ensure the generated type name for nested properties is valid
+            const nestedTypeName = sanitizeTypeName(`${name}-${propName}`);
+            const propType = compileSchema(propSchema, nestedTypeName, context);
+            const safePropName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName) ? propName : `"${propName}"`;
+            // Add JSDoc comment if description is present
+            const comment = propSchema.description ? `\n/** ${escapeJSDocComment(propSchema.description)} */\n` : '';
+            props.push(`${comment}${safePropName}${isRequired ? '' : '?'}: ${propType}`);
+        }
+    }
+    // Handle additional properties
+    if (schema.additionalProperties === true) {
+        props.push('[key: string]: any');
+    }
+    else if (schema.additionalProperties && isSchema(schema.additionalProperties)) {
+        const additionalTypeName = sanitizeTypeName(`${name}-additional`);
+        const additionalType = compileSchema(schema.additionalProperties, additionalTypeName, context);
+        props.push(`[key: string]: ${additionalType}`);
+    }
+    // Handle pattern properties
+    if (schema.patternProperties) {
+        // For simplicity, treat pattern properties as string index signature
+        const patternTypes = Object.values(schema.patternProperties)
+            .filter(isSchema)
+            .map((s, i) => compileSchema(s, sanitizeTypeName(`${name}-pattern-${i}`), context));
+        if (patternTypes.length > 0) {
+            props.push(`[key: string]: ${patternTypes.join(' | ')}`);
+        }
+    }
+    return props.length > 0 ? `{ ${props.join('; ')} }` : '{}';
+}
+function refToTypeName(ref) {
+    // Extract the last part of the reference as the type name
+    const parts = ref.split('/');
+    const name = parts[parts.length - 1];
+    // Convert kebab-case to PascalCase
+    return upperFirst(camelCase(name));
+}
+function wrapUnionType(type) {
+    // Wrap union types in parentheses for array types
+    return type.includes('|') ? `(${type})` : type;
+}
+function sanitizeTypeName(name) {
+    return upperFirst(camelCase(name));
+}
+// Utility function to escape JSDoc comment terminators in descriptions
+function escapeJSDocComment(description) {
+    if (!description)
+        return '';
+    return description.replace(/\*\//g, '*\\/');
+}

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1,2 @@
-import { KnownAny } from '../types.mjs';
+import type { KnownAny } from 'vovk';
 export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;

package/dist/utils/deepExtend.d.mts

@@ -0,0 +1,54 @@
+/*!
+ * @description Recursive object extending
+ * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type SpecificValue = Buffer | Date | RegExp;
+declare function isSpecificValue(val: any): val is SpecificValue;
+declare function cloneSpecificValue(val: SpecificValue): SpecificValue;
+/**
+ * Recursive cloning array.
+ */
+declare function deepCloneArray<T = any>(arr: T[]): T[];
+declare function safeGetProperty<T extends object>(object: T, property: PropertyKey): any;
+/**
+ * Extending object that entered in first argument.
+ *
+ * Returns extended object or false if have no target object or incorrect type.
+ *
+ * If you wish to clone source object (without modify it), just use empty new
+ * object as first argument, like this:
+ *   deepExtend({}, yourObj_1, [yourObj_N]);
+ */
+declare function deepExtend<T extends object>(...args: [T, ...Partial<T>[]]): T;
+declare function deepExtend<T extends object, U extends object>(target: T, source: U): T & U;
+declare function deepExtend<T extends object, U extends object, V extends object>(target: T, source1: U, source2: V): T & U & V;
+declare function deepExtend<T extends object, U extends object, V extends object, W extends object>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+declare function deepExtend<T extends object>(target: T, ...sources: any[]): T;
+export default deepExtend;
+export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
+export type { DeepPartial, SpecificValue };

package/dist/utils/deepExtend.mjs

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/*!
+ * @description Recursive object extending
+ * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+ * @license MIT
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+function isSpecificValue(val) {
+    return val instanceof Buffer || val instanceof Date || val instanceof RegExp;
+}
+function cloneSpecificValue(val) {
+    if (val instanceof Buffer) {
+        const x = Buffer.alloc ? Buffer.alloc(val.length) : Buffer.from(val);
+        val.copy(x);
+        return x;
+    }
+    else if (val instanceof Date) {
+        return new Date(val.getTime());
+    }
+    else if (val instanceof RegExp) {
+        return new RegExp(val);
+    }
+    else {
+        throw new Error('Unexpected situation');
+    }
+}
+/**
+ * Recursive cloning array.
+ */
+function deepCloneArray(arr) {
+    const clone = [];
+    arr.forEach((item, index) => {
+        if (typeof item === 'object' && item !== null) {
+            if (Array.isArray(item)) {
+                clone[index] = deepCloneArray(item);
+            }
+            else if (isSpecificValue(item)) {
+                clone[index] = cloneSpecificValue(item);
+            }
+            else {
+                clone[index] = deepExtend({}, item);
+            }
+        }
+        else {
+            clone[index] = item;
+        }
+    });
+    return clone;
+}
+function safeGetProperty(object, property) {
+    return property === '__proto__' ? undefined : object[property];
+}
+function deepExtend(...args) {
+    if (args.length < 1 || typeof args[0] !== 'object') {
+        return false;
+    }
+    if (args.length < 2) {
+        return args[0];
+    }
+    const target = args[0];
+    // convert arguments to array and cut off target object
+    const sources = args.slice(1);
+    sources.forEach((obj) => {
+        // skip argument if isn't an object, is null, or is an array
+        if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+            return;
+        }
+        Object.keys(obj).forEach((key) => {
+            const src = safeGetProperty(target, key); // source value
+            const val = safeGetProperty(obj, key); // new value
+            // recursion prevention
+            if (val === target) {
+                return;
+            }
+            else if (typeof val !== 'object' || val === null) {
+                /**
+                 * if new value isn't object then just overwrite by new value
+                 * instead of extending.
+                 */
+                target[key] = val;
+                return;
+            }
+            // just clone arrays (and recursive clone objects inside)
+            else if (Array.isArray(val)) {
+                target[key] = deepCloneArray(val);
+                return;
+            }
+            // custom cloning and overwrite for specific objects
+            else if (isSpecificValue(val)) {
+                target[key] = cloneSpecificValue(val);
+                return;
+            }
+            // overwrite by new value if source isn't object or array
+            else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
+                target[key] = deepExtend({}, val);
+                return;
+            }
+            // source value and new value is objects both, extending...
+            else {
+                target[key] = deepExtend(src, val);
+                return;
+            }
+        });
+    });
+    return target;
+}
+export default deepExtend;
+export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };

package/dist/utils/formatLoggedSegmentName.d.mts

@@ -1,4 +1,6 @@
-export default function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst }?: {
+export default function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst, isStatic, segmentType, }?: {
     withChalk?: boolean;
     upperFirst?: boolean;
+    isStatic?: boolean;
+    segmentType?: 'segment' | 'mixin';
 }): string;

package/dist/utils/formatLoggedSegmentName.mjs

@@ -1,7 +1,8 @@
 import upperFirstLodash from 'lodash/upperFirst.js';
 import chalkHighlightThing from './chalkHighlightThing.mjs';
-export default function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false } = {}) {
-    let text = segmentName ? `segment "${segmentName}"` : 'the root segment';
+export default function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false, isStatic = false, segmentType = 'segment', // TODO: Apply to all formatLoggedSegmentName invocations
+ } = {}) {
+    let text = segmentName ? `${isStatic ? 'static ' : ''}${segmentType} "${segmentName}"` : 'the root segment';
     text = upperFirst ? upperFirstLodash(text) : text;
     return withChalk ? chalkHighlightThing(text) : text;
 }

package/dist/utils/generateFnName.d.mts

@@ -0,0 +1,23 @@
+import { HttpMethod } from 'vovk';
+export interface VerbMapEntry {
+    noParams?: string;
+    withParams?: string;
+    default?: string;
+}
+export declare const VERB_MAP: Record<HttpMethod, VerbMapEntry>;
+export declare function capitalize(str: string): string;
+interface GenerateFnNameOptions {
+    /** Segments to strip out (e.g. ['api','v1']) */
+    ignoreSegments?: string[];
+}
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export declare function generateFnName(method: HttpMethod, rawPath: string, opts?: GenerateFnNameOptions): string;
+export {};

package/dist/utils/generateFnName.mjs

@@ -0,0 +1,76 @@
+export const VERB_MAP = {
+    GET: { noParams: 'list', withParams: 'get' },
+    POST: { default: 'create' },
+    PUT: { default: 'update' },
+    PATCH: { default: 'patch' },
+    DELETE: { default: 'delete' },
+    HEAD: { default: 'head' },
+    OPTIONS: { default: 'options' },
+};
+export function capitalize(str) {
+    if (str.length === 0)
+        return '';
+    return str[0].toUpperCase() + str.slice(1);
+}
+const DEFAULT_OPTIONS = {
+    ignoreSegments: ['api'],
+};
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export function generateFnName(method, rawPath, opts = {}) {
+    const { ignoreSegments } = {
+        ...DEFAULT_OPTIONS,
+        ...opts,
+    };
+    // 1. Clean & split path
+    const parts = rawPath
+        .replace(/^\/|\/$/g, '') // strip leading/trailing slash
+        .split('/')
+        .filter((seg) => !ignoreSegments?.includes(seg.toLowerCase()))
+        .filter(Boolean);
+    // 2. Separate resource tokens from path-params
+    const resources = [];
+    const params = [];
+    parts.forEach((seg) => {
+        const match = seg.match(/^{?([^}]+)}?$/);
+        if (match) {
+            params.push(match[1]);
+        }
+        else {
+            resources.push(seg);
+        }
+    });
+    // 3. Pick base verb from VERB_MAP
+    let baseVerb;
+    if (method === 'GET') {
+        baseVerb = params.length ? VERB_MAP.GET.withParams : VERB_MAP.GET.noParams;
+    }
+    else {
+        baseVerb = VERB_MAP[method].default;
+    }
+    // 4. Build the “resource” part
+    const resourcePart = resources.map(capitalize).join('');
+    // 5. Build the “ByParam” suffix
+    const byParams = params.length ? 'By' + params.map(capitalize).join('') : '';
+    // 6. Combine and ensure camelCase
+    const rawName = `${baseVerb}${resourcePart}${byParams}`;
+    return rawName[0].toLowerCase() + rawName.slice(1);
+}
+/*
+// --- Example usage ---
+console.log(generateFnName('GET', '/users')); // listUsers
+console.log(generateFnName('GET', '/users/{id}')); // getUsersById
+console.log(generateFnName('POST', '/users')); // createUsers
+console.log(generateFnName('PATCH', '/users/{userId}/profile')); // patchUsersProfileByUserId
+console.log(generateFnName('DELETE', '/v1/api/orders/{orderId}')); // deleteOrdersByOrderId
+
+// You can also enable singularization:
+console.log(generateFnName('GET', '/users/{userId}/orders', { singularizeResources: true })); // getUserOrderByUserId
+*/

package/dist/utils/getPackageJson.d.mts

@@ -0,0 +1,3 @@
+import { PackageJson } from 'type-fest';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare function getPackageJson(cwd: string, log: ProjectInfo['log']): Promise<PackageJson>;

package/dist/utils/getPackageJson.mjs

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+let cachedPromise;
+export function getPackageJson(cwd, log) {
+    const pkgPath = path.join(cwd, 'package.json');
+    // If we have a cached promise, return it
+    if (cachedPromise) {
+        return cachedPromise;
+    }
+    const promise = fs
+        .readFile(pkgPath, 'utf8')
+        .then((content) => JSON.parse(content))
+        .catch(() => {
+        cachedPromise = undefined;
+        log.warn(`Failed to read package.json at ${pkgPath}. Using a fallback.`);
+        return {
+            name: 'unknown',
+        };
+    });
+    cachedPromise = promise;
+    return promise;
+}

package/dist/utils/getPublicModuleNameFromPath.d.mts

@@ -0,0 +1,4 @@
+export default function getPublicModuleNameFromPath(modulePath: string): {
+    moduleName: string | null;
+    restPath: string;
+};

package/dist/utils/getPublicModuleNameFromPath.mjs

@@ -0,0 +1,9 @@
+export default function getPublicModuleNameFromPath(modulePath) {
+    if (modulePath && !modulePath.startsWith('.') && !modulePath.startsWith('/')) {
+        const pathParts = modulePath.split('/');
+        const moduleName = pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0];
+        const restPath = pathParts.slice(pathParts[0].startsWith('@') ? 2 : 1).join('/');
+        return { moduleName, restPath };
+    }
+    return { moduleName: null, restPath: modulePath };
+}

package/dist/utils/normalizeOpenAPIMixin.d.mts

@@ -0,0 +1,14 @@
+import { HttpMethod, VovkOperationObject, VovkStrictConfig, type VovkConfig } from 'vovk';
+import { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export type GetOpenAPINameFn = (config: {
+    operationObject: VovkOperationObject;
+    method: HttpMethod;
+    path: string;
+    openAPIObject: OpenAPIObject;
+}) => string;
+export declare function normalizeOpenAPIMixin({ mixinModule, log, cwd, }: {
+    mixinModule: NonNullable<NonNullable<NonNullable<NonNullable<VovkConfig['outputConfig']>['segments']>[string]>['openAPIMixin']>;
+    log: ProjectInfo['log'];
+    cwd?: string;
+}): Promise<NonNullable<NonNullable<NonNullable<NonNullable<VovkStrictConfig['outputConfig']>['segments']>[string]>['openAPIMixin']>>;