@pikku/cli 0.12.160 → 0.12.163

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,14 +49,70 @@ 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']>
 
+const retryUnlessClientError = (failureCount: number, error: Error) => {
+  const status = (error as { status?: number }).status
+  return !(status !== undefined && status >= 400 && status < 500) && failureCount < 3
+}
+
 export const usePikkuQuery = <Name extends keyof FlattenedRPCMap>(
   name: Name,
   data: FlattenedRPCMap[Name]['input'],
@@ -66,6 +122,7 @@ export const usePikkuQuery = <Name extends keyof FlattenedRPCMap>(
   return useQuery<FlattenedRPCMap[Name]['output'], Error>({
     queryKey: [name, data],
     queryFn: () => rpc.invoke(name, data),
+    retry: retryUnlessClientError,
     ...options,
   })
 }
@@ -104,5 +161,5 @@ export const usePikkuInfiniteQuery = <Name extends PaginatedKeys>(
     ...options,
   })
 }
-${workflowHooks}`;
+${sessionHook}${workflowHooks}`;
 };

package/dist/src/functions/workflows/all.workflow.js

@@ -6,6 +6,7 @@ import { warnOnSplitTypeIdentity } from '../validate/type-identity-checks.js';
 import { pruneLegacyScaffoldFiles, refreshScaffoldsImportingRemovedEntryPoints, removeRetiredScaffoldFiles, } from '../../utils/remove-legacy-scaffold-file.js';
 import { writeSurfaceUsage } from '../surface/write-surface-usage.js';
 import { writeSchemaArtifact } from '../db/local-db.js';
+import { ensureDbTypes } from '../db/ensure-db-types.js';
 import { PikkuTypecheckFailedError, renderTscFull, renderTscSummary, runProjectTypecheck, } from '../../utils/tsc-check.js';
 const scaffoldFiles = (config) => {
     const files = [];
@@ -58,9 +59,14 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         await pruneLegacyScaffoldFiles(config);
         await refreshScaffoldsImportingRemovedEntryPoints(config);
         await removeRetiredScaffoldFiles(config);
+        const needsBootstrap = !existsSync(config.outDir);
+        const dbTypes = await ensureDbTypes(config.rootDir, config.outDir, config.runtimeDir, config.db);
+        if (dbTypes === 'stubbed') {
+            logger.warn('db/schema.gen.ts could not be generated from the migrations; wrote an empty DB until `pikku db migrate` runs');
+        }
         const allImports = [];
         let functionTypesFileExists = true;
-        if (!existsSync(config.outDir)) {
+        if (needsBootstrap) {
             logger.debug(`• .pikku directory not found, running bootstrap first...`);
             // Every `getInspectorState` step below discards its result on purpose. A
             // step's return value is stored as the step result and stays reachable for