@podosoft/podokit 1.2.0 → 1.3.0

package/dist/templates/modules/sse/files/tests/api/events.api.spec.ts

@@ -119,6 +119,52 @@ test("sse: streams require a session and a valid topic list", async ({ playwrigh
   }
 });
 
+function openStream(cookie: string, controller: AbortController): Promise<Response> {
+  return fetch(`${base}/api/events/stream?topics=${uniqueTopic()}`, {
+    headers: { ...origin, cookie },
+    signal: controller.signal,
+  });
+}
+
+test("sse: a user's open streams are capped per replica", async ({ playwright }) => {
+  const member = await newContext(playwright);
+  const other = await newContext(playwright);
+  const controllers: AbortController[] = [];
+  try {
+    test.skip(!(await signUp(member)), "requires the auth module");
+    expect(await signUp(other)).toBeDefined();
+    const cookie = await cookieHeader(member);
+    // The limit is SSE_MAX_STREAMS_PER_USER on the server, so open until refused.
+    let refused: Response | undefined;
+    for (let attempt = 0; attempt < 64 && !refused; attempt += 1) {
+      const controller = new AbortController();
+      const response = await openStream(cookie, controller);
+      if (response.status === 200) controllers.push(controller);
+      else refused = response;
+    }
+    expect(controllers.length).toBeGreaterThan(0);
+    expect(refused?.status).toBe(429);
+    expect((await refused?.json()).error.code).toBe("EVENTS_STREAM_LIMIT");
+
+    // Another user is unaffected, and closing a stream frees its slot.
+    const otherController = new AbortController();
+    controllers.push(otherController);
+    expect((await openStream(await cookieHeader(other), otherController)).status).toBe(200);
+    controllers.shift()?.abort();
+    await expect.poll(async () => {
+      const controller = new AbortController();
+      const response = await openStream(cookie, controller);
+      if (response.status === 200) controllers.push(controller);
+      else controller.abort();
+      return response.status;
+    }, { timeout: 8_000 }).toBe(200);
+  } finally {
+    for (const controller of controllers) controller.abort();
+    await member.dispose();
+    await other.dispose();
+  }
+});
+
 test("sse: only administrators may publish", async ({ playwright }) => {
   const member = await newContext(playwright);
   try {

package/dist/templates/modules/sse/module.manifest.json

@@ -17,7 +17,9 @@
   "targetApp": "api",
   "env": [
     "# Maximum encoded Server-Sent Event payload",
-    "SSE_MAX_EVENT_BYTES=65536"
+    "SSE_MAX_EVENT_BYTES=65536",
+    "# Open event streams per user on each API replica",
+    "SSE_MAX_STREAMS_PER_USER=8"
   ],
   "inject": [
     { "file": "apps/api/src/app.ts", "marker": "// podokit:end:imports", "text": "import { eventsModule } from \"./events/events.module\";" },

package/dist/update.d.ts

@@ -1,5 +1,6 @@
 import { type TemplateVars } from "@podosoft/podokit-template-engine";
 import { type Tier } from "./lockfile";
+import type { ProviderCapability } from "@podosoft/podokit-runtime";
 import type { Toolchain } from "./toolchain";
 /**
  * `podo update` planner. For now it produces a dry-run plan only: it assembles
@@ -17,11 +18,23 @@ export interface FileChange {
     /** Why the action was chosen (for the report). */
     note: string;
 }
+/** A module the target version needs that the project does not record yet. */
+export interface AddedModule {
+    name: string;
+    /** Installed or added module that needs it. */
+    requiredBy: string;
+    /** Provider capability it implements, when added for a capability requirement. */
+    capability?: ProviderCapability;
+    /** Selected provider it implements. */
+    provider?: string;
+}
 export interface UpdatePlan {
     fromVersion: string;
     toVersion: string;
     template: string;
     modules: string[];
+    /** Modules the update adds, ordered ahead of the modules that need them. */
+    addedModules: AddedModule[];
     changes: FileChange[];
 }
 /**
@@ -51,6 +64,8 @@ export interface ApplyOptions {
     abortOnConflict?: boolean;
 }
 export interface ApplyResult {
+    /** Modules added because the target version requires them. */
+    addedModules: string[];
     written: string[];
     /** Files relocated by module update migrations. */
     moved: {
@@ -71,5 +86,7 @@ export interface ApplyResult {
  * stamps the new version.
  */
 export declare function applyUpdate(projectRoot: string, templatesDir: string, options?: ApplyOptions): ApplyResult;
+/** Why an update adds a module, for the plan report. */
+export declare function addedModuleReason(module: AddedModule): string;
 /** Count actions for a one-line summary. */
 export declare function summarize(plan: UpdatePlan): Record<Action, number>;

package/dist/update.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.planUpdate = planUpdate;
 exports.applyUpdate = applyUpdate;
+exports.addedModuleReason = addedModuleReason;
 exports.summarize = summarize;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
@@ -25,17 +26,21 @@ function diskContent(projectRoot, path) {
 }
 /**
  * Expand the recorded module list against the target manifests. A module may
- * gain a new requirement after it was first added to a project; updates must
- * apply that requirement before rebuilding the dependent module or the target
- * tree can contain imports and wiring for files that were never installed.
+ * gain a new requirement after it was first added to a project, either another
+ * module or a provider capability. Updates must apply that requirement before
+ * the dependent module: modules configure in this order, and the target tree
+ * would otherwise wire files that were never installed. A capability resolves
+ * to the module implementing the project's selected provider, as `podo add`
+ * would choose it.
  */
-function targetModules(projectRoot, templatesDir, modules) {
+function targetModules(projectRoot, templatesDir, modules, providers) {
     const modulesDir = (0, node_path_1.join)(templatesDir, "modules");
     const recorded = new Map(modules.map((module) => [module.name, module]));
     const ordered = [];
+    const added = [];
     const visiting = new Set();
     const visited = new Set();
-    const visit = (name, requiredBy) => {
+    const visit = (name, requiredBy, capability) => {
         if (visited.has(name))
             return;
         if (visiting.has(name)) {
@@ -52,12 +57,24 @@ function targetModules(projectRoot, templatesDir, modules) {
         const moduleManifest = (0, add_1.readModuleManifest)(resolved.dir);
         for (const required of moduleManifest.requires ?? [])
             visit(required, name);
+        for (const required of moduleManifest.requiresCapabilities ?? []) {
+            visit((0, add_1.selectedProviderModule)(modulesDir, projectRoot, providers, required), name, required);
+        }
         visiting.delete(name);
         visited.add(name);
+        if (!existing && requiredBy) {
+            added.push({
+                name: resolved.name,
+                requiredBy,
+                ...(capability ? { capability, provider: providers[capability] } : {}),
+            });
+        }
         ordered.push({
             ...(existing ?? {
                 name: resolved.name,
                 addedWith: (0, lockfile_1.podokitVersion)(),
+                // A freshly added module ships its current layout, as `podo add` records it.
+                appliedMigrations: (moduleManifest.migrations ?? []).map((migration) => migration.id),
             }),
             order: ordered.length,
             ...(resolved.packageName
@@ -71,7 +88,7 @@ function targetModules(projectRoot, templatesDir, modules) {
     for (const module of [...modules].sort((a, b) => a.order - b.order)) {
         visit(module.name);
     }
-    return ordered;
+    return { modules: ordered, added };
 }
 function targetManagedOverrides(projectRoot, templatesDir, modules, current = []) {
     const overrides = new Set(current);
@@ -102,7 +119,7 @@ function planUpdate(projectRoot, templatesDir, options = {}) {
     const lock = (0, lockfile_1.readFilesLock)(projectRoot);
     if (!manifest || !lock)
         throw new inspect_1.NotAProjectError();
-    const modules = targetModules(projectRoot, templatesDir, manifest.modules);
+    const { modules, added } = targetModules(projectRoot, templatesDir, manifest.modules, manifest.providers);
     const newTree = (0, assemble_1.assembleProject)({
         templatesDir,
         template: manifest.template,
@@ -210,6 +227,7 @@ function planUpdate(projectRoot, templatesDir, options = {}) {
         toVersion: (0, lockfile_1.podokitVersion)(),
         template: manifest.template,
         modules: modules.map((module) => module.name),
+        addedModules: added,
         changes,
     };
 }
@@ -333,7 +351,7 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
         forceManagedPaths: options.forceManagedPaths,
         onlyPaths: options.onlyPaths,
     });
-    const modules = targetModules(projectRoot, templatesDir, manifest.modules);
+    const { modules } = targetModules(projectRoot, templatesDir, manifest.modules, manifest.providers);
     const newTree = (0, assemble_1.assembleProject)({
         templatesDir,
         template: manifest.template,
@@ -396,6 +414,7 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
         }
     }
     const result = {
+        addedModules: plan.addedModules.map((module) => module.name),
         written: [],
         moved: (0, module_migrations_1.applyModuleMigrations)(projectRoot, migrationPlan),
         removed: [],
@@ -469,6 +488,12 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
     });
     return result;
 }
+/** Why an update adds a module, for the plan report. */
+function addedModuleReason(module) {
+    return module.capability
+        ? `${module.capability} provider "${module.provider}" required by ${module.requiredBy}`
+        : `required by ${module.requiredBy}`;
+}
 /** Count actions for a one-line summary. */
 function summarize(plan) {
     const counts = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podosoft/podokit",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "An opinionated Bun and Elysia full-stack TypeScript starter toolkit and CLI with SvelteKit, TailwindCSS, shadcn-svelte, Docker, and k3s.",
   "license": "Apache-2.0",
   "repository": {