@idevconn/create-icore 0.5.0 → 0.5.1

package/templates/libs/shared/src/bootstrap.ts

@@ -0,0 +1,79 @@
+import { formatEnvBanner } from './env';
+
+interface MicroserviceLike {
+  listen: () => Promise<unknown>;
+  close: () => Promise<void>;
+}
+
+interface LoggerLike {
+  log: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string, trace?: unknown) => void;
+}
+
+const RETRY_DELAY_MS = 3000;
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Boots a microservice and binds its transport, surviving a broker that isn't
+ * up yet.
+ *
+ * NestJS `ServerRedis`/`ServerNats` REJECT `app.listen()` on the *initial*
+ * connect failure — the ioredis retryStrategy / NATS reconnect only governs
+ * re-connection after a first successful connect. So without this helper a MS
+ * would `process.exit(1)` whenever Redis/NATS is down on boot, even though the
+ * transport options ask for infinite retries.
+ *
+ * Behaviour (honours the "never crash on missing infra" rule):
+ *  - tcp transport, or NODE_ENV=production → fail fast: `process.exit(1)`.
+ *  - redis/nats in dev → log a boxed banner and retry `listen()` forever, so
+ *    the service idles until the broker appears, then binds automatically.
+ *
+ * `createApp` must construct a *fresh* app each call: a failed listen closes
+ * the transport's clients, so the next attempt needs a new instance.
+ */
+export async function bootstrapMicroservice(
+  prefix: string,
+  createApp: () => Promise<MicroserviceLike>,
+  logger: LoggerLike,
+): Promise<void> {
+  const transport = (process.env[`${prefix}_TRANSPORT`] ?? 'tcp').toLowerCase();
+  const isProd = process.env['NODE_ENV'] === 'production';
+  const failFast = transport === 'tcp' || isProd;
+
+  for (let attempt = 1; ; attempt++) {
+    let app: MicroserviceLike | undefined;
+    try {
+      app = await createApp();
+      await app.listen();
+      logger.log(`${prefix} microservice listening — transport=${transport}`);
+      return;
+    } catch (err) {
+      if (app) await app.close().catch(() => undefined);
+      const reason = err instanceof Error ? err.message : String(err);
+
+      if (failFast) {
+        logger.error(
+          `${prefix} microservice bootstrap failed`,
+          err instanceof Error ? err.stack : err,
+        );
+        process.exit(1);
+      }
+
+      logger.warn(
+        formatEnvBanner({
+          service: `${prefix} microservice`,
+          provider: transport,
+          missing: [],
+          envPath: `the service .env (${prefix}_${transport.toUpperCase()}_URL)`,
+          reason: `${reason} — retry ${attempt} in ${RETRY_DELAY_MS / 1000}s; idling until the ${transport} broker is reachable`,
+          headline: `⚠  ${prefix} microservice — ${transport} broker unreachable (idling, not crashing)`,
+        }),
+      );
+      await delay(RETRY_DELAY_MS);
+    }
+  }
+}

package/templates/libs/shared/src/index.ts

@@ -1,4 +1,5 @@
 export * from './env';
+export * from './bootstrap';
 export * from './abilities';
 export * from './jobs';
 export * from './strategies';

package/templates/libs/shared/src/transport.ts

@@ -67,15 +67,37 @@ export function buildTransport(prefix: string): ClientOptions {
       // ioredis accepts a connection URL string; the NestJS RedisOptions type
       // exposes host/port fields but passes options directly to ioredis which
       // also accepts a url field at runtime.
+      //
+      // retryAttempts/retryDelay are mandatory for resilience: NestJS
+      // ServerRedis builds its ioredis retryStrategy from them, and when
+      // retryAttempts is unset it logs "retry attempts not specified", stops
+      // reconnecting, and `app.listen()` REJECTS → the MS process exits. With
+      // an effectively-infinite retry the initial connect stays pending and
+      // keeps reconnecting, so a not-yet-up Redis never crashes the service —
+      // it idles and attaches once Redis is reachable.
       return {
         transport: Transport.REDIS,
-        options: { url: required(`${prefix}_REDIS_URL`) },
+        options: {
+          url: required(`${prefix}_REDIS_URL`),
+          retryAttempts: Number.POSITIVE_INFINITY,
+          retryDelay: 2000,
+        },
       } as unknown as ClientOptions;
     case 'nats':
+      // reconnect/maxReconnectAttempts: -1 retries forever once connected, so a
+      // dropped broker re-attaches instead of giving up. The *initial* connect
+      // is intentionally allowed to reject when NATS is down on boot —
+      // bootstrapMicroservice() catches that, logs a banner, and retries, giving
+      // the same visible behaviour as the Redis transport above.
       return {
         transport: Transport.NATS,
-        options: { servers: required(`${prefix}_NATS_URL`).split(',') },
-      };
+        options: {
+          servers: required(`${prefix}_NATS_URL`).split(','),
+          reconnect: true,
+          maxReconnectAttempts: -1,
+          reconnectTimeWait: 2000,
+        },
+      } as unknown as ClientOptions;
     default:
       throw new Error(`Unknown transport: ${kind}`);
   }

package/templates/tsconfig.base.json

@@ -29,7 +29,8 @@
       "@icore/payment-client": ["./libs/payment-client/src/index.ts"],
       "@icore/notes-client": ["./libs/notes-client/src/index.ts"],
       "@icore/jobs-client": ["./libs/jobs-client/src/index.ts"],
-      "@icore/vite-plugins": ["./libs/vite-plugins/src/index.d.mts"]
+      "@icore/vite-plugins": ["./libs/vite-plugins/src/index.d.mts"],
+      "@icore/firebase-admin": ["./libs/firebase-admin/src/index.ts"]
     }
   },
   "exclude": ["node_modules", "dist", ".nx"]