awesome-dart-auth

import 'package:awesome_dart_auth/awesome_dart_auth.dart';
import 'package:shelf/shelf.dart';
import 'package:shelf/shelf_io.dart' as shelf_io;

Future<void> main() async {
  final config = AuthConfig.development(jwtSecret: 'your-secret-here');

  final router = AuthRouter(
    config: config,
    authService: AuthService(
      config: config,
      userStore: myUserStore,
      sessionStore: mySessionStore,
    ),
    // Optional: supply side-effect callbacks to enable full auth flows
    callbacks: AuthCallbacks(
      onForgotPassword: (user, token) async {
        await mailer.send(user.email, 'Reset your password', token);
      },
      onMagicLinkSend: (user, token) async {
        await mailer.send(user.email, 'Your magic link', token);
      },
      onMagicLinkVerify: (token, mode) async {
        return await tokenStore.verify(token); // returns userId or null
      },
    ),
  );

  // Add CSRF middleware for Angular web clients
  final handler = const Pipeline()
      .addMiddleware(csrfMiddleware(apiBasePath: '/auth'))
      .addHandler(router.handler);

  final server = await shelf_io.serve(handler, 'localhost', 8080);
  print('Listening on http://localhost:${server.port}');
}

final config = AuthConfig(
  jwtSecret: 'your-secret',          // JWT signing secret
  issuer: 'https://auth.example.com',
  accessTokenTtl: Duration(minutes: 15),
  refreshTokenTtl: Duration(days: 30),
  sessionCheckOn: SessionCheckOn.refresh, // allCalls | refresh | none
  cookieSecure: true,                // Set false for local HTTP
  cookieSameSite: 'lax',
  cookiePrefix: '__Host-',           // Optional: __Host- or __Secure-
  uiConfig: {'theme': 'dark'},       // Returned by GET /auth/ui/config
  enableIdpMode: true,               // Expose OIDC discovery, JWKS, userinfo, token
  oauthProviders: {'google', 'github'},
);

class PostgresUserStore implements UserStore {
  @override
  Future<AuthUser?> findByEmail(String email) async { /* … */ }

  @override
  Future<AuthUser?> findById(String id) async { /* … */ }

  @override
  Future<AuthUser> save(AuthUser user) async { /* … */ }

  @override
  Future<AuthUser> update(AuthUser user) async { /* … */ }

  @override
  Future<void> delete(String id) async { /* … */ }
}

final router = AuthRouter(
  config: config,
  authService: service,
  callbacks: AuthCallbacks(
    onRegister: (user) async {
      await sendWelcomeEmail(user.email);
      return user;
    },
    onForgotPassword: (user, token) async {
      final link = 'https://myapp.com/reset-password?token=$token';
      await mailer.send(user.email, 'Reset your password', link);
    },
    onMagicLinkSend: (user, token) async {
      await mailer.send(user.email, 'Your magic link', token);
    },
    onMagicLinkVerify: (token, mode) async {
      return await magicLinkStore.verify(token); // userId or null
    },
    onSmsSend: (user, otp) async {
      await smsClient.send(user.phoneNumber!, 'Your OTP: $otp');
    },
    onSmsVerify: (user, code) async {
      return await otpStore.verify(user.id, code);
    },
    onOAuthStart: (provider, redirectUri) async {
      return oauthClient.authorizationUrl(provider, redirectUri);
    },
    onOAuthCallback: (provider, code, redirectUri) async {
      return await oauthClient.handleCallback(provider, code, redirectUri);
    },
  ),
);

final handler = const Pipeline()
    .addMiddleware(
      csrfMiddleware(
        apiBasePath: '/auth',
        cookieSecure: true,      // false for local HTTP development
        cookieSameSite: 'lax',
      ),
    )
    .addHandler(router.handler);

final tools = AuthTools(
  sse: mySseDistributor,
  notificationService: NotificationService(
    email: MailerConfig(
      endpoint: 'https://mailer.example.com/send',
      apiKey: 'mailer-key',
      fromAddress: 'no-reply@example.com',
    ),
    sms: SmsConfig(
      endpoint: 'https://sms.example.com/send',
      apiKey: 'sms-key',
    ),
  ),
  userStore: myUserStore,
  eventBus: myBus,
);

// SSE only (default)
await tools.notify('user:123', type: 'ping', data: {'msg': 'Hello!'});

// Email + SSE
await tools.notify(
  'user:123',
  type: 'subscription_expiring',
  data: {'days': 3},
  userId: '123',
  channels: [NotifyChannel.sse, NotifyChannel.email],
  emailSubject: 'Your subscription expires soon',
);

// Track a domain event
await tools.track('identity.auth.login.success', userId: 'user-123');

final bus = InMemoryAuthEventBus();

// Subscribe
bus.subscribe().listen((event) {
  print('Event: ${event.type} for user ${event.userId}');
});

// Publish
await bus.publish(AuthEvent(
  type: 'identity.auth.login.success',
  occurredAt: DateTime.now().toUtc(),
  userId: 'user-123',
));

final auth = AuthClient(AuthOptions(
  apiPrefix: 'http://your-server/auth',
));
await auth.checkSession();
final result = await auth.login(LoginRequest(
  email: 'alice@example.com',
  password: 'secret123',
));