@pikku/openapi-parser 0.12.21 → 0.12.22

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pikku/openapi-parser
 
+## 0.12.22
+
+### Patch Changes
+
+- 17d8746: An addon generated with `pikku new addon --openapi` never built. Every function file declared its zod schemas next to an import of `#pikku/function`, and `pikku all` loads the file that declares a schema to convert it. At runtime `#pikku` resolves through the addon's `imports` into `dist/`, which the first build has not written yet, so every schema failed with `Could not convert Zod schema … Cannot find module …/dist/.pikku/function/index.js` and the build stopped there. Each operation's schemas now go in a sibling `<operation>.schemas.ts` that imports only zod, and the function file imports them from it.
+
+  The generated imports also named the wrong tree. An addon's generated code lives under `.pikku/addon/`, so `#pikku/function` and `#pikku/variables/…` pointed at leaves that do not exist, and `tsc` failed even once codegen had run. They are now `#pikku/addon/function` and `#pikku/addon/variables/…`, as the hand-written addon scaffold already had them.
+
+  `pikku validate` now reports an installed Pikku package that resolves a different copy of a type-identity package (`zod`, `kysely`, `@pikku/core`, `better-auth`) than the project as an error, `skewed-type-identity-…`, and the codegen preflight warns about it as `PKU719`. Under bun's isolated layout `@pikku/cli` can carry its own `zod` beside it in the store. Codegen then reads the app's schemas with a different zod than wrote them, and correct schemas fail to convert. The existing check only looked at dependencies linked from outside the project, so it never saw this case.
+
+  The `pikku-build` skill now recognises an OpenAPI spec or an n8n export handed over with the request, says so, converts it first, then carries on building the app. `pikku-addon` gains an OpenAPI reference and corrects its addon import paths and build steps. `pikku-n8n-import` joins the `core` install group.
+
 ## 0.12.21
 
 ### Patch Changes

package/dist/codegen.js

@@ -281,8 +281,11 @@ export function generateAddonFromOpenAPI(spec, vars, flags) {
             camelCase: flags.camelCase,
         });
         const inlineSchemas = singleSchemasPerOp.get(i) ?? new Set();
-        const funcCode = generateFunctionFile(named, parsed, vars, funcCtx, spec, flags, inlineSchemas, sharedWithDeps, schemaIdentityMap);
-        files[`src/functions/${named.functionName}.function.ts`] = funcCode;
+        const { functionFile, schemasFile } = generateFunctionFile(named, parsed, vars, funcCtx, spec, flags, inlineSchemas, sharedWithDeps, schemaIdentityMap);
+        files[`src/functions/${named.functionName}.function.ts`] = functionFile;
+        if (schemasFile) {
+            files[`src/functions/${named.functionName}.schemas.ts`] = schemasFile;
+        }
         functionExports.push(named.functionName);
     }
     // Delegated login: emit the upstream authenticate() implementation
@@ -516,14 +519,19 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
     }
     // Determine error imports needed
     const errorClasses = getErrorClassesForResponses(parsed.errorResponses);
-    const needsZod = hasInput || !!parsed.responseSchema || inlineSchemas.size > 0;
-    if (needsZod) {
-        lines.push("import { z } from 'zod'");
-    }
-    lines.push("import { pikkuSessionlessFunc } from '#pikku/function'");
+    const schemaExports = [
+        ...(hasInput && inputCode ? [inputName] : []),
+        ...(parsed.responseSchema && outputCode ? [outputName] : []),
+    ];
+    lines.push("import { pikkuSessionlessFunc } from '#pikku/addon/function'");
     if (errorClasses.length > 0) {
         lines.push(`import { ${errorClasses.join(', ')} } from '@pikku/core/errors'`);
     }
+    if (schemaExports.length > 0) {
+        lines.push(`import { ${schemaExports.join(', ')} } from './${named.functionName}.schemas.js'`);
+    }
+    lines.push('');
+    const schemaLines = ["import { z } from 'zod'"];
     // Import referenced component schemas from the types file.
     // Only import schemas that are in the shared set (not inlined ones).
     // In addition to the refs tracked through usedRefs, scan the generated Zod
@@ -543,10 +551,10 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
                 .filter(Boolean)),
         ].sort();
         if (schemaImports.length > 0) {
-            lines.push(`import { ${schemaImports.join(', ')} } from '../${name}.types.js'`);
+            schemaLines.push(`import { ${schemaImports.join(', ')} } from '../${name}.types.js'`);
         }
     }
-    lines.push('');
+    schemaLines.push('');
     // Emit inline (single-use) schema definitions before input/output
     if (inlineSchemas.size > 0) {
         // Build a mini component schemas map for just the inline schemas
@@ -607,7 +615,7 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
             const emittedTypeNames = new Set();
             // Forward declarations for cycles and forward references within inline schemas
             if (forwardRefs.size > 0) {
-                lines.push('// Forward declarations for circular references');
+                schemaLines.push('// Forward declarations for circular references');
                 for (const sName of forwardRefs) {
                     if (!inlineSchemas.has(sName))
                         continue;
@@ -615,8 +623,8 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
                     const typeN = sanitizeTypeName(sName);
                     emittedVarNames.add(varN);
                     emittedTypeNames.add(typeN);
-                    lines.push(`const ${varN}: z.ZodType<any> = z.lazy(() => _${varN})`);
-                    lines.push('');
+                    schemaLines.push(`const ${varN}: z.ZodType<any> = z.lazy(() => _${varN})`);
+                    schemaLines.push('');
                 }
             }
             for (const sName of inlineSorted) {
@@ -624,24 +632,24 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
                 emittedVarNames.add(varN);
                 const zodCode = generatedCode.get(sName);
                 if (forwardRefs.has(sName)) {
-                    lines.push(`const _${varN} = ${zodCode}`);
+                    schemaLines.push(`const _${varN} = ${zodCode}`);
                 }
                 else {
-                    lines.push(`const ${varN} = ${zodCode}`);
+                    schemaLines.push(`const ${varN} = ${zodCode}`);
                 }
-                lines.push('');
+                schemaLines.push('');
             }
         }
     }
     // Build Input schema (exported for pikku schema discovery)
     if (hasInput && inputCode) {
-        lines.push(`export const ${inputName} = ${inputCode}`);
-        lines.push('');
+        schemaLines.push(`export const ${inputName} = ${inputCode}`);
+        schemaLines.push('');
     }
     // Build Output schema (exported for pikku schema discovery)
     if (parsed.responseSchema && outputCode) {
-        lines.push(`export const ${outputName} = ${outputCode}`);
-        lines.push('');
+        schemaLines.push(`export const ${outputName} = ${outputCode}`);
+        schemaLines.push('');
     }
     const description = humanDescription(parsed);
     const method = parsed.method.toUpperCase();
@@ -671,7 +679,10 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
     lines.push(funcConfig.join('\n'));
     lines.push('})');
     lines.push('');
-    return lines.join('\n');
+    return {
+        functionFile: lines.join('\n'),
+        schemasFile: schemaExports.length > 0 ? schemaLines.join('\n') : undefined,
+    };
 }
 function buildInputSchema(parsed, ctx) {
     const props = [];
@@ -950,7 +961,7 @@ function generateServiceFile(spec, opPairs, vars, flags) {
     if (allErrorClasses.size > 0) {
         lines.push(`import { ${[...allErrorClasses].sort().join(', ')} } from '@pikku/core/errors'`);
     }
-    lines.push(`import type { TypedVariablesService } from '#pikku/variables/pikku-variables.gen.js'`);
+    lines.push(`import type { TypedVariablesService } from '#pikku/addon/variables/pikku-variables.gen.js'`);
     lines.push('');
     // Generate route map from parsed operations
     const routes = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/openapi-parser",
-  "version": "0.12.21",
+  "version": "0.12.22",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",