@rhythmjs/rhythm 0.0.19 → 0.0.21

package/README.md

@@ -6,7 +6,7 @@ The composition kernel at the core of Rhythm, the Bun-native backend framework,
 
 Rhythm separates **when** something happens:
 
-- **Startup time: `register()`.** Runs a callback once, immediately, against the app's shared startup context. Use it to create what lives for the whole process (a DB connection, config) and, optionally, how to close it. `stop()` runs the cleanups in reverse order.
+- **Startup time: `register()`.** Runs a callback once against the app's shared startup context: immediately, or, if an earlier `register` is still pending, right after it settles, so a callback always sees what the ones before it added (a failed one skips the rest and fails the app). Use it to create what lives for the whole process (a DB connection, config) and, optionally, how to close it. `stop()` runs the cleanups in reverse order.
 - **Request time: `use()`.** Adds an onion middleware step that runs on every call of the handler, before _and_ after `next()`.
 
 Four small composable functions plug into those two methods, each for one purpose:
@@ -53,7 +53,7 @@ await app.stop(); // shut down
 
 ## Startup: `register()`
 
-`register(callback, cleanup?)` calls `callback(ctx, app)` right away with the shared startup context. Return a promise and the first request waits for it. `cleanup(ctx, app)` is optional and runs on `stop()`; if several cleanups throw, `stop()` still runs all of them and rejects with an `AggregateError`. `Rhythm` is also `AsyncDisposable`, so `await using app = ...` stops it for you.
+`register(callback, cleanup?)` calls `callback(ctx, app)` with the shared startup context, right away unless an earlier `register` is still pending. Registrations run in order, so a callback sees everything the earlier ones added, even async ones (`include`, a database connection). Return a promise and the first request waits for it; if one fails, the later ones are skipped and the first request rejects. `cleanup(ctx, app)` is optional and runs on `stop()`; if several cleanups throw, `stop()` still runs all of them and rejects with an `AggregateError`. `Rhythm` is also `AsyncDisposable`, so `await using app = ...` stops it for you.
 
 ```ts
 const app = new Rhythm().register(

package/dist/mount.d.ts

@@ -1,3 +1,3 @@
-import type { Middleware, MountMiddleware, Mountable } from "./types";
+import type { Input, Middleware, MountMiddleware, Mountable } from "./types";
 export declare function mount<I extends object>(plugin: Mountable<I>): MountMiddleware<I>;
-export declare function mount<T extends object = {}, I extends object = any>(plugin: Mountable<I> & (T extends I ? unknown : never), condition: (ctx: T) => boolean): Middleware<T>;
+export declare function mount<T extends object = {}, I extends object = any>(plugin: Mountable<I> & (T extends I ? unknown : never), condition: (ctx: T) => boolean): Middleware<T> & Input<T>;

package/dist/rhythm.js

@@ -27,21 +27,33 @@ class Rhythm extends Pipeline2 {
   #ctx = {};
   #cleanups = [];
   #ready;
+  #tail;
   transparent = true;
   constructor(options) {
     super({ type: "module", ...options });
   }
   register(callback, cleanup) {
     this.adopt(sourceOf2(callback));
-    const result = callback(this.#ctx, this);
-    if (result instanceof Promise) {
-      this.#ready = Promise.all([this.#ready, result]);
+    if (this.#tail) {
+      this.#track(this.#tail.then(() => callback(this.#ctx, this)));
+    } else {
+      const result = callback(this.#ctx, this);
+      if (result instanceof Promise)
+        this.#track(result);
     }
     if (cleanup) {
       this.#cleanups.push(() => cleanup(this.#ctx, this));
     }
     return this;
   }
+  #track(pending) {
+    this.#ready = this.#tail = pending;
+    const clear = () => {
+      if (this.#tail === pending)
+        this.#tail = undefined;
+    };
+    pending.then(clear, clear);
+  }
   async stop() {
     const errors = [];
     while (this.#cleanups.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/rhythm",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "A minimal, type-safe middleware and startup-composition kernel: register() at startup, use() per request, with derive, decorate, mount and include.",
   "homepage": "https://rhythm.js.org/rhythm",
   "license": "ISC",