feat: Implement automation engine

apps/api/package.json

@@ -52,6 +52,7 @@
     "@langfuse/core": "4.2.0",
     "@langfuse/otel": "4.2.0",
     "@langfuse/tracing": "4.2.0",
+    "@maily-to/render": "^0.2.3",
     "@microsoft/microsoft-graph-client": "3.0.7",
     "@nestjs/common": "10.4.17",
     "@nestjs/config": "3.2.3",
@@ -113,6 +114,7 @@
     "load-esm": "1.0.3",
     "lodash": "4.17.21",
     "mammoth": "1.10.0",
+    "marked": "^18.0.5",
     "mime-types": "3.0.2",
     "multer": "2.0.2",
     "nanoid": "3.3.7",
@@ -133,6 +135,7 @@
     "redis": "4.7.0",
     "reflect-metadata": "0.2.0",
     "rxjs": "7.8.1",
+    "sanitize-html": "^2.17.5",
     "sharp": "0.34.5",
     "slugify": "1.6.6",
     "socket.io": "4.8.1",
@@ -166,6 +169,7 @@
     "@types/passport-jwt": "4.0.1",
     "@types/passport-local": "1.0.38",
     "@types/passport-microsoft": "2.1.0",
+    "@types/sanitize-html": "^2.16.1",
     "@types/supertest": "6.0.2",
     "@types/unzipper": "0.10.11",
     "@types/uuid": "10.0.0",

apps/api/src/announcements/handlers/announcement-email.handler.ts

@@ -64,14 +64,15 @@ export class AnnouncementEmailHandler implements IEventHandler<AnnouncementPubli
           announcement.baseLanguage,
         );
         const content = htmlToPlainText(localizedContent);
-        const { text, html } = this.buildEmail({
+        const emailTemplate = this.buildEmail({
           title,
           content,
           template: announcement.emailTemplate,
           link: this.getButtonLink(tenantOrigin, announcement.emailTemplate, announcement.sourceId),
           ...defaultEmailSettings,
           language: emailLanguage,
         });
+        const [text, html] = await Promise.all([emailTemplate.text, emailTemplate.html]);
 
         await this.emailService.sendEmailWithLogo(
           {

apps/api/src/announcements/types/automations-source.types.ts

@@ -0,0 +1,67 @@
+import { Type } from "node_modules/@sinclair/typebox/build/cjs/type";
+import { createSelectSchema } from "node_modules/drizzle-typebox/index.cjs";
+
+import { automationSteps } from "src/storage/schema";
+import { omitTenantId } from "src/utils/omitTenantId";
+
+import type { AutomationStatus, AutomationType } from "./automations.types";
+import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import type { LocalizedText } from "node_modules/@repo/shared/dist/index.cjs";
+import type { Static } from "node_modules/@sinclair/typebox/build/cjs/type";
+import type { UUIDType } from "src/common";
+import type { automationLogs } from "src/storage/schema";
+
+export type AutomationRecordInput = {
+  tenantId: UUIDType;
+  name: LocalizedText;
+  description: LocalizedText;
+  status: AutomationStatus;
+};
+
+export type AutomationRecordUpdateInput = Partial<AutomationRecordInput>;
+
+export type AutomationStepRecordInput = {
+  parentId: UUIDType | null;
+  automationId: UUIDType;
+  type: AutomationType;
+  typeContext: TypeContext;
+};
+export type TypeContext = {
+  name: string;
+  providedVariables: Array<{
+    key: string;
+    value: unknown;
+  }>;
+};
+
+export type SendEmailActionContext = TypeContext & {
+  templateId: string;
+  language?: string;
+  variableMapping: Record<string, string>;
+};
+
+export type AutomationStepUpdateInput = {
+  type: AutomationType;
+  typeContext: TypeContext;
+};
+
+export type AutomationStepBulkUpdate = {
+  id: UUIDType;
+  parentId: UUIDType | null;
+  automationId: UUIDType;
+  type: AutomationType;
+  typeContext: TypeContext;
+};
+
+export type AutomationActionStep = {
+  typeContext: TypeContext;
+};
+export type AutomationLogRecord = InferSelectModel<typeof automationLogs>;
+export type AutomationLogRecordInput = InferInsertModel<typeof automationLogs>;
+
+export const AutomationStepSchema = Type.Omit(omitTenantId(createSelectSchema(automationSteps)), [
+  "createdAt",
+  "updatedAt",
+]);
+
+export type AutomationStep = Static<typeof AutomationStepSchema>;

apps/api/src/announcements/types/automations.types.ts

@@ -0,0 +1,60 @@
+import {
+  UserInviteEvent,
+  UsersImportInviteEmailsEvent,
+  UserPasswordReminderEvent,
+  UserWelcomeEvent,
+  UserFirstLoginEvent,
+  UsersAssignedToCourseEvent,
+  UsersShortInactivityEvent,
+  UsersLongInactivityEvent,
+  UserChapterFinishedEvent,
+  UserCourseFinishedEvent,
+  UserRegisteredEvent,
+  UserPasswordCreatedEvent,
+  CourseCompletedEvent,
+  CertificateExpirationWarningEmailEvent,
+  CertificateArchivedEmailEvent,
+  AnnouncementPublishedEvent,
+  CourseChatUserMentionedEvent,
+  CourseDueDateReminderEmailEvent,
+} from "src/events";
+
+import type { AutomationEventTypes } from "src/automations/handlers/automations-handler";
+
+export enum AutomationStatus {
+  Enabled = "enabled",
+  Disabled = "disabled",
+  Archived = "archived",
+  Draft = "draft",
+}
+
+export const automationTypes = ["action", "condition", "trigger"] as const;
+
+export type AutomationType = (typeof automationTypes)[number];
+
+export const AutomationStepType = {
+  Action: "action",
+  Condition: "condition",
+  Trigger: "trigger",
+} as const;
+
+export const AutomationEventNames: Record<AutomationEventTypes["constructor"]["name"], string> = {
+  [UserInviteEvent.name]: "user_invited",
+  [UsersImportInviteEmailsEvent.name]: "users_imported_invite",
+  [UserPasswordReminderEvent.name]: "user_password_reminder",
+  [UserWelcomeEvent.name]: "user_welcome",
+  [UserFirstLoginEvent.name]: "user_first_login",
+  [UsersAssignedToCourseEvent.name]: "users_assigned_to_course",
+  [UsersShortInactivityEvent.name]: "users_short_inactivity",
+  [UsersLongInactivityEvent.name]: "users_long_inactivity",
+  [UserChapterFinishedEvent.name]: "user_chapter_finished",
+  [UserCourseFinishedEvent.name]: "user_course_finished",
+  [UserRegisteredEvent.name]: "user_registered",
+  [UserPasswordCreatedEvent.name]: "user_password_created",
+  [CourseCompletedEvent.name]: "course_completed",
+  [CertificateExpirationWarningEmailEvent.name]: "certificate_expiration_warning",
+  [CertificateArchivedEmailEvent.name]: "certificate_archived",
+  [AnnouncementPublishedEvent.name]: "announcement_published",
+  [CourseChatUserMentionedEvent.name]: "course_chat_user_mentioned",
+  [CourseDueDateReminderEmailEvent.name]: "course_due_date_reminder",
+};

apps/api/src/app.module.ts

@@ -25,6 +25,7 @@ import { AuthModule } from "./auth/auth.module";
 import { GoogleStrategy } from "./auth/strategy/google.strategy";
 import { MicrosoftStrategy } from "./auth/strategy/microsoft.strategy";
 import { SlackStrategy } from "./auth/strategy/slack.strategy";
+import { AutomationsModule } from "./automations/automations.module";
 import { BunnyStreamModule } from "./bunny/bunnyStream.module";
 import { CacheModule } from "./cache/cache.module";
 import { CalendarModule } from "./calendar/calendar.module";
@@ -48,6 +49,8 @@ import { PermissionsGuard } from "./common/guards/permissions.guard";
 import { StagingGuard } from "./common/guards/staging.guard";
 import { CourseChatModule } from "./course-chat/course-chat.module";
 import { CourseModule } from "./courses/course.module";
+import { PublicCourseThumbnailModule } from "./courses/public-course-thumbnail.module";
+import { EmailNotificationTemplatesModule } from "./email-notification-templates/email-templates.module";
 import { EventsModule } from "./events/events.module";
 import { FileModule } from "./file/files.module";
 import { GlobalSearchModule } from "./global-search/global-search.module";
@@ -63,6 +66,7 @@ import { LumaModule } from "./luma/luma.module";
 import { NewsModule } from "./news/news.module";
 import { OutboxModule } from "./outbox/outbox.module";
 import { PermissionsModule } from "./permissions/permissions.module";
+import { PublicEmailTemplateImageModule } from "./public-email-template-image/public-email-template-image.module";
 import { QuestionsModule } from "./questions/question.module";
 import { AppThrottlerGuard } from "./rate-limit/app-throttler.guard";
 import { RedisThrottlerStorage } from "./rate-limit/redis-throttler.storage";
@@ -168,6 +172,9 @@ import type { RedisClient } from "src/redis";
     ScormModule,
     CertificatesModule,
     AnnouncementsModule,
+    EmailNotificationTemplatesModule,
+    PublicCourseThumbnailModule,
+    PublicEmailTemplateImageModule,
     IngestionModule,
     IntegrationModule,
     LearningTimeModule,
@@ -185,6 +192,7 @@ import type { RedisClient } from "src/redis";
     LumaModule,
     LiveTrainingModule,
     CalendarModule,
+    AutomationsModule,
   ],
   controllers: [],
   providers: [

apps/api/src/auth/auth.service.ts

@@ -675,7 +675,7 @@ export class AuthService {
     email: string,
     oldTokenHash: string,
     createToken: string,
-    emailTemplate: { text: string; html: string },
+    emailTemplate: { text: Promise<string> | string; html: Promise<string> | string },
     expiryDate: Date,
     reminderCount: number,
   ) {
@@ -695,12 +695,14 @@ export class AuthService {
           userId,
         );
 
+        const [text, html] = await Promise.all([emailTemplate.text, emailTemplate.html]);
+
         await this.emailService.sendEmailWithLogo(
           {
             to: email,
             subject: getEmailSubject("passwordReminderEmail", defaultEmailSettings.language),
-            text: emailTemplate.text,
-            html: emailTemplate.html,
+            text,
+            html,
           },
           { tenantId },
         );
@@ -876,7 +878,7 @@ export class AuthService {
         ...defaultEmailSettings,
       });
 
-      const { html, text } = magicLinkEmail;
+      const [text, html] = await Promise.all([magicLinkEmail.text, magicLinkEmail.html]);
 
       await this.emailService.sendEmailWithLogo(
         {

apps/api/src/automations/automation-logs/automation-logs.controller.spec.ts

@@ -0,0 +1,84 @@
+import { Test } from "@nestjs/testing";
+
+import { BaseResponse } from "src/common";
+
+import { AutomationLogsRepository } from "../repositories/automation-logs/automation-logs";
+
+import { AutomationLogsController } from "./automation-logs.controller";
+
+import type { TestingModule } from "@nestjs/testing";
+import type { UUIDType } from "src/common";
+
+describe("AutomationLogsController", () => {
+  let controller: AutomationLogsController;
+  let repository: jest.Mocked<AutomationLogsRepository>;
+
+  const automationId = "auto-1" as UUIDType;
+
+  const mockLogs = [
+    { id: "log-1", automationId, status: "success", createdAt: "2025-07-01" },
+    { id: "log-2", automationId, status: "failed", createdAt: "2025-07-02" },
+  ];
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AutomationLogsController],
+      providers: [
+        {
+          provide: AutomationLogsRepository,
+          useValue: {
+            getAll: jest.fn(),
+            GetByAutomationId: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get(AutomationLogsController);
+    repository = module.get(AutomationLogsRepository);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("getAll", () => {
+    it("returns all logs wrapped in BaseResponse", async () => {
+      repository.getAll.mockResolvedValue(mockLogs as any);
+
+      const result = await controller.getAll();
+
+      expect(repository.getAll).toHaveBeenCalled();
+      expect(result).toBeInstanceOf(BaseResponse);
+      expect(result.data).toEqual(mockLogs);
+    });
+
+    it("returns empty array when no logs exist", async () => {
+      repository.getAll.mockResolvedValue([]);
+
+      const result = await controller.getAll();
+
+      expect(result.data).toEqual([]);
+    });
+  });
+
+  describe("getByAutomationId", () => {
+    it("returns logs for specific automation wrapped in BaseResponse", async () => {
+      repository.GetByAutomationId.mockResolvedValue(mockLogs as any);
+
+      const result = await controller.getByAutomationId(automationId);
+
+      expect(repository.GetByAutomationId).toHaveBeenCalledWith(automationId);
+      expect(result).toBeInstanceOf(BaseResponse);
+      expect(result.data).toEqual(mockLogs);
+    });
+
+    it("returns empty array when no logs for automation", async () => {
+      repository.GetByAutomationId.mockResolvedValue([]);
+
+      const result = await controller.getByAutomationId(automationId);
+
+      expect(result.data).toEqual([]);
+    });
+  });
+});

apps/api/src/automations/automation-logs/automation-logs.controller.ts

@@ -0,0 +1,25 @@
+import { Controller, Get, Param } from "@nestjs/common";
+import { PERMISSIONS } from "@repo/shared";
+
+import { BaseResponse, UUIDType } from "src/common";
+import { RequirePermission } from "src/common/decorators/require-permission.decorator";
+
+import { AutomationLogsRepository } from "../repositories/automation-logs/automation-logs";
+
+@RequirePermission(PERMISSIONS.AUTOMATION_MANAGE)
+@Controller("automation-logs")
+export class AutomationLogsController {
+  constructor(private readonly automationLogsRepository: AutomationLogsRepository) {}
+
+  @Get()
+  async getAll() {
+    const logs = await this.automationLogsRepository.getAll();
+    return new BaseResponse(logs);
+  }
+
+  @Get("automation/:automationId")
+  async getByAutomationId(@Param("automationId") automationId: UUIDType) {
+    const logs = await this.automationLogsRepository.GetByAutomationId(automationId);
+    return new BaseResponse(logs);
+  }
+}