coregen-cli 3.1.6__py3-none-any.whl

generators/static/templates/home/screen_template.jinja

@@ -0,0 +1,12 @@
+import 'package:flutter/material.dart';
+
+class [[screen_name]]Screen extends StatelessWidget {
+  const [[screen_name]]Screen({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return const Center(
+      child: Text('[[screen_title]] Page'),
+    );
+  }
+}

generators/static/templates/injection_template.jinja

@@ -0,0 +1,8 @@
+import 'package:[[project_name]]/injection.config.dart';
+import 'package:get_it/get_it.dart';
+import 'package:injectable/injectable.dart';
+
+final GetIt getIt = GetIt.instance;
+
+@InjectableInit()
+Future<void> configureDependencies(String env) async => getIt.init(environment: env);

generators/static/templates/logging/analytics_logging_template.jinja

@@ -0,0 +1,42 @@
+/*
+ * Analytics logging integration for production monitoring
+ * Implements LoggingIntegration for external analytics services:
+ * - Placeholder for analytics service integration
+ * - Different handling per log level
+ * - Ready for services like Firebase Analytics, Crashlytics, etc.
+ *
+ * Customize the switch cases to integrate with your
+ * preferred analytics and crash reporting services
+ */
+
+import 'package:[[project_name]]/logging/logger.dart';
+
+class AnalyticsLoggingIntegration implements LoggingIntegration {
+  const AnalyticsLoggingIntegration();
+
+{% raw %}
+  @override
+  void log(String message, LoggerLevel level, {dynamic ex, dynamic st}) async {
+    switch (level) {
+      case LoggerLevel.fatal:
+        // TODO: recordFatal($message, error: $ex, stack: $st);
+        break;
+      case LoggerLevel.error:
+        // TODO: recordError($message, error: $ex, stack: $st);
+        break;
+      case LoggerLevel.warning:
+        break;
+      case LoggerLevel.info:
+        break;
+      case LoggerLevel.verbose:
+        break;
+      case LoggerLevel.success:
+        break;
+      case LoggerLevel.apiReq:
+        break;
+      case LoggerLevel.apiRes:
+        break;
+    }
+  }
+{% endraw %}
+}

generators/static/templates/logging/console_template.jinja

@@ -0,0 +1,50 @@
+/*
+ * Console logging integration for development
+ * Implements LoggingIntegration for console output with:
+ * - Colored console output for different log levels
+ * - The [message] argument already includes prefix and body; for error/fatal the
+ *   [Logger] appends exception and stack trace so one $message line is enough here.
+ *
+ * Perfect for development and debugging scenarios
+ * with color-coded messages for easy identification
+ */
+
+import 'dart:developer' as developer;
+
+import 'package:[[project_name]]/logging/logger.dart';
+
+class ConsoleLoggingIntegration implements LoggingIntegration {
+  const ConsoleLoggingIntegration();
+
+{% raw %}
+  @override
+  void log(String message, LoggerLevel level, {dynamic ex, dynamic st}) {
+    switch (level) {
+      case LoggerLevel.fatal:
+        developer.log('\x1B[31m$message\x1B[0m');
+        break;
+      case LoggerLevel.error:
+        developer.log('\x1B[91m$message\x1B[0m');
+        break;
+      case LoggerLevel.warning:
+        developer.log('\x1B[33m$message\x1B[0m');
+        break;
+      case LoggerLevel.info:
+        developer.log('\x1B[37m$message\x1B[0m');
+        break;
+      case LoggerLevel.verbose:
+        developer.log('\x1B[34m$message\x1B[0m');
+        break;
+      case LoggerLevel.success:
+        developer.log('\x1B[32m$message\x1B[0m');
+        break;
+      case LoggerLevel.apiReq:
+        developer.log('\x1B[93m$message\x1B[0m');
+        break;
+      case LoggerLevel.apiRes:
+        developer.log('\x1B[32m$message\x1B[0m');
+        break;
+    }
+  }
+{% endraw %}
+}

generators/static/templates/logging/logger_injectable_module_template.jinja

@@ -0,0 +1,24 @@
+/*
+ * Logger dependency injection module
+ * Registers logging integrations with Injectable:
+ * - Analytics logging integration
+ * - Console logging integration
+ * - Configurable list of logging backends
+ * 
+ * This module makes logging integrations available
+ * throughout the app via dependency injection
+ */
+
+import 'package:injectable/injectable.dart';
+import 'package:[[project_name]]/logging/analytics_logging.dart';
+import 'package:[[project_name]]/logging/console.dart';
+import 'package:[[project_name]]/logging/logger.dart';
+
+@module
+abstract class RegisterModule {
+  @lazySingleton
+  List<LoggingIntegration> get loggingIntegrations => <LoggingIntegration>[
+        const AnalyticsLoggingIntegration(),
+        const ConsoleLoggingIntegration(),
+      ];
+}

generators/static/templates/logging/logger_template.jinja

@@ -0,0 +1,118 @@
+/*
+ * Centralized logger template for application-wide logging
+ * Provides structured logging with:
+ * - Multiple log levels (verbose, info, warning, error, etc.)
+ * - Pluggable logging integrations (console, analytics, etc.)
+ * - Dependency injection support
+ * - Consistent logging interface across the app
+ *
+ * For error/fatal, the text passed to integrations includes $message plus
+ * optional lines for $ex and $st when provided.
+ */
+
+import 'package:injectable/injectable.dart';
+
+enum LoggerLevel {
+  verbose,
+  info,
+  warning,
+  error,
+  fatal,
+  success,
+  apiReq,
+  apiRes,
+}
+
+abstract class LoggingIntegration {
+  void log(String message, LoggerLevel level, {dynamic ex, dynamic st});
+}
+
+@injectable
+class Logger {
+  Logger(this._integrations);
+
+  final List<LoggingIntegration> _integrations;
+
+  void logVerbose(String message) {
+    _log(message, LoggerLevel.verbose);
+  }
+
+  void logInfo(String message) {
+    _log(message, LoggerLevel.info);
+  }
+
+  void logWarning(String message) {
+    _log(message, LoggerLevel.warning);
+  }
+
+  void logSuccess(String message) {
+    _log(message, LoggerLevel.success);
+  }
+
+  void logError(String message, {dynamic ex, dynamic st}) {
+    _log(message, LoggerLevel.error, ex: ex, st: st);
+  }
+
+  void logFatal(String message, {dynamic ex, dynamic st}) {
+    _log(message, LoggerLevel.fatal, ex: ex, st: st);
+  }
+
+  void logApiReq(String message) {
+    _log(message, LoggerLevel.apiReq);
+  }
+
+  void logApiRes(String message) {
+    _log(message, LoggerLevel.apiRes);
+  }
+
+{% raw %}
+  void _log(String message, LoggerLevel level, {dynamic ex, dynamic st}) {
+    final StringBuffer buffer = StringBuffer();
+    final String prefix = _getLogPrefix(level);
+    if (prefix.isNotEmpty) {
+      buffer.write(prefix);
+      buffer.write(' ');
+    }
+    buffer.write(message);
+
+    if (level == LoggerLevel.error || level == LoggerLevel.fatal) {
+      if (ex != null) {
+        buffer.writeln();
+        buffer.write('Exception: $ex');
+      }
+      if (st != null) {
+        buffer.writeln();
+        buffer.write('StackTrace: $st');
+      }
+    }
+
+    final String finalMessage = buffer.toString();
+
+    for (final LoggingIntegration integration in _integrations) {
+      integration.log(finalMessage, level, ex: ex, st: st);
+    }
+  }
+{% endraw %}
+
+  // Returns the log prefix for the given LoggingLevel
+  String _getLogPrefix(LoggerLevel level) {
+    switch (level) {
+      case LoggerLevel.verbose:
+        return "[Verbose]";
+      case LoggerLevel.info:
+        return "[Info]";
+      case LoggerLevel.warning:
+        return "[Warning]";
+      case LoggerLevel.error:
+        return "[Error]";
+      case LoggerLevel.fatal:
+        return "[Fatal error]";
+      case LoggerLevel.success:
+        return "[Done]";
+      case LoggerLevel.apiReq:
+        return "[API Request]";
+      case LoggerLevel.apiRes:
+        return "[API Response]";
+    }
+  }
+}

generators/static/templates/main_template.jinja

@@ -0,0 +1,43 @@
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart';
+import 'package:injectable/injectable.dart';
+import 'package:intl/date_symbol_data_local.dart';
+import 'package:[[project_name]]/apis/common/constants.dart';
+import 'package:[[project_name]]/apis/common/data_source_config.dart';
+import 'package:[[project_name]]/injection.dart';
+import 'package:[[project_name]]/core/presentation/app_widget.dart';
+
+Future<void> main() async {
+  CaravaggioUI.initialize(
+    primaryColor: const [[primary_color]], // From coregen.yaml styling.primary_color
+    secondaryColor: const [[secondary_color]] // From coregen.yaml styling.secondary_color
+    // fontFamily: 'Noto Sans', // Uncomment and set your desired font family
+  );
+
+  WidgetsFlutterBinding.ensureInitialized();
+  await initializeDateFormatting('en_US');
+
+  initEnvironment();
+  validateDataSources();
+
+  await configureDependencies(Environment.dev);
+
+  runApp(const AppWidget());
+}
+
+void initEnvironment() {
+  // Mock-only default: leave [Constants.apiUrl] empty — no backend required.
+  // Set a real URL only when switching entities to DataSource.remote in
+  // lib/apis/common/data_source_config.dart.
+  Constants.apiUrl = '';
+
+  // Optional per-environment overrides (uncomment when API is ready):
+  // const String environment = String.fromEnvironment('ENV', defaultValue: 'local');
+  // if (environment.toLowerCase() == 'production') {
+  //   Constants.apiUrl = 'https://api.example.com';
+  // }
+}
+
+void validateDataSources() {
+  DataSourceConfig.validateRemoteRequiresApiUrl();
+}

generators/static/templates/page_template.jinja

@@ -0,0 +1,29 @@
+/*
+ * Simple page template for Flutter screens
+ * Generates a basic StatelessWidget page with:
+ * - CustomScaffold with page title
+ * - Centered content placeholder
+ * - Route name constant for navigation
+ * Use this template for creating simple, static pages
+ */
+
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart';
+import 'package:[[project_name]]/widgets/common/custom_scaffold.dart';
+
+class [[page_name|title]]Page extends StatelessWidget {
+  static const String routeName = '/[[page_name]]';
+
+  const [[page_name|title]]Page({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return CustomScaffold(
+      title: CText.title('[[page_name|replace("_", " ")|title]]', size: TextSize.small),
+      showBackButton: true,
+      body: Center(
+        child: CText.body('[[page_name|replace("_", " ")|title]] Page'),
+      ),
+    );
+  }
+}

generators/static/templates/router_template.jinja

@@ -0,0 +1,26 @@
+{% if has_login %}
+import 'package:[[project_name]]/features/auth/presentation/login_page.dart';
+{% endif %}
+import 'package:[[project_name]]/features/home/home_page.dart';
+import 'package:flutter/material.dart';
+import 'package:[[project_name]]/features/splash/splash_page.dart';
+import 'package:go_router/go_router.dart';
+
+final GoRouter router = GoRouter(
+  routes: <RouteBase>[
+{% if has_login %}
+    GoRoute(
+        path: LoginPage.routeName,
+        builder: (BuildContext context, GoRouterState state) => const LoginPage(),
+    ),
+{% endif %}
+    GoRoute(
+      path: HomePage.routeName,
+      builder: (BuildContext context, GoRouterState state) => const HomePage(),
+    ),
+    GoRoute(
+      path: SplashPage.routeName,
+      builder: (BuildContext context, GoRouterState state) => const SplashPage(),
+    ),
+  ],
+);

generators/static/templates/splash/presentation/splash_screen_auth_template.jinja

@@ -0,0 +1,97 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:[[project_name]]/features/auth/application/auth_bloc.dart';
+import 'package:[[project_name]]/features/auth/presentation/login_page.dart';
+import 'package:[[project_name]]/features/home/home_page.dart';
+import 'package:[[project_name]]/widgets/common/custom_scaffold.dart';
+import 'package:go_router/go_router.dart';
+
+class SplashPage extends StatefulWidget {
+  static const String routeName = '/';
+
+  const SplashPage({super.key});
+
+  @override
+  State<SplashPage> createState() => _SplashPageState();
+}
+
+class _SplashPageState extends State<SplashPage> {
+  static const Duration _splashMinDuration = Duration(seconds: 1);
+
+  bool _minDelayElapsed = false;
+  bool _hasNavigated = false;
+  AuthState? _resolvedAuthState;
+  int _animation = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      setState(() {
+        _animation = 1;
+      });
+    });
+    Future<void>.delayed(_splashMinDuration, () {
+      if (!mounted) {
+        return;
+      }
+      setState(() {
+        _minDelayElapsed = true;
+      });
+      _tryNavigate();
+    });
+  }
+
+  void _onAuthStateChanged(AuthState state) {
+    if (_hasNavigated) {
+      return;
+    }
+    if (state is Authenticated || state is Unauthenticated) {
+      _resolvedAuthState = state;
+      _tryNavigate();
+    }
+  }
+
+  void _tryNavigate() {
+    if (_hasNavigated || _resolvedAuthState == null) {
+      return;
+    }
+
+    final AuthState state = _resolvedAuthState!;
+
+    if (state is Authenticated) {
+      _hasNavigated = true;
+      context.replace(HomePage.routeName);
+      return;
+    }
+
+    if (state is Unauthenticated && _minDelayElapsed) {
+      _hasNavigated = true;
+      context.pushReplacement(LoginPage.routeName);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return BlocListener<AuthBloc, AuthState>(
+      listener: (BuildContext context, AuthState state) => _onAuthStateChanged(state),
+      child: CustomScaffold(
+        showBackButton: false,
+        body: Center(
+          child: Hero(
+            tag: LoginPage.logoHeroTag,
+            child: Material(
+              type: MaterialType.transparency,
+              child: AnimatedContainer(
+                duration: const Duration(seconds: 1),
+                curve: Curves.easeInOut,
+                width: _animation == 1 ? 200 : 100,
+                child: Image.asset('assets/logo.png'),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}

generators/static/templates/splash/presentation/splash_screen_template.jinja

@@ -0,0 +1,51 @@
+/*
+ * Splash screen template for app initialization
+ * Creates an initial loading screen that:
+ * - Shows app logo or branding
+ * - Performs initialization tasks
+ * - Automatically navigates to home screen after delay
+ * - Provides smooth app startup experience
+ * 
+ * Perfect for app startup, loading assets, or initialization processes
+ */
+
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:[[project_name]]/features/home/home_page.dart';
+import 'package:[[project_name]]/widgets/common/custom_scaffold.dart';
+
+class SplashPage extends StatefulWidget {
+  static const String routeName = '/';
+
+  const SplashPage({super.key});
+
+  @override
+  State<SplashPage> createState() => _SplashPageState();
+}
+
+class _SplashPageState extends State<SplashPage> {
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      // After 500 milliseconds, navigate to the next screen
+      Future<void>.delayed(const Duration(milliseconds: 500), () {
+        // Navigate to the next screen or perform any action here
+        context.replace(HomePage.routeName);
+      });
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return CustomScaffold(
+      showBackButton: false,
+      body: Center(
+        child: SizedBox(
+          width: 200,
+          child: Image.asset('assets/logo.png'),
+        ),
+      ),
+    );
+  }
+}

generators/static/templates/storage/storage_repository_template.jinja

@@ -0,0 +1,80 @@
+import 'package:injectable/injectable.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+const String tokenDataKey = 'token_key';
+const String refreshTokenDataKey = 'refresh_token_key';
+const String guestTokenKey = 'guest_token_key';
+const String isGuestModeKey = 'is_guest_mode_key';
+
+/// Access + optional refresh token bundle (used by [AuthInterceptor] after refresh).
+class TokenData {
+  const TokenData({required this.token, this.refreshToken = ''});
+
+  final String token;
+  final String refreshToken;
+
+  bool get hasRefresh => refreshToken.isNotEmpty;
+}
+
+@Singleton()
+class StorageRepository {
+  Future<bool> hasToken() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    final String? token = prefs.getString(tokenDataKey);
+    return token != null && token.isNotEmpty;
+  }
+
+  /// Persists access token and optional refresh token (SharedPreferences — consider flutter_secure_storage for production).
+  Future<void> saveToken(TokenData data) async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.setString(tokenDataKey, data.token);
+    await prefs.setString(refreshTokenDataKey, data.refreshToken);
+  }
+
+  Future<String?> getToken() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    return prefs.getString(tokenDataKey);
+  }
+
+  Future<String?> getRefreshToken() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    return prefs.getString(refreshTokenDataKey);
+  }
+
+  Future<void> removeToken() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.remove(tokenDataKey);
+    await prefs.remove(refreshTokenDataKey);
+  }
+
+  Future<void> saveGuestToken(String guestToken) async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.setString(guestTokenKey, guestToken);
+    await prefs.setBool(isGuestModeKey, true);
+    await prefs.remove(tokenDataKey);
+    await prefs.remove(refreshTokenDataKey);
+  }
+
+  Future<String?> getGuestToken() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    return prefs.getString(guestTokenKey);
+  }
+
+  Future<bool> isGuestMode() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(isGuestModeKey) ?? false;
+  }
+
+  Future<void> clearGuestToken() async {
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.remove(guestTokenKey);
+    await prefs.remove(isGuestModeKey);
+  }
+
+  Future<void> clearAll() async {
+    await removeToken();
+    await clearGuestToken();
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+    await prefs.clear();
+  }
+}

generators/static/templates/user_profile/infrastructure/user_profile_dto_template.jinja

@@ -0,0 +1,27 @@
+/*
+ * UserProfile DTO (Data Transfer Object)
+ * Used for API communication when syncing UserProfile with backend
+ * 
+ * DTOs represent the data structure expected by the API
+ * and are mapped to/from domain entities via UserProfileMapper
+ */
+
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'user_profile_dto.freezed.dart';
+part 'user_profile_dto.g.dart';
+
+@freezed
+abstract class UserProfileDto with _$UserProfileDto {
+  const factory UserProfileDto({
+    required String id,
+    required String name,
+    required String emailAddress,
+    @JsonKey(name: 'avatar_url') String? avatarUrl,
+    @JsonKey(name: 'created_at') required String createdAt,
+    @JsonKey(name: 'updated_at') required String updatedAt,
+  }) = _UserProfileDto;
+
+  factory UserProfileDto.fromJson(Map<String, dynamic> json) =>
+      _$UserProfileDtoFromJson(json);
+}

generators/static/templates/user_profile/infrastructure/user_profile_mapper_template.jinja

@@ -0,0 +1,43 @@
+/*
+ * UserProfile mapper
+ * Maps between UserProfile DTO (API layer) and UserProfile Domain Entity
+ * 
+ * Extends BaseMapper which provides default toDomainList/toDtoList implementations.
+ */
+
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import 'package:[[project_name]]/core/infrastructure/base_mapper.dart';
+import 'package:[[project_name]]/core/model/value_objects.dart';
+import 'package:[[project_name]]/domain/auth/model/value_objects.dart';
+import 'package:[[project_name]]/domain/user_profile/infrastructure/user_profile_dto.dart';
+import 'package:[[project_name]]/domain/user_profile/model/user_profile.dart';
+
+@lazySingleton
+class UserProfileMapper extends BaseMapper<UserProfile, UserProfileDto> {
+  UserProfileMapper();
+
+  @override
+  UserProfile toDomain(UserProfileDto dto) {
+    return UserProfile(
+      id: UniqueId.fromUniqueString(dto.id),
+      name: StringSingleLine(dto.name),
+      emailAddress: EmailAddress(dto.emailAddress),
+      avatarUrl: dto.avatarUrl != null ? some(dto.avatarUrl!) : none(),
+      createdAt: DateTime.parse(dto.createdAt),
+      updatedAt: DateTime.parse(dto.updatedAt),
+    );
+  }
+
+  @override
+  UserProfileDto toDto(UserProfile entity) {
+    return UserProfileDto(
+      id: entity.id.getOrCrash(),
+      name: entity.name.getOrCrash(),
+      emailAddress: entity.emailAddress.getOrCrash(),
+      avatarUrl: entity.avatarUrl.fold(() => null, (String url) => url),
+      createdAt: entity.createdAt.toIso8601String(),
+      updatedAt: entity.updatedAt.toIso8601String(),
+    );
+  }
+}