@pikku/cli 0.12.159 → 0.12.162

package/dist/src/functions/wirings/rpc/serialize-react-query-hooks.js

@@ -1,4 +1,4 @@
-export const serializeReactQueryHooks = (rpcMapPath, workflowMapPath) => {
+export const serializeReactQueryHooks = (rpcMapPath, workflowMapPath, hasAuth) => {
     const workflowImport = workflowMapPath
         ? `\nimport type { FlattenedWorkflowMap } from '${workflowMapPath}'`
         : '';
@@ -49,10 +49,61 @@ export const useWorkflowStatus = (
     ...options,
   })
 }
+`
+        : '';
+    /**
+     * The session — and, for free, the thing that heals the session cookie.
+     *
+     * Under `betterAuthStatelessSession` the signed `session_data` cookie is the
+     * only thing authenticating a request, and nothing rewrites it once someone
+     * is signed in. When it ages out, better-auth's cookie-cache branch bails on
+     * the stale payload and falls through to the database, reading the session
+     * from the still-valid `session_token` and minting a fresh cookie on the way
+     * out. So an ordinary cached read heals an expired cookie by itself.
+     *
+     * Which is why this does NOT pass `disableCookieCache`. Forcing it would turn
+     * every refetch into a database read — the exact cost the cookie cache exists
+     * to avoid — to re-mint a cookie that has most of its life left. The read is
+     * worth paying once, when the cookie has actually expired, and that is when
+     * better-auth does it anyway.
+     *
+     * better-auth's own sliding renewal (`session.cookieCache.refreshCache`) is
+     * not the answer either: it is force-disabled whenever a database is
+     * configured, and where it does apply it re-signs the cached blob without
+     * reading the database, so a banned user's cookie would renew forever.
+     */
+    const sessionImport = hasAuth ? ', usePikkuFetch' : '';
+    const sessionHook = hasAuth
+        ? `
+/* Short enough that an expired cookie is healed long before anyone notices,
+   and cheap: while the cookie is good this is a cache hit with no database
+   behind it. */
+const SESSION_REFETCH_MS = 10 * 60 * 1000
+/* A tab flicked away from and back to should not refetch on every glance. */
+const SESSION_STALE_MS = 2 * 60 * 1000
+
+export const useSession = <Session = unknown>(
+  options?: Omit<UseQueryOptions<Session | null, Error>, 'queryKey' | 'queryFn'>
+) => {
+  const fetch = usePikkuFetch()
+  return useQuery<Session | null, Error>({
+    queryKey: ['pikkuSession'],
+    queryFn: async () => {
+      const response = await fetch.fetch('/auth/get-session', 'GET', undefined)
+      if (!response.ok) return null
+      // Signed out is a null body, not an error status.
+      return ((await response.json().catch(() => null)) ?? null) as Session | null
+    },
+    refetchInterval: SESSION_REFETCH_MS,
+    refetchOnWindowFocus: true,
+    staleTime: SESSION_STALE_MS,
+    ...options,
+  })
+}
 `
         : '';
     return `import { useQuery, useInfiniteQuery, useMutation, type UseQueryOptions, type UseInfiniteQueryOptions, type UseMutationOptions, type InfiniteData } from '@tanstack/react-query'
-import { usePikkuRPC } from '@pikku/react'
+import { usePikkuRPC${sessionImport} } from '@pikku/react'
 import type { FlattenedRPCMap } from '${rpcMapPath}'${workflowImport}
 
 type RPCInvoke = <Name extends keyof FlattenedRPCMap>(name: Name, data: FlattenedRPCMap[Name]['input']) => Promise<FlattenedRPCMap[Name]['output']>
@@ -104,5 +155,5 @@ export const usePikkuInfiniteQuery = <Name extends PaginatedKeys>(
     ...options,
   })
 }
-${workflowHooks}`;
+${sessionHook}${workflowHooks}`;
 };

package/dist/src/functions/wirings/scenarios/serialize-feature-meta.js

@@ -17,6 +17,7 @@ export const buildFeaturesMeta = (featureFiles) => {
             name: feature.name ?? id,
             ...(feature.description ? { description: feature.description } : {}),
             tags: feature.tags ?? [],
+            ...(feature.document === undefined ? {} : { document: feature.document }),
             entries: feature.entries.map((entry) => entry.data === undefined
                 ? { scenario: entry.scenario }
                 : { scenario: entry.scenario, data: entry.data }),

package/dist/src/functions/wirings/workflow/serialize-scenario-types.js

@@ -223,6 +223,12 @@ type PikkuFeatureConfig<Scenarios extends readonly unknown[]> = {
   name: string
   description?: string
   tags?: string[]
+  /**
+   * Whether this feature is guide material, defaulting to true. \`pikku scenario
+   * guide\` requires every documented feature to be cited by a page; a feature
+   * that is pure plumbing sets this false rather than being written about.
+   */
+  document?: boolean
   scenarios: { [K in keyof Scenarios]: PikkuFeatureEntry<Scenarios[K]> }
   /**
    * Runs ONCE before the whole group — not before each scenario. Per-scenario

package/dist/src/services.js

@@ -383,6 +383,8 @@ export const createSingletonServices = async (config) => {
     // Keeping the check in this single place avoids `typeof Bun` branches leaking
     // into the deploy pipeline / dev command.
     const isBun = typeof globalThis.Bun !== 'undefined';
+    const deployBundler = config.deploy?.bundler ?? 'auto';
+    const bundleWithBun = deployBundler === 'bun' || (deployBundler === 'auto' && isBun);
     return {
         config,
         logger,
@@ -392,7 +394,7 @@ export const createSingletonServices = async (config) => {
         getInspectorState,
         invalidateInspectorState,
         workflowService,
-        bundler: isBun ? new BunBundler() : new NodeBundler(),
+        bundler: bundleWithBun ? new BunBundler() : new NodeBundler(),
         devServerRunner: isBun
             ? new BunServerRunner()
             : new NodeServerRunner(rootDir),