@bymax-one/nest-queue 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -7,6 +7,92 @@ versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [1.0.4] — 2026-08-01
+
+### Fixed
+
+- **`BymaxQueueModuleAsyncOptions.useFactory` rejected the factory this library
+  documents.** It was declared `(...args: unknown[]) => …`, and a parameter typed
+  `unknown` accepts no narrower parameter under `strictFunctionTypes`. So the
+  shape shown in the README and in `BymaxQueueModule`'s own `@example`:
+
+  ```ts
+  useFactory: (client: Redis) => ({ connection: { client } })
+  ```
+
+  failed to typecheck **against the exported interface**:
+
+  ```
+  TS2322: Type '(client: Redis) => …' is not assignable to
+          type '(...args: unknown[]) => …'
+  ```
+
+  Scope, precisely: `forRootAsync` is typed by NestJS's `ASYNC_OPTIONS_TYPE`, not
+  by this interface, so passing the object **inline** always compiled. Only a
+  consumer who annotated it — extracting the options into a
+  `const opts: BymaxQueueModuleAsyncOptions = { … }` — hit the error. The
+  interface was stricter than the module it describes.
+
+  It is now declared with **method syntax**. `strictFunctionTypes` makes
+  parameters contravariant for function-typed _properties_ but leaves method
+  parameters bivariant, so the interface accepts a factory that names its
+  injected types. This **widens** what is accepted: every factory that compiled
+  before still does, the variadic `(...args: unknown[])` form included. Nothing
+  needs changing in consumer code.
+
+  Method syntax rather than a looser parameter type, because the factory has to
+  stay **callable**: NestJS invokes it with the values `inject` resolves, and a
+  consumer may call it directly in a unit test. A `never[]` rest parameter would
+  have bought the same assignability and silently cost that —
+  `options.useFactory(client)` fails with `TS2345: Argument of type 'Redis' is
+not assignable to parameter of type 'never'`.
+
+  Pinned by seven cases in `test/types/public-api.test-d.ts` — typed parameter,
+  async, several parameters, zero parameters, the pre-1.0.4 variadic form, and
+  two for callability — where `useFactory` was previously pinned by nothing,
+  which is why this went unnoticed. Red-checked against **both** rejected
+  signatures: the original property form fails the assignability cases, and
+  `never[]` fails the callability ones.
+
+  No runtime change, verified rather than asserted: diffed against the published
+  `1.0.3` tarball, all four emitted runtime files (`server` and `shared`, `.mjs`
+  and `.cjs`) are byte-identical, and only `dist/server/index.d.ts` / `.d.cts`
+  differ. The altered source declares types only, so it produces no Stryker
+  mutants and the 99.06% score stands.
+
+---
+
+## [1.0.3] — 2026-08-01
+
+Documentation only. `dist/` is byte-identical to `1.0.2` — verified by unpacking
+the published tarball and diffing it against a fresh build — so there is no
+runtime change of any kind for consumers.
+
+### Fixed
+
+- **The "Example App" link in the README pointed at a path that no longer
+  exists.** It resolved to
+  `github.com/bymaxone/nest-queue/tree/main/examples/nest-queue-example`, a
+  directory that was renamed to `test/consumer-app` in this repository. The link
+  returned **404** for anyone reading the package page on npm, which is where a
+  README link matters most and where a broken one is least visible to us.
+
+  It now points at [`bymaxone/nest-queue-example`](https://github.com/bymaxone/nest-queue-example),
+  the actual reference application.
+
+### Changed
+
+- **The README no longer implies that `test/consumer-app` is a demo.** The two
+  artifacts had been sharing one name, and only one of them is something to copy
+  from:
+
+  |                                 | What it is                                                                                                                                                                                                |
+  | ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+  | `bymaxone/nest-queue-example`   | The reference application — an API and a web console exercising every public export against a real Redis. **Start here.**                                                                                 |
+  | `test/consumer-app` (this repo) | A typecheck fixture. CI compiles it against the freshly built library on every pull request to catch an ergonomic break in the decorator API that a signature test cannot see. Not published, not a demo. |
+
+---
+
 ## [1.0.2] — 2026-07-30
 
 ### Security

package/README.md

@@ -26,7 +26,7 @@
   <a href="https://github.com/bymaxone/nest-queue/issues">Issues</a> ·
   <a href="#-quick-start">Quick Start</a> ·
   <a href="#-api-reference">API Reference</a> ·
-  <a href="https://github.com/bymaxone/nest-queue/tree/main/examples/nest-queue-example">Example App</a>
+  <a href="https://github.com/bymaxone/nest-queue-example">Example App</a>
 </p>
 
 ---
@@ -123,10 +123,14 @@ Both subpaths ship ESM **and** CommonJS with declarations for each format, so a
 ---
 
 > [!TIP]
-> A runnable reference application lives in
-> [`examples/nest-queue-example`](https://github.com/bymaxone/nest-queue/tree/main/examples/nest-queue-example) —
-> a NestJS app that consumes this library and exercises producers, decorated
-> processors, and a health endpoint against a real Redis.
+> A full reference application lives in
+> [`bymaxone/nest-queue-example`](https://github.com/bymaxone/nest-queue-example) —
+> an API and a web console exercising every public export against a real Redis.
+>
+> The `test/consumer-app` directory in this repository is **not** that. It is a
+> typecheck fixture: a few hundred lines of application-shaped code that CI
+> compiles against the freshly built library on every pull request, to catch an
+> ergonomic break in the decorator API that a signature test cannot see.
 
 ---
 

package/dist/server/index.d.cts

@@ -97,8 +97,29 @@ interface BymaxQueueOptionsFactory {
 }
 /** Asynchronous configuration mirroring the NestJS async dynamic-module pattern. */
 interface BymaxQueueModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    /** Factory returning the module options. */
-    useFactory?: (...args: unknown[]) => Promise<BymaxQueueModuleOptions> | BymaxQueueModuleOptions;
+    /**
+     * Factory returning the module options. Its parameters are whatever `inject`
+     * resolves to, so declare them with the types you expect:
+     *
+     * ```ts
+     * useFactory: (client: Redis) => ({ connection: { client } })
+     * ```
+     *
+     * Declared with **method syntax** on purpose. `strictFunctionTypes` makes
+     * parameters contravariant for function-typed *properties* but leaves method
+     * parameters bivariant, so this accepts a factory that names its injected
+     * types — which a property typed `(...args: unknown[]) => …` rejects, since
+     * `unknown` is assignable from no narrower parameter. That rejection is what
+     * made the form above fail against this interface while compiling when passed
+     * inline to `forRootAsync`.
+     *
+     * Bivariance is the right trade here rather than a looser parameter type:
+     * NestJS resolves these arguments from `inject` at runtime, so no signature
+     * can make them statically safe, and method syntax keeps the factory
+     * **callable** — `options.useFactory(client)` typechecks, which a
+     * `never[]` rest parameter would have broken.
+     */
+    useFactory?(...args: unknown[]): Promise<BymaxQueueModuleOptions> | BymaxQueueModuleOptions;
     /** Class implementing the options factory. */
     useClass?: Type<BymaxQueueOptionsFactory>;
     /** Existing provider implementing the options factory. */

package/dist/server/index.d.ts

@@ -97,8 +97,29 @@ interface BymaxQueueOptionsFactory {
 }
 /** Asynchronous configuration mirroring the NestJS async dynamic-module pattern. */
 interface BymaxQueueModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    /** Factory returning the module options. */
-    useFactory?: (...args: unknown[]) => Promise<BymaxQueueModuleOptions> | BymaxQueueModuleOptions;
+    /**
+     * Factory returning the module options. Its parameters are whatever `inject`
+     * resolves to, so declare them with the types you expect:
+     *
+     * ```ts
+     * useFactory: (client: Redis) => ({ connection: { client } })
+     * ```
+     *
+     * Declared with **method syntax** on purpose. `strictFunctionTypes` makes
+     * parameters contravariant for function-typed *properties* but leaves method
+     * parameters bivariant, so this accepts a factory that names its injected
+     * types — which a property typed `(...args: unknown[]) => …` rejects, since
+     * `unknown` is assignable from no narrower parameter. That rejection is what
+     * made the form above fail against this interface while compiling when passed
+     * inline to `forRootAsync`.
+     *
+     * Bivariance is the right trade here rather than a looser parameter type:
+     * NestJS resolves these arguments from `inject` at runtime, so no signature
+     * can make them statically safe, and method syntax keeps the factory
+     * **callable** — `options.useFactory(client)` typechecks, which a
+     * `never[]` rest parameter would have broken.
+     */
+    useFactory?(...args: unknown[]): Promise<BymaxQueueModuleOptions> | BymaxQueueModuleOptions;
     /** Class implementing the options factory. */
     useClass?: Type<BymaxQueueOptionsFactory>;
     /** Existing provider implementing the options factory. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bymax-one/nest-queue",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "NestJS dynamic module wrapping BullMQ — typed jobs, flows, job schedulers, deduplication, OpenTelemetry, graceful shutdown",
   "author": "Bymax One <support@bymax.one>",
   "license": "MIT",