nestjs-mailbridge 1.0.0

package/dist/calendar/calendar-feature.module.d.ts

@@ -0,0 +1,4 @@
+import { DynamicModule } from "@nestjs/common";
+export declare class CalendarFeatureModule {
+    static forRoot(): DynamicModule;
+}

package/dist/calendar/calendar-feature.module.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var CalendarFeatureModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarFeatureModule = void 0;
+const common_1 = require("@nestjs/common");
+const calendar_service_1 = require("./calendar.service");
+const calendar_repository_1 = require("./calendar.repository");
+const google_oauth_service_1 = require("./oauth/google-oauth.service");
+const email_feature_module_1 = require("../email-feature.module");
+let CalendarFeatureModule = CalendarFeatureModule_1 = class CalendarFeatureModule {
+    static forRoot() {
+        return {
+            module: CalendarFeatureModule_1,
+            imports: [email_feature_module_1.EmailFeatureModule],
+            providers: [
+                calendar_service_1.CalendarService,
+                calendar_repository_1.CalendarRepository,
+                google_oauth_service_1.GoogleOAuthService,
+            ],
+            exports: [calendar_service_1.CalendarService],
+        };
+    }
+};
+exports.CalendarFeatureModule = CalendarFeatureModule;
+exports.CalendarFeatureModule = CalendarFeatureModule = CalendarFeatureModule_1 = __decorate([
+    (0, common_1.Module)({})
+], CalendarFeatureModule);

package/dist/calendar/calendar.repository.d.ts

@@ -0,0 +1,15 @@
+import { PrismaLike } from "../email.types";
+export declare class CalendarRepository {
+    private prisma;
+    constructor(prisma: PrismaLike);
+    findUserById(id: string): any;
+    findUserByEmail(email: string): any;
+    updateUser(id: string, data: any): any;
+    createEvent(data: any): any;
+    findUserEvents(userId: string): any;
+    findEvent(id: string, userId: string): any;
+    updateEvent(id: string, data: any): any;
+    deleteEvent(id: string): any;
+    findUnsyncedEvents(userId: string): any;
+    findConflict(userId: string, start: Date, end: Date): any;
+}

package/dist/calendar/calendar.repository.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarRepository = void 0;
+const common_1 = require("@nestjs/common");
+const email_types_1 = require("../email.types");
+let CalendarRepository = class CalendarRepository {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    findUserById(id) {
+        return this.prisma.user.findUnique({ where: { id } });
+    }
+    findUserByEmail(email) {
+        return this.prisma.user.findUnique({ where: { email } });
+    }
+    updateUser(id, data) {
+        return this.prisma.user.update({
+            where: { id },
+            data,
+        });
+    }
+    createEvent(data) {
+        return this.prisma.calendarEvent.create({ data });
+    }
+    findUserEvents(userId) {
+        return this.prisma.calendarEvent.findMany({
+            where: { userId },
+            orderBy: { startTime: "asc" },
+        });
+    }
+    findEvent(id, userId) {
+        return this.prisma.calendarEvent.findFirst({
+            where: { id, userId },
+        });
+    }
+    updateEvent(id, data) {
+        return this.prisma.calendarEvent.update({
+            where: { id },
+            data,
+        });
+    }
+    deleteEvent(id) {
+        return this.prisma.calendarEvent.delete({ where: { id } });
+    }
+    findUnsyncedEvents(userId) {
+        return this.prisma.calendarEvent.findMany({
+            where: { userId, googleEventId: null },
+        });
+    }
+    findConflict(userId, start, end) {
+        return this.prisma.calendarEvent.findFirst({
+            where: {
+                userId,
+                startTime: { lt: end },
+                endTime: { gt: start },
+            },
+        });
+    }
+};
+exports.CalendarRepository = CalendarRepository;
+exports.CalendarRepository = CalendarRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_types_1.EMAIL_PRISMA)),
+    __metadata("design:paramtypes", [Object])
+], CalendarRepository);

package/dist/calendar/calendar.service.d.ts

@@ -0,0 +1,34 @@
+import { CalendarRepository } from "./calendar.repository";
+import { GoogleOAuthService } from "./oauth/google-oauth.service";
+import { CreateCalendarDto } from "./dto/create-calendar.dto";
+import { UpdateCalendarDto } from "./dto/update-calendar.dto";
+export declare class CalendarService {
+    private readonly repo;
+    private readonly googleOAuth;
+    constructor(repo: CalendarRepository, googleOAuth: GoogleOAuthService);
+    getGoogleConnectionStatus(userId: string): Promise<{
+        connected: boolean;
+        email: any;
+        userId: any;
+    }>;
+    getGoogleAuthUrl(userId: string): Promise<{
+        url: string;
+    }>;
+    handleGoogleCallback(code: string, email: string): Promise<{
+        connected: boolean;
+    }>;
+    private getGoogleClient;
+    create(dto: CreateCalendarDto, userId: string): Promise<any>;
+    createByUserIdNoAuth(userId: string, dto: CreateCalendarDto): Promise<any>;
+    findAll(userId: string): any;
+    findByUserId(userId: string): any;
+    findOne(id: string, userId: string): Promise<any>;
+    update(id: string, dto: UpdateCalendarDto, userId: string): Promise<any>;
+    remove(id: string, userId: string): Promise<any>;
+    private defaultEndTime;
+    syncToGoogle(eventId: string, userId: string): Promise<{
+        googleEventId: string | null | undefined;
+        htmlLink: string | null | undefined;
+    }>;
+    syncAllToGoogle(userId: string): Promise<any[]>;
+}

package/dist/calendar/calendar.service.js

@@ -0,0 +1,213 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarService = void 0;
+const common_1 = require("@nestjs/common");
+const googleapis_1 = require("googleapis");
+const calendar_repository_1 = require("./calendar.repository");
+const google_oauth_service_1 = require("./oauth/google-oauth.service");
+let CalendarService = class CalendarService {
+    constructor(repo, googleOAuth) {
+        this.repo = repo;
+        this.googleOAuth = googleOAuth;
+    }
+    // ---- Google OAuth ----
+    async getGoogleConnectionStatus(userId) {
+        const user = await this.repo.findUserById(userId);
+        if (!user)
+            throw new common_1.NotFoundException("User not found");
+        return {
+            connected: !!user.googleAccessToken,
+            email: user.email,
+            userId: user.id,
+        };
+    }
+    async getGoogleAuthUrl(userId) {
+        const user = await this.repo.findUserById(userId);
+        if (!user)
+            throw new common_1.NotFoundException("User not found");
+        if (!user.email)
+            throw new common_1.BadRequestException("User email missing");
+        return { url: this.googleOAuth.getAuthUrl(user.email) };
+    }
+    async handleGoogleCallback(code, email) {
+        const tokens = await this.googleOAuth.exchangeCode(code);
+        const user = await this.repo.findUserByEmail(email);
+        if (!user)
+            throw new common_1.NotFoundException("User not found");
+        // IMPORTANT: refresh_token may be missing if user already authorized before.
+        // Your controller already uses prompt=consent, so most cases will be ok.
+        await this.repo.updateUser(user.id, {
+            googleAccessToken: tokens.access_token ?? null,
+            googleRefreshToken: tokens.refresh_token ?? user.googleRefreshToken ?? null,
+            googleCalendarConnected: true,
+        });
+        return { connected: true };
+    }
+    async getGoogleClient(userId) {
+        const user = await this.repo.findUserById(userId);
+        if (!user)
+            throw new common_1.NotFoundException("User not found");
+        if (!user.googleAccessToken)
+            throw new common_1.UnauthorizedException("Google not connected");
+        const auth = await this.googleOAuth.createClient(user.googleAccessToken, user.googleRefreshToken);
+        return googleapis_1.google.calendar({ version: "v3", auth });
+    }
+    // ---- CRUD ----
+    async create(dto, userId) {
+        const user = await this.repo.findUserById(userId);
+        if (!user)
+            throw new common_1.NotFoundException("User not found");
+        const start = new Date(dto.startTime);
+        const end = dto.endTime ? new Date(dto.endTime) : null;
+        return this.repo.createEvent({
+            title: dto.title,
+            description: dto.description ?? null,
+            startTime: start,
+            endTime: end,
+            userId,
+            property: dto.property ?? null,
+            tags: dto.tags ?? null,
+        });
+    }
+    async createByUserIdNoAuth(userId, dto) {
+        const user = await this.repo.findUserById(userId);
+        if (!user)
+            throw new common_1.BadRequestException("User does not exist");
+        const start = new Date(dto.startTime);
+        const end = dto.endTime
+            ? new Date(dto.endTime)
+            : new Date(start.getTime() + 60 * 60 * 1000);
+        const conflict = await this.repo.findConflict(userId, start, end);
+        if (conflict)
+            throw new common_1.BadRequestException("Time conflict");
+        return this.repo.createEvent({
+            title: dto.title,
+            description: dto.description ?? null,
+            startTime: start,
+            endTime: end,
+            userId,
+            property: dto.property ?? null,
+            tags: dto.tags ?? null,
+        });
+    }
+    findAll(userId) {
+        return this.repo.findUserEvents(userId);
+    }
+    findByUserId(userId) {
+        return this.repo.findUserEvents(userId);
+    }
+    async findOne(id, userId) {
+        const event = await this.repo.findEvent(id, userId);
+        if (!event)
+            throw new common_1.NotFoundException("Event not found");
+        return event;
+    }
+    async update(id, dto, userId) {
+        const event = await this.findOne(id, userId);
+        const data = {};
+        if (dto.title !== undefined)
+            data.title = dto.title;
+        if (dto.description !== undefined)
+            data.description = dto.description;
+        if (dto.property !== undefined)
+            data.property = dto.property;
+        if (dto.tags !== undefined)
+            data.tags = dto.tags;
+        if (dto.startTime)
+            data.startTime = new Date(dto.startTime);
+        if (dto.endTime)
+            data.endTime = new Date(dto.endTime);
+        const updated = await this.repo.updateEvent(id, data);
+        // 👇 GOOGLE UPDATE
+        if (event.googleEventId) {
+            const calendar = await this.getGoogleClient(userId);
+            await calendar.events.patch({
+                calendarId: "primary",
+                eventId: event.googleEventId,
+                requestBody: {
+                    summary: updated.title,
+                    description: updated.description ?? undefined,
+                    start: {
+                        dateTime: updated.startTime.toISOString(),
+                        timeZone: "UTC",
+                    },
+                    end: updated.endTime
+                        ? {
+                            dateTime: updated.endTime.toISOString(),
+                            timeZone: "UTC",
+                        }
+                        : undefined,
+                },
+            });
+        }
+        return updated;
+    }
+    async remove(id, userId) {
+        const event = await this.findOne(id, userId);
+        if (event.googleEventId) {
+            const calendar = await this.getGoogleClient(userId);
+            await calendar.events.delete({
+                calendarId: "primary",
+                eventId: event.googleEventId,
+            });
+        }
+        return this.repo.deleteEvent(id);
+    }
+    // ---- Google Sync ----
+    defaultEndTime(start) {
+        return new Date(start.getTime() + 30 * 60000);
+    }
+    async syncToGoogle(eventId, userId) {
+        const event = await this.repo.findEvent(eventId, userId);
+        if (!event)
+            throw new common_1.NotFoundException("Event not found");
+        const calendar = await this.getGoogleClient(userId);
+        const end = event.endTime ?? this.defaultEndTime(event.startTime);
+        const result = await calendar.events.insert({
+            calendarId: "primary",
+            requestBody: {
+                summary: event.title,
+                description: event.description ?? undefined,
+                start: { dateTime: event.startTime.toISOString(), timeZone: "UTC" },
+                end: { dateTime: end.toISOString(), timeZone: "UTC" },
+            },
+        });
+        await this.repo.updateEvent(eventId, {
+            googleEventId: result.data.id,
+            synced: true,
+        });
+        return {
+            googleEventId: result.data.id,
+            htmlLink: result.data.htmlLink,
+        };
+    }
+    async syncAllToGoogle(userId) {
+        const events = await this.repo.findUnsyncedEvents(userId);
+        const results = [];
+        for (const e of events) {
+            try {
+                const r = await this.syncToGoogle(e.id, userId);
+                results.push({ id: e.id, success: true, ...r });
+            }
+            catch (err) {
+                results.push({ id: e.id, success: false, error: err.message });
+            }
+        }
+        return results;
+    }
+};
+exports.CalendarService = CalendarService;
+exports.CalendarService = CalendarService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [calendar_repository_1.CalendarRepository,
+        google_oauth_service_1.GoogleOAuthService])
+], CalendarService);

package/dist/calendar/dto/create-calendar.dto.d.ts

@@ -0,0 +1,8 @@
+export declare class CreateCalendarDto {
+    title: string;
+    description?: string;
+    startTime: string;
+    endTime?: string;
+    property?: string;
+    tags?: string;
+}

package/dist/calendar/dto/create-calendar.dto.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCalendarDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+class CreateCalendarDto {
+}
+exports.CreateCalendarDto = CreateCalendarDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateCalendarDto.prototype, "title", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateCalendarDto.prototype, "description", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsDateString)(),
+    __metadata("design:type", String)
+], CreateCalendarDto.prototype, "startTime", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsDateString)(),
+    __metadata("design:type", String)
+], CreateCalendarDto.prototype, "endTime", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateCalendarDto.prototype, "property", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateCalendarDto.prototype, "tags", void 0);

package/dist/calendar/dto/update-calendar.dto.d.ts

@@ -0,0 +1,5 @@
+import { CreateCalendarDto } from "./create-calendar.dto";
+declare const UpdateCalendarDto_base: import("@nestjs/common").Type<Partial<CreateCalendarDto>>;
+export declare class UpdateCalendarDto extends UpdateCalendarDto_base {
+}
+export {};

package/dist/calendar/dto/update-calendar.dto.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCalendarDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const create_calendar_dto_1 = require("./create-calendar.dto");
+class UpdateCalendarDto extends (0, swagger_1.PartialType)(create_calendar_dto_1.CreateCalendarDto) {
+}
+exports.UpdateCalendarDto = UpdateCalendarDto;

package/dist/calendar/oauth/google-oauth.service.d.ts

@@ -0,0 +1,13 @@
+import { EmailFeatureConfig } from "../../email.types";
+export declare class GoogleOAuthService {
+    private cfg;
+    constructor(cfg: EmailFeatureConfig);
+    private redirectUri;
+    private oauth;
+    /**
+     * State should contain userEmail (your controller expects that)
+     */
+    getAuthUrl(userEmail: string): string;
+    exchangeCode(code: string): Promise<import("google-auth-library").Credentials>;
+    createClient(accessToken: string | null, refreshToken: string | null): Promise<import("google-auth-library").OAuth2Client>;
+}

package/dist/calendar/oauth/google-oauth.service.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleOAuthService = void 0;
+const common_1 = require("@nestjs/common");
+const googleapis_1 = require("googleapis");
+const email_types_1 = require("../../email.types");
+let GoogleOAuthService = class GoogleOAuthService {
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    redirectUri() {
+        return this.cfg.googleCalendarRedirectUri ?? this.cfg.google.redirectUri;
+    }
+    oauth() {
+        return new googleapis_1.google.auth.OAuth2(this.cfg.google.clientId, this.cfg.google.clientSecret, this.redirectUri());
+    }
+    /**
+     * State should contain userEmail (your controller expects that)
+     */
+    getAuthUrl(userEmail) {
+        const state = Buffer.from(JSON.stringify({ userEmail })).toString("base64");
+        return this.oauth().generateAuthUrl({
+            access_type: "offline",
+            prompt: "consent",
+            include_granted_scopes: true,
+            scope: [
+                "https://www.googleapis.com/auth/calendar",
+                "https://www.googleapis.com/auth/calendar.events",
+            ],
+            state,
+        });
+    }
+    async exchangeCode(code) {
+        const { tokens } = await this.oauth().getToken(code);
+        return tokens;
+    }
+    async createClient(accessToken, refreshToken) {
+        const client = new googleapis_1.google.auth.OAuth2(this.cfg.google.clientId, this.cfg.google.clientSecret, this.redirectUri());
+        client.setCredentials({
+            access_token: accessToken || undefined,
+            refresh_token: refreshToken || undefined,
+        });
+        return client;
+    }
+};
+exports.GoogleOAuthService = GoogleOAuthService;
+exports.GoogleOAuthService = GoogleOAuthService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_types_1.EMAIL_FEATURE_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], GoogleOAuthService);

package/dist/calendar/oauth/outlook-calendar.service.d.ts

@@ -0,0 +1,13 @@
+import { EmailFeatureConfig } from "../../email.types";
+export declare class GoogleOAuthService {
+    private cfg;
+    constructor(cfg: EmailFeatureConfig);
+    private redirectUri;
+    private oauth;
+    /**
+     * State should contain userEmail (your controller expects that)
+     */
+    getAuthUrl(userEmail: string): string;
+    exchangeCode(code: string): Promise<import("google-auth-library").Credentials>;
+    createClient(accessToken: string | null, refreshToken: string | null): Promise<import("google-auth-library").OAuth2Client>;
+}

package/dist/calendar/oauth/outlook-calendar.service.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleOAuthService = void 0;
+const common_1 = require("@nestjs/common");
+const googleapis_1 = require("googleapis");
+const email_types_1 = require("../../email.types");
+let GoogleOAuthService = class GoogleOAuthService {
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    redirectUri() {
+        return this.cfg.googleCalendarRedirectUri ?? this.cfg.google.redirectUri;
+    }
+    oauth() {
+        return new googleapis_1.google.auth.OAuth2(this.cfg.google.clientId, this.cfg.google.clientSecret, this.redirectUri());
+    }
+    /**
+     * State should contain userEmail (your controller expects that)
+     */
+    getAuthUrl(userEmail) {
+        const state = Buffer.from(JSON.stringify({ userEmail })).toString("base64");
+        return this.oauth().generateAuthUrl({
+            access_type: "offline",
+            prompt: "consent",
+            include_granted_scopes: true,
+            scope: [
+                "https://www.googleapis.com/auth/calendar",
+                "https://www.googleapis.com/auth/calendar.events",
+            ],
+            state,
+        });
+    }
+    async exchangeCode(code) {
+        const { tokens } = await this.oauth().getToken(code);
+        return tokens;
+    }
+    async createClient(accessToken, refreshToken) {
+        const client = new googleapis_1.google.auth.OAuth2(this.cfg.google.clientId, this.cfg.google.clientSecret, this.redirectUri());
+        client.setCredentials({
+            access_token: accessToken || undefined,
+            refresh_token: refreshToken || undefined,
+        });
+        return client;
+    }
+};
+exports.GoogleOAuthService = GoogleOAuthService;
+exports.GoogleOAuthService = GoogleOAuthService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_types_1.EMAIL_FEATURE_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], GoogleOAuthService);

package/dist/dto/send-email.dto.d.ts

@@ -0,0 +1,6 @@
+export declare class SendEmailDto {
+    accountId: string;
+    to: string;
+    subject: string;
+    body: string;
+}

package/dist/dto/send-email.dto.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendEmailDto = void 0;
+const class_validator_1 = require("class-validator");
+class SendEmailDto {
+}
+exports.SendEmailDto = SendEmailDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], SendEmailDto.prototype, "accountId", void 0);
+__decorate([
+    (0, class_validator_1.IsEmail)(),
+    __metadata("design:type", String)
+], SendEmailDto.prototype, "to", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], SendEmailDto.prototype, "subject", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], SendEmailDto.prototype, "body", void 0);

package/dist/email-feature.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from "@nestjs/common";
+import { EmailFeatureConfig, PrismaLike } from "./email.types";
+export declare class EmailFeatureModule {
+    static forRoot(options: {
+        config: EmailFeatureConfig;
+        prisma: PrismaLike;
+    }): DynamicModule;
+}

package/dist/email-feature.module.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var EmailFeatureModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailFeatureModule = void 0;
+const common_1 = require("@nestjs/common");
+const email_types_1 = require("./email.types");
+const email_service_1 = require("./email.service");
+const email_repository_1 = require("./email.repository");
+const google_auth_service_1 = require("./google/google-auth.service");
+const google_gmail_service_1 = require("./google/google-gmail.service");
+let EmailFeatureModule = EmailFeatureModule_1 = class EmailFeatureModule {
+    static forRoot(options) {
+        return {
+            module: EmailFeatureModule_1,
+            providers: [
+                { provide: email_types_1.EMAIL_FEATURE_CONFIG, useValue: options.config },
+                { provide: email_types_1.EMAIL_PRISMA, useValue: options.prisma },
+                email_service_1.EmailService,
+                email_repository_1.EmailRepository,
+                google_auth_service_1.GoogleAuthService,
+                google_gmail_service_1.GoogleGmailService,
+            ],
+            exports: [email_service_1.EmailService, google_gmail_service_1.GoogleGmailService, email_repository_1.EmailRepository, email_types_1.EMAIL_FEATURE_CONFIG, email_types_1.EMAIL_PRISMA],
+        };
+    }
+};
+exports.EmailFeatureModule = EmailFeatureModule;
+exports.EmailFeatureModule = EmailFeatureModule = EmailFeatureModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], EmailFeatureModule);

package/dist/email.repository.d.ts

@@ -0,0 +1,11 @@
+import { PrismaLike } from "./email.types";
+export declare class EmailRepository {
+    private prisma;
+    constructor(prisma: PrismaLike);
+    listAccounts(userId: string): any;
+    findAccount(userId: string, accountId: string): any;
+    findByEmail(email: string): any;
+    upsertGoogle(userId: string, email: string, data: any): any;
+    updateAccount(id: string, data: any): any;
+    saveIncoming(userId: string, payload: any): Promise<any>;
+}

package/dist/email.repository.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailRepository = void 0;
+const common_1 = require("@nestjs/common");
+const email_types_1 = require("./email.types");
+let EmailRepository = class EmailRepository {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    listAccounts(userId) {
+        return this.prisma.emailAccount.findMany({
+            where: { userId, status: "CONNECTED" },
+            orderBy: { createdAt: "desc" },
+            select: { id: true, provider: true, emailAddress: true, status: true, createdAt: true },
+        });
+    }
+    findAccount(userId, accountId) {
+        return this.prisma.emailAccount.findFirst({
+            where: { id: accountId, userId },
+        });
+    }
+    findByEmail(email) {
+        return this.prisma.emailAccount.findFirst({
+            where: { emailAddress: email, provider: "GOOGLE" },
+        });
+    }
+    upsertGoogle(userId, email, data) {
+        return this.prisma.emailAccount.upsert({
+            where: {
+                provider_emailAddress: {
+                    provider: "GOOGLE",
+                    emailAddress: email,
+                },
+            },
+            update: { userId, status: "CONNECTED", ...data },
+            create: { userId, provider: "GOOGLE", emailAddress: email, status: "CONNECTED", ...data },
+        });
+    }
+    updateAccount(id, data) {
+        return this.prisma.emailAccount.update({ where: { id }, data });
+    }
+    async saveIncoming(userId, payload) {
+        if (!this.prisma.message)
+            return null;
+        return this.prisma.message.create({
+            data: {
+                userId,
+                channel: "EMAIL",
+                status: "PENDING",
+                ...payload,
+            },
+        });
+    }
+};
+exports.EmailRepository = EmailRepository;
+exports.EmailRepository = EmailRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_types_1.EMAIL_PRISMA)),
+    __metadata("design:paramtypes", [Object])
+], EmailRepository);

package/dist/email.service.d.ts

@@ -0,0 +1,12 @@
+import { GoogleAuthService } from "./google/google-auth.service";
+import { EmailRepository } from "./email.repository";
+export declare class EmailService {
+    private auth;
+    private repo;
+    constructor(auth: GoogleAuthService, repo: EmailRepository);
+    connect(userId: string): {
+        url: string;
+    };
+    callback(userId: string, code: string): Promise<any>;
+    accounts(userId: string): any;
+}

package/dist/email.service.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailService = void 0;
+const common_1 = require("@nestjs/common");
+const googleapis_1 = require("googleapis");
+const google_auth_service_1 = require("./google/google-auth.service");
+const email_repository_1 = require("./email.repository");
+let EmailService = class EmailService {
+    constructor(auth, repo) {
+        this.auth = auth;
+        this.repo = repo;
+    }
+    connect(userId) {
+        return { url: this.auth.url(userId) };
+    }
+    async callback(userId, code) {
+        const tokens = await this.auth.exchange(code);
+        // IMPORTANT
+        if (!tokens.access_token || !tokens.refresh_token) {
+            throw new Error("Missing tokens from Google. Ensure prompt=consent + access_type=offline. If you authorized before, revoke access and reconnect.");
+        }
+        const client = this.auth.build(tokens.access_token, tokens.refresh_token);
+        const gmail = googleapis_1.google.gmail({ version: "v1", auth: client });
+        const profile = await gmail.users.getProfile({ userId: "me" });
+        const email = profile.data.emailAddress;
+        if (!email)
+            throw new Error("Cannot fetch Gmail profile emailAddress");
+        return this.repo.upsertGoogle(userId, email, {
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            tokenExpiry: tokens.expiry_date ? new Date(tokens.expiry_date) : null,
+        });
+    }
+    accounts(userId) {
+        return this.repo.listAccounts(userId);
+    }
+};
+exports.EmailService = EmailService;
+exports.EmailService = EmailService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [google_auth_service_1.GoogleAuthService, email_repository_1.EmailRepository])
+], EmailService);

package/dist/email.types.d.ts

@@ -0,0 +1,54 @@
+export type EmailProvider = "GOOGLE" | "OUTLOOK" | "IMAP";
+export type EmailFeatureConfig = {
+    google: {
+        clientId: string;
+        clientSecret: string;
+        /**
+         * Email redirect URI (email/google/callback)
+         * Example: https://api.domain.com/email/google/callback
+         */
+        redirectUri: string;
+    };
+    /**
+     * Optional: Calendar redirect URI (calendar/google/callback)
+     * If not provided, falls back to google.redirectUri
+     */
+    googleCalendarRedirectUri?: string;
+    /**
+     * Pub/Sub topic for Gmail watch
+     */
+    gmailPubSubTopic?: string;
+    /**
+     * Optional Outlook OAuth config for calendar
+     */
+    outlook?: {
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+        tenant?: string;
+    };
+};
+export declare const EMAIL_FEATURE_CONFIG: unique symbol;
+export declare const EMAIL_PRISMA: unique symbol;
+export type PrismaLike = {
+    emailAccount: {
+        findMany: Function;
+        findFirst: Function;
+        upsert: Function;
+        update: Function;
+    };
+    message?: {
+        create: Function;
+    };
+    user: {
+        findUnique: Function;
+        update: Function;
+    };
+    calendarEvent: {
+        create: Function;
+        findMany: Function;
+        findFirst: Function;
+        update: Function;
+        delete: Function;
+    };
+};

package/dist/email.types.js

@@ -0,0 +1,6 @@
+"use strict";
+// src/email.types.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMAIL_PRISMA = exports.EMAIL_FEATURE_CONFIG = void 0;
+exports.EMAIL_FEATURE_CONFIG = Symbol("EMAIL_FEATURE_CONFIG");
+exports.EMAIL_PRISMA = Symbol("EMAIL_PRISMA");

package/dist/google/gmail-parser.d.ts

@@ -0,0 +1,3 @@
+export declare const decode: (s: string) => string;
+export declare const header: (h: any[] | undefined, n: string) => any;
+export declare const body: (p: any) => string;

package/dist/google/gmail-parser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.body = exports.header = exports.decode = void 0;
+const decode = (s) => Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString();
+exports.decode = decode;
+const header = (h = [], n) => h.find((x) => x?.name?.toLowerCase() === n.toLowerCase())?.value;
+exports.header = header;
+const body = (p) => {
+    if (p?.body?.data)
+        return (0, exports.decode)(p.body.data);
+    for (const part of p?.parts ?? []) {
+        const r = (0, exports.body)(part);
+        if (r)
+            return r;
+    }
+    return "";
+};
+exports.body = body;

package/dist/google/google-auth.service.d.ts

@@ -0,0 +1,10 @@
+import { Credentials } from "google-auth-library";
+import { EmailFeatureConfig } from "../email.types";
+export declare class GoogleAuthService {
+    private cfg;
+    constructor(cfg: EmailFeatureConfig);
+    private client;
+    url(state: string): string;
+    exchange(code: string): Promise<Credentials>;
+    build(access: string, refresh: string): import("google-auth-library").OAuth2Client;
+}

package/dist/google/google-auth.service.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAuthService = void 0;
+const common_1 = require("@nestjs/common");
+const googleapis_1 = require("googleapis");
+const email_types_1 = require("../email.types");
+let GoogleAuthService = class GoogleAuthService {
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    client() {
+        return new googleapis_1.google.auth.OAuth2(this.cfg.google.clientId, this.cfg.google.clientSecret, this.cfg.google.redirectUri);
+    }
+    url(state) {
+        return this.client().generateAuthUrl({
+            access_type: "offline",
+            prompt: "consent",
+            scope: [
+                "https://www.googleapis.com/auth/userinfo.email",
+                "https://www.googleapis.com/auth/gmail.readonly",
+                "https://www.googleapis.com/auth/gmail.send",
+            ],
+            state,
+        });
+    }
+    async exchange(code) {
+        const { tokens } = await this.client().getToken(code);
+        return tokens;
+    }
+    build(access, refresh) {
+        const c = this.client();
+        c.setCredentials({ access_token: access, refresh_token: refresh });
+        return c;
+    }
+};
+exports.GoogleAuthService = GoogleAuthService;
+exports.GoogleAuthService = GoogleAuthService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(email_types_1.EMAIL_FEATURE_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], GoogleAuthService);

package/dist/google/google-gmail.service.d.ts

@@ -0,0 +1,31 @@
+import { EmailRepository } from "../email.repository";
+import { GoogleAuthService } from "./google-auth.service";
+import { EmailFeatureConfig } from "../email.types";
+export declare class GoogleGmailService {
+    private repo;
+    private auth;
+    private cfg;
+    constructor(repo: EmailRepository, auth: GoogleAuthService, cfg: EmailFeatureConfig);
+    private getClient;
+    send(userId: string, accountId: string, to: string, subject: string, text: string): Promise<import("googleapis-common").GaxiosResponseWithHTTP2<import("googleapis").gmail_v1.Schema$Message>>;
+    listInbox(userId: string, accountId: string, max?: number, q?: string): Promise<{
+        id: string | null | undefined;
+        threadId: string | null | undefined;
+        subject: any;
+        from: any;
+        date: any;
+        snippet: string | null | undefined;
+    }[]>;
+    getSingle(userId: string, accountId: string, messageId: string): Promise<{
+        id: string | null | undefined;
+        threadId: string | null | undefined;
+        subject: any;
+        from: any;
+        to: any;
+        date: any;
+        snippet: string | null | undefined;
+        body: string;
+    }>;
+    watch(userId: string, accountId: string, topicName?: string): Promise<import("googleapis").gmail_v1.Schema$WatchResponse>;
+    sync(email: string, historyId: string): Promise<void>;
+}

package/dist/google/google-gmail.service.js

@@ -0,0 +1,157 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleGmailService = void 0;
+const common_1 = require("@nestjs/common");
+const googleapis_1 = require("googleapis");
+const email_repository_1 = require("../email.repository");
+const google_auth_service_1 = require("./google-auth.service");
+const gmail_parser_1 = require("./gmail-parser");
+const email_types_1 = require("../email.types");
+let GoogleGmailService = class GoogleGmailService {
+    constructor(repo, auth, cfg) {
+        this.repo = repo;
+        this.auth = auth;
+        this.cfg = cfg;
+    }
+    async getClient(userId, accountId) {
+        const acc = await this.repo.findAccount(userId, accountId);
+        if (!acc)
+            throw new common_1.NotFoundException("Email account not found");
+        if (!acc.accessToken || !acc.refreshToken)
+            throw new common_1.NotFoundException("Tokens missing");
+        const authClient = this.auth.build(acc.accessToken, acc.refreshToken);
+        const gmail = googleapis_1.google.gmail({ version: "v1", auth: authClient });
+        return { gmail, acc };
+    }
+    async send(userId, accountId, to, subject, text) {
+        const { gmail } = await this.getClient(userId, accountId);
+        const raw = Buffer.from(`To:${to}\r\nSubject:${subject}\r\n\r\n${text}`)
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
+        return gmail.users.messages.send({ userId: "me", requestBody: { raw } });
+    }
+    async listInbox(userId, accountId, max = 20, q) {
+        const { gmail } = await this.getClient(userId, accountId);
+        const list = await gmail.users.messages.list({
+            userId: "me",
+            labelIds: ["INBOX"],
+            maxResults: max,
+            q,
+        });
+        const ids = list.data.messages?.map((m) => m.id).filter(Boolean) ?? [];
+        if (!ids.length)
+            return [];
+        const messages = await Promise.all(ids.map((id) => gmail.users.messages.get({
+            userId: "me",
+            id,
+            format: "metadata",
+            metadataHeaders: ["Subject", "From", "Date"],
+        })));
+        return messages.map((m) => {
+            const headers = m.data.payload?.headers ?? [];
+            return {
+                id: m.data.id,
+                threadId: m.data.threadId,
+                subject: (0, gmail_parser_1.header)(headers, "Subject"),
+                from: (0, gmail_parser_1.header)(headers, "From"),
+                date: (0, gmail_parser_1.header)(headers, "Date"),
+                snippet: m.data.snippet,
+            };
+        });
+    }
+    async getSingle(userId, accountId, messageId) {
+        if (!messageId)
+            throw new common_1.NotFoundException("messageId is required");
+        const { gmail } = await this.getClient(userId, accountId);
+        const msg = await gmail.users.messages.get({
+            userId: "me",
+            id: messageId,
+            format: "full",
+        });
+        const payload = msg.data.payload;
+        const headers = payload?.headers ?? [];
+        return {
+            id: msg.data.id,
+            threadId: msg.data.threadId,
+            subject: (0, gmail_parser_1.header)(headers, "Subject"),
+            from: (0, gmail_parser_1.header)(headers, "From"),
+            to: (0, gmail_parser_1.header)(headers, "To"),
+            date: (0, gmail_parser_1.header)(headers, "Date"),
+            snippet: msg.data.snippet,
+            body: payload ? (0, gmail_parser_1.body)(payload) : "",
+        };
+    }
+    async watch(userId, accountId, topicName) {
+        const { gmail, acc } = await this.getClient(userId, accountId);
+        const realTopic = topicName ?? this.cfg.gmailPubSubTopic;
+        if (!realTopic)
+            throw new Error("Missing GMAIL Pub/Sub topicName");
+        const r = await gmail.users.watch({
+            userId: "me",
+            requestBody: { topicName: realTopic },
+        });
+        await this.repo.updateAccount(acc.id, {
+            lastHistoryId: r.data.historyId ?? null,
+            watchExpiration: r.data.expiration ? new Date(Number(r.data.expiration)) : null,
+        });
+        return r.data;
+    }
+    async sync(email, historyId) {
+        const acc = await this.repo.findByEmail(email);
+        if (!acc || !acc.accessToken || !acc.refreshToken)
+            return;
+        const authClient = this.auth.build(acc.accessToken, acc.refreshToken);
+        const gmail = googleapis_1.google.gmail({ version: "v1", auth: authClient });
+        // first time: store only
+        if (!acc.lastHistoryId) {
+            await this.repo.updateAccount(acc.id, { lastHistoryId: historyId });
+            return;
+        }
+        const h = await gmail.users.history.list({
+            userId: "me",
+            startHistoryId: acc.lastHistoryId ?? undefined,
+        });
+        for (const x of h.data.history ?? []) {
+            for (const m of x.messagesAdded ?? []) {
+                if (!m.message?.id)
+                    continue;
+                const g = await gmail.users.messages.get({
+                    userId: "me",
+                    id: m.message.id,
+                    format: "full",
+                });
+                const payload = g.data.payload;
+                const headers = payload?.headers ?? [];
+                await this.repo.saveIncoming(acc.userId, {
+                    subject: (0, gmail_parser_1.header)(headers, "Subject"),
+                    fromAddress: (0, gmail_parser_1.header)(headers, "From"),
+                    toAddress: (0, gmail_parser_1.header)(headers, "To"),
+                    body: payload ? (0, gmail_parser_1.body)(payload) : "",
+                    meta: { gmailId: m.message.id },
+                });
+            }
+        }
+        await this.repo.updateAccount(acc.id, { lastHistoryId: historyId });
+    }
+};
+exports.GoogleGmailService = GoogleGmailService;
+exports.GoogleGmailService = GoogleGmailService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)(email_types_1.EMAIL_FEATURE_CONFIG)),
+    __metadata("design:paramtypes", [email_repository_1.EmailRepository,
+        google_auth_service_1.GoogleAuthService, Object])
+], GoogleGmailService);

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./email-feature.module";
+export * from "./email.service";
+export * from "./email.repository";
+export * from "./google/google-gmail.service";
+export * from "./dto/send-email.dto";
+export * from "./calendar/calendar-feature.module";
+export * from "./calendar/calendar.service";
+export * from "./calendar/dto/create-calendar.dto";
+export * from "./calendar/dto/update-calendar.dto";

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./email-feature.module"), exports);
+__exportStar(require("./email.service"), exports);
+__exportStar(require("./email.repository"), exports);
+__exportStar(require("./google/google-gmail.service"), exports);
+__exportStar(require("./dto/send-email.dto"), exports);
+__exportStar(require("./calendar/calendar-feature.module"), exports);
+__exportStar(require("./calendar/calendar.service"), exports);
+__exportStar(require("./calendar/dto/create-calendar.dto"), exports);
+__exportStar(require("./calendar/dto/update-calendar.dto"), exports);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "nestjs-mailbridge",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.1.0",
+    "@nestjs/swagger": "^11.2.6",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
+    "google-auth-library": "^10.5.0",
+    "googleapis": "^171.4.0",
+    "swagger-ui-express": "^5.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3"
+  }
+}