@rhythmjs/rhythm 0.0.15 → 0.0.16

package/README.md

@@ -66,8 +66,9 @@ Keys prefixed with `#` are dropped from the context. For long-lived resources, c
 ```ts
 import { Rhythm, derive } from "@rhythmjs/rhythm";
 
-const authModule = new Rhythm<{ userId: string }, { db: Db }>({ name: "auth" })
-  .use(derive((ctx) => ({ user: ctx.db.findUser(ctx.userId) })));
+const authModule = new Rhythm<{ userId: string }, { db: Db }>({ name: "auth" }).use(
+  derive((ctx) => ({ user: ctx.db.findUser(ctx.userId) })),
+);
 authModule.context.db = connectToUserDb();
 
 const app = new Rhythm<{ userId: string }>()
@@ -80,7 +81,7 @@ The child runs in place: if it ends the chain without calling `next()`, the pare
 ## API
 
 - `new Rhythm<TInput, TStartup>(options?)`: creates a pipeline; `options.name`/`options.type` label errors from `register()`.
-- `.use(fn: (ctx, next) => Promise<void> | void)`: add an onion middleware step. `next()` takes no arguments; to extend the context pass a `derive()` middleware.
+- `.use(fn: (ctx, next) => Promise<void> | void, condition?: Condition)`: add an onion middleware step. With a second callback, the step runs only when `condition(ctx)` returns true and otherwise falls through to `next()`; a conditional `derive()` does not extend the context type. `next()` takes no arguments; to extend the context pass a `derive()` middleware.
 - `derive(fn: (ctx) => TExtra | Promise<TExtra>)`: middleware that merges `fn`'s result into the context and continues; the typed way to add fields.
 - `.context`: the startup values object, typed by `Rhythm<TInput, TStartup>`. Assign to it before serving; every request context carries it. Inherited by registered modules, never by the parent.
 - `.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.

package/dist/compose.d.ts

@@ -1,10 +1,11 @@
-import type { DeriveMiddleware, Middleware, NextFn } from "./types";
+import type { Condition, DeriveMiddleware, Middleware, NextFn } from "./types";
 type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
 type ContextOf<M> = M extends Middleware<infer C> ? C : never;
 type ExtraOf<M> = M extends DeriveMiddleware<any, infer E> ? E : {};
 export type ComposedMiddleware<TContext extends object, TExtra extends object> = ((context: TContext, next?: NextFn<TContext>) => Promise<TContext>) & Middleware<TContext> & {
     readonly "~derive": TExtra;
 };
+export declare function gate<TContext extends object>(fn: Middleware<TContext>, condition: Condition<TContext>): Middleware<TContext>;
 export declare function compose<const TMiddleware extends readonly Middleware<any>[]>(middleware: TMiddleware): ComposedMiddleware<UnionToIntersection<ContextOf<TMiddleware[number]>> & {}, UnionToIntersection<ExtraOf<TMiddleware[number]>> & {}>;
 export declare function compose<TContext extends object>(middleware: Middleware<TContext>[]): (context: TContext, next?: NextFn<TContext>) => Promise<TContext>;
 export {};

package/dist/compose.js

@@ -1,7 +1,9 @@
 // @bun
 import {
+  gate2,
   compose2
-} from "./rhythm-d9ycs7zz.js";
+} from "./rhythm-4by5yd5a.js";
 export {
-  compose2 as compose
+  compose2 as compose,
+  gate2 as gate
 };

package/dist/rhythm-4by5yd5a.js

@@ -0,0 +1,42 @@
+// @bun
+// src/compose.ts
+var toVoid = () => {};
+function gate2(fn, condition) {
+  if (typeof condition !== "function")
+    throw new TypeError("condition must be a function!");
+  return (ctx, next) => {
+    const pass = condition(ctx);
+    if (typeof pass === "boolean")
+      return pass ? fn(ctx, next) : next().then(toVoid);
+    return pass.then((ok) => ok ? fn(ctx, next) : next().then(toVoid));
+  };
+}
+function compose2(middleware) {
+  if (!Array.isArray(middleware))
+    throw new TypeError("Middleware stack must be an array!");
+  for (const fn of middleware) {
+    if (typeof fn !== "function")
+      throw new TypeError("Middleware must be composed of functions!");
+  }
+  return function(context, next) {
+    let index = -1;
+    return dispatch(0);
+    function dispatch(i) {
+      if (i <= index)
+        return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      const fn = i === middleware.length ? next : middleware[i];
+      if (!fn)
+        return Promise.resolve(context);
+      const dispatchNext = () => dispatch(i + 1);
+      try {
+        const call = fn;
+        return Promise.resolve(call(context, dispatchNext)).then(() => context);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  };
+}
+
+export { gate2, compose2 };

package/dist/rhythm-s2x65tdb.js

@@ -0,0 +1,42 @@
+// @bun
+// src/compose.ts
+var toVoid = () => {};
+function gate2(fn, when) {
+  if (typeof when !== "function")
+    throw new TypeError("when must be a function!");
+  return (ctx, next) => {
+    const pass = when(ctx);
+    if (typeof pass === "boolean")
+      return pass ? fn(ctx, next) : next().then(toVoid);
+    return pass.then((ok) => ok ? fn(ctx, next) : next().then(toVoid));
+  };
+}
+function compose2(middleware) {
+  if (!Array.isArray(middleware))
+    throw new TypeError("Middleware stack must be an array!");
+  for (const fn of middleware) {
+    if (typeof fn !== "function")
+      throw new TypeError("Middleware must be composed of functions!");
+  }
+  return function(context, next) {
+    let index = -1;
+    return dispatch(0);
+    function dispatch(i) {
+      if (i <= index)
+        return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      const fn = i === middleware.length ? next : middleware[i];
+      if (!fn)
+        return Promise.resolve(context);
+      const dispatchNext = () => dispatch(i + 1);
+      try {
+        const call = fn;
+        return Promise.resolve(call(context, dispatchNext)).then(() => context);
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  };
+}
+
+export { gate2, compose2 };

package/dist/rhythm.d.ts

@@ -1,4 +1,4 @@
-import type { DeriveMiddleware, Middleware, OmitHashKeys } from "./types";
+import type { Condition, DeriveMiddleware, Middleware, OmitHashKeys } from "./types";
 export interface RhythmOptions {
     name?: string;
     type?: string;
@@ -7,17 +7,12 @@ export interface RhythmOptions {
 export declare function derive<TContext extends object, TExtra extends object>(fn: (ctx: TContext) => TExtra | Promise<TExtra>): DeriveMiddleware<TContext, OmitHashKeys<TExtra>>;
 export declare class Rhythm<TInput extends object = {}, TStartup extends object = {}, TContext extends object = TInput & TStartup> {
     #private;
-    /**
-     * Startup-time values (a db connection, config, ...). Declare the shape as the second type parameter, assign
-     * before serving, and every request context carries them. Registered modules inherit their parent's values and
-     * can add their own; a module's values never reach its parent.
-     */
     readonly context: TStartup;
     parent?: Rhythm<any, any, any>;
     constructor(options?: RhythmOptions);
     get sources(): readonly object[];
     use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): Rhythm<TInput, TStartup, TContext & TExtra>;
-    use(fn: Middleware<TContext>): this;
+    use(fn: Middleware<TContext>, condition?: Condition<TContext>): this;
     register<TRegInput extends object, TRegContext extends object, TExported extends object = {}>(other: Rhythm<TRegInput, any, TRegContext> & (TContext extends TRegInput ? unknown : never), exportValue?: (result: TRegContext) => TExported): Rhythm<TInput, TStartup, TContext & TExported>;
     callback(): (input: TInput) => Promise<TContext>;
     run(input: TInput): Promise<TContext>;

package/dist/rhythm.js

@@ -1,7 +1,8 @@
 // @bun
 import {
+  gate2,
   compose2
-} from "./rhythm-d9ycs7zz.js";
+} from "./rhythm-4by5yd5a.js";
 import {
   withSource2,
   sourceOf2
@@ -46,10 +47,10 @@ class Rhythm {
       source.parent = this;
     this.#sources.push(source);
   }
-  use(fn) {
+  use(fn, condition) {
     if (typeof fn !== "function")
       throw new TypeError("middleware must be a function!");
-    this.#middleware.push(fn);
+    this.#middleware.push(condition ? gate2(fn, condition) : fn);
     this.#adopt(sourceOf2(fn));
     return this;
   }

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 export type OmitHashKeys<T> = {
     [K in keyof T as K extends `#${string}` ? never : K]: T[K];
 };
+export type Condition<TContext extends object> = (ctx: TContext) => boolean | Promise<boolean>;
 export type NextFn<TContext extends object> = () => Promise<TContext>;
 export type Middleware<TContext extends object> = (ctx: TContext, next: NextFn<TContext>) => Promise<void> | void;
 export type DeriveMiddleware<TContext extends object, TExtra extends object> = Middleware<TContext> & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/rhythm",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "A minimal, type-safe onion-middleware and provider composition kernel.",
   "homepage": "https://rhythm.js.org/rhythm",
   "license": "ISC",