@pikku/openapi-parser 0.12.19 → 0.12.21

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # @pikku/openapi-parser
 
+## 0.12.21
+
+### Patch Changes
+
+- 4c7a1b5: Run the monorepo's own scripts through bun instead of yarn. What moves is the
+  package manager each package's `prepublishOnly` and build scripts invoke, plus
+  the two manifest fixes bun needs to resolve the tree: `uWebSockets.js` is
+  declared with an explicit `github:` specifier, and `@pikku/uws-handler` marks
+  its `uWebSockets.js` peer optional so a bun install of a consumer that brings
+  its own uWS app does not try to fetch it from the registry.
+
+  Three published behaviours change, all of them cases where an isolated
+  `node_modules` or bun as the runtime had been papered over by yarn's hoisting:
+
+  - `@pikku/migrator-sql` turns foreign keys on when it opens a sqlite database
+    through bun. `node:sqlite` enforces them by default and `bun:sqlite` does not,
+    which silently turned every `ON DELETE CASCADE` into a no-op under
+    `bunx --bun pikku`.
+  - `@pikku/cli` resolves a deploy provider against the project being deployed
+    rather than against wherever the CLI itself is installed, which is what its
+    own "is not installed" error asks the user to arrange.
+  - `@pikku/cli` treats a specifier a runtime hands straight back — bun does this
+    for the modules it implements itself — as not resolved from the project, so
+    it falls back rather than loading the runtime's own copy.
+
+## 0.12.20
+
+### Patch Changes
+
+- 6eef0a0: Bump every dependency to its latest compatible minor/patch across the monorepo.
+- 266e3bc: `#pikku` is a namespace, not a module: one subpath per wiring
+
+  The bare `#pikku` specifier resolved to `.pikku/pikku-types.gen.ts`, a hub that
+  re-exported all twelve wiring leaves with `export *` — undoing the split the
+  leaves exist for, each of which still says so in its own generated header
+  ("HTTP-specific type definitions for tree-shaking optimization"). Reaching that
+  hub put 33 distinct `@pikku/core` subpaths into the module graph, and neither
+  consumer could drop them again: bundlers keep `export *` chains because the app
+  declares no `sideEffects`, and Node and tsx do not tree-shake at all, so an app
+  with no queues still executed `@pikku/core/queue` at boot.
+
+  The hub is gone. An app now imports the leaf the name belongs to —
+  `#pikku/function`, `#pikku/http`, `#pikku/workflow` — and a project's `imports`
+  map declares two patterns, because both resolvers pick the more specific one:
+
+  ```json
+  "#pikku/*.js": "./.pikku/*.ts",
+  "#pikku/*": "./.pikku/*/index.ts"
+  ```
+
+  A source tree names the `.ts` on both. Webpack, esbuild and Bun all rewrite a
+  `.js` specifier to the `.ts` beside it for a relative import but not for an
+  imports-map target, so a `.js` target there resolves to a file that does not
+  exist. The two places that keep `.js` are the ones where it is the real file: a
+  published addon, whose map points into `dist`, and a project that imports a
+  declaration-only generated file such as `pikku-rpc-wirings-map.gen.d.ts`, where
+  naming the `.js` lets the type resolver's own mapping reach the `.d.ts`.
+
+  `pikku` generates the leaf indexes and removes the hub, and `pikku validate`
+  reports a barrel import as an error. The split also turns the addon boundary
+  from advice into a rule: an addon never generates the wiring leaves, so
+  `#pikku/http` fails at the specifier rather than yielding "no exported member"
+  from a hub that quietly dropped the re-export.
+
 ## 0.12.19
 
 ### Patch Changes

package/dist/auth-config.d.ts

@@ -14,9 +14,9 @@ export declare const DelegatedLoginSchema: z.ZodObject<{
     loginPath: z.ZodString;
     loginMethod: z.ZodDefault<z.ZodString>;
     credentials: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        apiKey: "apiKey";
         email: "email";
         password: "password";
-        apiKey: "apiKey";
     }>>>;
     apiKeyHeader: z.ZodDefault<z.ZodString>;
     tokenPath: z.ZodString;
@@ -36,17 +36,17 @@ export declare const DelegatedLoginSchema: z.ZodObject<{
 export declare const AuthConfigSchema: z.ZodObject<{
     headerName: z.ZodOptional<z.ZodString>;
     headerFormat: z.ZodOptional<z.ZodEnum<{
-        raw: "raw";
         bearer: "bearer";
+        raw: "raw";
     }>>;
     extraHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     delegated: z.ZodOptional<z.ZodObject<{
         loginPath: z.ZodString;
         loginMethod: z.ZodDefault<z.ZodString>;
         credentials: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            apiKey: "apiKey";
             email: "email";
             password: "password";
-            apiKey: "apiKey";
         }>>>;
         apiKeyHeader: z.ZodDefault<z.ZodString>;
         tokenPath: z.ZodString;

package/dist/codegen.js

@@ -520,7 +520,7 @@ function generateFunctionFile(named, parsed, vars, ctx, spec, flags, inlineSchem
     if (needsZod) {
         lines.push("import { z } from 'zod'");
     }
-    lines.push("import { pikkuSessionlessFunc } from '#pikku'");
+    lines.push("import { pikkuSessionlessFunc } from '#pikku/function'");
     if (errorClasses.length > 0) {
         lines.push(`import { ${errorClasses.join(', ')} } from '@pikku/core/errors'`);
     }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { parseOpenAPISpec, computeContractHash, type ParsedSpec, } from './parse-openapi.js';
 export { generateAddonFromOpenAPI } from './codegen.js';
 export { loadAuthConfig, type AuthConfig, type DelegatedLoginConfig, } from './auth-config.js';
-export { type NamedOperation, } from './naming.js';
+export { type NamedOperation } from './naming.js';
 export { type OpenAPISchema, type ZodCodegenContext, createContext, schemaToZod, schemaVarName, sanitizeTypeName, } from './openapi-to-zod-schema.js';

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@pikku/openapi-parser",
-  "version": "0.12.19",
+  "version": "0.12.21",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/openapi-parser"
+  },
   "description": "OpenAPI spec parser and code generator for Pikku",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -12,16 +17,13 @@
     "ncu": "npx npm-check-updates",
     "build": "tsc -b",
     "test": "node --import tsx --test src/**/*.test.ts",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "bun run build"
   },
   "exports": {
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "yaml": "^2.7.1",
+    "yaml": "^2.9.0",
     "zod": "^4"
-  },
-  "devDependencies": {
-    "typescript": "^6.0.3"
   }
 }

package/src/auth-config.ts

@@ -1,94 +0,0 @@
-/**
- * Operator/agent-supplied auth configuration that overrides or augments an
- * OpenAPI spec's securitySchemes. Needed for real-world enterprise specs that
- * carry no machine-readable auth at all (auth described only in prose), or
- * that use a custom auth header the spec doesn't declare.
- */
-import { readFile } from 'fs/promises'
-import { z } from 'zod'
-
-export const DelegatedClaimsSchema = z.object({
-  /** Where identity claims live: the decoded login-JWT payload, or the login response body. */
-  source: z.enum(['jwt', 'response']),
-  /** Dot-path to the stable upstream user id (e.g. 'user._id'). */
-  externalId: z.string(),
-  email: z.string(),
-  /** One dot-path, or several joined with a space (e.g. first + last name). */
-  name: z.union([z.string(), z.array(z.string())]).optional(),
-  role: z.string().optional(),
-  tenantId: z.string().optional(),
-})
-
-export const DelegatedLoginSchema = z.object({
-  /** Spec-relative path of the login operation (e.g. '/users/login'). */
-  loginPath: z.string(),
-  loginMethod: z.string().default('post'),
-  /** Which credential fields the login accepts. email/password go in the JSON body; apiKey in a header. */
-  credentials: z
-    .array(z.enum(['email', 'password', 'apiKey']))
-    .default(['email', 'password']),
-  /** Header carrying the apiKey when 'apiKey' is a supported credential. */
-  apiKeyHeader: z.string().default('x-api-key'),
-  /** Dot-path to the token in the login response (e.g. 'token'). */
-  tokenPath: z.string(),
-  /** Dot-path to an epoch-seconds expiry in the response; defaults to the JWT `exp` claim when source is jwt. */
-  expiresAtPath: z.string().optional(),
-  claims: DelegatedClaimsSchema,
-})
-
-export const AuthConfigSchema = z.object({
-  /** Auth header the API expects on authenticated calls (e.g. 'authentication'). Overrides the spec. */
-  headerName: z.string().optional(),
-  /** 'raw' sends the bare token; 'bearer' prefixes it. Default: bearer for Authorization, raw for custom headers. */
-  headerFormat: z.enum(['raw', 'bearer']).optional(),
-  /**
-   * Static headers sent on EVERY request — the delegated login call and all
-   * proxied API calls. Needed for upstreams that route on a header, e.g. a
-   * multi-tenant API that resolves the tenant from an `Origin` header and
-   * rejects requests without it.
-   */
-  extraHeaders: z.record(z.string(), z.string()).optional(),
-  /** Present when end-users sign in with their existing upstream credentials (delegated login). */
-  delegated: DelegatedLoginSchema.optional(),
-})
-
-export type DelegatedLoginConfig = z.infer<typeof DelegatedLoginSchema>
-export type AuthConfig = z.infer<typeof AuthConfigSchema>
-
-/** The effective value template for the auth header. */
-export const authHeaderValue = (
-  config: AuthConfig,
-  tokenExpr: string
-): { header: string; value: string } => {
-  const header = config.headerName ?? 'Authorization'
-  const format =
-    config.headerFormat ??
-    (config.headerName && config.headerName !== 'Authorization'
-      ? 'raw'
-      : 'bearer')
-  return {
-    header,
-    value: format === 'bearer' ? `\`Bearer \${${tokenExpr}}\`` : tokenExpr,
-  }
-}
-
-/** Load and validate an auth-config JSON file; throws with the zod issue list on mismatch. */
-export async function loadAuthConfig(filePath: string): Promise<AuthConfig> {
-  const raw = await readFile(filePath, 'utf-8')
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(raw)
-  } catch (error) {
-    throw new Error(
-      `Auth config ${filePath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
-    )
-  }
-  const result = AuthConfigSchema.safeParse(parsed)
-  if (!result.success) {
-    const issues = result.error.issues
-      .map((i) => `  ${i.path.join('.') || '(root)'}: ${i.message}`)
-      .join('\n')
-    throw new Error(`Auth config ${filePath} is invalid:\n${issues}`)
-  }
-  return result.data
-}