vovk-cli 0.0.1-draft.35 → 0.0.1-draft.351

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';
-export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;
+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/debounceWithArgs.mjs

@@ -1,11 +1,29 @@
-import debounce from 'lodash/debounce.js';
-export default function debounceWithArgs(fn, wait) {
-    const debouncedFunctions = new Map();
+export default function debounceWithArgs(callback, wait) {
+    // Stores timeouts keyed by the stringified arguments
+    const timeouts = new Map();
     return (...args) => {
+        // Convert arguments to a JSON string (or any other stable key generation)
         const key = JSON.stringify(args);
-        if (!debouncedFunctions.has(key)) {
-            debouncedFunctions.set(key, debounce(fn, wait));
+        // Clear any existing timer for this specific key
+        if (timeouts.has(key)) {
+            clearTimeout(timeouts.get(key));
         }
-        return debouncedFunctions.get(key)(...args);
+        // Return a promise that resolves/rejects after the debounce delay
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(async () => {
+                try {
+                    const result = await callback(...args);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    // Remove the entry once the callback is invoked
+                    timeouts.delete(key);
+                }
+            }, wait);
+            timeouts.set(key, timeoutId);
+        });
     };
 }

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['generatorConfig']>['segments']>[string]>['openAPIMixin']>;
+    log: ProjectInfo['log'];
+    cwd?: string;
+}): Promise<NonNullable<NonNullable<NonNullable<VovkStrictConfig['generatorConfig']>['segments']>[string]>['openAPIMixin']>;

package/dist/utils/normalizeOpenAPIMixin.mjs

@@ -0,0 +1,114 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as YAML from 'yaml';
+import chalkHighlightThing from './chalkHighlightThing.mjs';
+import camelCase from 'lodash/camelCase.js';
+import { generateFnName } from './generateFnName.mjs';
+const getNamesNestJS = (operationObject) => {
+    const operationId = operationObject.operationId;
+    if (!operationId) {
+        throw new Error('Operation ID is required for NestJS module name generation');
+    }
+    const controllerHandlerMatch = operationId?.match(/^([A-Z][a-zA-Z0-9]*)_([a-zA-Z0-9_]+)/);
+    if (!controllerHandlerMatch) {
+        throw new Error(`Invalid operationId format for NestJS: ${operationId}`);
+    }
+    const [controllerName, handlerName] = controllerHandlerMatch.slice(1, 3);
+    return [controllerName.replace(/Controller$/, 'RPC'), handlerName];
+};
+const normalizeGetModuleName = (getModuleName) => {
+    if (getModuleName === 'nestjs-operation-id') {
+        getModuleName = ({ operationObject }) => getNamesNestJS(operationObject)[0];
+    }
+    else if (typeof getModuleName === 'string') {
+        const moduleName = getModuleName;
+        getModuleName = () => moduleName;
+    }
+    else if (typeof getModuleName !== 'function') {
+        throw new Error('getModuleName must be a function or one of the predefined strings');
+    }
+    return getModuleName;
+};
+const normalizeGetMethodName = (getMethodName) => {
+    if (getMethodName === 'nestjs-operation-id') {
+        getMethodName = ({ operationObject }) => getNamesNestJS(operationObject)[1];
+    }
+    else if (getMethodName === 'camel-case-operation-id') {
+        getMethodName = ({ operationObject }) => {
+            const operationId = operationObject.operationId;
+            if (!operationId) {
+                throw new Error('Operation ID is required for camel-case method name generation');
+            }
+            return camelCase(operationId);
+        };
+    }
+    else if (getMethodName === 'auto') {
+        getMethodName = ({ operationObject, method, path }) => {
+            const operationId = operationObject.operationId;
+            const isCamelCase = operationId && /^[a-z][a-zA-Z0-9]*$/.test(operationId);
+            const isSnakeCase = operationId && /^[a-z][a-z0-9_]+$/.test(operationId);
+            return isCamelCase ? operationId : isSnakeCase ? camelCase(operationId) : generateFnName(method, path);
+        };
+    }
+    else if (typeof getMethodName !== 'function') {
+        throw new Error('getMethodName must be a function or one of the predefined strings');
+    }
+    return getMethodName;
+};
+async function getOpenApiSpecLocal(openApiSpecFilePath, cwd) {
+    const openApiSpecAbsolutePath = path.resolve(cwd, openApiSpecFilePath);
+    const fileName = path.basename(openApiSpecAbsolutePath);
+    if (!fileName.endsWith('.json') && !fileName.endsWith('.yaml') && !fileName.endsWith('.yml')) {
+        throw new Error(`Invalid OpenAPI spec file format: ${fileName}. Please provide a JSON or YAML file.`);
+    }
+    const openApiSpecContent = await fs.readFile(openApiSpecAbsolutePath, 'utf8');
+    return (fileName.endsWith('.json') ? JSON.parse(openApiSpecContent) : YAML.parse(openApiSpecContent));
+}
+async function getOpenApiSpecRemote({ cwd, url, fallback, log, }) {
+    const resp = await fetch(url);
+    const text = await resp.text();
+    if (!resp.ok) {
+        if (fallback) {
+            log.warn(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}. Falling back to ${chalkHighlightThing(fallback)}`);
+            return getOpenApiSpecLocal(fallback, cwd);
+        }
+        throw new Error(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}`);
+    }
+    if (fallback) {
+        const fallbackAbsolutePath = path.resolve(cwd, fallback);
+        const existingFallback = await fs.readFile(fallbackAbsolutePath, 'utf8').catch(() => null);
+        if (existingFallback !== text) {
+            await fs.mkdir(path.dirname(fallbackAbsolutePath), { recursive: true });
+            await fs.writeFile(fallbackAbsolutePath, text);
+            log.info(`Saved OpenAPI spec to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+        else {
+            log.debug(`OpenAPI spec at ${chalkHighlightThing(url)} is unchanged. Skipping write to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+    }
+    return (text.trim().startsWith('{') || text.trim().startsWith('[') ? JSON.parse(text) : YAML.parse(text));
+}
+export async function normalizeOpenAPIMixin({ 
+// mixinName,
+mixinModule, log, cwd = process.cwd(), }) {
+    const { source, getModuleName, getMethodName } = mixinModule;
+    let openAPIObject;
+    if ('url' in source) {
+        openAPIObject = await getOpenApiSpecRemote({ url: source.url, fallback: source.fallback, log, cwd });
+    }
+    else if ('file' in source) {
+        openAPIObject = await getOpenApiSpecLocal(source.file, cwd);
+    }
+    else if ('object' in source) {
+        openAPIObject = source.object;
+    }
+    else {
+        throw new Error('Invalid source type for OpenAPI configuration');
+    }
+    return {
+        ...mixinModule,
+        source: { object: openAPIObject },
+        getModuleName: normalizeGetModuleName(getModuleName),
+        getMethodName: normalizeGetMethodName(getMethodName),
+    };
+}

package/dist/utils/pickSegmentFullSchema.d.mts

@@ -0,0 +1,3 @@
+import { type VovkSchema } from 'vovk';
+export default function pickSegmentFullSchema(schema: VovkSchema, segmentNames: string[]): VovkSchema;
+export declare function omitSegmentFullSchema(schema: VovkSchema, segmentNames: string[]): VovkSchema;

package/dist/utils/pickSegmentFullSchema.mjs

@@ -0,0 +1,15 @@
+import { VovkSchemaIdEnum } from 'vovk';
+export default function pickSegmentFullSchema(schema, segmentNames) {
+    return {
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        meta: schema.meta,
+        segments: Object.fromEntries(segmentNames.map((segmentName) => [segmentName, schema.segments[segmentName]])),
+    };
+}
+export function omitSegmentFullSchema(schema, segmentNames) {
+    return {
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        meta: schema.meta,
+        segments: Object.fromEntries(Object.entries(schema.segments).filter(([segmentName]) => !segmentNames.includes(segmentName))),
+    };
+}

package/dist/utils/removeUnlistedDirectories.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+declare function removeUnlistedDirectories(folderPath: string, allowedDirs: string[]): Promise<void>;
+export default removeUnlistedDirectories;