@hexabot-ai/api 3.2.2-alpha.1 → 3.2.2-alpha.2

package/src/utils/test/fixtures/contenttype.ts

@@ -7,9 +7,9 @@
 import { ContentType } from '@hexabot-ai/types';
 import { DataSource, DeepPartial } from 'typeorm';
 
-import { DEFAULT_CONTENT_TYPE_SCHEMA } from '@/cms';
 import { ContentTypeCreateDto } from '@/cms/dto/contentType.dto';
 import { ContentTypeOrmEntity } from '@/cms/entities/content-type.entity';
+import { DEFAULT_CONTENT_TYPE_SCHEMA } from '@/cms/services/content-type.service';
 
 import { getFixturesWithDefaultValues } from '../defaultValues';
 import { FixturesTypeBuilder } from '../types';

package/src/utils/test/test.ts

@@ -4,14 +4,45 @@
  * Full terms: see LICENSE.md.
  */
 
+import type { TestingModule } from '@nestjs/testing';
 import { DataSource } from 'typeorm';
 
 const typeOrmDataSources: DataSource[] = [];
+const testingModules: TestingModule[] = [];
 
 export const registerTypeOrmDataSource = (dataSource: DataSource) => {
   typeOrmDataSources.push(dataSource);
 };
 
+export const registerTestingModule = (module: TestingModule) => {
+  const close = module.close.bind(module);
+  let closed = false;
+
+  module.close = async () => {
+    if (closed) {
+      return;
+    }
+
+    closed = true;
+    const moduleIndex = testingModules.indexOf(module);
+
+    if (moduleIndex >= 0) {
+      testingModules.splice(moduleIndex, 1);
+    }
+
+    await close();
+  };
+
+  testingModules.push(module);
+};
+
+export const closeTestingModules = async () => {
+  const modules = [...testingModules];
+
+  testingModules.length = 0;
+  await Promise.all(modules.map((module) => module.close()));
+};
+
 export const closeTypeOrmConnections = async () => {
   await Promise.all(
     typeOrmDataSources.map(async (dataSource) => {
@@ -25,3 +56,11 @@ export const closeTypeOrmConnections = async () => {
 
 export const getLastTypeOrmDataSource = () =>
   typeOrmDataSources[typeOrmDataSources.length - 1];
+
+export const closeTestingResources = async () => {
+  try {
+    await closeTestingModules();
+  } finally {
+    await closeTypeOrmConnections();
+  }
+};

package/src/utils/test/utils.ts

@@ -33,7 +33,7 @@ import { SettingModule } from '@/setting/setting.module';
 
 import { I18nTestingModule } from './modules/i18n-testing.module';
 import { I18nServiceProvider } from './providers/i18n-service.provider';
-import { registerTypeOrmDataSource } from './test';
+import { registerTestingModule, registerTypeOrmDataSource } from './test';
 
 type TTypeOrToken = [
   new (...args: any[]) => any,
@@ -51,12 +51,16 @@ type TypeOrmTestingConfig = {
   fixtures?: TypeOrmFixture | TypeOrmFixture[];
   dataSourceOptions?: Partial<DataSourceOptions>;
 };
+type TypeOrmTestingInput =
+  | TypeOrmTestingConfig
+  | TypeOrmTestingConfig[]
+  | false;
 
 type buildTestingMocksProps<
   P extends ModuleMetadata['providers'] = ModuleMetadata['providers'],
   C extends ModuleMetadata['controllers'] = ModuleMetadata['controllers'],
 > = ModuleMetadata & {
-  typeorm?: TypeOrmTestingConfig | TypeOrmTestingConfig[];
+  typeorm?: TypeOrmTestingInput;
 } & (
     | {
         providers: NonNullable<P>;
@@ -108,7 +112,10 @@ const getParamTypes = (provider: Provider) =>
  * @param parentClass - The root provider class whose dependency graph is resolved.
  * @returns A complete array of unique provider dependencies.
  */
-const getClassDependencies = (parentClass: Provider): Provider[] => {
+const getClassDependencies = (
+  parentClass: Provider,
+  providedTokens = new Set<Provider>(),
+): Provider[] => {
   const dependencies: Provider[] = [];
   const seenClasses = new Set<Provider>();
   const classQueue: Provider[] = [parentClass];
@@ -124,7 +131,11 @@ const getClassDependencies = (parentClass: Provider): Provider[] => {
 
     if (currentClass) {
       getParamTypes(currentClass).forEach((paramType: Provider) => {
-        if (paramType && !seenClasses.has(paramType)) {
+        if (
+          paramType &&
+          !seenClasses.has(paramType) &&
+          !providedTokens.has(paramType)
+        ) {
           classQueue.push(paramType);
           dependencies.push(paramType);
         }
@@ -136,6 +147,17 @@ const getClassDependencies = (parentClass: Provider): Provider[] => {
 };
 const filterNestedDependencies = (dependency: Provider) =>
   dependency.valueOf().toString().slice(0, 6) === 'class ';
+const resolveProviderToken = (provider: Provider): Provider | undefined => {
+  if (
+    typeof provider === 'object' &&
+    provider !== null &&
+    'provide' in provider
+  ) {
+    return provider.provide as Provider;
+  }
+
+  return provider;
+};
 /**
  * Identifies nested class-based dependencies to be automatically injected into test modules.
  *
@@ -145,9 +167,14 @@ const filterNestedDependencies = (dependency: Provider) =>
 const autoInjectExclusions = new Set<Provider>([DataSource]);
 const getNestedDependencies = (providers: Provider[]): Provider[] => {
   const nestedDependencies = new Set<Provider>();
+  const providedTokens = new Set<Provider>(
+    providers
+      .map(resolveProviderToken)
+      .filter((provider): provider is Provider => provider !== undefined),
+  );
 
   providers.filter(filterNestedDependencies).forEach((provider) => {
-    getClassDependencies(provider)
+    getClassDependencies(provider, providedTokens)
       .filter(filterNestedDependencies)
       .forEach((dependency) => {
         if (autoInjectExclusions.has(dependency)) {
@@ -213,6 +240,24 @@ const buildEntityLookup = () => {
 
   return lookup;
 };
+const addEntityToLookup = (
+  lookup: Map<string, EntityTarget<any>>,
+  entity: EntityTarget<any> | undefined,
+): EntityTarget<any> | undefined => {
+  if (!entity) {
+    return undefined;
+  }
+
+  const key = resolveEntityTargetName(entity);
+  if (key) {
+    lookup.set(key, entity);
+  }
+
+  return entity;
+};
+const refreshEntityLookup = (lookup: Map<string, EntityTarget<any>>): void => {
+  buildEntityLookup().forEach((entity, key) => lookup.set(key, entity));
+};
 const registeredSubscribers = new Set<unknown>();
 const registerAllRepositorySubscribers = (
   dataSource: DataSource,
@@ -314,22 +359,41 @@ const extractInjectTokensFromProvider = (provider: ProviderLike): unknown[] => {
 
   return [];
 };
-const registerMetadataEntities = (
-  currentEntities: Set<EntityTarget<any>>,
-  lookup: Map<string, EntityTarget<any>>,
-): void => {
-  lookup.forEach((entity) => currentEntities.add(entity));
+const dependsOnDataSource = (provider: ProviderLike): boolean => {
+  if (!provider) {
+    return false;
+  }
+
+  if (typeof provider === 'function') {
+    return (
+      getParamTypes(provider).includes(DataSource) ||
+      extractCustomInjectTokens(provider).includes(DataSource)
+    );
+  }
+
+  if (typeof provider === 'object') {
+    if ('useClass' in provider && typeof provider.useClass === 'function') {
+      return dependsOnDataSource(provider.useClass);
+    }
+
+    if ('inject' in provider && Array.isArray(provider.inject)) {
+      return provider.inject.includes(DataSource);
+    }
+  }
+
+  return false;
 };
 const registerAutoDetectedTypeOrmEntities = (
   currentEntities: Set<EntityTarget<any>>,
   providers: Provider[],
   controllers: ModuleMetadata['controllers'],
   lookup: Map<string, EntityTarget<any>>,
-) => {
+): boolean => {
   if (!lookup.size) {
-    return;
+    return false;
   }
 
+  let detected = false;
   const controllerList = Array.isArray(controllers) ? controllers : [];
   const tokens = [
     ...providers.flatMap(extractInjectTokensFromProvider),
@@ -340,8 +404,147 @@ const registerAutoDetectedTypeOrmEntities = (
     const entity = resolveEntityFromToken(token, lookup);
     if (entity) {
       currentEntities.add(entity);
+      detected = true;
     }
   });
+
+  return detected;
+};
+const addEntityToSet = (
+  entities: Set<EntityTarget<any>>,
+  entity: EntityTarget<any> | undefined,
+  queue: EntityTarget<any>[],
+): void => {
+  if (!entity || entities.has(entity)) {
+    return;
+  }
+
+  entities.add(entity);
+  queue.push(entity);
+};
+const isSameEntityTarget = (
+  left: EntityTarget<any> | undefined,
+  right: EntityTarget<any>,
+): boolean => {
+  if (!left) {
+    return false;
+  }
+
+  if (left === right) {
+    return true;
+  }
+
+  const leftName = resolveEntityTargetName(left);
+  const rightName = resolveEntityTargetName(right);
+
+  return !!leftName && leftName === rightName;
+};
+const resolveRelationTarget = async (
+  relationType: unknown,
+  lookup: Map<string, EntityTarget<any>>,
+): Promise<EntityTarget<any> | undefined> => {
+  if (typeof relationType === 'string') {
+    return lookup.get(relationType);
+  }
+
+  if (typeof relationType === 'function') {
+    try {
+      const resolved = relationType();
+
+      if (typeof resolved === 'string') {
+        return resolveRelationTarget(resolved, lookup);
+      }
+
+      return addEntityToLookup(lookup, resolved as EntityTarget<any>);
+    } catch {
+      return addEntityToLookup(lookup, relationType as EntityTarget<any>);
+    }
+  }
+
+  return undefined;
+};
+const registerInheritedTypeOrmEntities = (
+  currentEntities: Set<EntityTarget<any>>,
+  entity: EntityTarget<any>,
+  lookup: Map<string, EntityTarget<any>>,
+  queue: EntityTarget<any>[],
+): void => {
+  if (typeof entity !== 'function') {
+    return;
+  }
+
+  let prototype = Object.getPrototypeOf(entity.prototype);
+
+  while (prototype?.constructor && prototype.constructor !== Object) {
+    const parent = lookup.get(prototype.constructor.name);
+    if (parent) {
+      addEntityToSet(currentEntities, parent, queue);
+    }
+
+    prototype = Object.getPrototypeOf(prototype);
+  }
+};
+const registerChildTypeOrmEntities = (
+  currentEntities: Set<EntityTarget<any>>,
+  entity: EntityTarget<any>,
+  lookup: Map<string, EntityTarget<any>>,
+  queue: EntityTarget<any>[],
+): void => {
+  if (typeof entity !== 'function') {
+    return;
+  }
+
+  getMetadataArgsStorage().tables.forEach((table) => {
+    if (
+      table.type !== 'entity-child' ||
+      typeof table.target !== 'function' ||
+      !entity.prototype.isPrototypeOf(table.target.prototype)
+    ) {
+      return;
+    }
+
+    addEntityToSet(
+      currentEntities,
+      addEntityToLookup(lookup, table.target as EntityTarget<any>),
+      queue,
+    );
+  });
+};
+const registerRelatedTypeOrmEntities = async (
+  currentEntities: Set<EntityTarget<any>>,
+  lookup: Map<string, EntityTarget<any>>,
+): Promise<void> => {
+  const queue = Array.from(currentEntities);
+
+  while (queue.length > 0) {
+    const entity = queue.shift()!;
+    const storage = getMetadataArgsStorage();
+
+    refreshEntityLookup(lookup);
+    registerInheritedTypeOrmEntities(currentEntities, entity, lookup, queue);
+    registerChildTypeOrmEntities(currentEntities, entity, lookup, queue);
+
+    const relations = storage.relations.filter((relation) =>
+      isSameEntityTarget(relation.target as EntityTarget<any>, entity),
+    );
+
+    for (const relation of relations) {
+      const relationEntity = await resolveRelationTarget(relation.type, lookup);
+      addEntityToSet(currentEntities, relationEntity, queue);
+    }
+
+    for (const relation of storage.relations) {
+      const relationEntity = await resolveRelationTarget(relation.type, lookup);
+
+      if (isSameEntityTarget(relationEntity, entity)) {
+        addEntityToSet(
+          currentEntities,
+          addEntityToLookup(lookup, relation.target as EntityTarget<any>),
+          queue,
+        );
+      }
+    }
+  }
 };
 
 /**
@@ -421,27 +624,33 @@ export const buildTestingMocks = async ({
         overrideTokens.has(provider as unknown as Provider)
       ),
   );
-  const defaultTypeOrmEntities: EntityTarget<any>[] = [
-    SettingOrmEntity,
-    MetadataOrmEntity,
-    LanguageOrmEntity,
-  ];
-  const typeOrmEntities = new Set<EntityTarget<any>>(defaultTypeOrmEntities);
+  const typeOrmDisabled = typeorm === false;
+  let typeOrmOptions: Partial<DataSourceOptions> | undefined;
+  const typeOrmFixtures: TypeOrmFixture[] = [];
+  const typeOrmConfigs =
+    !typeOrmDisabled && Array.isArray(typeorm)
+      ? typeorm.filter(Boolean)
+      : !typeOrmDisabled && typeorm
+        ? [typeorm]
+        : [];
+  const hasExplicitTypeOrmConfig = typeOrmConfigs.length > 0;
+  const typeOrmEntities = new Set<EntityTarget<any>>();
   const entityLookup = buildEntityLookup();
-  registerMetadataEntities(typeOrmEntities, entityLookup);
-  registerAutoDetectedTypeOrmEntities(
+  const hasTypeOrmEntityDependencies = registerAutoDetectedTypeOrmEntities(
     typeOrmEntities,
     providersList,
     controllers,
     entityLookup,
   );
-  let typeOrmOptions: Partial<DataSourceOptions> | undefined;
-  const typeOrmFixtures: TypeOrmFixture[] = [];
-  const typeOrmConfigs = Array.isArray(typeorm)
-    ? typeorm.filter(Boolean)
-    : typeorm
-      ? [typeorm]
-      : [];
+  const controllerList = Array.isArray(controllers) ? controllers : [];
+  const hasDataSourceDependencies = [...providersList, ...controllerList].some(
+    dependsOnDataSource,
+  );
+  const shouldUseTypeOrm =
+    !typeOrmDisabled &&
+    (hasExplicitTypeOrmConfig ||
+      hasTypeOrmEntityDependencies ||
+      hasDataSourceDependencies);
 
   typeOrmConfigs.forEach((config) => {
     config.entities?.forEach((entity) => typeOrmEntities.add(entity));
@@ -459,43 +668,59 @@ export const buildTestingMocks = async ({
     }
   });
 
+  if (shouldUseTypeOrm && typeOrmEntities.size === 0) {
+    entityLookup.forEach((entity) => typeOrmEntities.add(entity));
+  }
+
+  if (shouldUseTypeOrm) {
+    [SettingOrmEntity, MetadataOrmEntity, LanguageOrmEntity].forEach((entity) =>
+      typeOrmEntities.add(entity),
+    );
+    await registerRelatedTypeOrmEntities(typeOrmEntities, entityLookup);
+  }
+
   const runTypeOrmFixtures = async (dataSource: DataSource) => {
     for (const fixture of typeOrmFixtures) {
       await fixture(dataSource);
     }
   };
   const entitiesArray = Array.from(typeOrmEntities);
-  const baseOptions: DataSourceOptions = {
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    logging: false,
-    entities: entitiesArray,
-    ...(typeOrmOptions ?? {}),
-  } as DataSourceOptions;
-  const dataSource = new DataSource(baseOptions);
-  await dataSource.initialize();
-  registerAllRepositorySubscribers(dataSource, entitiesArray as any[]);
-  await runTypeOrmFixtures(dataSource);
-  registerTypeOrmDataSource(dataSource);
-
-  const typeOrmRootModule: DynamicModule = TypeOrmModule.forRootAsync({
-    useFactory: async () => baseOptions as DataSourceOptions,
-    dataSourceFactory: async () => dataSource,
-  });
-  const typeOrmProviders = entitiesArray.map((entity) => ({
-    provide: getRepositoryToken(entity as any),
-    useValue: dataSource.getRepository(entity),
-  }));
+  let typeOrmRootModule: DynamicModule | undefined;
+  let typeOrmProviders: Provider[] = [];
+
+  if (shouldUseTypeOrm) {
+    const baseOptions: DataSourceOptions = {
+      type: 'sqlite',
+      database: ':memory:',
+      synchronize: true,
+      dropSchema: true,
+      logging: false,
+      entities: entitiesArray,
+      ...(typeOrmOptions ?? {}),
+    } as DataSourceOptions;
+    const dataSource = new DataSource(baseOptions);
+    await dataSource.initialize();
+    registerAllRepositorySubscribers(dataSource, entitiesArray as any[]);
+    await runTypeOrmFixtures(dataSource);
+    registerTypeOrmDataSource(dataSource);
+
+    typeOrmRootModule = TypeOrmModule.forRootAsync({
+      useFactory: async () => baseOptions as DataSourceOptions,
+      dataSourceFactory: async () => dataSource,
+    });
+    typeOrmProviders = entitiesArray.map((entity) => ({
+      provide: getRepositoryToken(entity as any),
+      useValue: dataSource.getRepository(entity),
+    }));
+  }
+
   const testingModuleBuilder = Test.createTestingModule({
     imports: [
       LoggerModule,
       EventEmitterModule.forRoot({ global: true }),
       CacheModule.register({ isGlobal: true }),
-      typeOrmRootModule,
       I18nTestingModule,
-      SettingModule,
+      ...(typeOrmRootModule ? [typeOrmRootModule, SettingModule] : []),
       ...imports,
     ],
     providers: [
@@ -507,6 +732,7 @@ export const buildTestingMocks = async ({
     ...rest,
   });
   const module = await testingModuleBuilder.compile();
+  registerTestingModule(module);
 
   return {
     module,

package/src/websocket/websocket.gateway.ts

@@ -18,6 +18,7 @@ import {
   WebSocketGateway,
   WebSocketServer,
 } from '@nestjs/websockets';
+import { isUUID } from 'class-validator';
 import Cookie from 'cookie';
 import signature from 'cookie-signature';
 import { Request } from 'express';
@@ -25,7 +26,6 @@ import { Session as ExpressSession, SessionData } from 'express-session';
 import { ExtendedError, Server, Socket } from 'socket.io';
 import { DataSource } from 'typeorm';
 import { sync as uid } from 'uid-safe';
-import { validate as isUuid } from 'uuid';
 
 import { SourceOrmEntity } from '@/channel/entities/source.entity';
 import { config } from '@/config';
@@ -179,7 +179,7 @@ export class WebsocketGateway
   }
 
   private normalizeSourceId(value: string | null): string | null {
-    if (!value || !isUuid(value)) {
+    if (!value || !isUUID(value)) {
       return null;
     }
 

package/src/workflow/entities/workflow-version.entity.ts

@@ -5,6 +5,7 @@
  */
 
 import { createHash } from 'crypto';
+import { createRequire } from 'node:module';
 
 import {
   workflowVersionSchema,
@@ -32,7 +33,9 @@ import { AsRelation } from '@/utils';
 import { WorkflowVersionDto } from '../dto/workflow-version.dto';
 import { WorkflowVersionAction } from '../types';
 
-import { WorkflowOrmEntity } from './workflow.entity';
+import type { WorkflowOrmEntity } from './workflow.entity';
+
+const requireEntity = createRequire(__filename);
 
 @Entity({ name: 'workflow_versions' })
 @Index(['workflow', 'version'], { unique: true })
@@ -42,7 +45,7 @@ export class WorkflowVersionOrmEntity extends BaseOrmEntity<WorkflowVersionDto>
   fullCls = workflowVersionFullSchema;
 
   /** Workflow that owns this version snapshot. */
-  @ManyToOne(() => WorkflowOrmEntity, {
+  @ManyToOne(() => requireEntity('./workflow.entity').WorkflowOrmEntity, {
     nullable: false,
     onDelete: 'CASCADE',
   })
@@ -130,7 +133,9 @@ export class WorkflowVersionOrmEntity extends BaseOrmEntity<WorkflowVersionDto>
       return;
     }
 
-    const workflowRepository = event.manager.getRepository(WorkflowOrmEntity);
+    const WorkflowEntity = requireEntity('./workflow.entity').WorkflowOrmEntity;
+    const workflowRepository =
+      event.manager.getRepository<WorkflowOrmEntity>(WorkflowEntity);
     const workflow = await workflowRepository.findOne({
       where: { id: workflowId },
     });

package/src/workflow/services/memory.service.ts

@@ -40,6 +40,7 @@ export class MemoryService {
     const records = await this.memoryRecordService.findActiveByScope({
       ownerId,
       workflowId,
+      threadId,
       runId,
     });
 

package/src/workflow/utils/memory-store.ts

@@ -9,6 +9,7 @@ import { ZodSchema, z } from 'zod';
 
 import { cloneObject } from '@/utils/helpers/clone';
 import { deepFreeze } from '@/utils/helpers/freeze';
+import { deepMerge } from '@/utils/helpers/object';
 
 import { WorkflowRuntimeContext } from '../contexts/workflow-runtime.context';
 import {
@@ -377,9 +378,20 @@ export class MemoryStore {
 
     const updates = await Promise.all(
       entries.map(async ([slug, value]) => {
+        const currentValue = this.raw[slug];
+        const canMerge =
+          currentValue !== null &&
+          value !== null &&
+          typeof currentValue === 'object' &&
+          typeof value === 'object' &&
+          !Array.isArray(currentValue) &&
+          !Array.isArray(value);
+        const nextValue = canMerge
+          ? deepMerge(cloneObject(currentValue), value)
+          : value;
         const parsedValue = await this.updateStoreEntry(
           slug,
-          value,
+          nextValue,
           persistRecord,
         );
 

package/dist/mailer/mjml-adapter.class.d.ts

@@ -1,4 +0,0 @@
-import { TemplateAdapter } from '@nestjs-modules/mailer';
-export declare class MjmlAdapter implements TemplateAdapter {
-    compile: TemplateAdapter['compile'];
-}

package/dist/mailer/mjml-adapter.class.js

@@ -1,67 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MjmlAdapter = void 0;
-const fs = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
-const common_1 = require("@nestjs/common");
-const handlebars_1 = __importDefault(require("handlebars"));
-class MjmlAdapter {
-    constructor() {
-        this.compile = async (mail, callback, options) => {
-            try {
-                const templatePath = path_1.default.join(options.template?.dir || '', mail.data.template || '');
-                const content = fs.readFileSync(templatePath, 'utf-8');
-                const delegate = handlebars_1.default.compile(content);
-                const compiledHandlebars = delegate(mail.data.context);
-                const mjml2html = await Promise.resolve().then(() => __importStar(require('mjml')));
-                const { errors, html } = await mjml2html.default(compiledHandlebars);
-                if (errors.length) {
-                    throw 'Unable to compiling mjml';
-                }
-                mail.data.html = html;
-                callback();
-            }
-            catch (err) {
-                common_1.Logger.error('@nestjs-modules/mailer: Unable to compiling mjml', err);
-            }
-        };
-    }
-}
-exports.MjmlAdapter = MjmlAdapter;
-//# sourceMappingURL=mjml-adapter.class.js.map