@pikku/core 0.12.128 → 0.12.129

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.12.129
+
+### Patch Changes
+
+- 1ab6eb4: Fix app functions reached through `rpc.invoke`/`rpc.exposed` (including the generated `/rpc/:rpcName` endpoint) running without their wire services. Since `singletonServicesOnly`, the forwarding `rpcCaller` built none and the callee inherited that, so any service from `pikkuWireServices` was `undefined`. The runner now resolves the callee's factory itself. Channels pass their per-connection set as the new `wireServices` option, which is reused and left open.
+
 ## 0.12.128
 
 ### Patch Changes

package/dist/function/function-runner.d.ts

@@ -8,9 +8,14 @@ import type { AddonInstance } from '../wirings/addon/addon-runner.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any, any, any, any>, packageName?: string | null) => void;
 export declare const getFunctionNames: (packageName?: string | null) => string[];
 export declare const getAllFunctionNames: () => string[];
-export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedChannelMiddleware, wireChannelMiddleware, coerceDataFromSchema, wire, sessionService, credentialWireService, packageName, addonInstance, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { singletonServices, createWireServices, wireServices: providedWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedChannelMiddleware, wireChannelMiddleware, coerceDataFromSchema, wire, sessionService, credentialWireService, packageName, addonInstance, }: {
     singletonServices: CoreSingletonServices;
     createWireServices?: CreateWireServices;
+    /**
+     * Wire services the caller already built and still owns, such as a
+     * channel's per-connection set. Used as-is and never closed here.
+     */
+    wireServices?: Record<string, unknown>;
     data: () => Promise<In> | In;
     auth?: boolean;
     inheritedMiddleware?: MiddlewareMetadata[];

package/dist/function/function-runner.js

@@ -3,7 +3,7 @@ import { runMiddleware, combineMiddleware } from '../middleware-runner.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../wirings/channel/channel-middleware-runner.js';
 import { runPermissions } from '../permissions.js';
 import { withoutSecrets } from '../services/secretless.js';
-import { pikkuState } from '../pikku-state.js';
+import { getCreateWireServices, pikkuState } from '../pikku-state.js';
 import { applyDefaultsFromSchema, coerceTopLevelDataFromSchema, validateSchema, } from '../schema.js';
 import { parseVersionedId } from '../version.js';
 import { PikkuSessionService } from '../services/user-session-service.js';
@@ -64,7 +64,7 @@ export const getAllFunctionNames = () => {
     }
     return functions;
 };
-export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedChannelMiddleware, wireChannelMiddleware, coerceDataFromSchema, wire, sessionService, credentialWireService, packageName = null, addonInstance, }) => {
+export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServices, createWireServices, wireServices: providedWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedChannelMiddleware, wireChannelMiddleware, coerceDataFromSchema, wire, sessionService, credentialWireService, packageName = null, addonInstance, }) => {
     wire.wireType ??= wireType;
     wire.wireId ??= wireId;
     const funcMap = pikkuState(packageName, 'function', 'functions');
@@ -118,13 +118,14 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
     const resolvedSingletonServices = funcPackageName
         ? await getOrCreatePackageSingletonServices(funcPackageName, singletonServices, addonInstance)
         : singletonServices;
-    let resolvedCreateWireServices = createWireServices;
-    if (funcPackageName) {
-        const factories = pikkuState(funcPackageName, 'package', 'factories');
-        if (factories?.createWireServices) {
-            resolvedCreateWireServices = factories.createWireServices;
-        }
-    }
+    // knowledge: decisions/internals/the-runner-resolves-wire-services-itself.md
+    const packageCreateWireServices = funcPackageName
+        ? pikkuState(funcPackageName, 'package', 'factories')?.createWireServices
+        : undefined;
+    const reusedWireServices = packageCreateWireServices
+        ? undefined
+        : providedWireServices;
+    const resolvedCreateWireServices = packageCreateWireServices ?? createWireServices ?? getCreateWireServices();
     const allChannelMiddleware = combineChannelMiddleware(wireType, wireId, {
         wireInheritedChannelMiddleware: inheritedChannelMiddleware,
         wireChannelMiddleware,
@@ -256,11 +257,14 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         let invocationAuditLog;
         let invocationAnalytics;
         try {
-            wireServices = funcMeta.singletonServicesOnly
+            if (!funcMeta.singletonServicesOnly && !reusedWireServices) {
+                wireServices = (await resolvedCreateWireServices?.(resolvedSingletonServices, invocationWire));
+            }
+            const invocationWireServices = funcMeta.singletonServicesOnly
                 ? undefined
-                : (await resolvedCreateWireServices?.(resolvedSingletonServices, invocationWire));
-            let services = wireServices && Object.keys(wireServices).length > 0
-                ? { ...resolvedSingletonServices, ...wireServices }
+                : (reusedWireServices ?? wireServices);
+            let services = invocationWireServices && Object.keys(invocationWireServices).length > 0
+                ? { ...resolvedSingletonServices, ...invocationWireServices }
                 : resolvedSingletonServices;
             // knowledge: decisions/internals/core-function-runner-restores-the-wire-fields-it-overwrites.md
             if (resolvedAuditConfig &&
@@ -286,7 +290,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
             const callerPackageName = funcPackageName;
             Object.defineProperty(invocationWire, 'rpc', {
                 get() {
-                    const rpc = rpcService.getContextRPCService(services, invocationWire, { sessionService }, 0, callerPackageName);
+                    const rpc = rpcService.getContextRPCService(resolvedSingletonServices, invocationWire, { sessionService }, 0, callerPackageName);
                     Object.defineProperty(invocationWire, 'rpc', {
                         value: rpc,
                         writable: true,

package/dist/wirings/channel/channel-common.d.ts

@@ -2,7 +2,7 @@ import type { CoreSingletonServices } from '../../types/core.types.js';
 import type { MiddlewareMetadata } from '../../middleware/middleware.types.js';
 import type { CoreChannel, ChannelMessageMeta } from './channel.types.js';
 import { type PikkuSessionService } from '../../services/user-session-service.js';
-export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, userSession, }: {
+export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, userSession, wireServices, }: {
     channelConfig: CoreChannel<unknown, any>;
     meta: ChannelMessageMeta;
     lifecycleConfig: any;
@@ -16,4 +16,6 @@ export declare const runChannelLifecycleWithMiddleware: ({ channelConfig, meta,
      * just connected.
      */
     userSession?: PikkuSessionService<any>;
+    /** The connection's wire services, reused rather than rebuilt per call. */
+    wireServices?: Record<string, unknown>;
 }) => Promise<unknown>;

package/dist/wirings/channel/channel-common.js

@@ -2,7 +2,7 @@ import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from './channel-middleware-runner.js';
-export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, userSession, }) => {
+export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, lifecycleConfig, lifecycleType, services, channel, data, channelMiddlewareMeta, userSession, wireServices, }) => {
     const lifecycleMiddleware = typeof lifecycleConfig === 'object' && 'middleware' in lifecycleConfig
         ? lifecycleConfig.middleware || []
         : [];
@@ -25,6 +25,7 @@ export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, l
     const runLifecycle = async () => {
         return await runPikkuFunc('channel', channelConfig.name, meta.pikkuFuncId, {
             singletonServices: services,
+            wireServices,
             data: () => data,
             wire,
             sessionService: userSession,

package/dist/wirings/channel/channel-handler.d.ts

@@ -1,7 +1,7 @@
 import type { CoreServices, CoreUserSession } from '../../types/core.types.js';
 import type { BinaryData, CoreChannel, PikkuChannelHandler } from './channel.types.js';
 import type { SessionService } from '../../services/user-session-service.js';
-export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>) => {
+export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>, wireServices?: Record<string, unknown>) => {
     onMessage: (rawData: unknown) => Promise<unknown>;
     onBinaryMessage: ((data: BinaryData) => Promise<BinaryData | void>) | undefined;
 };

package/dist/wirings/channel/channel-handler.js

@@ -37,7 +37,7 @@ const validateAuth = (requiresSession, session, onMessage) => {
     }
     return true;
 };
-export const processMessageHandlers = (services, channelConfig, channelHandler, userSession) => {
+export const processMessageHandlers = (services, channelConfig, channelHandler, userSession, wireServices) => {
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
     const processMessage = async (data, onMessage, routingProperty, routerValue) => {
@@ -76,6 +76,7 @@ export const processMessageHandlers = (services, channelConfig, channelHandler,
         const wireChannelMiddleware = channelConfig.channelMiddleware || [];
         return await runPikkuFunc('channel', cacheKey, pikkuFuncId, {
             singletonServices: services,
+            wireServices,
             data: () => data,
             inheritedMiddleware,
             wireMiddleware,

package/dist/wirings/channel/local/local-channel-runner.js

@@ -89,6 +89,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                             data: openingData,
                             channelMiddlewareMeta: meta.channelMiddleware,
                             userSession,
+                            wireServices,
                         });
                         if (result !== undefined) {
                             await channel.send(result);
@@ -117,6 +118,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                             channel,
                             channelMiddlewareMeta: meta.channelMiddleware,
                             userSession,
+                            wireServices,
                         });
                     }
                     catch (e) {
@@ -131,7 +133,7 @@ export const runLocalChannel = async ({ channelId, request, response, route, ski
                 }
                 await closeServices();
             });
-            const { onMessage, onBinaryMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession);
+            const { onMessage, onBinaryMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession, wireServices);
             channelHandler.registerOnMessage(async (data) => {
                 try {
                     const result = await onMessage(data);

package/dist/wirings/channel/serverless/serverless-channel-runner.js

@@ -80,6 +80,7 @@ export const runChannelConnect = async ({ channelId, channelObject, request, res
                 data: openingData,
                 channelMiddlewareMeta: meta.channelMiddleware,
                 userSession,
+                wireServices,
             });
         }
         const pikkuUserId = userSession.getPikkuUserId();
@@ -150,6 +151,7 @@ export const runChannelDisconnect = async ({ channelId, channelStore, channelHan
                 channel,
                 channelMiddlewareMeta: meta.channelMiddleware,
                 userSession,
+                wireServices,
             });
         }
         catch (e) {
@@ -197,7 +199,7 @@ export const runChannelMessage = async ({ channelId, channelStore, channelHandle
     };
     let response;
     try {
-        const { onMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession);
+        const { onMessage } = processMessageHandlers(services, channelConfig, channelHandler, userSession, wireServices);
         response = await onMessage(data);
     }
     catch (e) {

package/knowledge/decisions/internals/index.md

@@ -62,6 +62,7 @@ caller is entitled to assume.
 - [A column's at-rest form is an axis of its own](core-column-form-is-an-axis-of-its-own.md) — How a value is stored is independent of how sensitive it is, so form carries a required nominal brand on writes while classification stays optional on reads
 - [The data-classification brand is an optional property](core-data-classification-brand-is-an-optional-property.md) — Making **classification** required would break ordinary Kysely operands, so the brand only constrains values flowing out
 - [The function runner restores the wire fields it overwrites](core-function-runner-restores-the-wire-fields-it-overwrites.md) — One wire object is reused across nested calls, so functionId, audit, addonNamespace and rpc are saved and put back in a finally
+- [The function runner resolves wire services itself](the-runner-resolves-wire-services-itself.md) — A function's wire services come from its own package's factory or the app's registered one, never borrowed from whoever called it
 - [Hot reload merges generated meta and never replaces it](core-hot-reload-merges-generated-meta-never-replaces-it.md) — Reloading codegen output must preserve runtime-registered meta, which no generated JSON contains
 - [Hot reload owns its module registry instead of re-importing](core-hot-reload-owns-its-module-registry.md) — Dev reload transpiles to CJS and runs modules through vm.compileFunction, because the native ESM loader map cannot be evicted
 - [Middleware order is resolution scope first, then priority](core-middleware-order-is-scope-then-priority.md) — Middleware is collected global to function, then stably sorted by priority, deduped, frozen and cached per wire

package/knowledge/decisions/internals/the-runner-resolves-wire-services-itself.md

@@ -0,0 +1,31 @@
+---
+type: decision
+title: The function runner resolves wire services itself
+description: A function's wire services come from its own package's factory or the app's registered one, never borrowed from whoever called it
+tags: core
+---
+
+# The function runner resolves wire services itself
+
+`runPikkuFunc` picks the wire-services factory for the function it is about to
+run: the function's addon package factory if it has one, else a factory the
+transport passed explicitly, else the app's registered one
+(`getCreateWireServices()`). A caller that passes nothing still gets the
+function its wire services.
+
+Before this, only the transports passed a factory. `rpc.invoke`, `rpc.exposed`,
+gateway handlers and webhook sources passed none, so an app function reached
+through them ran on whatever services its caller had already merged. That held
+until `singletonServicesOnly` let a caller skip building wire services: the
+generated `rpcCaller` behind `/rpc/:rpcName` reads no service, was marked, and
+every app function behind it lost `events` and every other wire service. Nested
+RPC therefore gets `resolvedSingletonServices`, not the caller's merged set.
+
+Channels are the one caller that legitimately shares wire services: they build
+one set per connection. They hand it over as `wireServices`, which the runner
+uses as-is and does not close, because the connection owns its lifetime.
+
+**What this rules out:** passing a caller's merged services down as
+`singletonServices` to carry wire services into a nested call, and deciding in
+one function's meta whether a different function gets wire services.
+`singletonServicesOnly` only ever describes the function it is set on.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.128",
+  "version": "0.12.129",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",