@dunx/create-app 3.0.5 → 3.1.1

package/dist/{chunk-5tn3ybzv.js → chunk-tn4dnvcw.js}

@@ -19,17 +19,33 @@ var CONFIG_GROUPS = Object.freeze({
     schema: [
       "LOG_LEVEL: z.enum(LogLevel).default(LogLevel.INFO),",
       "/** Unset means console only. Set it to also append JSON to a rotating file. */",
-      "LOG_FILE: z.string().optional(),"
+      "LOG_FILE: z.string().optional(),",
+      "/** Both cost a `req.clone().text()` on the hot path, so off in production. */",
+      "LOG_REQUEST_BODY: z.stringbool().default(false),",
+      "LOG_RESPONSE_BODY: z.stringbool().default(false),"
     ],
-    field: "readonly log: { readonly level: LogLevel; readonly file: string | undefined };",
-    map: "log: { level: value.LOG_LEVEL, file: value.LOG_FILE },",
+    field: "readonly log: { readonly level: LogLevel; readonly file: string | undefined; " + "readonly requestBody: boolean; readonly responseBody: boolean };",
+    map: "log: { level: value.LOG_LEVEL, file: value.LOG_FILE, " + "requestBody: value.LOG_REQUEST_BODY, responseBody: value.LOG_RESPONSE_BODY },",
     env: [{ name: "LOG_LEVEL", value: "info" }]
   },
   corsOrigin: {
-    schema: ["CORS_ORIGIN: z.string().default('https://example.com'),"],
-    field: "readonly corsOrigin: string;",
-    map: "corsOrigin: value.CORS_ORIGIN,",
-    env: [{ name: "CORS_ORIGIN", value: "https://example.com" }]
+    schema: [
+      "CORS_ORIGIN: z.string().default('https://example.com'),",
+      "/**",
+      " * Whether `x-forwarded-for` is believed. Off unless a trusted proxy is in",
+      " * front: with nothing stripping the header, any caller picks its own",
+      " * address, which fakes both rate limiting and the logged client address.",
+      " */",
+      "TRUST_PROXY: z.stringbool().default(false),"
+    ],
+    field: `readonly corsOrigin: string;
+  readonly trustProxy: boolean;`,
+    map: `corsOrigin: value.CORS_ORIGIN,
+    trustProxy: value.TRUST_PROXY,`,
+    env: [
+      { name: "CORS_ORIGIN", value: "https://example.com" },
+      { name: "TRUST_PROXY", value: "false" }
+    ]
   },
   database: {
     schema: [
@@ -142,7 +158,7 @@ var FEATURES = [
     requires: [],
     module: { klass: "HttpModule", from: "./http/http.module.js" },
     dependencies: [],
-    config: ["corsOrigin"]
+    config: ["corsOrigin", "redis"]
   },
   {
     name: "guards",

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
   packageVersion,
   resolveFeatures,
   scaffold
-} from "./chunk-5tn3ybzv.js";
+} from "./chunk-tn4dnvcw.js";
 
 // src/cli.ts
 import { parseArgs } from "util";

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   featureNames,
   isValidPackageName,
   scaffold
-} from "./chunk-5tn3ybzv.js";
+} from "./chunk-tn4dnvcw.js";
 export {
   FEATURES,
   ScaffoldError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/create-app",
-  "version": "3.0.5",
+  "version": "3.1.1",
   "description": "Scaffold a new dunx application - bunx @dunx/create-app my-api",
   "keywords": [
     "bun",

package/templates/features/cache/cache.module.ts

@@ -1,9 +1,21 @@
 import { Module } from '@dunx/core';
-import { RedisConnection, RedisModule } from '@dunx/infra/redis';
+import {
+  defaultRedisUrl,
+  RedisConnection,
+  RedisModule,
+} from '@dunx/infra/redis';
 import { AppConfigService } from '../config.js';
 import { CacheController } from './cache.controller.js';
+import { SessionsRedis } from './sessions.redis.js';
 import { Sessions } from './sessions.service.js';
 
+/** The configured server, database 1. A path already on the url is replaced. */
+const sessionsUrl = (url: string | undefined): string => {
+  const parsed = new URL(url ?? defaultRedisUrl());
+  parsed.pathname = '/1';
+  return parsed.href;
+};
+
 @Module({
   imports: [
     // No url, so Bun resolves $VALKEY_URL, $REDIS_URL, then localhost.
@@ -24,10 +36,27 @@ import { Sessions } from './sessions.service.js';
       },
       inject: [AppConfigService] as const,
     }),
+    /**
+     * A subclass rather than a name, so `SessionsRedis` is an ordinary
+     * constructor parameter, and it does not claim `RedisConnection`. Database 1:
+     * separate clients do not isolate what a `FLUSHDB` reaches, so a shared
+     * database would mean flushing the cache signed every user out.
+     */
+    RedisModule.forRootAsync(
+      {
+        useFactory: (config: AppConfigService) => ({
+          url: sessionsUrl(config.get('redis').url),
+          connectionTimeout: 500,
+          maxRetries: 0,
+        }),
+        inject: [AppConfigService] as const,
+      },
+      SessionsRedis,
+    ),
   ],
   controllers: [CacheController],
   providers: [Sessions],
   // Re-exported so the chat gateway fans out through the same connection.
-  exports: [RedisConnection, Sessions],
+  exports: [RedisConnection, SessionsRedis, Sessions],
 })
 export class CacheModule {}

package/templates/features/cache/sessions.redis.ts

@@ -0,0 +1,4 @@
+import { Redis } from '@dunx/infra/redis';
+
+/** The session store, on database 1 so a cache flush cannot sign users out. */
+export class SessionsRedis extends Redis {}

package/templates/features/cache/sessions.service.ts

@@ -1,16 +1,15 @@
 import { Logger } from '@dunx/core';
-import {
-  isConnectionError,
-  RedisConnection,
-  RedisOptions,
-} from '@dunx/infra/redis';
+import { isConnectionError, RedisOptions } from '@dunx/infra/redis';
+import { SessionsRedis } from './sessions.redis.js';
 
 export class Sessions {
   // Namespaced by pid so one run cannot read another run's keys.
   readonly #prefix = `dunx-full:${process.pid}`;
 
   constructor(
-    private readonly redis: RedisConnection,
+    // The subclass, not `RedisConnection`: a named connection is a parameter
+    // type now, so this needs no `inject()` in a field.
+    private readonly redis: SessionsRedis,
     private readonly options: RedisOptions,
     private readonly logger: Logger,
   ) {}

package/templates/features/http/http-options.ts

@@ -0,0 +1,73 @@
+import {
+  HttpOptionsProvider,
+  RedisRelay,
+  type CorsOptions,
+  type PubSubRelay,
+  type RequestLoggingOptions,
+} from '@dunx/http';
+import { AppConfigService, RELAY_CHANNEL } from '../config.js';
+
+/**
+ * The HTTP settings that come from validated config, answered from the container
+ * rather than computed before it exists.
+ *
+ * `main.ts` used to open with `const log = validate(Bun.env).log`, because
+ * `HttpFactory.create(root, options)` builds the container and so its argument
+ * has to be ready first. That was a second call to `validate` on a second copy of
+ * the environment, invisible to `ConfigModule`. This class injects
+ * `AppConfigService` like anything else.
+ *
+ * What stays an argument to `create()`: `websocket`, `relay` and `relayChannel`,
+ * which are constructed objects rather than settings read from the environment.
+ */
+export class AppHttpOptions extends HttpOptionsProvider {
+  constructor(
+    private readonly config: AppConfigService,
+    private readonly bus: RedisRelay,
+  ) {
+    super();
+    this.trustProxy = this.config.get('trustProxy');
+  }
+
+  /**
+   * A field on the base, so a field here (TS2611 rejects an accessor), assigned in
+   * the constructor, which is how a field derives from config. Defaults to
+   * **false**: believing `x-forwarded-for` with no proxy stripping it lets any
+   * caller pick its own address, faking the throttle subject and the logged one.
+   */
+  override readonly trustProxy: boolean;
+
+  override get prefix(): string {
+    return 'api';
+  }
+
+  override get cors(): CorsOptions {
+    return {
+      origin: this.config.get('corsOrigin'),
+      credentials: true,
+      exposedHeaders: ['x-handled-by'],
+      maxAge: 600,
+    };
+  }
+
+  /** Multi-node websocket fan-out, resolved rather than constructed. */
+  override get relay(): PubSubRelay {
+    return this.bus;
+  }
+
+  override readonly relayChannel = RELAY_CHANNEL;
+
+  override get requestLogging(): RequestLoggingOptions {
+    const log = this.config.get('log');
+    return {
+      // Off by default: both cost a `req.clone().text()` on the hot path.
+      requestBody: log.requestBody,
+      responseBody: log.responseBody,
+      // The dashboard polls every five seconds and would bury everything else.
+      ignorePrefix: ['/api/_dunx'],
+      // ~360 ns per request, so off by default. On here so `traceId` joins
+      // `requestId` and `@dunx/http/client` forwards it upstream.
+      trace: true,
+    };
+  }
+}

package/templates/features/http/http.module.ts

@@ -1,5 +1,11 @@
-import { Module } from '@dunx/core';
-import { CompressionModule } from '@dunx/http';
+import { Module, provide } from '@dunx/core';
+import {
+  CompressionModule,
+  HttpOptionsProvider,
+  WsRelayModule,
+} from '@dunx/http';
+import { AppConfigService } from '../config.js';
+import { AppHttpOptions } from './http-options.js';
 import { CompressionDemo } from './compression.demo.js';
 import { TraceController } from './trace.controller.js';
 import { TraceDemo } from './trace.demo.js';
@@ -19,9 +25,28 @@ import { RequestTrail, RequestTrailMiddleware } from './request-trail.js';
     // body under it is sent as it is, because gzip's header and trailer alone are
     // 18 bytes and a short JSON response comes out larger.
     CompressionModule.forRoot({ threshold: 1024 }),
+    /**
+     * The relay as a provider, imported here because `AppHttpOptions` is what
+     * consumes it. `main.ts` used to build `new RedisRelay(...)` and thread it
+     * into `HttpFactory.create`, which was the last hand-built object in the
+     * options. The container closes it at shutdown.
+     */
+    WsRelayModule.forRootAsync({
+      useFactory: (config: AppConfigService) => {
+        const { url } = config.get('redis');
+        return {
+          ...(url === undefined ? {} : { url }),
+          connectionTimeout: 500,
+        };
+      },
+      inject: [AppConfigService] as const,
+    }),
   ],
   controllers: [TraceController],
   providers: [
+    // The HTTP settings that read from config, resolved after the container
+    // exists. `HttpFactory` promotes a default, so binding this replaces it.
+    provide(HttpOptionsProvider, { useClass: AppHttpOptions }),
     RequestTrail,
     RequestTrailMiddleware,
     HttpDemo,
@@ -29,6 +54,7 @@ import { RequestTrail, RequestTrailMiddleware } from './request-trail.js';
     TraceDemo,
   ],
   exports: [
+    HttpOptionsProvider,
     RequestTrail,
     RequestTrailMiddleware,
     HttpDemo,

package/templates/features/upstream/health.client.ts

@@ -0,0 +1,4 @@
+import { HttpService } from '@dunx/http/client';
+
+/** A probe client with its own short timeout, taken as a parameter. */
+export class HealthClient extends HttpService {}

package/templates/features/upstream/upstream.demo.ts

@@ -4,6 +4,7 @@ import {
   FetchTransportError,
   HttpService,
 } from '@dunx/http/client';
+import { HealthClient } from './health.client.js';
 
 /**
  * Calling out over `fetch`. Three things a bare `fetch` does not do: retry a 503
@@ -14,6 +15,10 @@ export class UpstreamDemo {
   constructor(
     private readonly logger: Logger,
     private readonly http: HttpService,
+    // A named client as a constructor parameter, which is what registering it as
+    // a subclass buys: `inject(httpClient('health'))` in a field is the only way
+    // to reach one bound to a `Token`.
+    private readonly health: HealthClient,
   ) {}
 
   async demonstrate(url: string): Promise<void> {
@@ -22,6 +27,11 @@ export class UpstreamDemo {
     );
     this.logger.info(`GET api/notes -> ${JSON.stringify(notes)}`);
 
+    const live = await this.health.get<{ status: string }>(
+      new URL('api/health/live', url),
+    );
+    this.logger.info(`HealthClient -> ${live.status}`);
+
     const attempts: string[] = [];
     const recovered = await this.http.get<{ after: number }>(
       new URL('api/upstream/flaky', url),

package/templates/features/upstream/upstream.module.ts

@@ -2,6 +2,7 @@ import { Module } from '@dunx/core';
 import { HttpModule as HttpClientModule } from '@dunx/http/client';
 import { AppConfigService } from '../config.js';
 import { FlakyController } from './flaky.controller.js';
+import { HealthClient } from './health.client.js';
 import { UpstreamDemo } from './upstream.demo.js';
 
 /**
@@ -25,9 +26,36 @@ import { UpstreamDemo } from './upstream.demo.js';
       }),
       inject: [AppConfigService] as const,
     }),
+    /**
+     * A second client, bound to a subclass rather than a name, so `HealthClient`
+     * is an ordinary constructor parameter. It does not claim `HttpService`, so
+     * the default above is untouched.
+     */
+    HttpClientModule.forRootAsync(
+      {
+        useFactory: (config: AppConfigService) => ({
+          ...config.get('upstream'),
+          // A readiness probe waits far less than a business call.
+          timeoutMs: 1_000,
+          /**
+           * Bun-only, passed straight to `fetch`. A probe follows nothing: a
+           * redirect from a health endpoint is a failure, not a hop to chase.
+           *
+           * `protocol: 'http2'` is the other option worth knowing about and is
+           * **not** set here, because this app calls itself over cleartext HTTP
+           * and Bun raises `HTTP2Unsupported` rather than falling back
+           * (docs/bun-apis.md). Set it against an HTTPS upstream that offers h2.
+           */
+          maxRedirects: 0,
+          headers: { 'user-agent': `${config.get('appName')}/health` },
+        }),
+        inject: [AppConfigService] as const,
+      },
+      HealthClient,
+    ),
   ],
   controllers: [FlakyController],
   providers: [UpstreamDemo],
-  exports: [UpstreamDemo],
+  exports: [UpstreamDemo, HealthClient],
 })
 export class UpstreamModule {}

package/templates/features/users/users.repository.ts

@@ -1,4 +1,4 @@
-import { SyncDatabase } from '@dunx/infra/db';
+import { SyncDatabase, toDatabaseError } from '@dunx/infra/db';
 import { eq, like, sql } from 'drizzle-orm';
 import * as schema from '../database/schema.js';
 import { users, type User } from '../database/schema.js';
@@ -44,7 +44,17 @@ export class UsersRepository {
     return this.db.select().from(users).where(eq(users.id, id)).get() ?? null;
   }
 
+  /**
+   * `name` is UNIQUE, so a repeat is a conflict rather than a server fault.
+   * `toDatabaseError` turns the driver's `SQLITE_CONSTRAINT_UNIQUE` into a
+   * `ConstraintError` carrying 409, and `@dunx/http` reads the status off it -
+   * no error filter, and nothing here knows what a Response is.
+   */
   async create(name: string): Promise<User> {
-    return this.db.insert(users).values({ name }).returning().get();
+    try {
+      return this.db.insert(users).values({ name }).returning().get();
+    } catch (error) {
+      throw toDatabaseError(error);
+    }
   }
 }