@rhythmjs/rhythm 0.0.1 → 0.0.2

package/README.md

@@ -5,7 +5,7 @@ The core composition kernel `@rhythmjs/router` and `@rhythmjs/cli` are built on.
 ## Concepts
 
 - **Onion middleware** — `use()` wraps downstream steps, running code before _and_ after `next()`.
-- **Providers** — `provide()` registers a value or async factory that resolves once and is injected into every request's context. A returned key prefixed with `#` (e.g. `"#close"`) stays out of context but is still passed in full to `dispose()`.
+- **Providers** — `provide()` registers a value or async factory that resolves once and joins the context at its position in the chain: only middleware (and mounted controllers) added after it see the value. A returned key prefixed with `#` (e.g. `"#close"`) stays out of context but is still passed in full to `dispose()`.
 - **Encapsulated modules** — `register()` mounts a child `Rhythm`; its context stays sealed unless you explicitly export fields from it.
 - **Readonly context** — the context passed to middleware is deeply readonly at the type level; state only changes via `next(extra)`, or through a value branded with the `RhythmMutable` symbol (how `RhythmRouter`/`RhythmCli`'s response objects stay mutable).
 
@@ -32,7 +32,7 @@ await app.run({ userId: "u1" });
 await app.teardown();
 ```
 
-`provide()` factories run once, in declaration order, each receiving everything resolved so far via `deps`. `use()` middleware runs on every `run()` call, in onion order.
+`provide()` factories run once, in declaration order, each receiving everything resolved so far via `deps`. On each `run()`, the whole chain — middleware and provider injections alike — executes in registration order, onion-style: everything only applies to what was chained after it.
 
 ### Module registration
 
@@ -57,11 +57,11 @@ const app = new Rhythm<{ userId: string }>()
 
 - `new Rhythm<TInput>(options?)` — creates a pipeline; `options.name`/`options.type` label errors from `register()`.
 - `.use(fn: (ctx, next) => Promise<void> | void)` — add an onion middleware step.
-- `.provide(factory: (deps) => TValue | Promise<TValue>, dispose?)` — register a provider; resolved once, disposed in reverse order on `teardown()`.
-- `.register(other: Rhythm, exportValue?)` — mount a child module; sealed by default, opt in via `exportValue`.
+- `.provide(factory: (deps) => TValue | Promise<TValue>, dispose?)` — register a provider; resolved once, injected at its chain position, disposed in reverse order on `teardown()`.
+- `.register(other: Rhythm, exportValue?)` — mount a child `Rhythm` module; sealed by default, opt in via `exportValue`. Controllers (`RhythmRouter`, `RhythmCli`) are not modules — they mount via `.use()` instead.
 - `.run(input)` — runs `setup()` if needed, dispatches `input` through the middleware chain.
 - `.callback()` — returns the cached, reusable `(input) => Promise<TContext>` handler `run()` uses internally.
-- `.middleware()` — returns this instance as a plain middleware, for flat mounting into a parent via `.use()` instead of `.register()` (what `RhythmRouter.routes()`/`RhythmCli.commands()` build on).
+- `.middleware()` — returns this instance as a plain middleware, for flat mounting into a parent via `.use()` instead of `.register()`.
 - `.setup()` — resolves all providers, cascading into registered modules. Idempotent; retryable on failure.
 - `.teardown()` — disposes all providers in reverse order, cascading into registered modules.
 - `compose(middleware[])` — the standalone Koa-style onion dispatcher `Rhythm` is built on.

package/dist/rhythm.js

@@ -29,7 +29,6 @@ var Rhythm = class {
 	#options;
 	#providers = [];
 	#setupPromise = null;
-	#providedCache = null;
 	#composed = null;
 	#callbackFn = null;
 	constructor(options = {}) {
@@ -42,10 +41,17 @@ var Rhythm = class {
 		return this;
 	}
 	provide(factory, dispose) {
-		this.#providers.push({
+		const entry = {
 			factory,
 			dispose
+		};
+		this.#providers.push(entry);
+		this.#middleware.push(async (ctx, next) => {
+			const exported = {};
+			for (const [key, value] of Object.entries(entry.resolved)) if (!key.startsWith("#")) exported[key] = value;
+			await next(exported);
 		});
+		this.#invalidateCallback();
 		return this;
 	}
 	register(other, exportValue) {
@@ -87,7 +93,6 @@ var Rhythm = class {
 			entry.resolved = await entry.factory(resolved);
 			for (const [key, value] of Object.entries(entry.resolved)) if (!key.startsWith("#")) resolved[key] = value;
 		}
-		this.#providedCache = resolved;
 	}
 	async teardown() {
 		for (const entry of [...this.#providers].reverse()) await entry.dispose?.(entry.resolved);
@@ -98,10 +103,7 @@ var Rhythm = class {
 			const fn = this.#composed;
 			this.#callbackFn = async (input) => {
 				await this.setup();
-				return fn({
-					...this.#providedCache,
-					...input
-				});
+				return fn({ ...input });
 			};
 		}
 		return this.#callbackFn;
@@ -113,9 +115,7 @@ var Rhythm = class {
 		return async (ctx, next) => {
 			await this.setup();
 			if (!this.#composed) this.#composed = compose(this.#middleware);
-			const context = ctx;
-			Object.assign(context, this.#providedCache);
-			await this.#composed(context, next);
+			await this.#composed(ctx, next);
 		};
 	}
 };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@rhythmjs/rhythm",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A minimal, type-safe onion-middleware and provider composition kernel.",
+  "homepage": "https://rhythm.js.org/rhythm",
   "license": "ISC",
   "repository": {
     "type": "git",
@@ -30,10 +31,5 @@
   },
   "engines": {
     "node": ">=20.19.0"
-  },
-  "scripts": {
-    "build": "vp pack",
-    "typecheck": "tsc --noEmit",
-    "test": "vp test"
   }
 }