@nik2208/node-auth 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nik2208
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,636 @@
+# node-auth
+
+A production-ready, **database-agnostic** JWT authentication library for Node.js written in TypeScript. Compatible with any Node.js framework (NestJS, Next.js, Express, Fastify, etc.) and any database through a simple interface pattern.
+
+## Features
+
+- 🔐 **JWT Authentication** – Access & refresh token pair management with HttpOnly cookies
+- 🏠 **Local Strategy** – Email/password authentication with bcrypt hashing
+- 🔄 **OAuth 2.0** – Extensible Google & GitHub OAuth strategies
+- 🪄 **Magic Links** – Passwordless email authentication
+- 📱 **SMS OTP** – Phone number verification codes
+- 🔑 **TOTP 2FA** – Time-based one-time passwords (Google Authenticator compatible)
+- 🗃️ **Database Agnostic** – Implement a simple interface to use any database
+- 🧩 **Strategy Pattern** – Plug in only the auth methods you need
+- 🛡️ **Middleware** – Express-compatible JWT verification middleware
+- 🚀 **Express Router** – Drop-in `/auth` router with all endpoints
+
+## Installation
+
+```bash
+npm install node-auth
+```
+
+## Quick Start
+
+```typescript
+import express from 'express';
+import { AuthConfigurator } from 'node-auth';
+import { myUserStore } from './my-user-store'; // Your IUserStore implementation
+
+const app = express();
+app.use(express.json());
+
+const auth = new AuthConfigurator(
+  {
+    accessTokenSecret: process.env.ACCESS_TOKEN_SECRET!,
+    refreshTokenSecret: process.env.REFRESH_TOKEN_SECRET!,
+    accessTokenExpiresIn: '15m',
+    refreshTokenExpiresIn: '7d',
+  },
+  myUserStore
+);
+
+// Mount the auth router at /auth
+app.use('/auth', auth.router());
+
+// Protect routes
+app.get('/protected', auth.middleware(), (req, res) => {
+  res.json({ user: req.user });
+});
+
+app.listen(3000);
+```
+
+## Database Integration — Implementing IUserStore
+
+The library is **completely database-agnostic**. The only coupling point to your database is the
+`IUserStore` interface. Implement it once for your DB and pass the instance to `AuthConfigurator`.
+
+### Interface contract
+
+```typescript
+import { IUserStore, BaseUser } from 'node-auth';
+
+export class MyUserStore implements IUserStore {
+  // ---- Required: core CRUD ---------------------------------------------------
+
+  /** Find a user by email address (used for login, magic link, password reset). */
+  async findByEmail(email: string): Promise<BaseUser | null> { /* ... */ }
+
+  /** Find a user by primary key (used for token refresh, 2FA, SMS). */
+  async findById(id: string): Promise<BaseUser | null> { /* ... */ }
+
+  /** Create a new user (used by OAuth strategies when user doesn't exist yet). */
+  async create(data: Partial<BaseUser>): Promise<BaseUser> { /* ... */ }
+
+  // ---- Required: token field updates ----------------------------------------
+
+  async updateRefreshToken(userId: string, token: string | null, expiry: Date | null): Promise<void> { /* ... */ }
+  async updateResetToken(userId: string, token: string | null, expiry: Date | null): Promise<void> { /* ... */ }
+  async updatePassword(userId: string, hashedPassword: string): Promise<void> { /* ... */ }
+  async updateTotpSecret(userId: string, secret: string | null): Promise<void> { /* ... */ }
+  async updateMagicLinkToken(userId: string, token: string | null, expiry: Date | null): Promise<void> { /* ... */ }
+  async updateSmsCode(userId: string, code: string | null, expiry: Date | null): Promise<void> { /* ... */ }
+
+  // ---- Optional: token look-ups (required for specific features) ------------
+
+  /**
+   * Required for: POST /auth/reset-password
+   * Find a user whose `resetToken` field matches the given token.
+   */
+  async findByResetToken(token: string): Promise<BaseUser | null> { /* ... */ }
+
+  /**
+   * Required for: POST /auth/magic-link/verify
+   * Find a user whose `magicLinkToken` field matches the given token.
+   */
+  async findByMagicLinkToken(token: string): Promise<BaseUser | null> { /* ... */ }
+}
+```
+
+### Ready-to-use example implementations
+
+The `examples/` directory contains complete implementations for the most common databases and frameworks:
+
+| File | Description |
+|------|-------------|
+| `examples/in-memory-user-store.ts` | In-memory store — ideal for testing and prototyping |
+| `examples/sqlite-user-store.example.ts` | `better-sqlite3` store — production-ready SQL example |
+| `examples/mysql-user-store.example.ts` | `mysql2` store — MySQL / MariaDB example |
+| `examples/mongodb-user-store.example.ts` | `mongodb` store — MongoDB example |
+| `examples/nestjs-integration.example.ts` | NestJS module, guard, controller and DI integration |
+| `examples/nextjs-integration.example.ts` | Next.js App Router & Pages Router integration |
+
+Copy the relevant file(s) into your project and adapt the schema to your needs.
+
+**In-memory store (testing/prototyping):**
+```typescript
+import { InMemoryUserStore } from './examples/in-memory-user-store';
+const userStore = new InMemoryUserStore();
+const auth = new AuthConfigurator(config, userStore);
+```
+
+**SQLite with `better-sqlite3`:**
+```typescript
+import Database from 'better-sqlite3';
+import { SqliteUserStore } from './examples/sqlite-user-store.example';
+
+const db = new Database('app.db');
+db.pragma('journal_mode = WAL');
+db.pragma('foreign_keys = ON');
+
+const userStore = new SqliteUserStore(db); // creates the `users` table automatically
+const auth = new AuthConfigurator(config, userStore);
+```
+
+**MySQL / MariaDB with `mysql2`:**
+```typescript
+import mysql from 'mysql2/promise';
+import { MySqlUserStore } from './examples/mysql-user-store.example';
+
+const pool = mysql.createPool({
+  host:     process.env.DB_HOST,
+  user:     process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  database: process.env.DB_NAME,
+});
+
+const userStore = new MySqlUserStore(pool);
+await userStore.init(); // creates the `users` table automatically
+const auth = new AuthConfigurator(config, userStore);
+```
+
+**MongoDB with the `mongodb` driver:**
+```typescript
+import { MongoClient } from 'mongodb';
+import { MongoDbUserStore } from './examples/mongodb-user-store.example';
+
+const client = new MongoClient(process.env.MONGODB_URI!);
+await client.connect();
+
+const userStore = new MongoDbUserStore(client.db('myapp'));
+await userStore.init(); // creates indexes automatically
+const auth = new AuthConfigurator(config, userStore);
+```
+
+**PostgreSQL (example skeleton):**
+```typescript
+import { Pool } from 'pg';
+import { IUserStore, BaseUser } from 'node-auth';
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+export class PgUserStore implements IUserStore {
+  async findByEmail(email: string) {
+    const { rows } = await pool.query('SELECT * FROM users WHERE email=$1', [email]);
+    return rows[0] ?? null;
+  }
+  async findById(id: string) {
+    const { rows } = await pool.query('SELECT * FROM users WHERE id=$1', [id]);
+    return rows[0] ?? null;
+  }
+  // ... implement remaining methods
+}
+```
+
+
+## Framework Integration
+
+### NestJS
+
+See `examples/nestjs-integration.example.ts` for a full working example that includes:
+
+- **`AuthModule.forRoot()`** — NestJS DynamicModule wrapping `AuthConfigurator`
+- **`JwtAuthGuard`** — NestJS `CanActivate` guard backed by `auth.middleware()`
+- **`@CurrentUser()`** — parameter decorator that extracts `req.user`
+- **`AuthController`** — catch-all controller that forwards `/auth/*` traffic to `auth.router()`
+
+```typescript
+// app.module.ts
+import { AuthModule } from './auth.module';
+import { MyUserStore } from './my-user-store';
+
+@Module({
+  imports: [
+    AuthModule.forRoot({
+      config:    authConfig,
+      userStore: new MyUserStore(),
+    }),
+  ],
+})
+export class AppModule {}
+
+// Protect a route
+@Controller('profile')
+export class ProfileController {
+  @Get()
+  @UseGuards(JwtAuthGuard)
+  getProfile(@CurrentUser() user: BaseUser) {
+    return user;
+  }
+}
+```
+
+### Next.js
+
+See `examples/nextjs-integration.example.ts` for a full working example that covers both the **App Router** (Next.js 13+) and the legacy **Pages Router**.
+
+**Pages Router (simplest approach):**
+
+```typescript
+// pages/api/auth/[...auth].ts
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { getAuth } from '../../lib/auth';
+
+export const config = { api: { bodyParser: false } };
+
+export default function handler(req: NextApiRequest, res: NextApiResponse) {
+  const router = getAuth().router();
+  req.url = req.url!.replace(/^\/api\/auth/, '') || '/';
+  router(req as any, res as any, () => res.status(404).end());
+}
+```
+
+**Protecting a Server Component (App Router):**
+
+```typescript
+// app/dashboard/page.tsx
+import { cookies } from 'next/headers';
+import { redirect } from 'next/navigation';
+import { TokenService } from 'node-auth';
+import { authConfig } from '../../lib/auth';
+
+export default async function DashboardPage() {
+  const token = cookies().get('access_token')?.value;
+  if (!token) redirect('/login');
+
+  const payload = new TokenService().verifyAccessToken(token, authConfig);
+  if (!payload) redirect('/login');
+
+  return <div>Welcome, {payload.email}!</div>;
+}
+```
+
+## Auth Router Endpoints
+
+When you mount `auth.router()`, the following endpoints are available:
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `POST` | `/auth/login` | Login with email/password |
+| `POST` | `/auth/logout` | Logout and clear cookies |
+| `POST` | `/auth/refresh` | Refresh access token |
+| `GET` | `/auth/me` | Get current user (protected) |
+| `POST` | `/auth/forgot-password` | Send password reset email |
+| `POST` | `/auth/reset-password` | Reset password with token |
+| `POST` | `/auth/2fa/setup` | Get TOTP secret + QR code (protected) |
+| `POST` | `/auth/2fa/verify-setup` | Verify TOTP code and enable 2FA (protected) |
+| `POST` | `/auth/2fa/verify` | Complete 2FA login |
+| `POST` | `/auth/2fa/disable` | Disable 2FA (protected) |
+| `POST` | `/auth/magic-link/send` | Send magic link email |
+| `POST` | `/auth/magic-link/verify` | Verify magic link token |
+| `POST` | `/auth/sms/send` | Send SMS verification code |
+| `POST` | `/auth/sms/verify` | Verify SMS code |
+| `GET` | `/auth/oauth/google` | Initiate Google OAuth |
+| `GET` | `/auth/oauth/google/callback` | Google OAuth callback |
+| `GET` | `/auth/oauth/github` | Initiate GitHub OAuth |
+| `GET` | `/auth/oauth/github/callback` | GitHub OAuth callback |
+
+## Configuration
+
+```typescript
+import { AuthConfig } from 'node-auth';
+
+const config: AuthConfig = {
+  // Required
+  accessTokenSecret: process.env.ACCESS_TOKEN_SECRET!,
+  refreshTokenSecret: process.env.REFRESH_TOKEN_SECRET!,
+
+  // Token lifetimes (default: 15m / 7d)
+  accessTokenExpiresIn: '15m',
+  refreshTokenExpiresIn: '7d',
+
+  // Cookie options
+  cookieOptions: {
+    secure: true,       // HTTPS only (recommended in production)
+    sameSite: 'lax',
+    domain: 'yourdomain.com',
+  },
+
+  // bcrypt salt rounds (default: 12)
+  bcryptSaltRounds: 12,
+
+  // Email — see "Mailer Configuration" section below
+  email: {
+    siteUrl: 'https://yourapp.com',
+    mailer: {
+      endpoint: process.env.MAILER_ENDPOINT!,   // HTTP POST endpoint
+      apiKey:   process.env.MAILER_API_KEY!,
+      from:     'noreply@yourapp.com',
+      fromName: 'My App',
+      defaultLang: 'en',                         // 'en' or 'it'
+    },
+  },
+
+  // SMS (for OTP verification codes)
+  sms: {
+    endpoint:             'https://sms.example.com/sendsms',
+    apiKey:               process.env.SMS_API_KEY!,
+    username:             process.env.SMS_USERNAME!,
+    password:             process.env.SMS_PASSWORD!,
+    codeExpiresInMinutes: 10,
+  },
+
+  // OAuth
+  oauth: {
+    google: {
+      clientId:     process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+      callbackUrl:  'https://yourapp.com/auth/oauth/google/callback',
+    },
+    github: {
+      clientId:     process.env.GITHUB_CLIENT_ID!,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+      callbackUrl:  'https://yourapp.com/auth/oauth/github/callback',
+    },
+  },
+
+  // 2FA app name shown in authenticator apps
+  twoFactor: {
+    appName: 'My App',
+  },
+};
+```
+
+## Mailer Configuration
+
+The library ships a built-in **HTTP mailer transport** (`MailerService`) that sends transactional
+emails (password reset, magic links, welcome) via an HTTP POST to any configurable endpoint — no
+SMTP required. Built-in templates are available in **English** (`en`) and **Italian** (`it`).
+
+### Option A — Built-in HTTP mailer transport (recommended)
+
+Configure `email.mailer` in `AuthConfig`. The library will automatically send emails using the
+built-in templates whenever a reset link or magic link needs to go out.
+
+```typescript
+import { AuthConfig, MailerConfig } from 'node-auth';
+
+const config: AuthConfig = {
+  // ...jwt secrets, cookies...
+  email: {
+    siteUrl: 'https://yourapp.com',
+    mailer: {
+      /** Full URL of your mailer API endpoint. Receives a JSON POST. */
+      endpoint:    process.env.MAILER_ENDPOINT!,   // e.g. 'https://api.mailgun.net/v3/...'
+      /** API key sent as the X-API-Key request header. */
+      apiKey:      process.env.MAILER_API_KEY!,
+      /** Sender address. */
+      from:        'noreply@yourapp.com',
+      /** Sender display name (optional). */
+      fromName:    'My App',
+      /**
+       * Default language for built-in templates.
+       * Supported: 'en' (default) | 'it'
+       * Can be overridden per-request by passing emailLang in the request body.
+       */
+      defaultLang: 'en',
+    },
+  },
+};
+```
+
+The mailer sends a **POST** request to `endpoint` with the following JSON body:
+
+```json
+{
+  "to":       "user@example.com",
+  "from":     "noreply@yourapp.com",
+  "fromName": "My App",
+  "subject":  "Reset your password",
+  "html":     "<p>Click the link...</p>",
+  "text":     "Click the link..."
+}
+```
+
+and the header `X-API-Key: <apiKey>`.
+
+Your mailer API (Mailgun, Resend, SendGrid, a custom proxy, etc.) only needs to accept this JSON
+shape and forward it to the email provider. The content-type is `application/json`.
+
+#### Per-request language override
+
+For `POST /auth/forgot-password` and `POST /auth/magic-link/send`, pass `emailLang` in the request
+body to override `defaultLang` for a single request:
+
+```json
+{ "email": "user@example.com", "emailLang": "it" }
+```
+
+#### Using `MailerService` directly
+
+```typescript
+import { MailerService } from 'node-auth';
+
+const mailer = new MailerService({
+  endpoint:    'https://mailer.example.com/send',
+  apiKey:      'key-xxx',
+  from:        'noreply@example.com',
+  defaultLang: 'it',
+});
+
+await mailer.sendPasswordReset(to, token, resetLink, 'it');
+await mailer.sendMagicLink(to, token, magicLink);
+await mailer.sendWelcome(to, { loginUrl: 'https://yourapp.com/login', tempPassword: 'Temp@123' }, 'it');
+```
+
+### Option B — Custom callbacks
+
+If you prefer full control, provide callback functions instead of (or in addition to) `mailer`.
+**Callbacks always take precedence over the `mailer` transport.**
+
+```typescript
+email: {
+  siteUrl: 'https://yourapp.com',
+  sendPasswordReset: async (to, token, link, lang) => {
+    await myEmailClient.send({ to, subject: 'Reset your password', html: `...${link}...` });
+  },
+  sendMagicLink: async (to, token, link, lang) => {
+    await myEmailClient.send({ to, subject: 'Your sign-in link', html: `...${link}...` });
+  },
+  sendWelcome: async (to, data, lang) => {
+    await myEmailClient.send({ to, subject: 'Welcome!', html: `...${data.loginUrl}...` });
+  },
+},
+```
+
+
+## OAuth Strategies
+
+OAuth strategies are abstract—extend them to implement your own user lookup logic:
+
+```typescript
+import { GoogleStrategy, BaseUser, AuthConfig } from 'node-auth';
+
+class MyGoogleStrategy extends GoogleStrategy<BaseUser> {
+  constructor(config: AuthConfig, private userStore: MyUserStore) {
+    super(config);
+  }
+
+  async findOrCreateUser(profile: { id: string; email: string; name?: string; picture?: string }) {
+    let user = await this.userStore.findByEmail(profile.email);
+    if (!user) {
+      user = await this.userStore.create({ email: profile.email, role: 'user' });
+    }
+    return user;
+  }
+}
+
+// Pass to router
+app.use('/auth', auth.router({
+  googleStrategy: new MyGoogleStrategy(config, userStore),
+  githubStrategy: new MyGithubStrategy(config, userStore),
+}));
+```
+
+## Using Services Directly
+
+Access the underlying services for custom flows:
+
+```typescript
+const auth = new AuthConfigurator(config, userStore);
+
+// Hash passwords
+const hash = await auth.passwordService.hash('mypassword');
+const valid = await auth.passwordService.compare('mypassword', hash);
+
+// Generate/verify tokens
+const tokens = auth.tokenService.generateTokenPair({ sub: userId, email }, config);
+const payload = auth.tokenService.verifyAccessToken(token, config);
+
+// Get a local strategy instance
+const localStrategy = auth.strategy('local');
+const user = await localStrategy.authenticate({ email, password }, config);
+```
+
+## Using Strategies Independently
+
+```typescript
+import {
+  MagicLinkStrategy,
+  SmsStrategy,
+  TotpStrategy,
+  LocalStrategy,
+  PasswordService,
+} from 'node-auth';
+
+// Magic Links
+const magicLink = new MagicLinkStrategy();
+await magicLink.sendMagicLink(email, userStore, config);
+const user = await magicLink.verify(token, userStore);
+
+// SMS OTP
+const sms = new SmsStrategy();
+await sms.sendCode(phone, userId, userStore, config);
+const valid = await sms.verify(userId, code, userStore);
+
+// TOTP 2FA
+const totpStrategy = new TotpStrategy();
+const { secret, otpauthUrl, qrCode } = totpStrategy.generateSecret(email, 'MyApp');
+const qrDataUrl = await qrCode; // data:image/png;base64,...
+const isValid = await totpStrategy.verify(token, secret);
+```
+
+## BaseUser Model
+
+```typescript
+interface BaseUser {
+  id: string;
+  email: string;
+  password?: string;
+  role?: string;
+  refreshToken?: string | null;
+  refreshTokenExpiry?: Date | null;
+  resetToken?: string | null;
+  resetTokenExpiry?: Date | null;
+  totpSecret?: string | null;
+  isTotpEnabled?: boolean;
+  magicLinkToken?: string | null;
+  magicLinkTokenExpiry?: Date | null;
+  smsCode?: string | null;
+  smsCodeExpiry?: Date | null;
+  phoneNumber?: string | null;
+}
+```
+
+## Error Handling
+
+The library throws `AuthError` for authentication failures:
+
+```typescript
+import { AuthError } from 'node-auth';
+
+try {
+  await localStrategy.authenticate({ email, password }, config);
+} catch (err) {
+  if (err instanceof AuthError) {
+    console.log(err.code);       // e.g. 'INVALID_CREDENTIALS'
+    console.log(err.statusCode); // e.g. 401
+    console.log(err.message);    // e.g. 'Invalid credentials'
+  }
+}
+```
+
+## Custom Strategies
+
+Extend `BaseAuthStrategy` to create custom authentication strategies:
+
+```typescript
+import { BaseAuthStrategy, AuthConfig } from 'node-auth';
+
+class ApiKeyStrategy extends BaseAuthStrategy<{ apiKey: string }, MyUser> {
+  name = 'api-key';
+
+  async authenticate(input: { apiKey: string }, config: AuthConfig): Promise<MyUser> {
+    const user = await myStore.findByApiKey(input.apiKey);
+    if (!user) throw new AuthError('Invalid API key', 'INVALID_API_KEY', 401);
+    return user;
+  }
+}
+```
+
+## Rate Limiting
+
+Auth routes should be rate-limited in production to prevent brute-force attacks. Pass an optional `rateLimiter` middleware to `createAuthRouter()`:
+
+```typescript
+import rateLimit from 'express-rate-limit';
+
+const limiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 20 });
+
+app.use('/auth', auth.router({ rateLimiter: limiter }));
+```
+
+All sensitive endpoints (login, refresh, password reset, 2FA, magic links, SMS) will be protected.
+
+## Building
+
+```bash
+npm run build
+```
+
+## Testing
+
+```bash
+npm test
+npm run test:coverage
+```
+
+## Architecture
+
+```
+src/
+├── interfaces/          # IUserStore, ITokenStore, IAuthStrategy
+├── models/              # BaseUser, TokenPair, AuthConfig, AuthError
+├── abstract/            # BaseAuthStrategy, BaseOAuthStrategy
+├── strategies/          # Local, Google, GitHub, MagicLink, SMS, TOTP
+├── services/            # TokenService, PasswordService, SmsService
+├── middleware/          # createAuthMiddleware()
+├── router/              # createAuthRouter() – full Express router
+└── auth-configurator.ts # Main entry point
+```
+
+## License
+
+MIT

package/dist/abstract/base-auth-strategy.abstract.d.ts

@@ -0,0 +1,7 @@
+import { AuthConfig } from '../models/auth-config.model';
+import { BaseUser } from '../models/user.model';
+export declare abstract class BaseAuthStrategy<TInput = unknown, TUser = BaseUser> {
+    abstract name: string;
+    abstract authenticate(input: TInput, config: AuthConfig): Promise<TUser>;
+}
+//# sourceMappingURL=base-auth-strategy.abstract.d.ts.map

package/dist/abstract/base-auth-strategy.abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-auth-strategy.abstract.d.ts","sourceRoot":"","sources":["../../src/abstract/base-auth-strategy.abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,8BAAsB,gBAAgB,CAAC,MAAM,GAAG,OAAO,EAAE,KAAK,GAAG,QAAQ;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC;CACzE"}

package/dist/abstract/base-auth-strategy.abstract.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAuthStrategy = void 0;
+class BaseAuthStrategy {
+}
+exports.BaseAuthStrategy = BaseAuthStrategy;
+//# sourceMappingURL=base-auth-strategy.abstract.js.map

package/dist/abstract/base-auth-strategy.abstract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-auth-strategy.abstract.js","sourceRoot":"","sources":["../../src/abstract/base-auth-strategy.abstract.ts"],"names":[],"mappings":";;;AAGA,MAAsB,gBAAgB;CAGrC;AAHD,4CAGC"}