@rhythmjs/rhythm 0.0.20 → 0.0.22

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/compose.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   compose2
-} from "./rhythm-5w3dm83b.js";
+} from "./rhythm-yg6xk73t.js";
 export {
   compose2 as compose
 };

package/dist/mount.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   mount2
-} from "./rhythm-bhjtktgq.js";
+} from "./rhythm-eybt80rf.js";
 import"./rhythm-7z989406.js";
 export {
   mount2 as mount

package/dist/pipeline.js

@@ -1,8 +1,8 @@
 // @bun
 import {
   Pipeline2
-} from "./rhythm-vpajpf9k.js";
-import"./rhythm-5w3dm83b.js";
+} from "./rhythm-5wyfm5pt.js";
+import"./rhythm-yg6xk73t.js";
 import"./rhythm-7z989406.js";
 export {
   Pipeline2 as Pipeline

package/dist/{rhythm-vpajpf9k.js → rhythm-5wyfm5pt.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   compose2
-} from "./rhythm-5w3dm83b.js";
+} from "./rhythm-yg6xk73t.js";
 import {
   sourceOf2
 } from "./rhythm-7z989406.js";

package/dist/rhythm-eybt80rf.js

@@ -0,0 +1,31 @@
+// @bun
+import {
+  withSource2
+} from "./rhythm-7z989406.js";
+import {
+  wrapFailure
+} from "./rhythm-vd616d70.js";
+
+// src/mount.ts
+function mount2(plugin, condition) {
+  const handler = plugin.callback();
+  const wrap = (cause) => {
+    throw wrapFailure("mounted", plugin, cause);
+  };
+  const middleware = (ctx, next) => {
+    try {
+      if (condition && !condition(ctx))
+        return next();
+    } catch (cause) {
+      return Promise.reject(cause);
+    }
+    try {
+      return handler(ctx).then(() => next(), wrap);
+    } catch (cause) {
+      return Promise.reject(wrapFailure("mounted", plugin, cause));
+    }
+  };
+  return withSource2(middleware, plugin);
+}
+
+export { mount2 };

package/dist/rhythm-yg6xk73t.js

@@ -0,0 +1,28 @@
+// @bun
+// src/compose.ts
+var done = Promise.resolve();
+function compose2(middleware) {
+  const last = middleware.length;
+  return (ctx, next) => {
+    if (last === 0)
+      return next ? next() : done;
+    let index = -1;
+    function dispatch(i) {
+      if (i <= index)
+        return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      const fn = i === last ? next : middleware[i];
+      if (!fn)
+        return done;
+      try {
+        const result = fn(ctx, () => dispatch(i + 1));
+        return result instanceof Promise ? result : Promise.resolve(result);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    }
+    return dispatch(0);
+  };
+}
+
+export { compose2 };

package/dist/rhythm.js

@@ -1,14 +1,14 @@
 // @bun
 import {
   compose2
-} from "./rhythm-5w3dm83b.js";
+} from "./rhythm-yg6xk73t.js";
 import {
   withSource2,
   sourceOf2
 } from "./rhythm-7z989406.js";
 import {
   Pipeline2
-} from "./rhythm-vpajpf9k.js";
+} from "./rhythm-5wyfm5pt.js";
 import {
   decorate2
 } from "./rhythm-k0635rcp.js";
@@ -20,28 +20,40 @@ import {
 } from "./rhythm-bq68je0h.js";
 import {
   mount2
-} from "./rhythm-bhjtktgq.js";
+} from "./rhythm-eybt80rf.js";
 
 // src/rhythm.ts
 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) {
@@ -64,13 +76,15 @@ class Rhythm extends Pipeline2 {
   }
   callback() {
     const fn = this.chain();
-    return async (input) => {
-      if (this.#ready)
-        await this.#ready;
-      const ctx = Object.assign({}, this.#ctx, input);
-      await fn(ctx);
-      return ctx;
+    const run = (input) => {
+      try {
+        const ctx = Object.assign({}, this.#ctx, input);
+        return fn(ctx).then(() => ctx);
+      } catch (error) {
+        return Promise.reject(error);
+      }
     };
+    return (input) => this.#ready ? this.#ready.then(() => run(input)) : run(input);
   }
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/rhythm",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "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",
@@ -56,6 +56,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "prebuild": "bun run clean",
+    "build": "bun build src/rhythm.ts src/compose.ts src/pipeline.ts src/derive.ts src/decorate.ts src/mount.ts src/include.ts src/source.ts src/types.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run typecheck && bun test && bun run build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
   "devDependencies": {
     "@types/bun": "^1.4.2",
     "@types/node": "^26.6.3",
@@ -63,10 +71,5 @@
   },
   "engines": {
     "bun": ">=1.2.0"
-  },
-  "scripts": {
-    "build": "rm -rf dist && bun build src/rhythm.ts src/compose.ts src/pipeline.ts src/derive.ts src/decorate.ts src/mount.ts src/include.ts src/source.ts src/types.ts --outdir dist --root src --format esm --target bun --packages external --splitting && tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test"
   }
-}
+}

package/dist/rhythm-5w3dm83b.js

@@ -1,20 +0,0 @@
-// @bun
-// src/compose.ts
-function compose2(middleware) {
-  return (ctx, next) => {
-    let index = -1;
-    async function dispatch(i) {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      const fn = i === middleware.length ? next : middleware[i];
-      if (!fn)
-        return;
-      await fn(ctx, () => dispatch(i + 1));
-    }
-    return dispatch(0);
-  };
-}
-
-export { compose2 };

package/dist/rhythm-bhjtktgq.js

@@ -1,25 +0,0 @@
-// @bun
-import {
-  withSource2
-} from "./rhythm-7z989406.js";
-import {
-  wrapFailure
-} from "./rhythm-vd616d70.js";
-
-// src/mount.ts
-function mount2(plugin, condition) {
-  const handler = plugin.callback();
-  const middleware = async (ctx, next) => {
-    if (!condition || condition(ctx)) {
-      try {
-        await handler(ctx);
-      } catch (cause) {
-        throw wrapFailure("mounted", plugin, cause);
-      }
-    }
-    await next();
-  };
-  return withSource2(middleware, plugin);
-}
-
-export { mount2 };