@pikku/cli 0.12.145 → 0.12.152

package/dist/src/deploy/analyzer/grouping.d.ts

@@ -1,23 +1,57 @@
-export type GroupingStrategy = 'function' | 'single';
-export interface GroupingRule {
-    unit: string;
-    tags?: string[];
-    addon?: string;
-    routes?: string[];
-}
+import type { GroupingRule } from '@pikku/deploy';
+export type GroupingStrategy = 'function' | 'single' | 'services';
+export type { GroupingRule } from '@pikku/deploy';
 export interface GroupingConfig {
+    /**
+     * Defaults to `'services'`: one unit per distinct service combination. The
+     * alternatives are `'function'` (one unit per function — the smallest bundles
+     * and the most of them) and `'single'` (everything in one).
+     */
     strategy?: GroupingStrategy;
     rules?: GroupingRule[];
 }
 export interface UnitResolverInput {
     routesForFunction: (funcId: string) => string[];
     tagsForFunction: (funcId: string) => string[];
+    /**
+     * The singleton services the function's own body destructures. Only used by
+     * `strategy: 'services'`, which keys a unit on this set.
+     */
+    servicesForFunction: (funcId: string) => string[];
+    /**
+     * Where the function runs. Part of the `strategy: 'services'` key, because a
+     * target is not always implied by the services: a function carrying no
+     * serverless-incompatible service can still name `deploy: 'server'` itself,
+     * and merging it with a serverless function that happens to build the same
+     * services is the one grouping a target refusal exists to stop.
+     */
+    targetForFunction: (funcId: string) => 'serverless' | 'server';
 }
 export interface UnitResolver {
     forFunction: (funcId: string) => string;
     forAddon: (namespace: string) => string;
     isGrouped: boolean;
     ruleForUnit: (unitName: string) => GroupingRule | undefined;
+    /**
+     * The service set that named a unit under `strategy: 'services'`, or
+     * undefined for a unit that came from a rule or from one-per-function. The
+     * manifest's own `services` list cannot stand in for it: that list is keyed
+     * by capability, so `workflowService` and `workflowRunService` both arrive as
+     * `workflow-state` and two genuinely different units read as identical.
+     */
+    serviceKeyForUnit: (unitName: string) => string[] | undefined;
 }
+/**
+ * The distinguishing services in a set: what is left once the services every
+ * unit gets regardless are removed. This is the grouping key.
+ */
+export declare const serviceKey: (services: string[]) => string[];
+/**
+ * The unit name for one service set. Names the services themselves so a plan
+ * reads as what each unit builds; a set too long to spell out keeps the first
+ * few names and a digest of the whole set, which stays stable for that exact
+ * set and distinct from every other.
+ */
+export declare const serviceUnitName: (services: string[], target?: 'serverless' | 'server') => string;
 export declare const validateGrouping: (config: GroupingConfig) => void;
 export declare const createUnitResolver: (config: GroupingConfig | undefined, input: UnitResolverInput) => UnitResolver;

package/dist/src/deploy/analyzer/grouping.js

@@ -1,5 +1,66 @@
+import { createHash } from 'node:crypto';
 import { toSafeKebab } from './naming.js';
 const SINGLE_UNIT_NAME = 'app';
+/**
+ * One unit per distinct service combination. `'function'` gives a deployment
+ * as many units as it has functions, which is a cold start and a deploy step
+ * each for bundles that mostly build the same services.
+ */
+const DEFAULT_STRATEGY = 'services';
+/**
+ * Services every unit is given regardless of what it holds, so they say nothing
+ * about which functions belong together. `config`, `logger`, `variables`,
+ * `schema` and `secrets` are written into every generated services map as
+ * `defaultServices`; `rpc`, `mcp`, `channel` and `userSession` are the
+ * per-request services the inspector already excludes from tree-shaking.
+ *
+ * Only the base set is subtracted. A service that happens to be app-wide today
+ * — `auth` under a declared auth definition, say — is left in the key on
+ * purpose: it is constant, so it cannot split a partition, and dropping it
+ * would make the unit name lie about what the unit builds.
+ */
+const BASE_SERVICES = new Set([
+    'config',
+    'logger',
+    'variables',
+    'schema',
+    'secrets',
+    'rpc',
+    'mcp',
+    'channel',
+    'userSession',
+]);
+const SERVICE_UNIT_PREFIX = 'svc';
+/** Kept short enough to survive a provider's own name length limits. */
+const SERVICE_UNIT_NAME_LIMIT = 58;
+/**
+ * The distinguishing services in a set: what is left once the services every
+ * unit gets regardless are removed. This is the grouping key.
+ */
+export const serviceKey = (services) => [...new Set(services)].filter((service) => !BASE_SERVICES.has(service)).sort();
+/**
+ * The unit name for one service set. Names the services themselves so a plan
+ * reads as what each unit builds; a set too long to spell out keeps the first
+ * few names and a digest of the whole set, which stays stable for that exact
+ * set and distinct from every other.
+ */
+export const serviceUnitName = (services, target = 'serverless') => {
+    const suffix = target === 'server' ? '-server' : '';
+    const key = serviceKey(services);
+    if (key.length === 0) {
+        return `${SERVICE_UNIT_PREFIX}-base${suffix}`;
+    }
+    const full = `${SERVICE_UNIT_PREFIX}-${key.map(toSafeKebab).join('-')}${suffix}`;
+    if (full.length <= SERVICE_UNIT_NAME_LIMIT) {
+        return full;
+    }
+    const digest = createHash('sha256')
+        .update(key.join(','))
+        .digest('hex')
+        .slice(0, 6);
+    const room = SERVICE_UNIT_NAME_LIMIT - digest.length - suffix.length - 1;
+    return `${full.slice(0, room).replace(/-+$/, '')}-${digest}${suffix}`;
+};
 const routeMatcher = (pattern) => {
     const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
     return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
@@ -21,7 +82,7 @@ export const validateGrouping = (config) => {
     }
 };
 export const createUnitResolver = (config, input) => {
-    const strategy = config?.strategy ?? 'function';
+    const strategy = config?.strategy ?? DEFAULT_STRATEGY;
     const rules = config?.rules ?? [];
     if (config) {
         validateGrouping(config);
@@ -34,6 +95,7 @@ export const createUnitResolver = (config, input) => {
         routes: rule.routes?.map(routeMatcher),
     }));
     const byUnitName = new Map(compiled.map((c) => [c.unit, c.rule]));
+    const serviceKeys = new Map();
     const matches = (c, tags, routes, addon) => {
         if (c.tags && !c.tags.some((tag) => tags.includes(tag))) {
             return false;
@@ -46,10 +108,22 @@ export const createUnitResolver = (config, input) => {
         }
         return true;
     };
-    const fallback = (funcId) => strategy === 'single' ? SINGLE_UNIT_NAME : toSafeKebab(funcId);
+    const fallback = (funcId) => {
+        if (strategy === 'single') {
+            return SINGLE_UNIT_NAME;
+        }
+        if (strategy === 'services') {
+            const services = input.servicesForFunction(funcId);
+            const name = serviceUnitName(services, input.targetForFunction(funcId));
+            serviceKeys.set(name, serviceKey(services));
+            return name;
+        }
+        return toSafeKebab(funcId);
+    };
     return {
         isGrouped: strategy !== 'function' || compiled.length > 0,
         ruleForUnit: (unitName) => byUnitName.get(unitName),
+        serviceKeyForUnit: (unitName) => serviceKeys.get(unitName),
         forFunction: (funcId) => {
             if (compiled.length > 0) {
                 const tags = input.tagsForFunction(funcId);

package/dist/src/deploy/build-pipeline.js

@@ -267,6 +267,9 @@ export async function runBuildPipeline(options) {
         // Step 2b: Server units — single codegen pass with all server function IDs
         if (serverUnits.length > 0) {
             const serverUnitName = MERGED_SERVER_UNIT_NAME;
+            const forcedBy = [
+                ...new Set(serverUnits.flatMap((u) => u.targetForcedBy ?? [])),
+            ];
             // Create a merged server unit with all server function IDs
             const mergedServerUnit = {
                 name: serverUnitName,
@@ -277,6 +280,7 @@ export async function runBuildPipeline(options) {
                 dependsOn: [],
                 handlers: serverUnits.flatMap((u) => u.handlers),
                 tags: [],
+                ...(forcedBy.length > 0 && { targetForcedBy: forcedBy }),
             };
             // Run per-unit codegen for the merged server unit (tree-shakes to only server functions)
             const serverManifest = { ...manifest, units: [mergedServerUnit] };