@idevconn/create-icore 0.7.2 → 0.9.0

package/dist/manifest/audit.js

@@ -0,0 +1,122 @@
+// src/manifest/audit.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".nx"]);
+async function walk(dir, out = []) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      if (!IGNORE_DIRS.has(e.name)) await walk(join(dir, e.name), out);
+    } else if (/\.(ts|tsx|mjs)$/.test(e.name)) {
+      out.push(join(dir, e.name));
+    }
+  }
+  return out;
+}
+async function tsconfigAliases(dir) {
+  try {
+    const raw = await readFile(join(dir, "tsconfig.base.json"), "utf8");
+    const aliases = /* @__PURE__ */ new Set();
+    for (const m of raw.matchAll(/"(@icore\/[a-z0-9.-]+)"\s*:/g)) {
+      if (m[1]) aliases.add(m[1]);
+    }
+    return aliases;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+var PROVIDER_SDKS = {
+  supabase: ["@supabase/supabase-js"],
+  cloudinary: ["cloudinary"],
+  mongodb: ["mongoose"],
+  firebase: ["firebase-admin", "@icore/firebase-admin"]
+};
+async function readBlueprint(dir) {
+  try {
+    return JSON.parse(await readFile(join(dir, "blueprint.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function forbiddenFromBlueprint(bp) {
+  const chosen = new Set(
+    [bp.authProvider, bp.dbProvider, bp.upload].filter((p) => Boolean(p))
+  );
+  const forbidden = [];
+  for (const [provider, sdks] of Object.entries(PROVIDER_SDKS)) {
+    if (!chosen.has(provider)) forbidden.push(...sdks);
+  }
+  return forbidden;
+}
+async function allPackageJsons(dir) {
+  const out = [];
+  const root = join(dir, "package.json");
+  out.push(root);
+  async function walk2(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!IGNORE_DIRS.has(e.name)) await walk2(join(d, e.name));
+      } else if (e.name === "package.json") {
+        out.push(join(d, e.name));
+      }
+    }
+  }
+  await walk2(join(dir, "apps"));
+  return out;
+}
+async function depKeys(pkgPath) {
+  try {
+    const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    return /* @__PURE__ */ new Set([
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {})
+    ]);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+var ICORE_IMPORT = /(?:from|import\()\s*['"](@icore\/[a-z0-9.-]+)/g;
+async function auditProject(dir, opts = {}) {
+  const violations = [];
+  const aliases = await tsconfigAliases(dir);
+  for (const file of await walk(dir)) {
+    const src = await readFile(file, "utf8");
+    for (const m of src.matchAll(ICORE_IMPORT)) {
+      const alias = m[1];
+      if (alias && !aliases.has(alias)) {
+        violations.push({
+          kind: "import-of-absent-lib",
+          detail: `${file} imports ${alias} (no tsconfig path \u2192 lib absent)`
+        });
+      }
+    }
+  }
+  const bp = await readBlueprint(dir);
+  const forbidden = /* @__PURE__ */ new Set([
+    ...opts.forbiddenDeps ?? [],
+    ...bp ? forbiddenFromBlueprint(bp) : []
+  ]);
+  if (forbidden.size > 0) {
+    for (const pkgPath of await allPackageJsons(dir)) {
+      const deps = await depKeys(pkgPath);
+      for (const f of forbidden) {
+        if (deps.has(f)) {
+          violations.push({
+            kind: "forbidden-dep",
+            detail: `${pkgPath} keeps forbidden dep ${f}`
+          });
+        }
+      }
+    }
+  }
+  return violations;
+}
+export {
+  auditProject
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idevconn/create-icore",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Bootstrap a new project from the iCore scaffold (Nx + NestJS + React + Vite + shadcn/Tailwind, swappable auth + storage providers).",
   "license": "Apache-2.0",
   "author": "iDEVconn",

package/templates/apps/api/src/app/app.module.ts

@@ -6,9 +6,7 @@ import { AuthModule } from './auth/auth.module';
 import { ProfileModule } from './profile/profile.module';
 import { AbilitiesModule } from './abilities/abilities.module';
 import { StorageModule } from './storage/storage.module';
-import { PaymentModule } from './payment/payment.module';
-import { NotesModule } from './notes/notes.module';
-import { AdminModule } from './admin/admin.module';
+import { FeaturesModule } from './features.module';
 
 @Module({
   imports: [
@@ -21,9 +19,7 @@ import { AdminModule } from './admin/admin.module';
     AbilitiesModule,
     ProfileModule,
     StorageModule,
-    PaymentModule,
-    NotesModule,
-    AdminModule,
+    FeaturesModule,
   ],
 })
 export class AppModule {}

package/templates/apps/api/src/app/features.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { NotesModule } from './notes/notes.module';
+import { PaymentModule } from './payment/payment.module';
+import { AdminModule } from './admin/admin.module';
+
+@Module({
+  imports: [NotesModule, PaymentModule, AdminModule],
+})
+export class FeaturesModule {}

package/templates/apps/api/src/app/gateway-services.ts

@@ -0,0 +1,7 @@
+/** Microservices the gateway proxies. Generated by create-icore. */
+export const GATEWAY_SERVICES = [
+  { name: 'auth', prefix: 'AUTH' },
+  { name: 'upload', prefix: 'UPLOAD' },
+  { name: 'notes', prefix: 'NOTES' },
+  { name: 'payment', prefix: 'PAYMENT' },
+];

package/templates/apps/api/src/main.ts

@@ -5,13 +5,9 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import cookieParser from 'cookie-parser';
 import { formatGatewayBanner } from '@icore/shared';
 import { AppModule } from './app/app.module';
+import { GATEWAY_SERVICES } from './app/gateway-services';
 import pkg from '@icore/package.json';
 
-const GATEWAY_SERVICES = [
-  { name: 'auth', prefix: 'AUTH' },
-  { name: 'upload', prefix: 'UPLOAD' },
-];
-
 const DEFAULT_PORT = 3001;
 
 async function bootstrap() {

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

@@ -1,54 +1,8 @@
 import { join } from 'node:path';
-import { Module, Logger } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { createClient } from '@supabase/supabase-js';
-import { SupabaseAuthStrategy } from '@icore/auth-supabase';
-import { MongoDbAuthStrategy } from '@icore/auth-mongodb';
-import { FirebaseAuthStrategy, HttpIdentityToolkitClient } from '@icore/auth-firebase';
-import { getFirebaseAdmin, FIREBASE_ADMIN_REQUIRED_ENV } from '@icore/firebase-admin';
-import { MongooseModule, getConnectionToken } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-import { FakeAuthStrategy, missingEnv, formatEnvBanner } from '@icore/shared';
-import type { AuthStrategy } from '@icore/shared';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
 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'],
-  mongodb: ['MONGODB_URI', 'JWT_SECRET'],
-};
-
-function requireEnv(cfg: ConfigService, key: string): string {
-  return cfg.getOrThrow<string>(key);
-}
-
-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: app.auth(),
-  });
-}
-
-function makeMongoDbAuth(connection: Connection, cfg: ConfigService): AuthStrategy {
-  return new MongoDbAuthStrategy({
-    connection,
-    jwtSecret: requireEnv(cfg, 'JWT_SECRET'),
-  });
-}
+import { AuthProviderModule } from './auth.provider';
 
 @Module({
   imports: [
@@ -59,51 +13,8 @@ function makeMongoDbAuth(connection: Connection, cfg: ConfigService): AuthStrate
         join(process.cwd(), '.env'),
       ],
     }),
-    MongooseModule.forRootAsync({
-      useFactory: (cfg: ConfigService) => ({
-        uri: cfg.get<string>('MONGODB_URI'),
-      }),
-      inject: [ConfigService],
-    }),
+    AuthProviderModule,
   ],
   controllers: [AuthController],
-  providers: [
-    {
-      provide: 'AuthStrategy',
-      useFactory: (cfg: ConfigService, connection: Connection): 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 {
-          if (provider === 'supabase') return makeSupabaseAuth(cfg);
-          if (provider === 'mongodb') return makeMongoDbAuth(connection, cfg);
-          return makeFirebaseAuth(cfg);
-        } catch (err) {
-          // Vars present but invalid (e.g. placeholder URL the SDK rejects).
-          return fallback(err instanceof Error ? err.message : String(err));
-        }
-      },
-      inject: [ConfigService, getConnectionToken()],
-    },
-  ],
 })
 export class AppModule {}

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

@@ -0,0 +1,9 @@
+import { SupabaseAuthModule } from '@icore/auth-supabase';
+
+// Auth provider wiring. Selected at scaffold time by create-icore; the committed
+// default is supabase (matches AUTH_PROVIDER=supabase in .env.example). The
+// chosen XAuthModule.forRoot owns construction, required-env, and the
+// dev-fake / prod-fail fallback (see @icore/shared buildStrategyWithFallback).
+const ENV_PATH = 'apps/microservices/auth/.env';
+
+export const AuthProviderModule = SupabaseAuthModule.forRoot(ENV_PATH);

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

@@ -1,50 +1,8 @@
 import { join } from 'node:path';
-import { Module, Logger } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { createClient } from '@supabase/supabase-js';
-import { SupabaseDBStrategy } from '@icore/db-supabase';
-import { MongoDbDBStrategy } from '@icore/db-mongodb';
-import { FirestoreDBStrategy } from '@icore/db-firestore';
-import { getFirebaseAdmin, FIREBASE_ADMIN_REQUIRED_ENV } from '@icore/firebase-admin';
-import { MongooseModule, getConnectionToken } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-import { FakeDBStrategy, missingEnv, formatEnvBanner } from '@icore/shared';
-import type { DBStrategy } from '@icore/shared';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
 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],
-  mongodb: ['MONGODB_URI'],
-};
-
-function requireEnv(cfg: ConfigService, key: string): string {
-  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'],
-  });
-}
-
-function makeMongoDb(connection: Connection): DBStrategy {
-  return new MongoDbDBStrategy({ connection });
-}
+import { DbProviderModule } from './db.provider';
 
 @Module({
   imports: [
@@ -55,48 +13,8 @@ function makeMongoDb(connection: Connection): DBStrategy {
         join(process.cwd(), '.env'),
       ],
     }),
-    MongooseModule.forRootAsync({
-      useFactory: (cfg: ConfigService) => ({
-        uri: cfg.get<string>('MONGODB_URI'),
-      }),
-      inject: [ConfigService],
-    }),
+    DbProviderModule,
   ],
   controllers: [NotesController],
-  providers: [
-    {
-      provide: 'DBStrategy',
-      useFactory: (cfg: ConfigService, connection: Connection): 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 {
-          if (provider === 'supabase') return makeSupabaseDB(cfg);
-          if (provider === 'mongodb') return makeMongoDb(connection);
-          return makeFirestoreDB(cfg);
-        } catch (err) {
-          return fallback(err instanceof Error ? err.message : String(err));
-        }
-      },
-      inject: [ConfigService, getConnectionToken()],
-    },
-  ],
 })
 export class AppModule {}

package/templates/apps/microservices/notes/src/app/db.provider.ts

@@ -0,0 +1,9 @@
+import { SupabaseDbModule } from '@icore/db-supabase';
+
+// DB provider wiring. Selected at scaffold time by create-icore; the committed
+// default is supabase (matches DB_PROVIDER=supabase in .env.example). The chosen
+// XDbModule.forRoot owns construction, required-env, and the dev-fake / prod-fail
+// fallback.
+const ENV_PATH = 'apps/microservices/notes/.env';
+
+export const DbProviderModule = SupabaseDbModule.forRoot(ENV_PATH);

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

@@ -1,103 +1,8 @@
 import { join } from 'node:path';
-import { Module, Logger } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { createClient } from '@supabase/supabase-js';
-import { v2 as cloudinary } from 'cloudinary';
-import { SupabaseStorageStrategy } from '@icore/storage-supabase';
-import { MongoDbStorageStrategy } from '@icore/storage-mongodb';
-import { FirebaseStorageStrategy } from '@icore/storage-firebase';
-import { CloudinaryStorageStrategy, type CloudinaryApiLike } from '@icore/storage-cloudinary';
-import { getFirebaseAdmin, FIREBASE_ADMIN_REQUIRED_ENV } from '@icore/firebase-admin';
-import { MongooseModule, getConnectionToken } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-import { FakeStorageStrategy, missingEnv, formatEnvBanner } from '@icore/shared';
-import type { StorageStrategy } from '@icore/shared';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
 import { StorageController } from './storage.controller';
-
-const ENV_PATH = 'apps/microservices/upload/.env';
-
-const REQUIRED_ENV: Record<string, string[]> = {
-  supabase: ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY', 'SUPABASE_STORAGE_BUCKET'],
-  firebase: [...FIREBASE_ADMIN_REQUIRED_ENV, 'FIREBASE_STORAGE_BUCKET'],
-  cloudinary: ['CLOUDINARY_CLOUD_NAME', 'CLOUDINARY_API_KEY', 'CLOUDINARY_API_SECRET'],
-  mongodb: ['MONGODB_URI'],
-};
-
-function requireEnv(cfg: ConfigService, key: string): string {
-  return cfg.getOrThrow<string>(key);
-}
-
-function makeSupabaseStorage(cfg: ConfigService): StorageStrategy {
-  const client = createClient(
-    requireEnv(cfg, 'SUPABASE_URL'),
-    requireEnv(cfg, 'SUPABASE_SERVICE_ROLE_KEY'),
-    { auth: { autoRefreshToken: false, persistSession: false } },
-  );
-  return new SupabaseStorageStrategy({
-    client,
-    bucket: requireEnv(cfg, 'SUPABASE_STORAGE_BUCKET'),
-  });
-}
-
-function makeFirebaseStorage(cfg: ConfigService): StorageStrategy {
-  const bucketName = requireEnv(cfg, 'FIREBASE_STORAGE_BUCKET');
-  const app = getFirebaseAdmin(cfg);
-  return new FirebaseStorageStrategy({
-    bucket: app
-      .storage()
-      .bucket(bucketName) as unknown as import('@icore/storage-firebase').FirebaseStorageBucketLike,
-  });
-}
-
-function makeCloudinaryStorage(cfg: ConfigService): StorageStrategy {
-  cloudinary.config({
-    cloud_name: requireEnv(cfg, 'CLOUDINARY_CLOUD_NAME'),
-    api_key: requireEnv(cfg, 'CLOUDINARY_API_KEY'),
-    api_secret: requireEnv(cfg, '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',
-  });
-}
-
-function makeMongoDbStorage(connection: Connection): StorageStrategy {
-  return new MongoDbStorageStrategy({ connection });
-}
+import { StorageProviderModule } from './storage.provider';
 
 @Module({
   imports: [
@@ -108,49 +13,8 @@ function makeMongoDbStorage(connection: Connection): StorageStrategy {
         join(process.cwd(), '.env'),
       ],
     }),
-    MongooseModule.forRootAsync({
-      useFactory: (cfg: ConfigService) => ({
-        uri: cfg.get<string>('MONGODB_URI'),
-      }),
-      inject: [ConfigService],
-    }),
+    StorageProviderModule,
   ],
   controllers: [StorageController],
-  providers: [
-    {
-      provide: 'StorageStrategy',
-      useFactory: (cfg: ConfigService, connection: Connection): StorageStrategy => {
-        const logger = new Logger('StorageStrategy');
-        const provider = cfg.get<string>('STORAGE_PROVIDER')?.trim();
-        const keys = provider ? REQUIRED_ENV[provider] : undefined;
-        const missing = keys ? missingEnv((k) => cfg.get<string>(k), keys) : [];
-
-        const fallback = (reason?: string): StorageStrategy => {
-          const banner = formatEnvBanner({
-            service: 'upload MS',
-            provider,
-            missing,
-            envPath: ENV_PATH,
-            reason,
-          });
-          if (process.env.NODE_ENV === 'production') throw new Error(banner);
-          logger.warn(banner);
-          return new FakeStorageStrategy();
-        };
-
-        if (!keys || missing.length > 0) return fallback();
-
-        try {
-          if (provider === 'supabase') return makeSupabaseStorage(cfg);
-          if (provider === 'firebase') return makeFirebaseStorage(cfg);
-          if (provider === 'mongodb') return makeMongoDbStorage(connection);
-          return makeCloudinaryStorage(cfg);
-        } catch (err) {
-          return fallback(err instanceof Error ? err.message : String(err));
-        }
-      },
-      inject: [ConfigService, getConnectionToken()],
-    },
-  ],
 })
 export class AppModule {}

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

@@ -0,0 +1,9 @@
+import { SupabaseStorageModule } from '@icore/storage-supabase';
+
+// Storage provider wiring. Selected at scaffold time by create-icore; the
+// committed default is supabase (matches STORAGE_PROVIDER=supabase in
+// .env.example). The chosen XStorageModule.forRoot owns construction,
+// required-env, and the dev-fake / prod-fail fallback.
+const ENV_PATH = 'apps/microservices/upload/.env';
+
+export const StorageProviderModule = SupabaseStorageModule.forRoot(ENV_PATH);

package/templates/apps/templates/client-antd/src/components/layout/LayoutSider.tsx

@@ -3,41 +3,33 @@ import { Layout, Menu, type MenuProps } from 'antd';
 import { DashboardOutlined, FileTextOutlined, UserOutlined } from '@ant-design/icons';
 import { Link, useRouterState } from '@tanstack/react-router';
 import { useTranslation } from 'react-i18next';
+import type { ReactNode } from 'react';
+import { NAV_CONFIG, type NavItem } from '@/nav.config';
+
+const ICONS: Record<NavItem['iconName'], ReactNode> = {
+  dashboard: <DashboardOutlined />,
+  notes: <FileTextOutlined />,
+  profile: <UserOutlined />,
+};
 
 export function LayoutSider() {
   const { t } = useTranslation();
   const [collapsed, setCollapsed] = useState(false);
   const pathname = useRouterState({ select: (s) => s.location.pathname });
 
-  const selectedKey = pathname.includes('/notes')
-    ? 'notes'
-    : pathname.includes('/profile')
-      ? 'profile'
-      : 'dashboard';
+  const selected = NAV_CONFIG.find((n) => pathname.includes(n.to))?.to ?? '/dashboard';
 
-  const items: MenuProps['items'] = [
-    {
-      key: 'dashboard',
-      icon: <DashboardOutlined />,
-      label: <Link to="/dashboard">{t('nav.dashboard')}</Link>,
-    },
-    {
-      key: 'notes',
-      icon: <FileTextOutlined />,
-      label: <Link to="/notes">{t('notes.title')}</Link>,
-    },
-    {
-      key: 'profile',
-      icon: <UserOutlined />,
-      label: <Link to="/profile">{t('nav.profile')}</Link>,
-    },
-  ];
+  const items: MenuProps['items'] = NAV_CONFIG.map((n) => ({
+    key: n.to,
+    icon: ICONS[n.iconName],
+    label: <Link to={n.to}>{t(n.labelKey)}</Link>,
+  }));
 
   return (
     <Layout.Sider collapsible collapsed={collapsed} onCollapse={setCollapsed}>
       <Menu
         mode="inline"
-        selectedKeys={[selectedKey]}
+        selectedKeys={[selected]}
         items={items}
         style={{ height: '100%', borderRight: 0 }}
       />

package/templates/apps/templates/client-antd/src/nav.config.ts

@@ -0,0 +1,17 @@
+/**
+ * Sidebar navigation. UI-agnostic: each LayoutSider maps `iconName` to its own
+ * icon library. Generated by create-icore from a base (dashboard + profile) plus
+ * the chosen features' contributions (e.g. notes when example=notes).
+ */
+export interface NavItem {
+  to: string;
+  labelKey: string;
+  iconName: 'dashboard' | 'notes' | 'profile';
+  exact?: boolean;
+}
+
+export const NAV_CONFIG: NavItem[] = [
+  { to: '/dashboard', labelKey: 'nav.dashboard', iconName: 'dashboard', exact: true },
+  { to: '/notes', labelKey: 'nav.notes', iconName: 'notes' },
+  { to: '/profile', labelKey: 'nav.profile', iconName: 'profile' },
+];