@idevconn/create-icore 0.1.0

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

@@ -0,0 +1,60 @@
+import { Controller, Inject, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MessagePattern, Payload } from '@nestjs/microservices';
+import type { AuthSession, AuthStrategy, VerifiedToken } from '@icore/shared';
+
+@Controller()
+export class AuthController {
+  private readonly logger = new Logger(AuthController.name);
+
+  constructor(
+    @Inject('AuthStrategy') private readonly strategy: AuthStrategy,
+    private readonly cfg: ConfigService,
+  ) {}
+
+  @MessagePattern('auth.verify')
+  verify(@Payload() payload: { token: string }): Promise<VerifiedToken> {
+    return this.strategy.verifyToken(payload.token);
+  }
+
+  @MessagePattern('auth.login')
+  login(@Payload() payload: { email: string; password: string }): Promise<AuthSession> {
+    return this.strategy.signIn(payload.email, payload.password);
+  }
+
+  @MessagePattern('auth.signup')
+  async signup(@Payload() payload: { email: string; password: string }): Promise<AuthSession> {
+    const session = await this.strategy.signUp(payload.email, payload.password);
+    await this.assignInitialRole(session.user.id, session.user.email);
+    return session;
+  }
+
+  @MessagePattern('auth.refresh')
+  refresh(@Payload() payload: { refreshToken: string }): Promise<AuthSession> {
+    return this.strategy.refresh(payload.refreshToken);
+  }
+
+  @MessagePattern('auth.setRole')
+  setRole(@Payload() payload: { uid: string; role: string }): Promise<void> {
+    return this.strategy.setRole(payload.uid, payload.role);
+  }
+
+  // Idempotent: skips work when a role already exists. Admin emails come
+  // from ADMINS_LIST (comma-separated). Everyone else gets 'user'.
+  private async assignInitialRole(uid: string, email: string): Promise<void> {
+    const existing = await this.strategy.getRole(uid);
+    if (existing) {
+      this.logger.log(`Role already set for ${uid}: ${existing} — skipping`);
+      return;
+    }
+
+    const admins = (this.cfg.get<string>('ADMINS_LIST') ?? '')
+      .split(',')
+      .map((e) => e.trim().toLowerCase())
+      .filter((e) => e.length > 0);
+
+    const role = admins.includes(email.toLowerCase()) ? 'admin' : 'user';
+    await this.strategy.setRole(uid, role);
+    this.logger.log(`Assigned role '${role}' to ${uid} (${email})`);
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Logger } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { MicroserviceOptions } from '@nestjs/microservices';
+import { 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);
+  });

package/templates/apps/microservices/auth/tsconfig.app.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "types": ["node"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "target": "es2021"
+  },
+  "include": ["src/**/*.ts"]
+}

package/templates/apps/microservices/auth/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}

package/templates/apps/microservices/auth/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node", "vitest"]
+  },
+  "include": [
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.d.ts"
+  ]
+}

package/templates/apps/microservices/auth/vitest.config.mts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../../node_modules/.vite/apps/microservices/auth',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'auth',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../../coverage/apps/microservices/auth',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/templates/apps/microservices/auth/webpack.config.js

@@ -0,0 +1,25 @@
+const { NxAppWebpackPlugin } = require('@nx/webpack/app-plugin');
+const { join } = require('path');
+
+module.exports = {
+  output: {
+    path: join(__dirname, '../../../dist/apps/microservices/auth'),
+    clean: true,
+    ...(process.env.NODE_ENV !== 'production' && {
+      devtoolModuleFilenameTemplate: '[absolute-resource-path]',
+    }),
+  },
+  plugins: [
+    new NxAppWebpackPlugin({
+      target: 'node',
+      compiler: 'tsc',
+      main: './src/main.ts',
+      tsConfig: './tsconfig.app.json',
+      assets: ['./src/assets'],
+      optimization: false,
+      outputHashing: 'none',
+      generatePackageJson: true,
+      sourceMap: true,
+    }),
+  ],
+};

package/templates/apps/microservices/upload/.env.example

@@ -0,0 +1,30 @@
+# Transport (gateway ↔ this MS) — TCP by default; flip to redis or nats in prod
+UPLOAD_TRANSPORT=tcp
+UPLOAD_HOST=127.0.0.1
+UPLOAD_PORT=4002
+# UPLOAD_REDIS_URL=redis://localhost:6379
+# UPLOAD_NATS_URL=nats://localhost:4222
+
+# Which concrete StorageStrategy to instantiate
+STORAGE_PROVIDER=supabase
+# STORAGE_PROVIDER=firebase
+# STORAGE_PROVIDER=cloudinary
+
+# --- Supabase credentials (when STORAGE_PROVIDER=supabase) ---
+SUPABASE_URL=https://<your-project-ref>.supabase.co
+SUPABASE_SERVICE_ROLE_KEY=eyJ...
+SUPABASE_STORAGE_BUCKET=icore-uploads
+
+# --- Firebase Cloud Storage credentials (when STORAGE_PROVIDER=firebase) ---
+FB_ADMIN_TYPE=service_account
+FB_ADMIN_PROJECT_ID=<your-project-id>
+FB_ADMIN_PRIVATE_KEY='-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n'
+FB_ADMIN_CLIENT_EMAIL=firebase-adminsdk-<hash>@<project-id>.iam.gserviceaccount.com
+FIREBASE_STORAGE_BUCKET=<project-id>.appspot.com
+
+# --- Cloudinary credentials (when STORAGE_PROVIDER=cloudinary) ---
+CLOUDINARY_CLOUD_NAME=<your-cloud-name>
+CLOUDINARY_API_KEY=<key>
+CLOUDINARY_API_SECRET=<secret>
+# Synthetic StorageRef.bucket value (Cloudinary has no buckets). Optional, defaults to "cloudinary".
+# CLOUDINARY_BUCKET_TAG=icore-uploads

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

@@ -0,0 +1,21 @@
+{
+  "name": "upload",
+  "version": "0.0.1",
+  "private": true,
+  "dependencies": {
+    "@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",
+    "@nestjs/microservices": "^11.1.24",
+    "@supabase/supabase-js": "^2.106.2",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
+    "tslib": "^2.3.0"
+  }
+}

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

@@ -0,0 +1,65 @@
+{
+  "name": "upload",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "apps/microservices/upload/src",
+  "projectType": "application",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "webpack-cli build",
+        "args": ["--node-env=production"],
+        "cwd": "apps/microservices/upload"
+      },
+      "configurations": {
+        "development": {
+          "args": ["--node-env=development"]
+        }
+      }
+    },
+    "prune-lockfile": {
+      "dependsOn": ["build"],
+      "cache": true,
+      "executor": "@nx/js:prune-lockfile",
+      "outputs": [
+        "{workspaceRoot}/dist/apps/microservices/upload/package.json",
+        "{workspaceRoot}/dist/apps/microservices/upload/yarn.lock"
+      ],
+      "options": {
+        "buildTarget": "build"
+      }
+    },
+    "copy-workspace-modules": {
+      "dependsOn": ["build"],
+      "cache": true,
+      "outputs": ["{workspaceRoot}/dist/apps/microservices/upload/workspace_modules"],
+      "executor": "@nx/js:copy-workspace-modules",
+      "options": {
+        "buildTarget": "build"
+      }
+    },
+    "prune": {
+      "dependsOn": ["prune-lockfile", "copy-workspace-modules"],
+      "executor": "nx:noop"
+    },
+    "serve": {
+      "continuous": true,
+      "executor": "@nx/js:node",
+      "defaultConfiguration": "development",
+      "dependsOn": ["build"],
+      "options": {
+        "buildTarget": "upload:build",
+        "runBuildTargetDependencies": false
+      },
+      "configurations": {
+        "development": {
+          "buildTarget": "upload:build:development"
+        },
+        "production": {
+          "buildTarget": "upload:build:production"
+        }
+      }
+    }
+  },
+  "tags": []
+}

package/templates/apps/microservices/upload/src/app/__tests__/storage.controller.unit.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { FakeStorageStrategy } from '@icore/shared';
+import { StorageController } from '../storage.controller';
+
+const fixture = () => {
+  const strategy = new FakeStorageStrategy();
+  return { strategy, controller: new StorageController(strategy) };
+};
+
+const file = (filename = 'hello.txt') => ({
+  buffer: Buffer.from('hello world').toString('base64'),
+  filename,
+  mimeType: 'text/plain',
+});
+
+describe('StorageController', () => {
+  it('upload returns a StorageRef under the user prefix', async () => {
+    const { controller } = fixture();
+    const ref = await controller.upload({ userId: 'user-1', file: file() });
+    expect(ref.path.startsWith('user-1/')).toBe(true);
+  });
+
+  it('list returns previously uploaded files for the same user', async () => {
+    const { controller } = fixture();
+    await controller.upload({ userId: 'user-2', file: file() });
+    const refs = await controller.list({ userId: 'user-2' });
+    expect(refs.length).toBe(1);
+  });
+
+  it('signedUrl returns a non-empty string', async () => {
+    const { controller } = fixture();
+    const ref = await controller.upload({ userId: 'user-3', file: file() });
+    const url = await controller.signedUrl({ userId: 'user-3', ref, ttlSec: 60 });
+    expect(url.length).toBeGreaterThan(0);
+  });
+
+  it('remove deletes the file', async () => {
+    const { controller } = fixture();
+    const ref = await controller.upload({ userId: 'user-4', file: file() });
+    await controller.remove({ userId: 'user-4', ref });
+    expect(await controller.list({ userId: 'user-4' })).toEqual([]);
+  });
+
+  it('signedUrl for a foreign user throws', async () => {
+    const { controller } = fixture();
+    const ref = await controller.upload({ userId: 'owner', file: file() });
+    await expect(controller.signedUrl({ userId: 'attacker', ref })).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,117 @@
+import { join } from 'node:path';
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { createClient } from '@supabase/supabase-js';
+import * as admin from 'firebase-admin';
+import { v2 as cloudinary } from 'cloudinary';
+import { SupabaseStorageStrategy } from '@icore/storage-supabase';
+import { FirebaseStorageStrategy } from '@icore/storage-firebase';
+import { CloudinaryStorageStrategy, type CloudinaryApiLike } from '@icore/storage-cloudinary';
+import type { StorageStrategy } from '@icore/shared';
+import { StorageController } from './storage.controller';
+
+function makeFirebaseStorage(cfg: ConfigService): StorageStrategy {
+  const bucketName = cfg.getOrThrow<string>('FIREBASE_STORAGE_BUCKET');
+  if (admin.apps.length === 0) {
+    admin.initializeApp({
+      credential: admin.credential.cert({
+        projectId: cfg.getOrThrow<string>('FB_ADMIN_PROJECT_ID'),
+        clientEmail: cfg.getOrThrow<string>('FB_ADMIN_CLIENT_EMAIL'),
+        privateKey: cfg.getOrThrow<string>('FB_ADMIN_PRIVATE_KEY').replace(/\\n/g, '\n'),
+      }),
+    });
+  }
+  return new FirebaseStorageStrategy({
+    bucket: admin
+      .storage()
+      .bucket(bucketName) as unknown as import('@icore/storage-firebase').FirebaseStorageBucketLike,
+  });
+}
+
+function makeCloudinaryStorage(cfg: ConfigService): StorageStrategy {
+  cloudinary.config({
+    cloud_name: cfg.getOrThrow<string>('CLOUDINARY_CLOUD_NAME'),
+    api_key: cfg.getOrThrow<string>('CLOUDINARY_API_KEY'),
+    api_secret: cfg.getOrThrow<string>('CLOUDINARY_API_SECRET'),
+    secure: true,
+  });
+
+  const api: CloudinaryApiLike = {
+    async upload(buffer, opts) {
+      return new Promise((resolve, reject) => {
+        const stream = cloudinary.uploader.upload_stream(
+          { public_id: opts.public_id, resource_type: opts.resource_type ?? 'raw' },
+          (error, result) => {
+            if (error || !result) reject(error ?? new Error('upload_failed'));
+            else resolve({ public_id: result.public_id, secure_url: result.secure_url });
+          },
+        );
+        stream.end(buffer);
+      });
+    },
+    async destroy(publicId) {
+      await cloudinary.uploader.destroy(publicId);
+    },
+    privateDownloadUrl(publicId, format, opts) {
+      return cloudinary.utils.private_download_url(publicId, format ?? '', opts ?? {});
+    },
+    async resources(opts) {
+      const res = await cloudinary.api.resources({
+        prefix: opts.prefix,
+        type: opts.type ?? 'upload',
+      });
+      return {
+        resources: (res.resources ?? []).map((r: { public_id: string }) => ({
+          public_id: r.public_id,
+        })),
+      };
+    },
+  };
+
+  return new CloudinaryStorageStrategy({
+    api,
+    bucket: cfg.get<string>('CLOUDINARY_BUCKET_TAG') ?? 'cloudinary',
+  });
+}
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      envFilePath: [
+        join(process.cwd(), 'apps/microservices/upload/.env'),
+        join(process.cwd(), '.env'),
+      ],
+    }),
+  ],
+  controllers: [StorageController],
+  providers: [
+    {
+      provide: 'StorageStrategy',
+      useFactory: (cfg: ConfigService): StorageStrategy => {
+        const provider = cfg.getOrThrow<string>('STORAGE_PROVIDER');
+        switch (provider) {
+          case 'supabase': {
+            const client = createClient(
+              cfg.getOrThrow<string>('SUPABASE_URL'),
+              cfg.getOrThrow<string>('SUPABASE_SERVICE_ROLE_KEY'),
+              { auth: { autoRefreshToken: false, persistSession: false } },
+            );
+            return new SupabaseStorageStrategy({
+              client,
+              bucket: cfg.getOrThrow<string>('SUPABASE_STORAGE_BUCKET'),
+            });
+          }
+          case 'firebase':
+            return makeFirebaseStorage(cfg);
+          case 'cloudinary':
+            return makeCloudinaryStorage(cfg);
+          default:
+            throw new Error(`Unsupported STORAGE_PROVIDER: ${provider}`);
+        }
+      },
+      inject: [ConfigService],
+    },
+  ],
+})
+export class AppModule {}

package/templates/apps/microservices/upload/src/app/storage.controller.ts

@@ -0,0 +1,51 @@
+import { Controller, Inject } from '@nestjs/common';
+import { MessagePattern, Payload } from '@nestjs/microservices';
+import type { StorageRef, StorageStrategy } from '@icore/shared';
+
+interface UploadPayload {
+  userId: string;
+  file: { buffer: string; filename: string; mimeType: string };
+}
+
+interface RefPayload {
+  userId: string;
+  ref: StorageRef;
+}
+
+interface SignedUrlPayload extends RefPayload {
+  ttlSec?: number;
+}
+
+interface ListPayload {
+  userId: string;
+  prefix?: string;
+}
+
+@Controller()
+export class StorageController {
+  constructor(@Inject('StorageStrategy') private readonly strategy: StorageStrategy) {}
+
+  @MessagePattern('storage.upload')
+  upload(@Payload() payload: UploadPayload): Promise<StorageRef> {
+    return this.strategy.upload(payload.userId, {
+      buffer: Buffer.from(payload.file.buffer, 'base64'),
+      filename: payload.file.filename,
+      mimeType: payload.file.mimeType,
+    });
+  }
+
+  @MessagePattern('storage.remove')
+  remove(@Payload() payload: RefPayload): Promise<void> {
+    return this.strategy.remove(payload.userId, payload.ref);
+  }
+
+  @MessagePattern('storage.signedUrl')
+  signedUrl(@Payload() payload: SignedUrlPayload): Promise<string> {
+    return this.strategy.getSignedUrl(payload.userId, payload.ref, payload.ttlSec);
+  }
+
+  @MessagePattern('storage.list')
+  list(@Payload() payload: ListPayload): Promise<StorageRef[]> {
+    return this.strategy.list(payload.userId, payload.prefix);
+  }
+}

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

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

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

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "types": ["node"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "target": "es2021"
+  },
+  "include": ["src/**/*.ts"]
+}

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

@@ -0,0 +1,16 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}

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

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node", "vitest"]
+  },
+  "include": [
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.d.ts"
+  ]
+}

package/templates/apps/microservices/upload/vitest.config.mts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../../node_modules/.vite/apps/microservices/upload',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'upload',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    passWithNoTests: true,
+    coverage: {
+      reportsDirectory: '../../../coverage/apps/microservices/upload',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/templates/apps/microservices/upload/webpack.config.js

@@ -0,0 +1,25 @@
+const { NxAppWebpackPlugin } = require('@nx/webpack/app-plugin');
+const { join } = require('path');
+
+module.exports = {
+  output: {
+    path: join(__dirname, '../../../dist/apps/microservices/upload'),
+    clean: true,
+    ...(process.env.NODE_ENV !== 'production' && {
+      devtoolModuleFilenameTemplate: '[absolute-resource-path]',
+    }),
+  },
+  plugins: [
+    new NxAppWebpackPlugin({
+      target: 'node',
+      compiler: 'tsc',
+      main: './src/main.ts',
+      tsConfig: './tsconfig.app.json',
+      assets: ['./src/assets'],
+      optimization: false,
+      outputHashing: 'none',
+      generatePackageJson: true,
+      sourceMap: true,
+    }),
+  ],
+};

package/templates/apps/templates/client-shadcn/.env.example

@@ -0,0 +1,2 @@
+# API base URL — dev server reverse-proxies /api to the gateway
+VITE_API_URL=/api

package/templates/apps/templates/client-shadcn/eslint.config.mjs

@@ -0,0 +1,10 @@
+import baseConfig from '../../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+    // Override or add rules here
+    rules: {},
+  },
+];