@idevconn/create-icore 0.4.1 → 0.5.1

package/templates/apps/microservices/auth/src/app/app.module.ts

@@ -1,36 +1,41 @@
 import { join } from 'node:path';
-import { Module } from '@nestjs/common';
+import { Module, Logger } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { createClient } from '@supabase/supabase-js';
-import * as admin from 'firebase-admin';
 import { SupabaseAuthStrategy } from '@icore/auth-supabase';
 import { FirebaseAuthStrategy, HttpIdentityToolkitClient } from '@icore/auth-firebase';
-import { FakeAuthStrategy } from '@icore/shared';
+import { getFirebaseAdmin, FIREBASE_ADMIN_REQUIRED_ENV } from '@icore/firebase-admin';
+import { FakeAuthStrategy, missingEnv, formatEnvBanner } from '@icore/shared';
 import type { AuthStrategy } from '@icore/shared';
-import { Logger } from '@nestjs/common';
 import { AuthController } from './auth.controller';
 
+const ENV_PATH = 'apps/microservices/auth/.env';
+
+// Env vars each provider needs (besides AUTH_PROVIDER itself).
+const REQUIRED_ENV: Record<string, string[]> = {
+  supabase: ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY'],
+  firebase: [...FIREBASE_ADMIN_REQUIRED_ENV, 'FIREBASE_WEB_API_KEY'],
+};
+
 function requireEnv(cfg: ConfigService, key: string): string {
-  const val = cfg.getOrThrow<string>(key);
-  if (!val) throw new Error(`${key} is not set — check apps/microservices/auth/.env`);
-  return val;
+  return cfg.getOrThrow<string>(key);
 }
 
-function makeFirebaseStrategy(cfg: ConfigService): AuthStrategy {
-  const projectId = requireEnv(cfg, 'FB_ADMIN_PROJECT_ID');
-  if (admin.apps.length === 0) {
-    admin.initializeApp({
-      credential: admin.credential.cert({
-        projectId,
-        clientEmail: requireEnv(cfg, 'FB_ADMIN_CLIENT_EMAIL'),
-        privateKey: requireEnv(cfg, 'FB_ADMIN_PRIVATE_KEY').replace(/\\n/g, '\n'),
-      }),
-    });
-  }
+function makeSupabaseAuth(cfg: ConfigService): AuthStrategy {
+  const client = createClient(
+    requireEnv(cfg, 'SUPABASE_URL'),
+    requireEnv(cfg, 'SUPABASE_SERVICE_ROLE_KEY'),
+    { auth: { autoRefreshToken: false, persistSession: false } },
+  );
+  return new SupabaseAuthStrategy({ client });
+}
+
+function makeFirebaseAuth(cfg: ConfigService): AuthStrategy {
+  const app = getFirebaseAdmin(cfg);
   const identityToolkit = new HttpIdentityToolkitClient(requireEnv(cfg, 'FIREBASE_WEB_API_KEY'));
   return new FirebaseAuthStrategy({
     identityToolkit,
-    adminAuth: admin.auth(),
+    adminAuth: app.auth(),
   });
 }
 
@@ -49,28 +54,34 @@ function makeFirebaseStrategy(cfg: ConfigService): AuthStrategy {
     {
       provide: 'AuthStrategy',
       useFactory: (cfg: ConfigService): AuthStrategy => {
+        const logger = new Logger('AuthStrategy');
+        const provider = cfg.get<string>('AUTH_PROVIDER')?.trim();
+        const keys = provider ? REQUIRED_ENV[provider] : undefined;
+        const missing = keys ? missingEnv((k) => cfg.get<string>(k), keys) : [];
+
+        // Prod: fail fast — never silently run a fake auth strategy.
+        // Dev: warn with a boxed banner + fall back to the in-memory fake.
+        const fallback = (reason?: string): AuthStrategy => {
+          const banner = formatEnvBanner({
+            service: 'auth MS',
+            provider,
+            missing,
+            envPath: ENV_PATH,
+            reason,
+          });
+          if (process.env.NODE_ENV === 'production') throw new Error(banner);
+          logger.warn(banner);
+          return new FakeAuthStrategy();
+        };
+
+        if (!keys || missing.length > 0) return fallback();
+
         try {
-          const provider = requireEnv(cfg, 'AUTH_PROVIDER');
-          switch (provider) {
-            case 'supabase': {
-              const client = createClient(
-                requireEnv(cfg, 'SUPABASE_URL'),
-                requireEnv(cfg, 'SUPABASE_SERVICE_ROLE_KEY'),
-                { auth: { autoRefreshToken: false, persistSession: false } },
-              );
-              return new SupabaseAuthStrategy({ client });
-            }
-            case 'firebase':
-              return makeFirebaseStrategy(cfg);
-            default:
-              throw new Error(`Unsupported AUTH_PROVIDER: ${provider}`);
-          }
+          if (provider === 'supabase') return makeSupabaseAuth(cfg);
+          return makeFirebaseAuth(cfg);
         } catch (err) {
-          new Logger('AuthStrategy').warn(
-            `Not configured: ${err instanceof Error ? err.message : String(err)}. ` +
-              `Requests will fail until apps/microservices/auth/.env is set.`,
-          );
-          return new FakeAuthStrategy();
+          // Vars present but invalid (e.g. placeholder URL the SDK rejects).
+          return fallback(err instanceof Error ? err.message : String(err));
         }
       },
       inject: [ConfigService],

package/templates/apps/microservices/auth/src/main.ts

@@ -1,28 +1,11 @@
 import { Logger } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 import { MicroserviceOptions } from '@nestjs/microservices';
-import { buildTransportMS } from '@icore/shared';
+import { bootstrapMicroservice, buildTransportMS } from '@icore/shared';
 import { AppModule } from './app/app.module';
 
-async function bootstrap() {
-  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
-    AppModule,
-    buildTransportMS('AUTH'),
-  );
-  await app.listen();
-}
-
-bootstrap()
-  .then(() => {
-    const logger = new Logger('Auth-Bootstrap');
-    logger.log(
-      `Auth MS Bootstrap completed: transport=${process.env.AUTH_TRANSPORT ?? 'tcp'} host=${process.env.AUTH_HOST ?? '127.0.0.1'} port=${process.env.AUTH_PORT ?? '4001'}`,
-    );
-  })
-  .catch((err) => {
-    new Logger('Auth-Bootstrap').error(
-      'Auth MS bootstrap failed',
-      err instanceof Error ? err.stack : err,
-    );
-    process.exit(1);
-  });
+void bootstrapMicroservice(
+  'AUTH',
+  () => NestFactory.createMicroservice<MicroserviceOptions>(AppModule, buildTransportMS('AUTH')),
+  new Logger('Auth-Bootstrap'),
+);

package/templates/apps/microservices/jobs/project.json

@@ -50,7 +50,8 @@
       "dependsOn": ["build"],
       "options": {
         "buildTarget": "jobs:build",
-        "runBuildTargetDependencies": false
+        "runBuildTargetDependencies": false,
+        "port": 9234
       },
       "configurations": {
         "development": {

package/templates/apps/microservices/jobs/src/app/redis-connection.ts

@@ -0,0 +1,35 @@
+import { Logger } from '@nestjs/common';
+import IORedis from 'ioredis';
+import { formatEnvBanner } from '@icore/shared';
+
+/**
+ * Creates an IORedis connection that NEVER crashes the process when Redis is
+ * unreachable. Without an 'error' handler, ioredis emits an unhandled 'error'
+ * event → Node exits. Here we log one boxed banner and let ioredis keep
+ * retrying in the background, so the jobs MS stays up and connects once Redis
+ * is available (honours the "never crash on missing infra" rule).
+ */
+export function createJobsRedis(url: string, logger: Logger): IORedis {
+  const connection = new IORedis(url, {
+    maxRetriesPerRequest: null,
+    retryStrategy: (times) => Math.min(times * 200, 5000),
+  });
+
+  let warned = false;
+  connection.on('error', (err: Error) => {
+    if (warned) return;
+    warned = true;
+    logger.warn(
+      formatEnvBanner({
+        service: 'jobs MS',
+        provider: 'redis',
+        missing: [],
+        envPath: 'apps/microservices/jobs/.env (JOBS_REDIS_URL)',
+        reason: `${err.message} — retrying in the background until Redis is up at ${url}`,
+        headline: `⚠  jobs MS — Redis unreachable (workers idle until it's up)`,
+      }),
+    );
+  });
+
+  return connection;
+}

package/templates/apps/microservices/jobs/src/app/workers/cleanup.worker.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger, type OnModuleDestroy, type OnModuleInit } from '@ne
 import { ConfigService } from '@nestjs/config';
 import { Worker, type Job } from 'bullmq';
 import IORedis from 'ioredis';
+import { createJobsRedis } from '../redis-connection';
 import type { CleanupJob } from '@icore/shared';
 
 @Injectable()
@@ -15,7 +16,7 @@ export class CleanupWorker implements OnModuleInit, OnModuleDestroy {
   onModuleInit(): void {
     const url = this.cfg.get<string>('JOBS_REDIS_URL') ?? 'redis://localhost:6379';
     const concurrency = Number(this.cfg.get<string>('JOBS_WORKER_CONCURRENCY') ?? '5');
-    this.connection = new IORedis(url, { maxRetriesPerRequest: null });
+    this.connection = createJobsRedis(url, this.logger);
     this.worker = new Worker<CleanupJob>(
       'cleanup',
       async (job: Job<CleanupJob>) => {

package/templates/apps/microservices/jobs/src/app/workers/email.worker.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger, type OnModuleDestroy, type OnModuleInit } from '@ne
 import { ConfigService } from '@nestjs/config';
 import { Worker, type Job } from 'bullmq';
 import IORedis from 'ioredis';
+import { createJobsRedis } from '../redis-connection';
 import type { EmailJob } from '@icore/shared';
 
 @Injectable()
@@ -15,7 +16,7 @@ export class EmailWorker implements OnModuleInit, OnModuleDestroy {
   onModuleInit(): void {
     const url = this.cfg.get<string>('JOBS_REDIS_URL') ?? 'redis://localhost:6379';
     const concurrency = Number(this.cfg.get<string>('JOBS_WORKER_CONCURRENCY') ?? '5');
-    this.connection = new IORedis(url, { maxRetriesPerRequest: null });
+    this.connection = createJobsRedis(url, this.logger);
     this.worker = new Worker<EmailJob>(
       'email',
       async (job: Job<EmailJob>) => {

package/templates/apps/microservices/jobs/src/app/workers/image-process.worker.ts

@@ -2,6 +2,7 @@ import { Injectable, Logger, type OnModuleDestroy, type OnModuleInit } from '@ne
 import { ConfigService } from '@nestjs/config';
 import { Worker, type Job } from 'bullmq';
 import IORedis from 'ioredis';
+import { createJobsRedis } from '../redis-connection';
 import type { ImageProcessJob } from '@icore/shared';
 
 @Injectable()
@@ -15,7 +16,7 @@ export class ImageProcessWorker implements OnModuleInit, OnModuleDestroy {
   onModuleInit(): void {
     const url = this.cfg.get<string>('JOBS_REDIS_URL') ?? 'redis://localhost:6379';
     const concurrency = Number(this.cfg.get<string>('JOBS_WORKER_CONCURRENCY') ?? '5');
-    this.connection = new IORedis(url, { maxRetriesPerRequest: null });
+    this.connection = createJobsRedis(url, this.logger);
     this.worker = new Worker<ImageProcessJob>(
       'image-process',
       async (job: Job<ImageProcessJob>) => {

package/templates/apps/microservices/notes/project.json

@@ -50,7 +50,8 @@
       "dependsOn": ["build"],
       "options": {
         "buildTarget": "notes:build",
-        "runBuildTargetDependencies": false
+        "runBuildTargetDependencies": false,
+        "port": 9232
       },
       "configurations": {
         "development": {

package/templates/apps/microservices/notes/src/app/app.module.ts

@@ -1,19 +1,41 @@
 import { join } from 'node:path';
-import { Module } from '@nestjs/common';
+import { Module, Logger } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { createClient } from '@supabase/supabase-js';
-import * as admin from 'firebase-admin';
 import { SupabaseDBStrategy } from '@icore/db-supabase';
 import { FirestoreDBStrategy } from '@icore/db-firestore';
-import { FakeDBStrategy } from '@icore/shared';
+import { getFirebaseAdmin, FIREBASE_ADMIN_REQUIRED_ENV } from '@icore/firebase-admin';
+import { FakeDBStrategy, missingEnv, formatEnvBanner } from '@icore/shared';
 import type { DBStrategy } from '@icore/shared';
-import { Logger } from '@nestjs/common';
 import { NotesController } from './notes.controller';
 
+const ENV_PATH = 'apps/microservices/notes/.env';
+
+// DB_PROVIDER accepts supabase | firestore | firebase (latter two are Firestore).
+const REQUIRED_ENV: Record<string, string[]> = {
+  supabase: ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY'],
+  firestore: [...FIREBASE_ADMIN_REQUIRED_ENV],
+  firebase: [...FIREBASE_ADMIN_REQUIRED_ENV],
+};
+
 function requireEnv(cfg: ConfigService, key: string): string {
-  const val = cfg.getOrThrow<string>(key);
-  if (!val) throw new Error(`${key} is not set — check apps/microservices/notes/.env`);
-  return val;
+  return cfg.getOrThrow<string>(key);
+}
+
+function makeSupabaseDB(cfg: ConfigService): DBStrategy {
+  const client = createClient(
+    requireEnv(cfg, 'SUPABASE_URL'),
+    requireEnv(cfg, 'SUPABASE_SERVICE_ROLE_KEY'),
+    { auth: { autoRefreshToken: false, persistSession: false } },
+  );
+  return new SupabaseDBStrategy({ client });
+}
+
+function makeFirestoreDB(cfg: ConfigService): DBStrategy {
+  const app = getFirebaseAdmin(cfg);
+  return new FirestoreDBStrategy({
+    db: app.firestore() as unknown as ConstructorParameters<typeof FirestoreDBStrategy>[0]['db'],
+  });
 }
 
 @Module({
@@ -31,39 +53,31 @@ function requireEnv(cfg: ConfigService, key: string): string {
     {
       provide: 'DBStrategy',
       useFactory: (cfg: ConfigService): DBStrategy => {
+        const logger = new Logger('DBStrategy');
+        const provider = cfg.get<string>('DB_PROVIDER')?.trim();
+        const keys = provider ? REQUIRED_ENV[provider] : undefined;
+        const missing = keys ? missingEnv((k) => cfg.get<string>(k), keys) : [];
+
+        const fallback = (reason?: string): DBStrategy => {
+          const banner = formatEnvBanner({
+            service: 'notes MS',
+            provider,
+            missing,
+            envPath: ENV_PATH,
+            reason,
+          });
+          if (process.env.NODE_ENV === 'production') throw new Error(banner);
+          logger.warn(banner);
+          return new FakeDBStrategy();
+        };
+
+        if (!keys || missing.length > 0) return fallback();
+
         try {
-          const provider = requireEnv(cfg, 'DB_PROVIDER');
-          if (provider === 'supabase') {
-            const client = createClient(
-              requireEnv(cfg, 'SUPABASE_URL'),
-              requireEnv(cfg, 'SUPABASE_SERVICE_ROLE_KEY'),
-              { auth: { autoRefreshToken: false, persistSession: false } },
-            );
-            return new SupabaseDBStrategy({ client });
-          }
-          if (provider === 'firestore' || provider === 'firebase') {
-            if (admin.apps.length === 0) {
-              admin.initializeApp({
-                credential: admin.credential.cert({
-                  projectId: requireEnv(cfg, 'FB_ADMIN_PROJECT_ID'),
-                  clientEmail: requireEnv(cfg, 'FB_ADMIN_CLIENT_EMAIL'),
-                  privateKey: requireEnv(cfg, 'FB_ADMIN_PRIVATE_KEY').replace(/\\n/g, '\n'),
-                }),
-              });
-            }
-            return new FirestoreDBStrategy({
-              db: admin.firestore() as unknown as ConstructorParameters<
-                typeof FirestoreDBStrategy
-              >[0]['db'],
-            });
-          }
-          throw new Error(`Unsupported DB_PROVIDER: ${provider}`);
+          if (provider === 'supabase') return makeSupabaseDB(cfg);
+          return makeFirestoreDB(cfg);
         } catch (err) {
-          new Logger('DBStrategy').warn(
-            `Not configured: ${err instanceof Error ? err.message : String(err)}. ` +
-              `Requests will fail until apps/microservices/notes/.env is set.`,
-          );
-          return new FakeDBStrategy();
+          return fallback(err instanceof Error ? err.message : String(err));
         }
       },
       inject: [ConfigService],

package/templates/apps/microservices/notes/src/main.ts

@@ -1,28 +1,11 @@
 import { Logger } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 import { MicroserviceOptions } from '@nestjs/microservices';
-import { buildTransportMS } from '@icore/shared';
+import { bootstrapMicroservice, buildTransportMS } from '@icore/shared';
 import { AppModule } from './app/app.module';
 
-async function bootstrap() {
-  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
-    AppModule,
-    buildTransportMS('NOTES'),
-  );
-  await app.listen();
-}
-
-bootstrap()
-  .then(() => {
-    const logger = new Logger('Notes-Bootstrap');
-    logger.log(
-      `Notes MS Bootstrap completed: transport=${process.env.NOTES_TRANSPORT ?? 'tcp'} host=${process.env.NOTES_HOST ?? '127.0.0.1'} port=${process.env.NOTES_PORT ?? '4004'}`,
-    );
-  })
-  .catch((err) => {
-    new Logger('Notes-Bootstrap').error(
-      'Notes MS bootstrap failed',
-      err instanceof Error ? err.stack : err,
-    );
-    process.exit(1);
-  });
+void bootstrapMicroservice(
+  'NOTES',
+  () => NestFactory.createMicroservice<MicroserviceOptions>(AppModule, buildTransportMS('NOTES')),
+  new Logger('Notes-Bootstrap'),
+);

package/templates/apps/microservices/payment/project.json

@@ -50,7 +50,8 @@
       "dependsOn": ["build"],
       "options": {
         "buildTarget": "payment:build",
-        "runBuildTargetDependencies": false
+        "runBuildTargetDependencies": false,
+        "port": 9233
       },
       "configurations": {
         "development": {

package/templates/apps/microservices/payment/src/app/app.module.ts

@@ -1,9 +1,16 @@
 import { join } from 'node:path';
-import { Module } from '@nestjs/common';
+import { Module, Logger } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { PaymentRegistry, PaypalStrategy, createPayment } from '@idevconn/payment';
+import { missingEnv, formatEnvBanner } from '@icore/shared';
 import { PaymentController } from './payment.controller';
 
+const ENV_PATH = 'apps/microservices/payment/.env';
+
+const REQUIRED_ENV: Record<string, string[]> = {
+  paypal: ['PAYPAL_CLIENT_ID', 'PAYPAL_CLIENT_SECRET'],
+};
+
 @Module({
   imports: [
     ConfigModule.forRoot({
@@ -19,19 +26,37 @@ import { PaymentController } from './payment.controller';
     {
       provide: PaymentRegistry,
       useFactory: (cfg: ConfigService) => {
-        const provider = cfg.get<string>('PAYMENT_PROVIDER') ?? 'paypal';
-        if (provider === 'paypal') {
-          return createPayment({
-            strategies: {
-              paypal: new PaypalStrategy({
-                clientId: cfg.getOrThrow<string>('PAYPAL_CLIENT_ID'),
-                secret: cfg.getOrThrow<string>('PAYPAL_CLIENT_SECRET'),
-                environment: cfg.get<'sandbox' | 'live'>('PAYPAL_ENVIRONMENT') ?? 'sandbox',
-              }),
-            },
+        const logger = new Logger('PaymentRegistry');
+        const provider = (cfg.get<string>('PAYMENT_PROVIDER') ?? 'paypal').trim();
+        const keys = REQUIRED_ENV[provider];
+        if (!keys) throw new Error(`Unsupported PAYMENT_PROVIDER: ${provider}`);
+
+        const missing = missingEnv((k) => cfg.get<string>(k), keys);
+        if (missing.length > 0) {
+          const banner = formatEnvBanner({
+            service: 'payment MS',
+            provider,
+            missing,
+            envPath: ENV_PATH,
+            headline: `⚠  payment MS — ${provider} credentials missing (payments will fail)`,
           });
+          // Prod: fail fast. Dev: warn + register an EMPTY strategy map so the
+          // MS boots (PaypalStrategy's constructor throws on blank creds, so we
+          // must not instantiate it) — payment endpoints fail until creds are set.
+          if (process.env.NODE_ENV === 'production') throw new Error(banner);
+          logger.warn(banner);
+          return createPayment({ strategies: {} });
         }
-        throw new Error(`Unsupported PAYMENT_PROVIDER: ${provider}`);
+
+        return createPayment({
+          strategies: {
+            paypal: new PaypalStrategy({
+              clientId: cfg.getOrThrow<string>('PAYPAL_CLIENT_ID'),
+              secret: cfg.getOrThrow<string>('PAYPAL_CLIENT_SECRET'),
+              environment: cfg.get<'sandbox' | 'live'>('PAYPAL_ENVIRONMENT') ?? 'sandbox',
+            }),
+          },
+        });
       },
       inject: [ConfigService],
     },

package/templates/apps/microservices/payment/src/main.ts

@@ -1,28 +1,11 @@
 import { Logger } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 import { MicroserviceOptions } from '@nestjs/microservices';
-import { buildTransportMS } from '@icore/shared';
+import { bootstrapMicroservice, buildTransportMS } from '@icore/shared';
 import { AppModule } from './app/app.module';
 
-async function bootstrap() {
-  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
-    AppModule,
-    buildTransportMS('PAYMENT'),
-  );
-  await app.listen();
-}
-
-bootstrap()
-  .then(() => {
-    const logger = new Logger('Payment-Bootstrap');
-    logger.log(
-      `Payment MS Bootstrap completed: transport=${process.env.PAYMENT_TRANSPORT ?? 'tcp'} host=${process.env.PAYMENT_HOST ?? '127.0.0.1'} port=${process.env.PAYMENT_PORT ?? '4003'}`,
-    );
-  })
-  .catch((err) => {
-    new Logger('Payment-Bootstrap').error(
-      'Payment MS bootstrap failed',
-      err instanceof Error ? err.stack : err,
-    );
-    process.exit(1);
-  });
+void bootstrapMicroservice(
+  'PAYMENT',
+  () => NestFactory.createMicroservice<MicroserviceOptions>(AppModule, buildTransportMS('PAYMENT')),
+  new Logger('Payment-Bootstrap'),
+);

package/templates/apps/microservices/upload/package.json

@@ -3,12 +3,12 @@
   "version": "0.0.1",
   "private": true,
   "dependencies": {
+    "@icore/firebase-admin": "*",
     "@icore/shared": "*",
     "@icore/storage-cloudinary": "*",
     "@icore/storage-firebase": "*",
     "@icore/storage-supabase": "*",
     "cloudinary": "^2.0.0",
-    "firebase-admin": "^13.0.0",
     "@nestjs/common": "^11.1.24",
     "@nestjs/config": "^4.0.4",
     "@nestjs/core": "^11.1.24",

package/templates/apps/microservices/upload/project.json

@@ -50,7 +50,8 @@
       "dependsOn": ["build"],
       "options": {
         "buildTarget": "upload:build",
-        "runBuildTargetDependencies": false
+        "runBuildTargetDependencies": false,
+        "port": 9231
       },
       "configurations": {
         "development": {