@pikku/cli 0.12.83 → 0.12.86

package/dist/src/functions/wirings/scenarios/serialize-scenario-functions.d.ts

@@ -1,6 +1,10 @@
+export interface ScenarioGenOutput {
+    schemas: string;
+    functions: string;
+}
 /**
  * Generate the scenario instrumentation functions (`pikku scenario` coverage
  * snapshots and stub-call inspection) into the project scaffold, so scenario
  * runs work against any server without requiring the console addon.
  */
-export declare const serializeScenarioFunctions: (pathToPikkuTypes: string, requireAuth?: boolean) => string;
+export declare const serializeScenarioFunctions: (pathToPikkuTypes: string, requireAuth?: boolean) => ScenarioGenOutput;

package/dist/src/functions/wirings/scenarios/serialize-scenario-functions.js

@@ -5,7 +5,19 @@
  */
 export const serializeScenarioFunctions = (pathToPikkuTypes, requireAuth = true) => {
     const authFlag = requireAuth ? 'true' : 'false';
-    return `/**
+    const schemas = `/**
+ * Auto-generated scenario instrumentation schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+export const StubCallsQuery = z.object({
+  service: z.string().optional(),
+})
+
+export const Enabled = z.object({ enabled: z.boolean() })
+`;
+    const functions = `/**
  * Auto-generated scenario instrumentation functions
  * Do not edit manually - regenerate with 'npx pikku'
  */
@@ -16,14 +28,10 @@ import {
   getStubTracker,
   isTestRun,
   type CoverageFunctionMeta,
-  type FunctionCoverageReport,
-  type StubCall,
 } from '@pikku/core/services'
+import { StubCallsQuery, Enabled } from './scenarios.schemas.gen.js'
 
-export const pikkuScenarioTakeLiveCoverage = pikkuFunc<
-  null,
-  FunctionCoverageReport | null
->({
+export const pikkuScenarioTakeLiveCoverage = pikkuFunc({
   tags: ['pikku'],
   title: 'Take Live Coverage',
   description:
@@ -50,16 +58,14 @@ export const pikkuScenarioTakeLiveCoverage = pikkuFunc<
   },
 })
 
-export const pikkuScenarioResetLiveCoverage = pikkuFunc<
-  null,
-  { enabled: boolean }
->({
+export const pikkuScenarioResetLiveCoverage = pikkuFunc({
   tags: ['pikku'],
   title: 'Reset Live Coverage',
   description:
     'Clears V8 precise-coverage call counts so the next takeLiveCoverage snapshot is attributable to a single scenario run. Reports enabled: false when the server was not started with coverage enabled.',
   expose: true,
   auth: ${authFlag},
+  output: Enabled,
   func: async ({ coverageService }) => {
     if (!coverageService) return { enabled: false }
     await coverageService.reset()
@@ -67,32 +73,32 @@ export const pikkuScenarioResetLiveCoverage = pikkuFunc<
   },
 })
 
-export const pikkuScenarioResetStubs = pikkuFunc<null, { enabled: boolean }>({
+export const pikkuScenarioResetStubs = pikkuFunc({
   tags: ['pikku'],
   title: 'Reset Stubs',
   description:
     'Clears recorded stub calls so the next getStubCalls result is attributable to a single scenario run. Reports enabled: false when the server was not started in test mode.',
   expose: true,
   auth: ${authFlag},
+  output: Enabled,
   func: async () => {
     getStubTracker().reset()
     return { enabled: isTestRun() }
   },
 })
 
-export const pikkuScenarioGetStubCalls = pikkuFunc<
-  { service?: string },
-  StubCall[]
->({
+export const pikkuScenarioGetStubCalls = pikkuFunc({
   tags: ['pikku'],
   title: 'Get Stub Calls',
   description:
     'Returns calls recorded against stubbed/spied services (via the stub()/spy() core utils). Empty unless the server records service calls (pikku dev --test).',
   expose: true,
   auth: ${authFlag},
+  input: StubCallsQuery,
   func: async (_services, data) => {
     return getStubTracker().getCalls(data?.service ?? undefined)
   },
 })
 `;
+    return { schemas, functions };
 };

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler-types.d.ts

@@ -1 +1 @@
-export declare const pikkuSchedulerTypes: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuSchedulerTypes: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/scheduler/pikku-command-scheduler.d.ts

@@ -1 +1 @@
-export declare const pikkuScheduler: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuScheduler: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/scopes/pikku-command-scopes.d.ts

@@ -2,6 +2,6 @@ export declare const pikkuScopes: import("#pikku").PikkuFunctionConfig<{
     bootstrap?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/secrets/pikku-command-secrets.d.ts

@@ -1 +1 @@
-export declare const pikkuSecrets: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuSecrets: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/triggers/pikku-command-trigger-types.d.ts

@@ -2,6 +2,6 @@ export declare const pikkuTriggerTypes: import("#pikku").PikkuFunctionConfig<{
     bootstrap?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     bootstrap?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/triggers/pikku-command-trigger.d.ts

@@ -1 +1 @@
-export declare const pikkuTrigger: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuTrigger: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/user-admin/pikku-command-user-admin-functions.d.ts

@@ -0,0 +1 @@
+export declare const pikkuUserAdminFunctions: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/user-admin/pikku-command-user-admin-functions.js

@@ -0,0 +1,49 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeUserAdminFunctions } from './serialize-user-admin-functions.js';
+export const pikkuUserAdminFunctions = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        if (!config.scaffold?.userAdmin ||
+            !config.userAdminFunctionsFile ||
+            !config.userAdminSchemasFile) {
+            logger.debug({
+                message: 'Skipping user admin scaffold (set scaffold.userAdmin in pikku.config.json to enable).',
+                type: 'skip',
+            });
+            return false;
+        }
+        const { definition } = (await getInspectorState()).auth;
+        // These functions are thin wrappers over better-auth's admin() endpoints.
+        // Without that plugin the endpoints do not exist, so the scaffold would
+        // generate four RPCs that throw on every call and four scopes that grant
+        // nothing. Fail the codegen instead of shipping that.
+        if (!definition) {
+            throw new Error(`"scaffold.userAdmin" is enabled but no pikkuBetterAuth(...) was found in the project.\n` +
+                `User management wraps better-auth's admin() endpoints, so there is nothing to wrap.\n` +
+                `Fix: set up Better Auth before scaffolding user management, or remove ` +
+                `"scaffold.userAdmin" from pikku.config.json.`);
+        }
+        if (!definition.plugins.includes('admin')) {
+            throw new Error(`"scaffold.userAdmin" is enabled but better-auth is configured without the admin() plugin.\n` +
+                `Ban, delete, session-revocation and set-password are implemented by that plugin — without it ` +
+                `the generated functions would fail on every call.\n` +
+                `Fix: add admin() to the plugins array in ${definition.sourceFile}:\n` +
+                `  import { admin } from 'better-auth/plugins'\n` +
+                `  betterAuth({ plugins: [admin()] })\n` +
+                `Then re-run codegen. Or remove "scaffold.userAdmin" from pikku.config.json.`);
+        }
+        const pathToPikkuTypes = getFileImportRelativePath(config.userAdminFunctionsFile, config.typesDeclarationFile, config.packageMappings);
+        const { schemas, functions } = serializeUserAdminFunctions(pathToPikkuTypes, config.scaffold.userAdmin === 'auth');
+        await writeFileInDir(logger, config.userAdminSchemasFile, schemas);
+        await writeFileInDir(logger, config.userAdminFunctionsFile, functions);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating user management functions',
+            commandEnd: 'Generated user management functions',
+        }),
+    ],
+});

package/dist/src/functions/wirings/user-admin/serialize-user-admin-functions.d.ts

@@ -0,0 +1,24 @@
+export interface UserAdminGenOutput {
+    schemas: string;
+    functions: string;
+}
+/**
+ * Generate the user-management functions into the project scaffold: the
+ * directory read plus the writes that wrap better-auth's `admin()` endpoints.
+ *
+ * Scaffolded rather than shipped in an addon because managing users is ordinary
+ * application behaviour: an app should not have to install the console — which
+ * exists to be served alongside a running dev server — just to list or ban its
+ * own users. The console UI calls these same functions when it is present.
+ *
+ * Each function is gated on its own `admin:users:*` scope. The writes are only
+ * meaningful where `admin()` is wired, which is why this file is generated only
+ * in that case.
+ *
+ * Emitted as two files. The schemas are zod, and the inspector reads a zod
+ * schema by importing the module that declares it — which it cannot do for the
+ * functions file, whose relative pikku-types import per-unit deploy codegen
+ * rewrites. Keeping the schemas in a sibling module that imports nothing but
+ * zod sidesteps that entirely.
+ */
+export declare const serializeUserAdminFunctions: (pathToPikkuTypes: string, requireAuth?: boolean) => UserAdminGenOutput;

package/dist/src/functions/wirings/user-admin/serialize-user-admin-functions.js

@@ -0,0 +1,283 @@
+/**
+ * Generate the user-management functions into the project scaffold: the
+ * directory read plus the writes that wrap better-auth's `admin()` endpoints.
+ *
+ * Scaffolded rather than shipped in an addon because managing users is ordinary
+ * application behaviour: an app should not have to install the console — which
+ * exists to be served alongside a running dev server — just to list or ban its
+ * own users. The console UI calls these same functions when it is present.
+ *
+ * Each function is gated on its own `admin:users:*` scope. The writes are only
+ * meaningful where `admin()` is wired, which is why this file is generated only
+ * in that case.
+ *
+ * Emitted as two files. The schemas are zod, and the inspector reads a zod
+ * schema by importing the module that declares it — which it cannot do for the
+ * functions file, whose relative pikku-types import per-unit deploy codegen
+ * rewrites. Keeping the schemas in a sibling module that imports nothing but
+ * zod sidesteps that entirely.
+ */
+export const serializeUserAdminFunctions = (pathToPikkuTypes, requireAuth = true) => {
+    const authFlag = requireAuth ? 'true' : 'false';
+    const schemas = `/**
+ * Auto-generated user management schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+/**
+ * A user, as the directory sees one. Ban state is optional because those
+ * columns belong to better-auth's \`admin()\` plugin: a host without it reports
+ * no ban state at all, which a client can render as "unknown" rather than as a
+ * misleading "not banned".
+ */
+export const User = z.object({
+  id: z.string(),
+  email: z.string(),
+  name: z.string().optional(),
+  image: z.string().optional(),
+  createdAt: z.string().optional(),
+  banned: z.boolean().optional(),
+  banReason: z.string().optional(),
+  banExpires: z.string().optional(),
+})
+
+export const ListUsersInput = z.object({
+  search: z.string().optional(),
+  limit: z.number().int().positive().optional(),
+})
+
+export const ListUsersOutput = z.object({
+  users: z.array(User),
+})
+
+export const CreateUserInput = z.object({
+  email: z.string(),
+  password: z.string(),
+  name: z.string().optional(),
+})
+
+export const CreateUserOutput = z.object({
+  userId: z.string(),
+})
+
+/** Every write targets one user by id. */
+export const UserRef = z.object({
+  userId: z.string(),
+})
+
+export const SetUserBannedInput = z.object({
+  userId: z.string(),
+  banned: z.boolean(),
+  reason: z.string().optional(),
+  expiresInSeconds: z.number().int().positive().optional(),
+})
+
+export const SetUserPasswordInput = z.object({
+  userId: z.string(),
+  newPassword: z.string(),
+})
+
+export const Success = z.object({
+  success: z.boolean(),
+})
+`;
+    const functions = `/**
+ * Auto-generated user management functions
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuFunc, wireScope } from '${pathToPikkuTypes}'
+import { callAdminApi } from '@pikku/better-auth'
+import {
+  CreateUserInput,
+  CreateUserOutput,
+  ListUsersInput,
+  ListUsersOutput,
+  SetUserBannedInput,
+  SetUserPasswordInput,
+  Success,
+  UserRef,
+} from './user-admin.schemas.gen.js'
+
+// pikku requires every declaration of a shared scope root to be identical, so
+// this is the whole \`admin\` tree — not just the leaves gated below. It must stay
+// byte-identical to ADMIN_SCOPE_TREE in @pikku/better-auth and to the copy in
+// @pikku/addon-console, or codegen fails with conflicting declarations.
+wireScope({
+  admin: {
+    displayName: 'Administration',
+    description: 'Capabilities that act on the application as a whole',
+    scopes: {
+      impersonate: { description: 'Act as another user' },
+      credentials: {
+        description: 'Application-wide credentials',
+        scopes: {
+          link: { description: 'Bind a shared credential for every user' },
+        },
+      },
+      users: {
+        description: 'The user directory',
+        scopes: {
+          list: { description: 'List and search users' },
+          create: { description: 'Create users out of band' },
+          ban: { description: 'Ban and unban users' },
+          remove: { description: 'Delete users and all their data' },
+          sessions: { description: "Revoke a user's sessions" },
+          password: { description: "Set a user's password" },
+        },
+      },
+    },
+  },
+})
+
+/**
+ * Synthetic principals — the platform credential owner, fabric service users
+ * and agent actors — are not people, so they never belong in a directory a
+ * human picks from.
+ */
+const isPerson = (row: any) =>
+  row.fabric !== true && row.actor !== true && row.id !== 'pikku-platform'
+
+export const pikkuAdminListUsers = pikkuFunc({
+  tags: ['pikku'],
+  title: 'List Users',
+  description:
+    'Lists and searches the user directory, read through the auth adapter rather than an admin endpoint so it works on any database better-auth supports.',
+  expose: true,
+  auth: ${authFlag},
+  scopes: ['admin:users:list'],
+  input: ListUsersInput,
+  output: ListUsersOutput,
+  func: async ({ auth }, { search, limit }) => {
+    const ctx = await (await auth()).$context
+    const rows = (await ctx.adapter.findMany({
+      model: 'user',
+      limit: limit ?? 200,
+      where: search
+        ? [{ field: 'email', operator: 'contains', value: search }]
+        : undefined,
+    })) as any[]
+
+    return {
+      users: rows.filter(isPerson).map((row) => ({
+        id: row.id,
+        email: row.email,
+        name: row.name ?? undefined,
+        image: row.image ?? undefined,
+        createdAt: row.createdAt
+          ? new Date(row.createdAt).toISOString()
+          : undefined,
+        banned: typeof row.banned === 'boolean' ? row.banned : undefined,
+        banReason: row.banReason ?? undefined,
+        banExpires: row.banExpires
+          ? new Date(row.banExpires).toISOString()
+          : undefined,
+      })),
+    }
+  },
+})
+
+export const pikkuAdminCreateUser = pikkuFunc({
+  tags: ['pikku'],
+  title: 'Create User',
+  description:
+    'Creates a user directly, for provisioning an account out of band rather than through your sign-up flow. better-auth enforces the configured password bounds and rejects a duplicate email.',
+  expose: true,
+  auth: ${authFlag},
+  scopes: ['admin:users:create'],
+  input: CreateUserInput,
+  output: CreateUserOutput,
+  func: async ({ auth }, { email, password, name }, { http }) => {
+    const created: any = await callAdminApi(auth, http, (api, headers) =>
+      api.createUser!({
+        body: { email, password, name: name ?? email },
+        headers,
+      })
+    )
+    return { userId: created?.user?.id ?? created?.id }
+  },
+})
+
+export const pikkuAdminSetUserBanned = pikkuFunc({
+  tags: ['pikku'],
+  title: 'Ban or Unban User',
+  description:
+    'Bans a user — revoking their sessions and blocking sign-in — or lifts an existing ban. An expiry lets the ban lapse on its own; without one it holds until it is lifted.',
+  expose: true,
+  auth: ${authFlag},
+  scopes: ['admin:users:ban'],
+  input: SetUserBannedInput,
+  output: Success,
+  func: async (
+    { auth },
+    { userId, banned, reason, expiresInSeconds },
+    { http }
+  ) => {
+    await callAdminApi(auth, http, (api, headers) =>
+      banned
+        ? api.banUser!({
+            body: { userId, banReason: reason, banExpiresIn: expiresInSeconds },
+            headers,
+          })
+        : api.unbanUser!({ body: { userId }, headers })
+    )
+    return { success: true }
+  },
+})
+
+export const pikkuAdminRemoveUser = pikkuFunc({
+  tags: ['pikku'],
+  title: 'Remove User',
+  description:
+    'Permanently deletes a user along with their sessions and linked accounts. Cannot be undone.',
+  expose: true,
+  auth: ${authFlag},
+  scopes: ['admin:users:remove'],
+  input: UserRef,
+  output: Success,
+  func: async ({ auth }, { userId }, { http }) => {
+    await callAdminApi(auth, http, (api, headers) =>
+      api.removeUser!({ body: { userId }, headers })
+    )
+    return { success: true }
+  },
+})
+
+export const pikkuAdminRevokeUserSessions = pikkuFunc({
+  tags: ['pikku'],
+  title: 'Revoke User Sessions',
+  description:
+    'Signs a user out of every device by deleting all of their sessions. They keep their account and can sign in again.',
+  expose: true,
+  auth: ${authFlag},
+  scopes: ['admin:users:sessions'],
+  input: UserRef,
+  output: Success,
+  func: async ({ auth }, { userId }, { http }) => {
+    await callAdminApi(auth, http, (api, headers) =>
+      api.revokeUserSessions!({ body: { userId }, headers })
+    )
+    return { success: true }
+  },
+})
+
+export const pikkuAdminSetUserPassword = pikkuFunc({
+  tags: ['pikku'],
+  title: "Set User's Password",
+  description:
+    'Sets a user password out of band, for when they cannot complete a reset themselves. better-auth enforces the configured length bounds.',
+  expose: true,
+  auth: ${authFlag},
+  scopes: ['admin:users:password'],
+  input: SetUserPasswordInput,
+  output: Success,
+  func: async ({ auth }, { userId, newPassword }, { http }) => {
+    await callAdminApi(auth, http, (api, headers) =>
+      api.setUserPassword!({ body: { userId, newPassword }, headers })
+    )
+    return { success: true }
+  },
+})
+`;
+    return { schemas, functions };
+};

package/dist/src/functions/wirings/variables/pikku-command-variables.d.ts

@@ -1 +1 @@
-export declare const pikkuVariables: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuVariables: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/webhook/pikku-command-webhook.d.ts

@@ -1 +1 @@
-export declare const pikkuWebhook: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuWebhook: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/webhook/pikku-command-webhook.js

@@ -2,6 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeWebhook } from './serialize-webhook.js';
 export const pikkuWebhook = pikkuSessionlessFunc({
     func: async ({ logger, config, variables }) => {
@@ -9,9 +10,12 @@ export const pikkuWebhook = pikkuSessionlessFunc({
         if (deployCodegenFlag === '1') {
             return false;
         }
-        if (config.webhookWorkersFile) {
+        if (config.webhookWorkersFile && config.webhookSchemasFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.webhookWorkersFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.webhookWorkersFile, serializeWebhook(pathToPikkuTypes));
+            const { schemas, functions } = serializeWebhook(pathToPikkuTypes);
+            await writeFileInDir(logger, config.webhookSchemasFile, schemas);
+            await writeFileInDir(logger, config.webhookWorkersFile, functions);
+            await removeLegacyScaffoldFile(config.webhookWorkersFile);
             return true;
         }
         return false;

package/dist/src/functions/wirings/webhook/serialize-webhook.d.ts

@@ -1,14 +1,11 @@
+export interface WebhookGenOutput {
+    schemas: string;
+    functions: string;
+}
 /**
  * Generate the outgoing webhook delivery queue worker.
  *
- * The payload type is an inline TS literal (not zod): the inspector imports a
- * zod schema's declaring module at codegen time, and the wiring file's
- * pikku-types import can go stale between deploy per-unit codegen runs, which
- * would fail schema generation before the wiring gets rewritten. TS-based
- * schema generation goes through the type checker instead, so it never
- * imports this file.
- *
  * The handler is inlined: it is wired exactly once, so a named export would
  * only be indirection.
  */
-export declare const serializeWebhook: (pathToPikkuTypes: string) => string;
+export declare const serializeWebhook: (pathToPikkuTypes: string) => WebhookGenOutput;

package/dist/src/functions/wirings/webhook/serialize-webhook.js

@@ -1,34 +1,41 @@
 /**
  * Generate the outgoing webhook delivery queue worker.
  *
- * The payload type is an inline TS literal (not zod): the inspector imports a
- * zod schema's declaring module at codegen time, and the wiring file's
- * pikku-types import can go stale between deploy per-unit codegen runs, which
- * would fail schema generation before the wiring gets rewritten. TS-based
- * schema generation goes through the type checker instead, so it never
- * imports this file.
- *
  * The handler is inlined: it is wired exactly once, so a named export would
  * only be indirection.
  */
 export const serializeWebhook = (pathToPikkuTypes) => {
-    return `/**
+    const schemas = `/**
+ * Auto-generated outgoing webhook delivery schemas
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { z } from 'zod'
+
+export const WebhookDelivery = z.object({
+  url: z.string(),
+  event: z.string().optional(),
+  body: z.string(),
+  headers: z.record(z.string(), z.string()),
+  deliveryId: z.string().optional(),
+})
+`;
+    const functions = `/**
  * Auto-generated outgoing webhook delivery queue worker
  * Do not edit manually - regenerate with 'npx pikku'
  */
 import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
 import { pikkuWebhookWorkerFunc } from '@pikku/core/services'
+import { WebhookDelivery } from './webhook.schemas.gen.js'
 
 wireQueueWorker({
   name: 'pikku-outgoing-webhooks',
   tags: ['pikku'],
-  func: pikkuSessionlessFunc<
-    { url: string, event?: string, body: string, headers: Record<string, string>, deliveryId?: string },
-    void
-  >({
+  func: pikkuSessionlessFunc({
     tags: ['pikku'],
+    input: WebhookDelivery,
     func: async (services, data) => pikkuWebhookWorkerFunc(services, data),
   }),
 })
 `;
+    return { schemas, functions };
 };

package/dist/src/functions/wirings/workflow/pikku-command-workflow-routes.d.ts

@@ -1 +1 @@
-export declare const pikkuWorkflowRoutes: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuWorkflowRoutes: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/workflow/pikku-command-workflow-routes.js

@@ -2,12 +2,18 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { removeLegacyScaffoldFile } from '../../../utils/remove-legacy-scaffold-file.js';
 import { serializeWorkflowRoutes } from './serialize-workflow-routes.js';
 export const pikkuWorkflowRoutes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.scaffold?.workflow && config.workflowRoutesFile) {
+        if (config.scaffold?.workflow &&
+            config.workflowRoutesFile &&
+            config.workflowRoutesSchemasFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.workflowRoutesFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.workflowRoutesFile, serializeWorkflowRoutes(pathToPikkuTypes, config.scaffold?.workflow === 'auth'));
+            const { schemas, functions } = serializeWorkflowRoutes(pathToPikkuTypes, config.scaffold?.workflow === 'auth');
+            await writeFileInDir(logger, config.workflowRoutesSchemasFile, schemas);
+            await writeFileInDir(logger, config.workflowRoutesFile, functions);
+            await removeLegacyScaffoldFile(config.workflowRoutesFile);
             return true;
         }
         return false;

package/dist/src/functions/wirings/workflow/pikku-command-workflow.d.ts

@@ -1,5 +1,5 @@
 type WorkflowCommandInput = {
     bootstrap?: boolean;
 };
-export declare const pikkuWorkflow: import("#pikku").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuWorkflow: import("#pikku").PikkuFunctionConfig<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<WorkflowCommandInput, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export {};