@flusys/nestjs-auth 7.0.2 → 7.1.0

package/fesm/controllers/social-auth-config.controller.js

@@ -0,0 +1,97 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { createApiController } from '@flusys/nestjs-shared/classes';
+import { SOCIAL_AUTH_CONFIG_PERMISSIONS } from '@flusys/nestjs-shared/constants';
+import { Controller, Inject } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { CreateSocialAuthConfigDto, SocialAuthConfigResponseDto, UpdateSocialAuthConfigDto } from '../dtos/social-auth.dto';
+import { SocialAuthConfigService } from '../services/social-auth-config.service';
+export class SocialAuthConfigController extends createApiController(CreateSocialAuthConfigDto, UpdateSocialAuthConfigDto, SocialAuthConfigResponseDto, {
+    entityName: 'social.config',
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.CREATE
+            ]
+        },
+        bulkUpsert: {
+            level: 'permission',
+            permissions: [
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.CREATE,
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.UPDATE
+            ],
+            operator: 'AND'
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.READ
+            ]
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                SOCIAL_AUTH_CONFIG_PERMISSIONS.DELETE
+            ]
+        }
+    },
+    enabledEndpoints: [
+        'insert',
+        'bulkUpsert',
+        'getById',
+        'getAll',
+        'update',
+        'delete'
+    ]
+}) {
+    constructor(socialAuthConfigService){
+        super(socialAuthConfigService), _define_property(this, "socialAuthConfigService", void 0), this.socialAuthConfigService = socialAuthConfigService;
+    }
+}
+SocialAuthConfigController = _ts_decorate([
+    ApiTags('Social Auth Config'),
+    Controller('auth/social-config'),
+    _ts_param(0, Inject(SocialAuthConfigService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SocialAuthConfigService === "undefined" ? Object : SocialAuthConfigService
+    ])
+], SocialAuthConfigController);

package/fesm/controllers/social-auth.controller.js

@@ -0,0 +1,165 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseInterceptors } from '@nestjs/common';
+import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { Throttle } from '@nestjs/throttler';
+import { AUTH_MESSAGES, SOCIAL_AUTH_MESSAGES } from '../config';
+import { SocialAuthorizeDto, SocialAuthorizeResponseDto, SocialCallbackDto, SocialProviderInfoDto, SocialProvidersDto } from '../dtos/social-auth.dto';
+import { SetToken } from '../interceptors/set-token.interceptor';
+import { SocialAuthService } from '../services/social-auth.service';
+export class SocialAuthController {
+    async getProviders(dto) {
+        const data = await this.socialAuthService.listEnabledProviders(dto.redirectUri);
+        return {
+            success: true,
+            message: 'Social providers retrieved successfully',
+            messageKey: SOCIAL_AUTH_MESSAGES.PROVIDERS_SUCCESS,
+            data
+        };
+    }
+    async authorize(dto) {
+        const data = await this.socialAuthService.createAuthorization(dto.provider, dto.redirectUri);
+        return {
+            success: true,
+            message: 'Authorization URL generated successfully',
+            messageKey: SOCIAL_AUTH_MESSAGES.AUTHORIZE_SUCCESS,
+            data
+        };
+    }
+    async callback(dto) {
+        const result = await this.socialAuthService.completeLogin(dto.code, dto.state, dto.redirectUri);
+        if ('requiresSelection' in result) {
+            return {
+                success: true,
+                message: 'Company selection required',
+                messageKey: AUTH_MESSAGES.LOGIN_REQUIRES_SELECTION,
+                data: result
+            };
+        }
+        return {
+            success: true,
+            message: 'Login successful',
+            messageKey: SOCIAL_AUTH_MESSAGES.LOGIN_SUCCESS,
+            data: result
+        };
+    }
+    constructor(socialAuthService){
+        _define_property(this, "socialAuthService", void 0);
+        this.socialAuthService = socialAuthService;
+    }
+}
+_ts_decorate([
+    Post('providers'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 30,
+            ttl: 60000
+        }
+    }),
+    ApiOperation({
+        summary: 'List enabled social sign-in providers'
+    }),
+    ApiBody({
+        type: SocialProvidersDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: [
+            SocialProviderInfoDto
+        ]
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SocialProvidersDto === "undefined" ? Object : SocialProvidersDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], SocialAuthController.prototype, "getProviders", null);
+_ts_decorate([
+    Post('authorize'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 10,
+            ttl: 60000
+        }
+    }),
+    ApiOperation({
+        summary: "Start a sign-in and get the provider's consent URL"
+    }),
+    ApiBody({
+        type: SocialAuthorizeDto
+    }),
+    ApiResponse({
+        status: 200,
+        type: SocialAuthorizeResponseDto
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SocialAuthorizeDto === "undefined" ? Object : SocialAuthorizeDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], SocialAuthController.prototype, "authorize", null);
+_ts_decorate([
+    Post('callback'),
+    HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 10,
+            ttl: 60000
+        }
+    }),
+    UseInterceptors(SetToken),
+    ApiOperation({
+        summary: 'Complete a social sign-in'
+    }),
+    ApiBody({
+        type: SocialCallbackDto
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'Sign-in successful, or company selection is still required'
+    }),
+    _ts_param(0, Body()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SocialCallbackDto === "undefined" ? Object : SocialCallbackDto
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], SocialAuthController.prototype, "callback", null);
+SocialAuthController = _ts_decorate([
+    ApiTags('Social Authentication'),
+    Controller('auth/social'),
+    _ts_param(0, Inject(SocialAuthService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof SocialAuthService === "undefined" ? Object : SocialAuthService
+    ])
+], SocialAuthController);

package/fesm/controllers/social-auth.controller.spec.js

@@ -0,0 +1,75 @@
+import { AUTH_MESSAGES, SOCIAL_AUTH_MESSAGES } from '../config';
+import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
+import { SocialAuthController } from './social-auth.controller';
+const REDIRECT_URI = 'http://localhost:2001/auth/social/callback';
+describe('SocialAuthController', ()=>{
+    let controller;
+    let mockSocialAuthService;
+    beforeEach(()=>{
+        mockSocialAuthService = {
+            listEnabledProviders: jest.fn(),
+            createAuthorization: jest.fn(),
+            completeLogin: jest.fn()
+        };
+        controller = new SocialAuthController(mockSocialAuthService);
+    });
+    it('wraps the enabled provider list', async ()=>{
+        const providers = [
+            {
+                provider: SocialProviderTypeEnum.GOOGLE,
+                redirectUri: REDIRECT_URI
+            }
+        ];
+        mockSocialAuthService.listEnabledProviders.mockResolvedValue(providers);
+        const result = await controller.getProviders({
+            redirectUri: REDIRECT_URI
+        });
+        expect(result.data).toBe(providers);
+        expect(result.messageKey).toBe(SOCIAL_AUTH_MESSAGES.PROVIDERS_SUCCESS);
+        expect(mockSocialAuthService.listEnabledProviders).toHaveBeenCalledWith(REDIRECT_URI);
+    });
+    it('wraps the authorization URL', async ()=>{
+        mockSocialAuthService.createAuthorization.mockResolvedValue({
+            provider: SocialProviderTypeEnum.GOOGLE,
+            authorizationUrl: 'https://provider.test/consent',
+            state: 'state-token'
+        });
+        const result = await controller.authorize({
+            provider: SocialProviderTypeEnum.GOOGLE,
+            redirectUri: REDIRECT_URI
+        });
+        expect(result.data?.authorizationUrl).toBe('https://provider.test/consent');
+        expect(result.messageKey).toBe(SOCIAL_AUTH_MESSAGES.AUTHORIZE_SUCCESS);
+    });
+    it('wraps a completed sign-in', async ()=>{
+        mockSocialAuthService.completeLogin.mockResolvedValue({
+            accessToken: 'a',
+            refreshToken: 'r'
+        });
+        const result = await controller.callback({
+            code: 'code',
+            state: 'state-token',
+            redirectUri: REDIRECT_URI
+        });
+        expect(result.messageKey).toBe(SOCIAL_AUTH_MESSAGES.LOGIN_SUCCESS);
+        expect(result.data).toEqual(expect.objectContaining({
+            accessToken: 'a'
+        }));
+        expect(mockSocialAuthService.completeLogin).toHaveBeenCalledWith('code', 'state-token', REDIRECT_URI);
+    });
+    it('wraps a sign-in that still needs a company, like the password login does', async ()=>{
+        mockSocialAuthService.completeLogin.mockResolvedValue({
+            requiresSelection: true,
+            sessionId: 'sess-1'
+        });
+        const result = await controller.callback({
+            code: 'code',
+            state: 'state-token',
+            redirectUri: REDIRECT_URI
+        });
+        expect(result.messageKey).toBe(AUTH_MESSAGES.LOGIN_REQUIRES_SELECTION);
+        expect(result.data).toEqual(expect.objectContaining({
+            requiresSelection: true
+        }));
+    });
+});

package/fesm/docs/auth-swagger.config.js

@@ -319,6 +319,7 @@ function buildDescription(enableCompanyFeature, enableEmailVerification, isMulti
     const features = [
         '- User registration',
         '- Login with email/password',
+        '- Social sign-in (Google, Facebook, LinkedIn, Microsoft)',
         '- JWT token-based authentication',
         ...enableEmailVerification ? [
             '- Email verification',
@@ -372,6 +373,13 @@ POST /auth/verify-email → { accessToken, refreshToken, user }
 - \`POST /auth/resend-verification\` - Resend verification email
 - \`POST /auth/verify-email\` - Verify email using token
 ` : '';
+    const socialSection = `
+### Social Sign-In Endpoints
+- \`POST /auth/social/providers\` - List the providers an administrator enabled
+- \`POST /auth/social/authorize\` - Start a sign-in and get the provider's consent URL
+- \`POST /auth/social/callback\` - Exchange the provider's code for a session
+- \`POST /auth/social-config/*\` - Manage provider credentials
+`;
     const administrationSection = enableCompanyFeature ? `
 ### Administration Endpoints
 - \`POST /administration/users/*\` - User management
@@ -412,7 +420,7 @@ Handles user authentication${enableCompanyFeature ? ', company/branch management
 
 ### Features
 ${features}
-${loginFlowSection}${emailVerificationSection}${administrationSection}${registrationSection}`;
+${loginFlowSection}${emailVerificationSection}${socialSection}${administrationSection}${registrationSection}`;
 }
 // ============================================================================
 // Config factory

package/fesm/dtos/index.js

@@ -1,5 +1,6 @@
 export * from './authentication.dto';
 export * from './company-branch.dto';
 export * from './company.dto';
+export * from './social-auth.dto';
 export * from './user.dto';
 export * from './user-permission.dto';

package/fesm/dtos/social-auth.dto.js

@@ -0,0 +1,282 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { IdentityResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ApiProperty, ApiPropertyOptional, PartialType } from '@nestjs/swagger';
+import { Expose, Transform } from 'class-transformer';
+import { ArrayMaxSize, IsArray, IsBoolean, IsEnum, IsNotEmpty, IsObject, IsOptional, IsString, IsUrl, MaxLength } from 'class-validator';
+import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
+export class CreateSocialAuthConfigDto {
+    constructor(){
+        _define_property(this, "provider", void 0);
+        _define_property(this, "isEnabled", void 0);
+        _define_property(this, "clientId", void 0);
+        _define_property(this, "clientSecret", void 0);
+        _define_property(this, "scopes", void 0);
+        _define_property(this, "extraConfig", void 0);
+    }
+}
+_ts_decorate([
+    Expose(),
+    ApiProperty({
+        enum: SocialProviderTypeEnum,
+        example: SocialProviderTypeEnum.GOOGLE
+    }),
+    IsEnum(SocialProviderTypeEnum),
+    IsNotEmpty(),
+    _ts_metadata("design:type", typeof SocialProviderTypeEnum === "undefined" ? Object : SocialProviderTypeEnum)
+], CreateSocialAuthConfigDto.prototype, "provider", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional({
+        example: true,
+        description: 'Offer this provider on the login page'
+    }),
+    IsBoolean(),
+    IsOptional(),
+    _ts_metadata("design:type", Boolean)
+], CreateSocialAuthConfigDto.prototype, "isEnabled", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional({
+        example: '1234567890-abc.apps.googleusercontent.com'
+    }),
+    IsString(),
+    IsOptional(),
+    MaxLength(512),
+    _ts_metadata("design:type", String)
+], CreateSocialAuthConfigDto.prototype, "clientId", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional({
+        example: 'GOCSPX-secret-value'
+    }),
+    IsString(),
+    IsOptional(),
+    _ts_metadata("design:type", String)
+], CreateSocialAuthConfigDto.prototype, "clientSecret", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional({
+        type: [
+            String
+        ],
+        example: [
+            'openid',
+            'email',
+            'profile'
+        ],
+        description: "Overrides the provider's default scopes when set"
+    }),
+    IsArray(),
+    IsString({
+        each: true
+    }),
+    ArrayMaxSize(30),
+    IsOptional(),
+    _ts_metadata("design:type", Array)
+], CreateSocialAuthConfigDto.prototype, "scopes", void 0);
+_ts_decorate([
+    Expose(),
+    ApiPropertyOptional({
+        type: 'object',
+        additionalProperties: true,
+        description: "Provider specific extras, such as Microsoft's tenantId",
+        example: {
+            tenantId: 'common'
+        }
+    }),
+    IsObject(),
+    IsOptional(),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], CreateSocialAuthConfigDto.prototype, "extraConfig", void 0);
+export class UpdateSocialAuthConfigDto extends PartialType(CreateSocialAuthConfigDto) {
+    constructor(...args){
+        super(...args), _define_property(this, "id", void 0);
+    }
+}
+_ts_decorate([
+    Expose(),
+    ApiProperty({
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    IsString(),
+    IsNotEmpty(),
+    _ts_metadata("design:type", String)
+], UpdateSocialAuthConfigDto.prototype, "id", void 0);
+export class SocialAuthConfigResponseDto extends IdentityResponseDto {
+    constructor(...args){
+        super(...args), _define_property(this, "provider", void 0), _define_property(this, "isEnabled", void 0), _define_property(this, "clientId", void 0), _define_property(this, "hasClientSecret", void 0), _define_property(this, "scopes", void 0), _define_property(this, "extraConfig", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        enum: SocialProviderTypeEnum,
+        example: SocialProviderTypeEnum.GOOGLE
+    }),
+    Expose(),
+    _ts_metadata("design:type", typeof SocialProviderTypeEnum === "undefined" ? Object : SocialProviderTypeEnum)
+], SocialAuthConfigResponseDto.prototype, "provider", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: true
+    }),
+    Expose(),
+    _ts_metadata("design:type", Boolean)
+], SocialAuthConfigResponseDto.prototype, "isEnabled", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        nullable: true
+    }),
+    Expose(),
+    _ts_metadata("design:type", Object)
+], SocialAuthConfigResponseDto.prototype, "clientId", void 0);
+_ts_decorate([
+    ApiProperty({
+        description: 'Whether a client secret is currently stored for this provider'
+    }),
+    Expose(),
+    Transform(({ obj })=>!!obj.clientSecret),
+    _ts_metadata("design:type", Boolean)
+], SocialAuthConfigResponseDto.prototype, "hasClientSecret", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        type: [
+            String
+        ],
+        nullable: true
+    }),
+    Expose(),
+    _ts_metadata("design:type", Object)
+], SocialAuthConfigResponseDto.prototype, "scopes", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        type: 'object',
+        additionalProperties: true,
+        nullable: true
+    }),
+    Expose(),
+    _ts_metadata("design:type", Object)
+], SocialAuthConfigResponseDto.prototype, "extraConfig", void 0);
+export class SocialProviderInfoDto {
+    constructor(){
+        _define_property(this, "provider", void 0);
+        _define_property(this, "redirectUri", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        enum: SocialProviderTypeEnum,
+        example: SocialProviderTypeEnum.GOOGLE
+    }),
+    Expose(),
+    _ts_metadata("design:type", typeof SocialProviderTypeEnum === "undefined" ? Object : SocialProviderTypeEnum)
+], SocialProviderInfoDto.prototype, "provider", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: 'http://localhost:2001/auth/social/callback'
+    }),
+    Expose(),
+    _ts_metadata("design:type", String)
+], SocialProviderInfoDto.prototype, "redirectUri", void 0);
+export class SocialProvidersDto {
+    constructor(){
+        _define_property(this, "redirectUri", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        example: 'http://localhost:2001/auth/social/callback',
+        description: 'Must match the URI registered with the provider and the one sent on callback'
+    }),
+    IsUrl({
+        require_tld: false
+    }),
+    IsNotEmpty(),
+    MaxLength(2048),
+    _ts_metadata("design:type", String)
+], SocialProvidersDto.prototype, "redirectUri", void 0);
+export class SocialAuthorizeDto extends SocialProvidersDto {
+    constructor(...args){
+        super(...args), _define_property(this, "provider", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        enum: SocialProviderTypeEnum,
+        example: SocialProviderTypeEnum.GOOGLE
+    }),
+    IsEnum(SocialProviderTypeEnum),
+    IsNotEmpty(),
+    _ts_metadata("design:type", typeof SocialProviderTypeEnum === "undefined" ? Object : SocialProviderTypeEnum)
+], SocialAuthorizeDto.prototype, "provider", void 0);
+export class SocialAuthorizeResponseDto {
+    constructor(){
+        _define_property(this, "provider", void 0);
+        _define_property(this, "authorizationUrl", void 0);
+        _define_property(this, "state", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        enum: SocialProviderTypeEnum
+    }),
+    Expose(),
+    _ts_metadata("design:type", typeof SocialProviderTypeEnum === "undefined" ? Object : SocialProviderTypeEnum)
+], SocialAuthorizeResponseDto.prototype, "provider", void 0);
+_ts_decorate([
+    ApiProperty({
+        description: "The provider's consent screen to redirect the browser to"
+    }),
+    Expose(),
+    _ts_metadata("design:type", String)
+], SocialAuthorizeResponseDto.prototype, "authorizationUrl", void 0);
+_ts_decorate([
+    ApiProperty({
+        description: 'Opaque CSRF token, echoed back by the provider'
+    }),
+    Expose(),
+    _ts_metadata("design:type", String)
+], SocialAuthorizeResponseDto.prototype, "state", void 0);
+export class SocialCallbackDto extends SocialProvidersDto {
+    constructor(...args){
+        super(...args), _define_property(this, "code", void 0), _define_property(this, "state", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        description: 'Authorization code returned by the provider'
+    }),
+    IsString(),
+    IsNotEmpty(),
+    MaxLength(4096),
+    _ts_metadata("design:type", String)
+], SocialCallbackDto.prototype, "code", void 0);
+_ts_decorate([
+    ApiProperty({
+        description: 'The state issued by /auth/social/authorize'
+    }),
+    IsString(),
+    IsNotEmpty(),
+    MaxLength(128),
+    _ts_metadata("design:type", String)
+], SocialCallbackDto.prototype, "state", void 0);

package/fesm/entities/index.js

@@ -2,17 +2,20 @@ export * from './app-user.entity';
 export * from './company-branch.entity';
 export * from './company.entity';
 export * from './pending-registration.entity';
+export * from './social-auth-config.entity';
 export { PermissionType, UserCompanyPermission } from './user-company-permission.entity';
 export * from './user-token.entity';
 import { AppUser } from './app-user.entity';
 import { CompanyBranch } from './company-branch.entity';
 import { Company } from './company.entity';
 import { PendingRegistration } from './pending-registration.entity';
+import { SocialAuthConfig } from './social-auth-config.entity';
 import { UserCompanyPermission } from './user-company-permission.entity';
 import { UserToken } from './user-token.entity';
 const BaseEntities = [
     AppUser,
-    UserToken
+    UserToken,
+    SocialAuthConfig
 ];
 const EmailEntities = [
     PendingRegistration