@pikku/cli 0.12.6 → 0.12.8

package/dist/src/utils/openapi/naming.js

@@ -1,167 +0,0 @@
-/**
- * Derives function/method names from HTTP method + path.
- * Uses operationId when available, otherwise generates from path segments.
- */
-const IRREGULAR_PLURALS = {
-    addresses: 'address',
-    statuses: 'status',
-    indices: 'index',
-    analyses: 'analysis',
-    quizzes: 'quiz',
-    matrices: 'matrix',
-    vertices: 'vertex',
-    aliases: 'alias',
-    buses: 'bus',
-};
-export function singularize(word) {
-    const lower = word.toLowerCase();
-    if (IRREGULAR_PLURALS[lower]) {
-        const singular = IRREGULAR_PLURALS[lower];
-        return word[0] === word[0].toUpperCase()
-            ? singular.charAt(0).toUpperCase() + singular.slice(1)
-            : singular;
-    }
-    if (lower.endsWith('ies') && lower.length > 4) {
-        return word.slice(0, -3) + 'y';
-    }
-    // -shes, -ches, -xes, -zes, -sses → drop "es"
-    if (lower.endsWith('shes') || lower.endsWith('ches') || lower.endsWith('xes') || lower.endsWith('zes') || lower.endsWith('sses')) {
-        return word.slice(0, -2);
-    }
-    // General: drop trailing "s" (covers courses→course, products→product, etc.)
-    if (lower.endsWith('s') && !lower.endsWith('ss') && !lower.endsWith('us') && lower.length > 2) {
-        return word.slice(0, -1);
-    }
-    return word;
-}
-export function toCamelCase(str) {
-    return str
-        .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
-        .replace(/^[A-Z]/, (c) => c.toLowerCase());
-}
-export function toPascalCase(str) {
-    const camel = toCamelCase(str);
-    return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-/**
- * Strip common API prefix from paths (e.g. /api/v2/).
- * Uses majority voting — a prefix shared by >75% of paths is stripped,
- * so a few outlier paths (e.g. /oauth/...) don't break detection.
- */
-export function detectCommonPrefix(paths) {
-    if (paths.length === 0)
-        return '';
-    const segments = paths.map((p) => p.replace(/^\//, '').split('/'));
-    const threshold = Math.ceil(paths.length * 0.75);
-    // Find the longest prefix shared by at least `threshold` paths
-    let prefixLen = 0;
-    for (let i = 0; i < 10; i++) {
-        // Count how many paths have the same segment at position i as the first path
-        const candidateSeg = segments[0][i];
-        if (!candidateSeg || candidateSeg.startsWith('{'))
-            break;
-        const count = segments.filter((s) => s.length > i + 1 && s[i] === candidateSeg).length;
-        if (count >= threshold) {
-            prefixLen = i + 1;
-        }
-        else {
-            break;
-        }
-    }
-    if (prefixLen === 0)
-        return '';
-    return '/' + segments[0].slice(0, prefixLen).join('/') + '/';
-}
-/** Convert operationId to camelCase function name */
-function fromOperationId(operationId) {
-    // operationId might be snake_case, camelCase, PascalCase, or kebab-case
-    return toCamelCase(operationId
-        .replace(/[^a-zA-Z0-9_-]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_|_$/g, ''));
-}
-const METHOD_PREFIXES = {
-    get: 'get',
-    post: 'create',
-    put: 'update',
-    patch: 'update',
-    delete: 'delete',
-};
-/**
- * Generate function names for a list of operations.
- * Handles collision detection and auto-deduplication.
- */
-export function generateOperationNames(operations, commonPrefix) {
-    const results = [];
-    const usedNames = new Map();
-    for (const op of operations) {
-        let name;
-        if (op.operationId) {
-            name = fromOperationId(op.operationId);
-        }
-        else {
-            name = deriveNameFromPath(op.method, op.path, commonPrefix);
-        }
-        // Handle collisions
-        const existing = usedNames.get(name) ?? 0;
-        if (existing > 0) {
-            usedNames.set(name, existing + 1);
-            name = `${name}${existing + 1}`;
-        }
-        usedNames.set(name, (usedNames.get(name) ?? 0) || 1);
-        results.push({
-            method: op.method,
-            path: op.path,
-            functionName: name,
-            methodName: name,
-        });
-    }
-    return results;
-}
-function deriveNameFromPath(method, path, commonPrefix) {
-    // Strip common prefix
-    let cleanPath = path;
-    if (commonPrefix && cleanPath.startsWith(commonPrefix)) {
-        cleanPath = '/' + cleanPath.slice(commonPrefix.length);
-    }
-    const segments = cleanPath
-        .replace(/^\//, '')
-        .split('/')
-        .filter(Boolean);
-    const methodLower = method.toLowerCase();
-    const prefix = METHOD_PREFIXES[methodLower] || methodLower;
-    // Separate param and non-param segments
-    const nonParams = [];
-    let hasTrailingParam = false;
-    for (let i = 0; i < segments.length; i++) {
-        if (segments[i].startsWith('{')) {
-            if (i === segments.length - 1) {
-                hasTrailingParam = true;
-            }
-        }
-        else {
-            nonParams.push(segments[i]);
-        }
-    }
-    if (nonParams.length === 0) {
-        return prefix;
-    }
-    // For GET with trailing param: singularize the last non-param segment
-    // For GET without trailing param: keep plural (list)
-    // For POST without trailing param: use prefix (create)
-    const parts = nonParams.map((seg, i) => {
-        const isLast = i === nonParams.length - 1;
-        let word = seg;
-        if (isLast && hasTrailingParam) {
-            word = singularize(word);
-        }
-        // For GET on collection (no trailing param), use "list" prefix instead of "get"
-        return toPascalCase(word);
-    });
-    // For GET on collection, use "list" instead of "get"
-    let finalPrefix = prefix;
-    if (methodLower === 'get' && !hasTrailingParam) {
-        finalPrefix = 'list';
-    }
-    return finalPrefix + parts.join('');
-}

package/dist/src/utils/openapi/parse-openapi.d.ts

@@ -1,61 +0,0 @@
-import type { OpenAPISchema } from './zod-codegen.js';
-export interface ErrorResponse {
-    statusCode: number;
-    description: string;
-}
-export interface SecuritySchemeInfo {
-    type: 'oauth2' | 'http' | 'apiKey';
-    scheme?: string;
-    bearerFormat?: string;
-    name?: string;
-    in?: string;
-    flows?: {
-        authorizationUrl?: string;
-        tokenUrl?: string;
-        scopes?: Record<string, string>;
-    };
-}
-export interface ParsedSpec {
-    info: {
-        title: string;
-        version: string;
-        description?: string;
-    };
-    baseUrl: string;
-    serverUrls: string[];
-    authType: 'bearer' | 'oauth2' | 'apiKey' | 'none';
-    operations: ParsedOperation[];
-    componentSchemas: Record<string, OpenAPISchema>;
-    securitySchemes: Record<string, SecuritySchemeInfo>;
-    tagDescriptions: Record<string, string>;
-}
-export interface ParsedOperation {
-    operationId?: string;
-    method: string;
-    path: string;
-    summary?: string;
-    description?: string;
-    tags: string[];
-    pathParams: ParsedParam[];
-    queryParams: ParsedParam[];
-    headerParams: ParsedParam[];
-    requestBody?: OpenAPISchema;
-    requestBodyDescription?: string;
-    requestBodyRequired?: boolean;
-    responseSchema?: OpenAPISchema;
-    responseDescription?: string;
-    errorResponses: ErrorResponse[];
-    deprecated: boolean;
-}
-export interface ParsedParam {
-    name: string;
-    required: boolean;
-    schema: OpenAPISchema;
-    description?: string;
-    example?: unknown;
-}
-/**
- * Read and parse an OpenAPI spec from a file path.
- * Supports both YAML (.yaml, .yml) and JSON (.json) files.
- */
-export declare function parseOpenAPISpec(filePath: string): Promise<ParsedSpec>;

package/dist/src/utils/openapi/parse-openapi.js

@@ -1,306 +0,0 @@
-/**
- * Parses OpenAPI YAML/JSON specs, resolves $ref pointers, and produces a normalized IR.
- */
-import { readFile } from 'fs/promises';
-import { parse as parseYAML } from 'yaml';
-/**
- * Read and parse an OpenAPI spec from a file path.
- * Supports both YAML (.yaml, .yml) and JSON (.json) files.
- */
-export async function parseOpenAPISpec(filePath) {
-    const content = await readFile(filePath, 'utf-8');
-    let doc;
-    if (filePath.endsWith('.json')) {
-        doc = JSON.parse(content);
-    }
-    else {
-        doc = parseYAML(content);
-    }
-    // Validate spec version
-    const specVersion = doc.openapi ?? doc.swagger;
-    if (!specVersion) {
-        throw new Error('Not a valid OpenAPI/Swagger spec: missing "openapi" or "swagger" version field.');
-    }
-    const major = String(specVersion).split('.')[0];
-    if (major !== '2' && major !== '3') {
-        throw new Error(`Unsupported spec version "${specVersion}". Only OpenAPI 3.x and Swagger 2.x are supported.`);
-    }
-    // Resolve all $ref pointers in-place
-    resolveRefs(doc, doc);
-    const info = {
-        title: doc.info?.title ?? 'Unknown API',
-        version: doc.info?.version ?? '1.0.0',
-        description: doc.info?.description,
-    };
-    const serverUrls = extractServerUrls(doc);
-    const baseUrl = serverUrls[0] ?? '';
-    const authType = detectAuthType(doc);
-    const securitySchemes = extractSecuritySchemes(doc);
-    const tagDescriptions = extractTagDescriptions(doc);
-    // Extract component schemas
-    const componentSchemas = {};
-    if (doc.components?.schemas) {
-        for (const [name, schema] of Object.entries(doc.components.schemas)) {
-            componentSchemas[name] = schema;
-        }
-    }
-    // Extract operations (skip deprecated)
-    const operations = [];
-    if (doc.paths) {
-        for (const [path, pathItem] of Object.entries(doc.paths)) {
-            // Shared parameters at the path level
-            const sharedParams = pathItem.parameters ?? [];
-            for (const method of ['get', 'post', 'put', 'patch', 'delete']) {
-                const op = pathItem[method];
-                if (!op)
-                    continue;
-                // Skip deprecated operations
-                if (op.deprecated === true)
-                    continue;
-                const allParams = [...sharedParams, ...(op.parameters ?? [])];
-                const body = op.requestBody;
-                operations.push({
-                    operationId: op.operationId,
-                    method,
-                    path,
-                    summary: op.summary,
-                    description: op.description,
-                    tags: op.tags ?? [],
-                    pathParams: extractParams(allParams, 'path'),
-                    queryParams: extractParams(allParams, 'query'),
-                    headerParams: extractParams(allParams, 'header'),
-                    requestBody: extractRequestBody(op),
-                    requestBodyDescription: body?.description,
-                    requestBodyRequired: body?.required,
-                    responseSchema: extractResponseSchema(op),
-                    responseDescription: extractResponseDescription(op),
-                    errorResponses: extractErrorResponses(op),
-                    deprecated: false,
-                });
-            }
-        }
-    }
-    return {
-        info,
-        baseUrl,
-        serverUrls,
-        authType,
-        operations,
-        componentSchemas,
-        securitySchemes,
-        tagDescriptions,
-    };
-}
-/** Recursively resolve $ref pointers in-place */
-function resolveRefs(node, root) {
-    if (node === null || typeof node !== 'object')
-        return node;
-    if (Array.isArray(node)) {
-        for (let i = 0; i < node.length; i++) {
-            node[i] = resolveRefs(node[i], root);
-        }
-        return node;
-    }
-    if (typeof node.$ref === 'string') {
-        const resolved = resolveRefPath(node.$ref, root);
-        if (resolved && typeof resolved === 'object') {
-            // Merge any sibling properties (like description overrides)
-            const { $ref, ...siblings } = node;
-            const result = { ...resolved, ...siblings };
-            // Don't recurse infinitely — mark as resolved
-            return result;
-        }
-        return node;
-    }
-    for (const key of Object.keys(node)) {
-        node[key] = resolveRefs(node[key], root);
-    }
-    return node;
-}
-function resolveRefPath(ref, root) {
-    if (!ref.startsWith('#/'))
-        return undefined;
-    const parts = ref.slice(2).split('/');
-    let current = root;
-    for (const part of parts) {
-        const decoded = part.replace(/~1/g, '/').replace(/~0/g, '~');
-        if (current == null || typeof current !== 'object')
-            return undefined;
-        current = current[decoded];
-    }
-    return current;
-}
-function extractServerUrls(doc) {
-    // OpenAPI 3.x
-    if (doc.servers && doc.servers.length > 0) {
-        return doc.servers.map((s) => s.url).filter((url) => !!url);
-    }
-    // Swagger 2.x
-    if (doc.host) {
-        const schemes = doc.schemes?.length ? doc.schemes : ['https'];
-        const basePath = doc.basePath ?? '';
-        return schemes.map((scheme) => `${scheme}://${doc.host}${basePath}`);
-    }
-    return [];
-}
-function detectAuthType(doc) {
-    const securitySchemes = doc.components?.securitySchemes ?? doc.securityDefinitions ?? {};
-    for (const scheme of Object.values(securitySchemes)) {
-        if (scheme.type === 'oauth2')
-            return 'oauth2';
-        if (scheme.type === 'http' && scheme.scheme === 'bearer')
-            return 'bearer';
-        if (scheme.type === 'apiKey')
-            return 'apiKey';
-    }
-    return 'none';
-}
-/**
- * Build an OpenAPI schema object from v2-style parameter-level properties
- * (type, enum, items, format, default) that aren't nested under `schema`.
- */
-function paramToSchema(p) {
-    const schema = { type: p.type ?? 'string' };
-    if (p.enum)
-        schema.enum = p.enum;
-    if (p.items)
-        schema.items = p.items;
-    if (p.format)
-        schema.format = p.format;
-    if (p.default !== undefined)
-        schema.default = p.default;
-    return schema;
-}
-function extractParams(params, location) {
-    return params
-        .filter((p) => p.in === location)
-        .map((p) => ({
-        name: p.name,
-        required: p.required ?? location === 'path',
-        schema: (p.schema ?? paramToSchema(p)),
-        description: p.description,
-        example: p.example,
-    }));
-}
-function extractRequestBody(op) {
-    const body = op.requestBody;
-    if (!body)
-        return undefined;
-    const content = body.content;
-    if (!content)
-        return undefined;
-    // Prefer JSON
-    const jsonContent = content['application/json'];
-    if (jsonContent?.schema)
-        return jsonContent.schema;
-    // Fallback to first content type
-    const firstKey = Object.keys(content)[0];
-    if (firstKey && content[firstKey]?.schema) {
-        return content[firstKey].schema;
-    }
-    return undefined;
-}
-function extractResponseDescription(op) {
-    const responses = op.responses;
-    if (!responses)
-        return undefined;
-    for (const code of ['200', '201', '202']) {
-        const resp = responses[code];
-        if (resp?.description)
-            return resp.description;
-    }
-    return undefined;
-}
-function extractResponseSchema(op) {
-    const responses = op.responses;
-    if (!responses)
-        return undefined;
-    // Look for 2xx responses in order of preference
-    for (const code of ['200', '201', '202', '204']) {
-        const resp = responses[code];
-        if (!resp)
-            continue;
-        const content = resp.content;
-        if (!content)
-            continue;
-        const jsonContent = content['application/json'];
-        if (jsonContent?.schema)
-            return jsonContent.schema;
-        const firstKey = Object.keys(content)[0];
-        if (firstKey && content[firstKey]?.schema) {
-            return content[firstKey].schema;
-        }
-    }
-    // Fallback: any 2xx
-    for (const [code, resp] of Object.entries(responses)) {
-        if (code.startsWith('2') && resp.content) {
-            const jsonContent = resp.content['application/json'];
-            if (jsonContent?.schema)
-                return jsonContent.schema;
-        }
-    }
-    return undefined;
-}
-function extractErrorResponses(op) {
-    const responses = op.responses;
-    if (!responses)
-        return [];
-    const errors = [];
-    for (const [code, resp] of Object.entries(responses)) {
-        const statusCode = parseInt(code, 10);
-        if (isNaN(statusCode))
-            continue;
-        if (statusCode >= 400) {
-            errors.push({
-                statusCode,
-                description: resp.description ?? `Error ${statusCode}`,
-            });
-        }
-    }
-    return errors;
-}
-function extractSecuritySchemes(doc) {
-    const raw = doc.components?.securitySchemes ?? doc.securityDefinitions ?? {};
-    const result = {};
-    for (const [name, scheme] of Object.entries(raw)) {
-        const info = {
-            type: scheme.type === 'http' ? 'http' : scheme.type,
-        };
-        if (scheme.type === 'http') {
-            info.scheme = scheme.scheme;
-            info.bearerFormat = scheme.bearerFormat;
-        }
-        if (scheme.type === 'apiKey') {
-            info.name = scheme.name;
-            info.in = scheme.in;
-        }
-        if (scheme.type === 'oauth2') {
-            // Extract flows — prefer authorizationCode, then implicit, then clientCredentials
-            const flows = scheme.flows ?? {};
-            const flow = flows.authorizationCode ??
-                flows.implicit ??
-                flows.clientCredentials ??
-                flows.password;
-            if (flow) {
-                info.flows = {
-                    authorizationUrl: flow.authorizationUrl,
-                    tokenUrl: flow.tokenUrl,
-                    scopes: flow.scopes,
-                };
-            }
-        }
-        result[name] = info;
-    }
-    return result;
-}
-function extractTagDescriptions(doc) {
-    const result = {};
-    if (Array.isArray(doc.tags)) {
-        for (const tag of doc.tags) {
-            if (tag.name && tag.description) {
-                result[tag.name] = tag.description;
-            }
-        }
-    }
-    return result;
-}

package/dist/src/utils/openapi/zod-codegen.d.ts

@@ -1 +0,0 @@
-export { type OpenAPISchema, type ZodCodegenContext, createContext, schemaToZod, schemaVarName, sanitizeTypeName, } from '@pikku/openapi-to-zod-schema';

package/dist/src/utils/openapi/zod-codegen.js

@@ -1 +0,0 @@
-export { createContext, schemaToZod, schemaVarName, sanitizeTypeName, } from '@pikku/openapi-to-zod-schema';