@pikku/cli 0.12.2 → 0.12.3

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

@@ -16,6 +16,15 @@ export async function parseOpenAPISpec(filePath) {
     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 = {
@@ -23,8 +32,11 @@ export async function parseOpenAPISpec(filePath) {
         version: doc.info?.version ?? '1.0.0',
         description: doc.info?.description,
     };
-    const baseUrl = extractBaseUrl(doc);
+    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) {
@@ -32,7 +44,7 @@ export async function parseOpenAPISpec(filePath) {
             componentSchemas[name] = schema;
         }
     }
-    // Extract operations
+    // Extract operations (skip deprecated)
     const operations = [];
     if (doc.paths) {
         for (const [path, pathItem] of Object.entries(doc.paths)) {
@@ -42,7 +54,11 @@ export async function parseOpenAPISpec(filePath) {
                 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,
@@ -52,14 +68,28 @@ export async function parseOpenAPISpec(filePath) {
                     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, authType, operations, componentSchemas };
+    return {
+        info,
+        baseUrl,
+        serverUrls,
+        authType,
+        operations,
+        componentSchemas,
+        securitySchemes,
+        tagDescriptions,
+    };
 }
 /** Recursively resolve $ref pointers in-place */
 function resolveRefs(node, root) {
@@ -100,18 +130,18 @@ function resolveRefPath(ref, root) {
     }
     return current;
 }
-function extractBaseUrl(doc) {
+function extractServerUrls(doc) {
     // OpenAPI 3.x
     if (doc.servers && doc.servers.length > 0) {
-        return doc.servers[0].url ?? '';
+        return doc.servers.map((s) => s.url).filter((url) => !!url);
     }
     // Swagger 2.x
     if (doc.host) {
-        const scheme = doc.schemes?.[0] ?? 'https';
+        const schemes = doc.schemes?.length ? doc.schemes : ['https'];
         const basePath = doc.basePath ?? '';
-        return `${scheme}://${doc.host}${basePath}`;
+        return schemes.map((scheme) => `${scheme}://${doc.host}${basePath}`);
     }
-    return '';
+    return [];
 }
 function detectAuthType(doc) {
     const securitySchemes = doc.components?.securitySchemes ?? doc.securityDefinitions ?? {};
@@ -125,14 +155,31 @@ function detectAuthType(doc) {
     }
     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 ?? { type: 'string' }),
+        schema: (p.schema ?? paramToSchema(p)),
         description: p.description,
+        example: p.example,
     }));
 }
 function extractRequestBody(op) {
@@ -194,3 +241,66 @@ function extractResponseSchema(op) {
     }
     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,53 +1 @@
-/**
- * Converts OpenAPI schemas into Zod code strings.
- *
- * Chaining order: base → refinements → .nullable() → .optional() → .default() → .describe()
- */
-export interface OpenAPISchema {
-    type?: string;
-    format?: string;
-    description?: string;
-    enum?: unknown[];
-    items?: OpenAPISchema;
-    properties?: Record<string, OpenAPISchema>;
-    required?: string[];
-    nullable?: boolean;
-    default?: unknown;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    minItems?: number;
-    maxItems?: number;
-    oneOf?: OpenAPISchema[];
-    anyOf?: OpenAPISchema[];
-    allOf?: OpenAPISchema[];
-    additionalProperties?: boolean | OpenAPISchema;
-    $ref?: string;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-}
-export interface ZodCodegenContext {
-    /** Map from component schema name to its Zod variable name */
-    schemaRefs: Map<string, string>;
-    /** Track which refs are actually used */
-    usedRefs: Set<string>;
-    /** Indent level for readability */
-    indent: number;
-}
-export declare function createContext(schemaRefs?: Map<string, string>): ZodCodegenContext;
-/**
- * Convert a single OpenAPI schema to a Zod expression string.
- * Does NOT include .optional() — that's handled at the property level based on `required`.
- */
-export declare function schemaToZod(schema: OpenAPISchema, ctx: ZodCodegenContext, opts?: {
-    optional?: boolean;
-}): string;
-/**
- * Generate the Zod variable name for a component schema.
- * e.g. "PaginatedResponse" → "PaginatedResponseSchema"
- */
-export declare function schemaVarName(name: string): string;
+export { type OpenAPISchema, type ZodCodegenContext, createContext, schemaToZod, schemaVarName, } from '@pikku/openapi-to-zod-schema';

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

@@ -1,251 +1 @@
-/**
- * Converts OpenAPI schemas into Zod code strings.
- *
- * Chaining order: base → refinements → .nullable() → .optional() → .default() → .describe()
- */
-export function createContext(schemaRefs) {
-    return {
-        schemaRefs: schemaRefs ?? new Map(),
-        usedRefs: new Set(),
-        indent: 0,
-    };
-}
-/**
- * Convert a single OpenAPI schema to a Zod expression string.
- * Does NOT include .optional() — that's handled at the property level based on `required`.
- */
-export function schemaToZod(schema, ctx, opts = {}) {
-    let code = schemaToZodBase(schema, ctx);
-    // Refinements
-    code = applyRefinements(code, schema);
-    // Nullable
-    if (schema.nullable) {
-        code += '.nullable()';
-    }
-    // Optional
-    if (opts.optional) {
-        code += '.optional()';
-    }
-    // Default
-    if (schema.default !== undefined) {
-        code += `.default(${JSON.stringify(schema.default)})`;
-    }
-    // Description
-    if (schema.description) {
-        code += `.describe(${JSON.stringify(schema.description)})`;
-    }
-    return code;
-}
-function schemaToZodBase(schema, ctx) {
-    // Handle $ref
-    if (schema.$ref) {
-        const refName = schema.$ref.split('/').pop();
-        const zodName = ctx.schemaRefs.get(refName);
-        if (zodName) {
-            ctx.usedRefs.add(refName);
-            return zodName;
-        }
-        // Unknown ref — fallback to z.unknown()
-        return 'z.unknown()';
-    }
-    // Handle allOf — merge into single object
-    if (schema.allOf && schema.allOf.length > 0) {
-        return handleAllOf(schema.allOf, ctx);
-    }
-    // Handle oneOf/anyOf — union
-    if (schema.oneOf && schema.oneOf.length > 0) {
-        return handleUnion(schema.oneOf, ctx);
-    }
-    if (schema.anyOf && schema.anyOf.length > 0) {
-        return handleUnion(schema.anyOf, ctx);
-    }
-    // Handle enum
-    if (schema.enum && schema.enum.length > 0) {
-        return handleEnum(schema.enum);
-    }
-    // Handle by type
-    switch (schema.type) {
-        case 'string':
-            return handleString(schema);
-        case 'integer':
-            return 'z.number().int()';
-        case 'number':
-            return 'z.number()';
-        case 'boolean':
-            return 'z.boolean()';
-        case 'array':
-            return handleArray(schema, ctx);
-        case 'object':
-            return handleObject(schema, ctx);
-        default:
-            // No type specified but has properties — treat as object
-            if (schema.properties) {
-                return handleObject(schema, ctx);
-            }
-            return 'z.unknown()';
-    }
-}
-function handleString(schema) {
-    switch (schema.format) {
-        case 'uuid':
-            return 'z.string().uuid()';
-        case 'date-time':
-            return 'z.string().datetime()';
-        case 'date':
-            return 'z.string().date()';
-        case 'email':
-            return 'z.string().email()';
-        case 'uri':
-        case 'url':
-            return 'z.string().url()';
-        default:
-            return 'z.string()';
-    }
-}
-function handleEnum(values) {
-    // If all values are strings, use z.enum
-    if (values.every((v) => typeof v === 'string')) {
-        const enumValues = values.map((v) => JSON.stringify(v)).join(', ');
-        return `z.enum([${enumValues}])`;
-    }
-    // Mixed types — use z.union of z.literal
-    const literals = values.map((v) => `z.literal(${JSON.stringify(v)})`).join(', ');
-    return `z.union([${literals}])`;
-}
-function handleArray(schema, ctx) {
-    const itemsZod = schema.items
-        ? schemaToZodBase(schema.items, ctx)
-        : 'z.unknown()';
-    return `z.array(${itemsZod})`;
-}
-function indent(ctx) {
-    return '  '.repeat(ctx.indent);
-}
-function handleObject(schema, ctx) {
-    if (!schema.properties || Object.keys(schema.properties).length === 0) {
-        // Object with no defined properties
-        if (schema.additionalProperties) {
-            const valueSchema = typeof schema.additionalProperties === 'object'
-                ? schemaToZod(schema.additionalProperties, ctx)
-                : 'z.unknown()';
-            return `z.record(z.string(), ${valueSchema})`;
-        }
-        return 'z.record(z.string(), z.unknown())';
-    }
-    const inner = { ...ctx, indent: ctx.indent + 1 };
-    const pad = indent(inner);
-    const closePad = indent(ctx);
-    const requiredSet = new Set(schema.required ?? []);
-    const entries = [];
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-        const isOptional = !requiredSet.has(key);
-        const propZod = schemaToZod(propSchema, inner, { optional: isOptional });
-        entries.push(`${pad}${safeKey(key)}: ${propZod},`);
-    }
-    return `z.object({\n${entries.join('\n')}\n${closePad}})`;
-}
-function handleAllOf(schemas, ctx) {
-    // Collect all properties from all schemas
-    const mergedProps = {};
-    const mergedRequired = [];
-    for (const sub of schemas) {
-        if (sub.$ref) {
-            const refName = sub.$ref.split('/').pop();
-            const zodName = ctx.schemaRefs.get(refName);
-            if (zodName) {
-                ctx.usedRefs.add(refName);
-                // If it's a pure ref in an allOf, we'd need to merge/extend
-                // For simplicity, if we have refs mixed with objects, use .merge()
-            }
-        }
-        if (sub.properties) {
-            Object.assign(mergedProps, sub.properties);
-        }
-        if (sub.required) {
-            mergedRequired.push(...sub.required);
-        }
-    }
-    // If we have only refs, use .merge()
-    const refSchemas = schemas.filter((s) => s.$ref);
-    const objSchemas = schemas.filter((s) => !s.$ref && (s.properties || s.type === 'object'));
-    if (refSchemas.length > 0 && objSchemas.length === 0) {
-        const parts = refSchemas.map((s) => {
-            const refName = s.$ref.split('/').pop();
-            ctx.usedRefs.add(refName);
-            return ctx.schemaRefs.get(refName) || 'z.object({})';
-        });
-        if (parts.length === 1)
-            return parts[0];
-        return parts.reduce((acc, part) => `${acc}.merge(${part})`);
-    }
-    // Otherwise, merge into a single object
-    if (Object.keys(mergedProps).length > 0) {
-        return handleObject({
-            type: 'object',
-            properties: mergedProps,
-            required: [...new Set(mergedRequired)],
-        }, ctx);
-    }
-    // Fallback
-    return 'z.unknown()';
-}
-function handleUnion(schemas, ctx) {
-    const members = schemas.map((s) => schemaToZodBase(s, ctx));
-    if (members.length === 1)
-        return members[0];
-    return `z.union([${members.join(', ')}])`;
-}
-function applyRefinements(code, schema) {
-    let result = code;
-    // String refinements
-    if (schema.type === 'string' || (!schema.type && !schema.format)) {
-        if (schema.minLength !== undefined) {
-            result += `.min(${schema.minLength})`;
-        }
-        if (schema.maxLength !== undefined) {
-            result += `.max(${schema.maxLength})`;
-        }
-        if (schema.pattern) {
-            result += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
-        }
-    }
-    // Number refinements
-    if (schema.type === 'number' || schema.type === 'integer') {
-        if (schema.minimum !== undefined) {
-            result += `.min(${schema.minimum})`;
-        }
-        if (schema.maximum !== undefined) {
-            result += `.max(${schema.maximum})`;
-        }
-        if (schema.exclusiveMinimum !== undefined) {
-            result += `.gt(${schema.exclusiveMinimum})`;
-        }
-        if (schema.exclusiveMaximum !== undefined) {
-            result += `.lt(${schema.exclusiveMaximum})`;
-        }
-    }
-    // Array refinements
-    if (schema.type === 'array') {
-        if (schema.minItems !== undefined) {
-            result += `.min(${schema.minItems})`;
-        }
-        if (schema.maxItems !== undefined) {
-            result += `.max(${schema.maxItems})`;
-        }
-    }
-    return result;
-}
-/** Ensure property keys are safe identifiers, or quote them */
-function safeKey(key) {
-    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
-        return key;
-    }
-    return JSON.stringify(key);
-}
-/**
- * Generate the Zod variable name for a component schema.
- * e.g. "PaginatedResponse" → "PaginatedResponseSchema"
- */
-export function schemaVarName(name) {
-    return name.endsWith('Schema') ? name : `${name}Schema`;
-}
+export { createContext, schemaToZod, schemaVarName, } from '@pikku/openapi-to-zod-schema';

package/dist/src/utils/pikku-cli-config.js

@@ -319,8 +319,8 @@ const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields
             result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts');
         }
         const consoleDir = join(result.outDir, 'console');
-        if (!result.nodesMetaJsonFile) {
-            result.nodesMetaJsonFile = join(consoleDir, 'pikku-nodes-meta.gen.json');
+        if (!result.addonMetaJsonFile) {
+            result.addonMetaJsonFile = join(consoleDir, 'pikku-addon-meta.gen.json');
         }
         if (!result.nodeTypesFile) {
             result.nodeTypesFile = join(consoleDir, 'pikku-node-types.gen.ts');

package/dist/src/utils/strip-verbose-meta.d.ts

@@ -25,6 +25,8 @@
  * 2. Record of meta entries: { "entryName": { pikkuFuncId, description, tags, ... } }
  *    -> Strips description, tags from each entry (one level deep only)
  * 3. CLI meta and others with complex nesting: preserved as-is except for pikkuFuncId entries
+ *
+ * Also strips addon namespace prefixes from pikkuFuncId values where packageName is present.
  */
 export declare function stripVerboseFields<T>(obj: T): T;
 /**

package/dist/src/utils/strip-verbose-meta.js

@@ -75,6 +75,35 @@ function hasVerboseShallow(obj, additionalFields) {
     }
     return false;
 }
+/**
+ * Recursively strip addon namespace prefixes from pikkuFuncId values.
+ * When an entry has both pikkuFuncId (e.g. "swaggerPetstore:addPet") and packageName,
+ * the namespace prefix is redundant — strip it so runtime gets bare function names.
+ */
+function stripAddonNamespacePrefixes(obj) {
+    if (obj === null || obj === undefined || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(stripAddonNamespacePrefixes);
+    const record = obj;
+    const result = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (key === 'pikkuFuncId' &&
+            typeof value === 'string' &&
+            value.includes(':') &&
+            'packageName' in record &&
+            record.packageName) {
+            result[key] = value.substring(value.indexOf(':') + 1);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            result[key] = stripAddonNamespacePrefixes(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
 /**
  * Strip verbose fields from a meta object.
  *
@@ -84,8 +113,13 @@ function hasVerboseShallow(obj, additionalFields) {
  * 2. Record of meta entries: { "entryName": { pikkuFuncId, description, tags, ... } }
  *    -> Strips description, tags from each entry (one level deep only)
  * 3. CLI meta and others with complex nesting: preserved as-is except for pikkuFuncId entries
+ *
+ * Also strips addon namespace prefixes from pikkuFuncId values where packageName is present.
  */
 export function stripVerboseFields(obj) {
+    return stripAddonNamespacePrefixes(_stripVerboseFieldsInner(obj));
+}
+function _stripVerboseFieldsInner(obj) {
     if (obj === null || obj === undefined || typeof obj !== 'object') {
         return obj;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {
@@ -25,8 +25,9 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.2",
-    "@pikku/inspector": "^0.12.2",
+    "@pikku/core": "^0.12.3",
+    "@pikku/inspector": "^0.12.3",
+    "@pikku/openapi-to-zod-schema": "^0.12.2",
     "@types/cookie": "^1.0.0",
     "@types/json-schema": "^7.0.15",
     "chalk": "^5.6.2",