@pikku/cli 0.12.93 → 0.12.96

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

@@ -1,40 +0,0 @@
-export const serializeScenarioActors = (actors, agentMapImportPath, rpcMapImportPath) => {
-    return `/** Scenario actors declared in pikku.config.json (\`scenarios.actors\`) */
-import {
-  createHttpScenarioActors,
-  type HttpScenarioActorsConfig,
-  type ScenarioActor,
-  type ScenarioActorConfig,
-} from '@pikku/core/services'
-import type { AgentMap } from '${agentMapImportPath}'
-import type { FlattenedRPCMap } from '${rpcMapImportPath}'
-
-export const scenarioActorConfigs = ${JSON.stringify(actors, null, 2)} as const satisfies Record<string, ScenarioActorConfig>
-
-export type ScenarioActorName = keyof typeof scenarioActorConfigs
-
-/**
- * The same registry as a list, widened to \`ScenarioActorConfig\`. Iterating
- * \`scenarioActorConfigs\` directly yields the literal type of each entry, on
- * which an optional field an actor did not declare does not exist — so a seed
- * reading \`scopes\`/\`roles\` off every actor needs this instead.
- */
-export const scenarioActorList: ScenarioActorConfig[] = Object.values(
-  scenarioActorConfigs
-)
-
-export type AgentName = keyof AgentMap & string
-export type TypedScenarioActors = Record<
-  ScenarioActorName,
-  ScenarioActor<AgentName, FlattenedRPCMap>
->
-
-export const createScenarioActors = (
-  options: Omit<HttpScenarioActorsConfig, 'actors'>
-): TypedScenarioActors =>
-  createHttpScenarioActors({
-    ...options,
-    actors: scenarioActorConfigs,
-  }) as TypedScenarioActors
-`;
-};

package/dist/src/utils/resolve-scenario-actors.d.ts

@@ -1,23 +0,0 @@
-import type { PikkuCLIConfig } from '../../types/config.js';
-type ScenariosConfig = NonNullable<PikkuCLIConfig['scenarios']>;
-type ActorsConfig = NonNullable<ScenariosConfig['actors']>;
-type ActorConfig = ActorsConfig[string];
-/**
- * The actor registry a run actually sees: every declared actor, plus one
- * materialised actor for each persona nobody declared an actor for.
- *
- * A persona is the KIND of person (its `description`); an actor is one BODY
- * that signs in, with an email of its own. Most apps want exactly one body per
- * kind, so declaring the persona is enough — this fills in the actor. You only
- * write an actor by hand when a scenario needs TWO of the same kind, which is
- * what tenant-isolation and peer-sharing scenarios are made of.
- *
- * Every consumer must resolve through here rather than reading
- * `config.scenarios.actors` directly: codegen emits `scenarioActorConfigs` from
- * it (and `ScenarioActorName` is a `keyof` over that literal, so an actor missing
- * at codegen time can never be referenced in a typed step), while `scenario run`
- * builds the HTTP and Playwright actor maps from it. Those were already three
- * separate reads of the same field before personas existed.
- */
-export declare const resolveScenarioActors: (scenarios: ScenariosConfig | undefined) => ActorsConfig;
-export type { ActorConfig as ResolvedScenarioActorConfig };

package/dist/src/utils/resolve-scenario-actors.js

@@ -1,74 +0,0 @@
-/** Domain for the email of an actor nobody declared. Synthetic either way. */
-const AUTO_ACTOR_EMAIL_DOMAIN = 'actors.local';
-/** `orgAdmin` → `org-admin`, so a derived email reads like an email. */
-const kebab = (key) => key
-    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-    .replace(/[^a-zA-Z0-9]+/g, '-')
-    .toLowerCase();
-/**
- * The actor registry a run actually sees: every declared actor, plus one
- * materialised actor for each persona nobody declared an actor for.
- *
- * A persona is the KIND of person (its `description`); an actor is one BODY
- * that signs in, with an email of its own. Most apps want exactly one body per
- * kind, so declaring the persona is enough — this fills in the actor. You only
- * write an actor by hand when a scenario needs TWO of the same kind, which is
- * what tenant-isolation and peer-sharing scenarios are made of.
- *
- * Every consumer must resolve through here rather than reading
- * `config.scenarios.actors` directly: codegen emits `scenarioActorConfigs` from
- * it (and `ScenarioActorName` is a `keyof` over that literal, so an actor missing
- * at codegen time can never be referenced in a typed step), while `scenario run`
- * builds the HTTP and Playwright actor maps from it. Those were already three
- * separate reads of the same field before personas existed.
- */
-export const resolveScenarioActors = (scenarios) => {
-    const personas = scenarios?.personas ?? {};
-    const declared = scenarios?.actors ?? {};
-    const resolved = {};
-    for (const [name, actor] of Object.entries(declared)) {
-        // An actor named after a persona belongs to it without having to say so —
-        // the common case is one body per kind and they share the obvious name.
-        const persona = actor.persona ?? (personas[name] ? name : undefined);
-        if (persona && !personas[persona]) {
-            throw new Error(`Scenario actor '${name}' names persona '${persona}', which is not declared in scenarios.personas` +
-                `${Object.keys(personas).length ? ` (declared: ${Object.keys(personas).join(', ')})` : ' (no personas are declared)'}`);
-        }
-        resolved[name] = persona ? { ...actor, persona } : actor;
-    }
-    const claimed = new Set(Object.values(resolved)
-        .map((actor) => actor.persona)
-        .filter((persona) => Boolean(persona)));
-    for (const [persona, config] of Object.entries(personas)) {
-        if (claimed.has(persona))
-            continue;
-        // A `system` persona is the app acting on its own. There is nobody to sign
-        // in, so minting an actor for it would only produce a scenario that tries.
-        // Declaring one by hand is still allowed — a service account is a body.
-        if (config.kind === 'system')
-            continue;
-        resolved[persona] = {
-            persona,
-            email: `${kebab(persona)}@${AUTO_ACTOR_EMAIL_DOMAIN}`,
-        };
-    }
-    assertDistinctEmails(resolved);
-    return resolved;
-};
-/**
- * Two actors sharing an email are the same user row — sign-in keys on email
- * alone (see `HttpScenarioActors.signIn`). That silently collapses exactly the
- * scenarios a second body exists for: an isolation scenario whose two owners
- * are one user passes by construction and proves nothing.
- */
-const assertDistinctEmails = (actors) => {
-    const byEmail = new Map();
-    for (const [name, actor] of Object.entries(actors)) {
-        const email = actor.email.toLowerCase();
-        const owner = byEmail.get(email);
-        if (owner) {
-            throw new Error(`Scenario actors '${owner}' and '${name}' share the email '${actor.email}' — they would sign in as the same user`);
-        }
-        byEmail.set(email, name);
-    }
-};