@travetto/email-compiler 3.1.21 → 3.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/email-compiler",
-  "version": "3.1.21",
+  "version": "3.1.23",
   "description": "Email compiling module",
   "keywords": [
     "email",
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@travetto/base": "^3.1.3",
-    "@travetto/config": "^3.1.7",
+    "@travetto/config": "^3.1.8",
     "@travetto/di": "^3.1.4",
-    "@travetto/email": "^3.1.13",
+    "@travetto/email": "^3.1.14",
     "@travetto/image": "^3.1.4",
     "@types/inline-css": "^3.0.1",
     "html-entities": "^2.3.3",
@@ -38,7 +38,7 @@
     "purgecss": "^5.0.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.1.8"
+    "@travetto/cli": "^3.1.9"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 
 import { FileQueryProvider, TypedObject } from '@travetto/base';
-import { MessageCompilationSource, MessageCompiled } from '@travetto/email';
+import { EmailCompileSource, EmailCompiled, EmailCompileContext, MailUtil } from '@travetto/email';
 import { RootIndex, path } from '@travetto/manifest';
 import { DynamicFileLoader } from '@travetto/base/src/internal/file-loader';
 
@@ -15,13 +15,19 @@ const VALID_FILE = (file: string): boolean => /[.](scss|css|png|jpe?g|gif|ya?ml)
 export class EmailCompiler {
 
   /** Load Template */
-  static async loadTemplate(file: string): Promise<MessageCompilationSource> {
+  static async loadTemplate(file: string): Promise<EmailCompileContext> {
     const entry = RootIndex.getEntry(file);
     if (!entry) {
       throw new Error(`Unable to find template for ${file}`);
     }
     const root = (await import(entry.outputFile)).default;
-    const res: MessageCompilationSource = { ...await root.wrap(), file: entry.sourceFile };
+    const og: EmailCompileSource = await root.wrap();
+    const res = {
+      file: entry.sourceFile,
+      module: entry.module,
+      ...og
+    };
+
     const mod = RootIndex.getModule(entry.module)!;
 
     const resourcePaths = [
@@ -51,7 +57,7 @@ export class EmailCompiler {
   /**
    * Get output files
    */
-  static getOutputFiles(file: string): MessageCompiled {
+  static getOutputFiles(file: string): EmailCompiled {
     const entry = RootIndex.getEntry(file)!;
     const mod = RootIndex.getModule(entry.module)!;
     return EmailCompileUtil.getOutputs(file, path.join(mod.sourcePath, 'resources'));
@@ -67,12 +73,12 @@ export class EmailCompiler {
   /**
    * Write template to file
    */
-  static async writeTemplate(file: string, msg: MessageCompiled): Promise<void> {
+  static async writeTemplate(file: string, msg: EmailCompiled): Promise<void> {
     const outs = this.getOutputFiles(file);
     await Promise.all(TypedObject.keys(outs).map(async k => {
       if (msg[k]) {
         await fs.mkdir(path.dirname(outs[k]), { recursive: true });
-        await fs.writeFile(outs[k], msg[k], { encoding: 'utf8' });
+        await fs.writeFile(outs[k], MailUtil.buildBrand(file, msg[k], 'trv email:compile'), { encoding: 'utf8' });
       } else {
         await fs.unlink(outs[k]).catch(() => { }); // Remove file if data not provided
       }
@@ -82,7 +88,7 @@ export class EmailCompiler {
   /**
    * Compile a file given a resource provider
    */
-  static async compile(file: string, persist: boolean = false): Promise<MessageCompiled> {
+  static async compile(file: string, persist: boolean = false): Promise<EmailCompiled> {
     const src = await this.loadTemplate(file);
     const compiled = await EmailCompileUtil.compile(src);
     if (persist) {
@@ -128,6 +134,7 @@ export class EmailCompiler {
       try {
         if (EmailCompileUtil.isTemplateFile(file)) {
           await this.compile(file, true);
+          console.log(`Successfully compiled ${1} templates`, { changed: [file] });
           yield file;
         } else if (VALID_FILE(file)) {
           const rootFile = file.replace(/\/resources.*/, '/package.json');

package/src/util.ts

@@ -2,11 +2,13 @@ import util from 'util';
 import { Readable } from 'stream';
 
 import { FileResourceProvider, StreamUtil } from '@travetto/base';
-import { MessageCompilationImages, MessageCompilationSource, MessageCompilationStyles, MessageCompiled } from '@travetto/email';
+import {
+  EmailTemplateImageConfig, EmailTemplateStyleConfig,
+  EmailCompiled, EmailCompileContext
+} from '@travetto/email';
 import { ImageConverter } from '@travetto/image';
 import { path } from '@travetto/manifest';
 
-
 type Tokenized = {
   text: string;
   tokens: Map<string, string>;
@@ -42,7 +44,7 @@ export class EmailCompileUtil {
   /**
    * Get the different parts from the file name
    */
-  static getOutputs(file: string, prefix?: string): MessageCompiled {
+  static getOutputs(file: string, prefix?: string): EmailCompiled {
     return {
       html: this.buildOutputPath(file, '.compiled.html', prefix),
       subject: this.buildOutputPath(file, '.compiled.subject', prefix),
@@ -132,7 +134,7 @@ export class EmailCompileUtil {
   /**
    * Inline image sources
    */
-  static async inlineImages(html: string, opts: MessageCompilationImages): Promise<string> {
+  static async inlineImages(html: string, opts: EmailTemplateImageConfig): Promise<string> {
     const { tokens, finalize } = await this.tokenizeResources(html, this.#HTML_CSS_IMAGE_URLS);
     const pendingImages: [token: string, ext: string, stream: Readable | Promise<Readable>][] = [];
     const resources = new FileResourceProvider(opts.search ?? []);
@@ -157,6 +159,7 @@ export class EmailCompileUtil {
    */
   static handleHtmlEdgeCases(html: string): string {
     return html
+      .replace(/\n{3,100}/msg, '\n\n')
       .replace(/<(meta|img|link|hr|br)[^>]*>/g, a => a.replace('>', '/>')) // Fix self closing
       .replace(/&apos;/g, '&#39;') // Fix apostrophes, as outlook hates them
       .replace(/(background(?:-color)?:\s*)([#0-9a-f]{6,8})([^>.#,]+)>/ig,
@@ -164,14 +167,16 @@ export class EmailCompileUtil {
       .replace(/<([^>]+vertical-align:\s*(top|bottom|middle)[^>]+)>/g,
         (a, tag, valign) => tag.indexOf('valign') ? `<${tag}>` : `<${tag} valign="${valign}">`) // Vertically align if it has the style
       .replace(/<(table[^>]+expand[^>]+width:\s*)(100%\s+!important)([^>]+)>/g,
-        (a, left, size, right) => `<${left}100%${right}>`); // Drop important as a fix for outlook
+        (a, left, size, right) => `<${left}100%${right}>`) // Drop important as a fix for outlook
+      .trim()
+      .concat('\n');
   }
 
 
   /**
    * Apply styles into a given html document
    */
-  static async applyStyles(html: string, opts: MessageCompilationStyles): Promise<string> {
+  static async applyStyles(html: string, opts: EmailTemplateStyleConfig): Promise<string> {
     const styles: string[] = [];
 
     if (opts.global) {
@@ -200,11 +205,11 @@ export class EmailCompileUtil {
     return html;
   }
 
-  static async compile(src: MessageCompilationSource): Promise<MessageCompiled> {
-    const subject = await this.simplifiedText(await src.subject());
-    const text = await this.simplifiedText(await src.text());
+  static async compile(src: EmailCompileContext): Promise<EmailCompiled> {
+    const subject = await this.simplifiedText(await src.subject(src));
+    const text = await this.simplifiedText(await src.text(src));
 
-    let html = await src.html();
+    let html = await src.html(src);
 
     if (src.styles?.inline !== false) {
       html = await this.applyStyles(html, src.styles!);
@@ -216,6 +221,7 @@ export class EmailCompileUtil {
     if (src.images?.inline !== false) {
       html = await this.inlineImages(html, src.images!);
     }
+
     return { html, subject, text };
   }
 }

package/support/bin/config.ts

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 
-import { path } from '@travetto/manifest';
+import { RootIndex, path } from '@travetto/manifest';
 import { YamlUtil } from '@travetto/yaml';
 
 interface ConfigType {
@@ -22,7 +22,7 @@ interface ConfigType {
  */
 export class $EditorConfig {
 
-  #configFile = path.resolve('resources/email/dev.yml');
+  #configFile: Record<string, string> = {};
   #defaultConfig = {
     to: 'my-email@gmail.com',
     from: 'from-email@gmail.com',
@@ -42,9 +42,10 @@ export class $EditorConfig {
   /**
    *
    */
-  async get(): Promise<ConfigType> {
+  async get(file: string): Promise<ConfigType> {
     try {
-      const content = await fs.readFile(this.#configFile, 'utf8');
+      const mod = RootIndex.getModuleFromSource(file)!.name;
+      const content = await fs.readFile(this.#configFile[mod], 'utf8');
       return YamlUtil.parse<ConfigType>(content);
     } catch {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -52,13 +53,13 @@ export class $EditorConfig {
     }
   }
 
-  async getContext(): Promise<Exclude<ConfigType['context'], undefined>> {
-    const conf = await this.get();
+  async getContext(file: string): Promise<Exclude<ConfigType['context'], undefined>> {
+    const conf = await this.get(file);
     return conf.context ?? {};
   }
 
-  async getSenderConfig(): Promise<Exclude<ConfigType['sender'], undefined>> {
-    const conf = await this.get();
+  async getSenderConfig(file: string): Promise<Exclude<ConfigType['sender'], undefined>> {
+    const conf = await this.get(file);
     return conf.sender ?? {};
   }
 
@@ -66,13 +67,15 @@ export class $EditorConfig {
     return YamlUtil.serialize(this.#defaultConfig);
   }
 
-  async ensureConfig(): Promise<string> {
-    const file = this.#configFile;
-    if (!(await fs.stat(file).catch(() => { }))) {
-      await fs.mkdir(path.dirname(file), { recursive: true });
-      await fs.writeFile(file, this.getDefaultConfig(), { encoding: 'utf8' });
+  async ensureConfig(file: string): Promise<string> {
+    console.log('Ensuring config', file);
+    const mod = RootIndex.getModuleFromSource(file)!;
+    const resolved = this.#configFile[mod.name] ??= path.resolve(mod.sourcePath, 'resources/email/dev.yml');
+    if (!(await fs.stat(resolved).catch(() => { }))) {
+      await fs.mkdir(path.dirname(resolved), { recursive: true });
+      await fs.writeFile(resolved, this.getDefaultConfig(), { encoding: 'utf8' });
     }
-    return file;
+    return resolved;
   }
 }
 

package/support/bin/editor.ts

@@ -1,3 +1,5 @@
+import { ShutdownManager } from '@travetto/base';
+
 import { EmailCompilationManager } from './manager';
 import { EditorSendService } from './send';
 import { EditorConfig } from './config';
@@ -6,7 +8,7 @@ import { EmailCompiler } from '../../src/compiler';
 import { EmailCompileUtil } from '../../src/util';
 
 type InboundMessage =
-  { type: 'configure' } |
+  { type: 'configure', file: string } |
   { type: 'redraw', file: string } |
   { type: 'send', file: string, from?: string, to?: string };
 
@@ -23,12 +25,10 @@ type OutboundMessage =
 export class EditorState {
 
   #lastFile = '';
-  #sender: EditorSendService;
   #template: EmailCompilationManager;
 
   constructor(template: EmailCompilationManager) {
     this.#template = template;
-    this.#sender = new EditorSendService();
   }
 
   async renderFile(file: string): Promise<void> {
@@ -36,7 +36,7 @@ export class EditorState {
     if (file) {
       try {
         const content = await this.#template.resolveCompiledTemplate(
-          file, await EditorConfig.getContext()
+          file, await EditorConfig.getContext(file)
         );
         this.response({
           type: 'changed',
@@ -60,7 +60,7 @@ export class EditorState {
   }
 
   async onConfigure(msg: InboundMessage & { type: 'configure' }): Promise<void> {
-    this.response({ type: 'configured', file: await EditorConfig.ensureConfig() });
+    this.response({ type: 'configured', file: await EditorConfig.ensureConfig(msg.file) });
   }
 
   async #onRedraw(msg: InboundMessage & { type: 'redraw' }): Promise<void> {
@@ -77,15 +77,15 @@ export class EditorState {
   }
 
   async onSend(msg: InboundMessage & { type: 'send' }): Promise<void> {
-    const cfg = await EditorConfig.get();
+    const cfg = await EditorConfig.get(msg.file);
     const to = msg.to || cfg.to;
     const from = msg.from || cfg.from;
     const content = await this.#template.resolveCompiledTemplate(
-      msg.file!, await EditorConfig.getContext()
+      msg.file, await EditorConfig.getContext(msg.file)
     );
 
     try {
-      const url = await this.#sender.sendEmail({ from, to, ...content, });
+      const url = await EditorSendService.sendEmail(msg.file, { from, to, ...content, });
       this.response({ type: 'sent', to, file: msg.file, ...url });
     } catch (err) {
       if (err && err instanceof Error) {
@@ -107,6 +107,10 @@ export class EditorState {
         case 'send': this.onSend(msg); break;
       }
     });
+
+    process.on('disconnect', () => ShutdownManager.execute());
+    process.send?.('ready');
+
     for await (const f of EmailCompiler.watchCompile()) {
       await this.renderFile(f);
     }

package/support/bin/manager.ts

@@ -1,9 +1,9 @@
 import fs from 'fs/promises';
 
-import type { MailTemplateEngine, MessageCompiled } from '@travetto/email';
+import { type MailInterpolator, type EmailCompiled } from '@travetto/email';
 import { DependencyRegistry } from '@travetto/di';
 import { TypedObject } from '@travetto/base';
-import { MailTemplateEngineTarget } from '@travetto/email/src/internal/types';
+import { MailInterpolatorTarget } from '@travetto/email/src/internal/types';
 
 import { EmailCompiler } from '../../src/compiler';
 
@@ -14,20 +14,20 @@ export class EmailCompilationManager {
 
   static async createInstance(): Promise<EmailCompilationManager> {
     return new EmailCompilationManager(
-      await DependencyRegistry.getInstance<MailTemplateEngine>(MailTemplateEngineTarget),
+      await DependencyRegistry.getInstance<MailInterpolator>(MailInterpolatorTarget),
     );
   }
 
-  engine: MailTemplateEngine;
+  engine: MailInterpolator;
 
-  constructor(engine: MailTemplateEngine) {
+  constructor(engine: MailInterpolator) {
     this.engine = engine;
   }
 
   /**
    * Resolve template
    */
-  async resolveTemplateParts(file: string): Promise<MessageCompiled> {
+  async resolveTemplateParts(file: string): Promise<EmailCompiled> {
     const files = EmailCompiler.getOutputFiles(file);
     const missing = await Promise.all(Object.values(files).map(x => fs.stat(file).catch(() => { })));
 
@@ -41,21 +41,20 @@ export class EmailCompilationManager {
           .then(content => [key, content] as const)
       )
     );
-    return TypedObject.fromEntries<keyof MessageCompiled, string>(parts);
+    return TypedObject.fromEntries<keyof EmailCompiled, string>(parts);
   }
 
   /**
    * Render
    * @param rel
    */
-  async resolveCompiledTemplate(rel: string, context: Record<string, unknown>): Promise<MessageCompiled> {
+  async resolveCompiledTemplate(rel: string, context: Record<string, unknown>): Promise<EmailCompiled> {
+    const { MailUtil } = await import('@travetto/email');
     const { html, text, subject } = await this.resolveTemplateParts(rel);
 
-    return {
-      html: await this.engine.template(html, context),
-      text: await this.engine.template(text, context),
-      subject: await this.engine.template(subject, context),
-    };
-  }
+    const get = (input: string): Promise<string> =>
+      Promise.resolve(this.engine.render(input, context)).then(MailUtil.purgeBrand);
 
+    return { html: await get(html), text: await get(text), subject: await get(subject) };
+  }
 }

package/support/bin/send.ts

@@ -1,22 +1,25 @@
-import { MailService, MessageOptions, SentMessage } from '@travetto/email';
+import { MailService, EmailOptions, SentEmail } from '@travetto/email';
 import { MailTransportTarget } from '@travetto/email/src/internal/types';
 import { DependencyRegistry } from '@travetto/di';
 
 import { EditorConfig } from './config';
+import { RootIndex } from '@travetto/manifest';
 
 /**
  * Util for sending emails
  */
 export class EditorSendService {
 
-  #svc: MailService;
+  static #svc: Record<string, MailService> = {};
 
   /**
    * Get mail service
    */
-  async getMailService(): Promise<MailService> {
-    if (!this.#svc) {
-      const senderConfig = await EditorConfig.getSenderConfig();
+  static async getMailService(file: string): Promise<MailService> {
+    const mod = RootIndex.getModuleFromSource(file)!.name;
+
+    if (!this.#svc[mod]) {
+      const senderConfig = await EditorConfig.getSenderConfig(file);
 
       if (senderConfig?.host?.includes('ethereal.email')) {
         const cls = class { };
@@ -39,30 +42,30 @@ ${EditorConfig.getDefaultConfig()}`.trim();
         throw new Error(errorMessage);
       }
 
-      this.#svc = await DependencyRegistry.getInstance(MailService);
+      this.#svc[mod] = await DependencyRegistry.getInstance(MailService);
     }
-    return this.#svc;
+    return this.#svc[mod];
   }
 
   /**
    * Resolve template
    */
-  async sendEmail(message: MessageOptions): Promise<{
+  static async sendEmail(file: string, message: EmailOptions): Promise<{
     url?: string | false;
   }> {
     const to = message.to!;
     try {
       console.log('Sending email', { to });
       // Let the engine template
-      const svc = await this.getMailService();
+      const svc = await this.getMailService(file);
       if (!svc) {
         throw new Error('Node mailer support is missing');
       }
 
-      const info = await svc.send<{ host?: string } & SentMessage>(message);
+      const info = await svc.send<{ host?: string } & SentEmail>(message);
       console.log('Sent email', { to });
 
-      const senderConfig = await EditorConfig.getSenderConfig();
+      const senderConfig = await EditorConfig.getSenderConfig(file);
       return senderConfig.host?.includes('ethereal.email') ? {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
         url: (await import('nodemailer')).getTestMessageUrl(info as any)

package/support/cli.email_compile.ts

@@ -16,7 +16,8 @@ export class EmailCompileCommand implements CliCommandShape {
   envInit(): GlobalEnvConfig {
     return {
       debug: false,
-      dynamic: this.watch
+      dynamic: this.watch,
+      profiles: ['email-dev']
     };
   }
 

package/support/cli.email_editor.ts

@@ -1,6 +1,5 @@
-import { GlobalEnvConfig, ShutdownManager } from '@travetto/base';
+import { GlobalEnvConfig } from '@travetto/base';
 import { CliCommand } from '@travetto/cli';
-import { RootIndex } from '@travetto/manifest';
 import { RootRegistry } from '@travetto/registry';
 
 import { EditorState } from './bin/editor';
@@ -13,17 +12,13 @@ export class EmailEditorCommand {
   envInit(): GlobalEnvConfig {
     return {
       envName: 'dev',
-      resourcePaths: [`${RootIndex.getModule('@travetto/email-compiler')!.sourcePath}/resources`]
+      dynamic: true,
+      profiles: ['email-dev']
     };
   }
 
   async main(): Promise<void> {
     await RootRegistry.init();
-    const editor = new EditorState(await EmailCompilationManager.createInstance());
-    await editor.init();
-    if (process.send) {
-      process.on('disconnect', () => ShutdownManager.execute());
-      process.send('ready');
-    }
+    await new EditorState(await EmailCompilationManager.createInstance()).init();
   }
 }

package/support/cli.email_test.ts

@@ -16,7 +16,10 @@ import { EmailCompiler } from '../src/compiler';
 export class EmailTestCommand implements CliCommandShape {
 
   envInit(): GlobalEnvConfig {
-    return { envName: 'dev' };
+    return {
+      envName: 'dev',
+      profiles: ['email-dev']
+    };
   }
 
   async main(file: string, to: string): Promise<void> {
@@ -25,10 +28,9 @@ export class EmailTestCommand implements CliCommandShape {
     await EmailCompiler.compile(file, true);
 
     const mgr = await EmailCompilationManager.createInstance();
-    const send = new EditorSendService();
-    const cfg = await EditorConfig.get();
+    const cfg = await EditorConfig.get(file);
+    const content = await mgr.resolveCompiledTemplate(file, await EditorConfig.getContext(file));
 
-    const content = await mgr.resolveCompiledTemplate(file!, await EditorConfig.getContext());
-    await send.sendEmail({ from: cfg.from, to, ...content, });
+    await EditorSendService.sendEmail(file, { from: cfg.from, to, ...content, });
   }
 }