@travetto/email-compiler 4.0.0-rc.0 → 4.0.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/email-compiler",
-  "version": "4.0.0-rc.0",
+  "version": "4.0.0-rc.2",
   "description": "Email compiling module",
   "keywords": [
     "email",
@@ -26,20 +26,20 @@
     "directory": "module/email-compiler"
   },
   "dependencies": {
-    "@travetto/base": "^4.0.0-rc.0",
-    "@travetto/config": "^4.0.0-rc.0",
-    "@travetto/di": "^4.0.0-rc.0",
-    "@travetto/email": "^4.0.0-rc.0",
-    "@travetto/image": "^4.0.0-rc.0",
-    "@travetto/worker": "^4.0.0-rc.0",
+    "@travetto/base": "^4.0.0-rc.2",
+    "@travetto/config": "^4.0.0-rc.2",
+    "@travetto/di": "^4.0.0-rc.2",
+    "@travetto/email": "^4.0.0-rc.2",
+    "@travetto/image": "^4.0.0-rc.2",
+    "@travetto/worker": "^4.0.0-rc.2",
     "@types/inline-css": "^3.0.3",
     "html-entities": "^2.4.0",
     "inline-css": "^4.0.2",
     "purgecss": "^5.0.0",
-    "sass": "^1.69.5"
+    "sass": "^1.70.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.0.0-rc.0"
+    "@travetto/cli": "^4.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
@@ -47,7 +47,10 @@
     }
   },
   "travetto": {
-    "displayName": "Email Compilation Support"
+    "displayName": "Email Compilation Support",
+    "roles": [
+      "build"
+    ]
   },
   "publishConfig": {
     "access": "public"

package/src/compiler.ts

@@ -1,53 +1,27 @@
 import fs from 'node:fs/promises';
 
-import { FileLoader, TypedObject, WatchEvent, watchCompiler } from '@travetto/base';
-import { EmailCompileSource, EmailCompiled, EmailCompileContext, MailUtil } from '@travetto/email';
+import { TypedObject, Util, watchCompiler } from '@travetto/base';
+import { EmailCompiled, MailUtil, EmailTemplateImport, EmailTemplateModule } from '@travetto/email';
 import { RuntimeIndex, path } from '@travetto/manifest';
-import { WorkQueue } from '@travetto/worker';
 
 import { EmailCompileUtil } from './util';
 
-const VALID_FILE = (file: string): boolean => /[.](scss|css|png|jpe?g|gif|ya?ml)$/.test(file) && !/[.]compiled[.]/.test(file);
-
 /**
  * Email compilation support
  */
 export class EmailCompiler {
 
   /**
-   * Watch folders as needed
+   * Load Template
    */
-  static async #watchFolders(folders: string[], handler: (ev: WatchEvent) => void, signal: AbortSignal): Promise<void> {
-    for (const src of folders) {
-      (async (): Promise<void> => {
-        for await (const ev of fs.watch(src, {
-          recursive: true,
-          signal,
-          persistent: false
-        })) {
-          const exists = ev.filename ? await fs.stat(ev.filename).catch(() => false) : false;
-          handler({ action: !!exists ? 'create' : 'delete', file: path.toPosix(ev.filename!), folder: src });
-        }
-      })();
-    }
-  }
-
-  /** Load Template */
-  static async loadTemplate(file: string): Promise<EmailCompileContext> {
+  static async loadTemplate(file: string): Promise<EmailTemplateModule> {
     const entry = RuntimeIndex.getEntry(file);
-    if (!entry) {
+    const mod = entry ? RuntimeIndex.getModule(entry.module) : undefined;
+    if (!entry || !mod) {
       throw new Error(`Unable to find template for ${file}`);
     }
-    const root = (await import(entry.outputFile)).default;
-    const og: EmailCompileSource = await root.wrap();
-    const res: EmailCompileContext = {
-      file: entry.sourceFile,
-      module: entry.module,
-      images: {},
-      styles: {},
-      ...og
-    };
-    return res;
+    const root: EmailTemplateImport = (await import(entry.outputFile)).default;
+    return await root.prepare({ file, module: mod.name });
   }
 
   /**
@@ -86,10 +60,10 @@ export class EmailCompiler {
     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], MailUtil.buildBrand(file, msg[k], 'trv email:compile'), { encoding: 'utf8' });
+        const content = MailUtil.buildBrand(file, msg[k], 'trv email:compile');
+        await Util.bufferedFileWrite(outs[k], content);
       } else {
-        await fs.unlink(outs[k]).catch(() => { }); // Remove file if data not provided
+        await fs.rm(outs[k], { force: true }); // Remove file if data not provided
       }
     }));
   }
@@ -97,12 +71,10 @@ export class EmailCompiler {
   /**
    * Compile a file given a resource provider
    */
-  static async compile(file: string, persist: boolean = false): Promise<EmailCompiled> {
-    const src = await this.loadTemplate(file);
-    const compiled = await EmailCompileUtil.compile(src);
-    if (persist) {
-      await this.writeTemplate(file, compiled);
-    }
+  static async compile(file: string): Promise<EmailCompiled> {
+    const tpl = await this.loadTemplate(file);
+    const compiled = await EmailCompileUtil.compile(tpl);
+    await this.writeTemplate(file, compiled);
     return compiled;
   }
 
@@ -111,49 +83,24 @@ export class EmailCompiler {
    */
   static async compileAll(mod?: string): Promise<string[]> {
     const keys = this.findAllTemplates(mod);
-    await Promise.all(keys.map(src => this.compile(src, true)));
+    await Promise.all(keys.map(src => this.compile(src)));
     return keys;
   }
 
   /**
    * Watch compilation
    */
-  static async * watchCompile(): AsyncIterable<string> {
-    const all = FileLoader.resolvePaths(
-      this.findAllTemplates().map(x => `${RuntimeIndex.getEntry(x)!.module}#resources`)
-    );
-
-    const ctrl = new AbortController();
-    const stream = new WorkQueue<WatchEvent>([], ctrl.signal);
-
-    // watch resources
-    this.#watchFolders(all, ev => stream.add(ev), ctrl.signal);
-
+  static async * watchCompile(signal?: AbortSignal): AsyncIterable<string> {
     // Watch template files
-    watchCompiler(ev => {
-      const src = RuntimeIndex.getEntry(ev.file);
-      if (src && EmailCompileUtil.isTemplateFile(src.sourceFile)) {
-        setTimeout(() => stream.add({ ...ev, file: src.sourceFile }), 100); // Wait for it to be loaded
-      }
-    }, { signal: ctrl.signal });
-
-    for await (const { file, action } of stream) {
-      if (action === 'delete') {
+    for await (const { file, action } of watchCompiler({ signal })) {
+      const src = RuntimeIndex.getEntry(file);
+      if (!src || !EmailCompileUtil.isTemplateFile(src.sourceFile) || action === 'delete') {
         continue;
       }
-
       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');
-          const mod = RuntimeIndex.getFromSource(rootFile)!.module;
-          const changed = await this.compileAll(mod);
-          console.log(`Successfully compiled ${changed.length} templates`, { changed, file });
-          yield* changed;
-        }
+        await this.compile(file);
+        console.log('Successfully compiled template', { changed: [file] });
+        yield file;
       } catch (err) {
         console.error(`Error in compiling ${file}`, err && err instanceof Error ? err.message : `${err}`);
       }

package/src/util.ts

@@ -1,11 +1,8 @@
 import util from 'node:util';
-import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 
-import { ResourceLoader, StreamUtil } from '@travetto/base';
-import {
-  EmailTemplateImageConfig, EmailTemplateStyleConfig,
-  EmailCompiled, EmailCompileContext
-} from '@travetto/email';
+import { MemoryWritable } from '@travetto/base';
+import { EmailCompiled, EmailTemplateModule, EmailTemplateResource } from '@travetto/email';
 import { ImageConverter } from '@travetto/image';
 import { path } from '@travetto/manifest';
 
@@ -80,12 +77,12 @@ export class EmailCompileUtil {
   /**
    * Compile SCSS content with roots as search paths for additional assets
    */
-  static async compileSass(src: { data: string } | { file: string }, roots: string[] | readonly string[]): Promise<string> {
+  static async compileSass(src: { data: string } | { file: string }, opts: EmailTemplateResource): Promise<string> {
     const sass = await import('sass');
     const result = await util.promisify(sass.render)({
       ...src,
       sourceMap: false,
-      includePaths: roots.slice(0)
+      includePaths: opts.loader.searchPaths.slice(0)
     });
     return result!.css.toString();
   }
@@ -134,22 +131,27 @@ export class EmailCompileUtil {
   /**
    * Inline image sources
    */
-  static async inlineImages(html: string, opts: EmailTemplateImageConfig): Promise<string> {
+  static async inlineImages(html: string, opts: EmailTemplateResource): 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 resource = new ResourceLoader(opts.search);
+    const pendingImages: [token: string, ext: string, stream: Buffer | Promise<Buffer>][] = [];
 
     for (const [token, src] of tokens) {
       const ext = path.extname(src);
-      const stream = await resource.readStream(src);
-      pendingImages.push([token, ext, /^[.](jpe?g|png)$/.test(ext) ?
-        ImageConverter.optimize(ext === '.png' ? 'png' : 'jpeg', stream) : stream]);
+      if (/^[.](jpe?g|png)$/.test(ext)) {
+        const output = await ImageConverter.optimize(
+          ext === '.png' ? 'png' : 'jpeg', await opts.loader.readStream(src)
+        );
+        const buffer = new MemoryWritable();
+        await pipeline(output, buffer);
+        pendingImages.push([token, ext, buffer.toBuffer()]);
+      } else {
+        pendingImages.push([token, ext, opts.loader.read(src, true)]);
+      }
     }
 
-    const imageMap = new Map(await Promise.all(pendingImages.map(async ([token, ext, stream]) => {
-      const data = await StreamUtil.streamToBuffer(await stream);
-      return [token, `data:image/${ext.replace('.', '')};base64,${data.toString('base64')}`] as const;
-    })));
+    const imageMap = new Map(await Promise.all(pendingImages.map(async ([token, ext, data]) =>
+      [token, `data:image/${ext.replace('.', '')};base64,${data.toString('base64')}`] as const
+    )));
 
     return finalize(token => imageMap.get(token)!);
   }
@@ -176,22 +178,14 @@ export class EmailCompileUtil {
   /**
    * Apply styles into a given html document
    */
-  static async applyStyles(html: string, opts: EmailTemplateStyleConfig): Promise<string> {
-    const styles: string[] = [];
-
-    if (opts.global) {
-      styles.push(opts.global);
-    }
-
-    const resource = new ResourceLoader(opts.search);
-    const main = await resource.read('/email/main.scss').then(d => d, () => '');
-
-    if (main) {
-      styles.push(main);
-    }
+  static async applyStyles(html: string, opts: EmailTemplateResource): Promise<string> {
+    const styles = [
+      opts.globalStyles ?? '',
+      await opts.loader.read('/email/main.scss').catch(() => '')
+    ].filter(x => !!x).join('\n');
 
     if (styles.length) {
-      const compiled = await this.compileSass({ data: styles.join('\n') }, resource.searchPaths);
+      const compiled = await this.compileSass({ data: styles }, opts);
 
       // Remove all unused styles
       const finalStyles = await this.pruneCss(html, compiled);
@@ -203,21 +197,21 @@ export class EmailCompileUtil {
     return html;
   }
 
-  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));
+  static async compile(src: EmailTemplateModule): Promise<EmailCompiled> {
+    const subject = await this.simplifiedText(await src.subject());
+    const text = await this.simplifiedText(await src.text());
 
-    let html = await src.html(src);
+    let html = await src.html();
 
-    if (src.styles?.inline !== false) {
-      html = await this.applyStyles(html, src.styles!);
+    if (src.inlineStyle !== false) {
+      html = await this.applyStyles(html, src);
     }
 
     // Fix up html edge cases
     html = this.handleHtmlEdgeCases(html);
 
-    if (src.images?.inline !== false) {
-      html = await this.inlineImages(html, src.images!);
+    if (src.inlineImages !== false) {
+      html = await this.inlineImages(html, src);
     }
 
     return { html, subject, text };

package/support/bin/config.ts

@@ -1,29 +1,19 @@
 import fs from 'node:fs/promises';
 
-import { IndexedModule, RuntimeIndex, path } from '@travetto/manifest';
+import { RuntimeContext } from '@travetto/manifest';
 import { YamlUtil } from '@travetto/yaml';
+import { Util } from '@travetto/base';
 
-interface ConfigType {
-  to: string;
-  from: string;
-  context?: Record<string, unknown>;
-  sender?: {
-    port?: number;
-    host?: string;
-    auth?: {
-      user?: string;
-      pass?: string;
-    };
-  };
-}
+import { EditorConfigType } from './types';
+
+export const CONFIG_FILE = 'resources/email/local.yml';
 
 /**
  * Configuration utils
  */
-export class $EditorConfig {
+export class EditorConfig {
 
-  #configFile: Record<string, string> = {};
-  #defaultConfig = {
+  static DEFAULT_CONFIG = {
     to: 'my-email@gmail.com',
     from: 'from-email@gmail.com',
     context: {
@@ -39,49 +29,32 @@ export class $EditorConfig {
     },
   };
 
-  #getEmailConfig(mod: IndexedModule): string {
-    return this.#configFile[mod.name] ??= path.resolve(mod.sourcePath, 'resources/email/local.yml');
-  }
-
   /**
    *
    */
-  async get(file: string): Promise<ConfigType> {
+  static async get<K extends keyof EditorConfigType>(key: K): Promise<Exclude<EditorConfigType[K], undefined>>;
+  static async get(): Promise<EditorConfigType>;
+  static async get<K extends keyof EditorConfigType>(key?: K): Promise<EditorConfigType | EditorConfigType[K]> {
     try {
-      const mod = RuntimeIndex.getModuleFromSource(file)!;
-      const resolved = this.#getEmailConfig(mod);
+      const resolved = RuntimeContext.workspaceRelative(CONFIG_FILE);
       const content = await fs.readFile(resolved, 'utf8');
-      return YamlUtil.parse<ConfigType>(content);
+      const data = YamlUtil.parse<EditorConfigType>(content);
+      return key ? data[key] : data;
     } catch {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return {} as ConfigType;
+      return {} as EditorConfigType;
     }
   }
 
-  async getContext(file: string): Promise<Exclude<ConfigType['context'], undefined>> {
-    const conf = await this.get(file);
-    return conf.context ?? {};
+  static getDefaultConfig(): string {
+    return YamlUtil.serialize(this.DEFAULT_CONFIG);
   }
 
-  async getSenderConfig(file: string): Promise<Exclude<ConfigType['sender'], undefined>> {
-    const conf = await this.get(file);
-    return conf.sender ?? {};
-  }
-
-  getDefaultConfig(): string {
-    return YamlUtil.serialize(this.#defaultConfig);
-  }
-
-  async ensureConfig(file: string): Promise<string> {
-    console.log('Ensuring config', file);
-    const mod = RuntimeIndex.getModuleFromSource(file)!;
-    const resolved = this.#getEmailConfig(mod);
+  static async ensureConfig(): Promise<string> {
+    const resolved = RuntimeContext.workspaceRelative(CONFIG_FILE);
     if (!(await fs.stat(resolved).catch(() => { }))) {
-      await fs.mkdir(path.dirname(resolved), { recursive: true });
-      await fs.writeFile(resolved, this.getDefaultConfig(), { encoding: 'utf8' });
+      await Util.bufferedFileWrite(resolved, this.getDefaultConfig());
     }
     return resolved;
   }
-}
-
-export const EditorConfig = new $EditorConfig();
+}

package/support/bin/editor.ts

@@ -1,118 +1,97 @@
-import { ExecUtil } from '@travetto/base';
+import { Inject, Injectable } from '@travetto/di';
+import { MailUtil, EmailCompiled, MailInterpolator } from '@travetto/email';
+import { AppError, TypedObject } from '@travetto/base';
 
-import { EmailCompilationManager } from './manager';
 import { EditorSendService } from './send';
 import { EditorConfig } from './config';
+import { EditorRequest, EditorResponse } from './types';
 
 import { EmailCompiler } from '../../src/compiler';
-import { EmailCompileUtil } from '../../src/util';
-
-type InboundMessage =
-  { type: 'configure', file: string } |
-  { type: 'redraw', file: string } |
-  { type: 'send', file: string, from?: string, to?: string };
-
-type OutboundMessage =
-  { type: 'configured', file: string } |
-  { type: 'sent', to: string, file: string, url?: string | false } |
-  { type: 'changed', file: string, content: Record<'html' | 'subject' | 'text', string> } |
-  { type: 'sent-failed', message: string, stack: Error['stack'], to: string, file: string } |
-  { type: 'changed-failed', message: string, stack: Error['stack'], file: string };
 
 /**
  * Utils for interacting with editors
  */
-export class EditorState {
+@Injectable()
+export class EditorService {
 
-  #lastFile = '';
-  #template: EmailCompilationManager;
+  @Inject()
+  sender: EditorSendService;
 
-  constructor(template: EmailCompilationManager) {
-    this.#template = template;
-  }
+  @Inject()
+  engine: MailInterpolator;
 
-  async renderFile(file: string): Promise<void> {
-    file = EmailCompileUtil.isTemplateFile(file) ? file : this.#lastFile;
-    if (file) {
-      try {
-        const content = await this.#template.resolveCompiledTemplate(
-          file, await EditorConfig.getContext(file)
-        );
-        this.response({
-          type: 'changed',
-          file,
-          content
-        });
-      } catch (err) {
-        if (err && err instanceof Error) {
-          this.response({ type: 'changed-failed', message: err.message, stack: err.stack, file });
-        } else {
-          console.error(err);
-        }
-      }
-    }
+  async #interpolate(text: string, context: Record<string, unknown>): Promise<string> {
+    return Promise.resolve(this.engine.render(text, context)).then(MailUtil.purgeBrand);
   }
 
-  response(response: OutboundMessage): void {
-    if (process.connected) {
-      process.send?.(response);
-    }
+  async #renderTemplate(rel: string, context: Record<string, unknown>): Promise<EmailCompiled> {
+    const p = await EmailCompiler.compile(rel);
+    return TypedObject.fromEntries(
+      await Promise.all(TypedObject.entries(p).map(([k, v]) => this.#interpolate(v, context).then((t) => [k, t])))
+    );
   }
 
-  async onConfigure(msg: InboundMessage & { type: 'configure' }): Promise<void> {
-    this.response({ type: 'configured', file: await EditorConfig.ensureConfig(msg.file) });
+  async #renderFile(file: string): Promise<{ content: EmailCompiled, file: string }> {
+    const content = await this.#renderTemplate(file, await EditorConfig.get('context'));
+    return { content, file };
   }
 
-  async #onRedraw(msg: InboundMessage & { type: 'redraw' }): Promise<void> {
+  async #response<T>(op: Promise<T>, success: (v: T) => EditorResponse, fail?: (err: Error) => EditorResponse): Promise<void> {
     try {
-      await EmailCompiler.compile(msg.file, true);
-      await this.renderFile(msg.file);
+      const res = await op;
+      if (process.connected) { process.send?.(success(res)); }
     } catch (err) {
-      if (err && err instanceof Error) {
-        this.response({ type: 'changed-failed', message: err.message, stack: err.stack, file: msg.file });
+      if (fail && process.connected && err && err instanceof Error) {
+        process.send?.(fail(err));
       } else {
         console.error(err);
       }
     }
   }
 
-  async onSend(msg: InboundMessage & { type: 'send' }): Promise<void> {
-    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)
-    );
-
-    try {
-      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) {
-        this.response({ type: 'sent-failed', message: err.message, stack: err.stack, to, file: msg.file });
-      } else {
-        console.error(err);
-      }
-    }
+  async sendFile(file: string, to?: string): Promise<{ to: string, file: string, url?: string | false | undefined }> {
+    const cfg = await EditorConfig.get();
+    to ||= cfg.to;
+    const content = await this.#renderTemplate(file, cfg.context ?? {});
+    return { to, file, ...await this.sender.send({ from: cfg.from, to, ...content, }) };
   }
 
   /**
    * Initialize context, and listeners
    */
-  async init(): Promise<void> {
-    process.on('message', (msg: InboundMessage) => {
+  async listen(): Promise<void> {
+    if (!process.connected || !process.send) {
+      throw new AppError('Unable to run email editor, missing ipc channel', 'permissions');
+    }
+    process.on('message', async (msg: EditorRequest) => {
       switch (msg.type) {
-        case 'configure': this.onConfigure(msg); break;
-        case 'redraw': this.#onRedraw(msg); break;
-        case 'send': this.onSend(msg); break;
+        case 'configure': {
+          return await this.#response(EditorConfig.ensureConfig(), file => ({ type: 'configured', file }));
+        }
+        case 'compile': {
+          return await this.#response(this.#renderFile(msg.file),
+            res => ({ type: 'compiled', ...res }),
+            err => ({ type: 'compiled-failed', message: err.message, stack: err.stack, file: msg.file })
+          );
+        }
+        case 'send': {
+          return await this.#response(
+            this.sendFile(msg.file, msg.to),
+            res => ({ type: 'sent', ...res }),
+            err => ({ type: 'sent-failed', message: err.message, stack: err.stack, to: msg.to!, file: msg.file })
+          );
+        }
       }
     });
 
-    ExecUtil.exitOnDisconnect();
-    process.send?.('ready');
+    process.once('disconnect', () => process.exit());
+    process.send({ type: 'init' });
 
-    for await (const f of EmailCompiler.watchCompile()) {
-      await this.renderFile(f);
+    for await (const file of EmailCompiler.watchCompile()) {
+      await this.#response(this.#renderFile(file),
+        res => ({ type: 'compiled', ...res }),
+        err => ({ type: 'compiled-failed', message: err.message, stack: err.stack, file })
+      );
     }
   }
 }

package/support/bin/send.ts

@@ -1,72 +1,54 @@
 import { MailService, EmailOptions, SentEmail } from '@travetto/email';
 import { MailTransportTarget } from '@travetto/email/src/internal/types';
-import { DependencyRegistry } from '@travetto/di';
+import { DependencyRegistry, Injectable } from '@travetto/di';
 
 import { EditorConfig } from './config';
-import { RuntimeIndex } from '@travetto/manifest';
 
 /**
- * Util for sending emails
+ * Editor mail sender
  */
+@Injectable()
 export class EditorSendService {
 
-  static #svc: Record<string, MailService> = {};
+  ethereal = false;
 
-  /**
-   * Get mail service
-   */
-  static async getMailService(file: string): Promise<MailService> {
-    const mod = RuntimeIndex.getModuleFromSource(file)!.name;
-
-    if (!this.#svc[mod]) {
-      const senderConfig = await EditorConfig.getSenderConfig(file);
+  async service(): Promise<MailService> {
+    const transports = DependencyRegistry.getCandidateTypes(MailTransportTarget);
 
-      if (senderConfig?.host?.includes('ethereal.email')) {
-        const cls = class { };
+    if (!transports.length) {
+      try {
         const { NodemailerTransport } = await import('@travetto/email-nodemailer');
+        const senderConfig = await EditorConfig.get('sender');
+        const cls = class { };
         DependencyRegistry.registerFactory({
           fn: () => new NodemailerTransport(senderConfig),
           target: MailTransportTarget,
           src: cls,
           id: 'nodemailer',
         });
-
         DependencyRegistry.install(cls, { curr: cls, type: 'added' });
-      } else if (!DependencyRegistry.getCandidateTypes(MailTransportTarget).length) {
-        const errorMessage = `
-Please configure your email setup and/or credentials for testing. In the file \`email/local.yml\`, you can specify \`sender\` configuration.
-Email sending will not work until the above is fixed. A sample configuration would look like:     
 
-${EditorConfig.getDefaultConfig()}`.trim();
-        console.error(errorMessage);
-        throw new Error(errorMessage);
+        this.ethereal = !!senderConfig.host?.includes('ethereal.email');
+      } catch (err) {
+        console.error('A mail transport is currently needed to support sending emails.  Please install @travetto/email-nodemailer or any other compatible transport');
+        throw new Error('A mail transport is currently needed to support sending emails.  Please install @travetto/email-nodemailer or any other compatible transport');
       }
-
-      this.#svc[mod] = await DependencyRegistry.getInstance(MailService);
     }
-    return this.#svc[mod];
+    return await DependencyRegistry.getInstance(MailService);
   }
 
   /**
-   * Resolve template
+   * Send email
    */
-  static async sendEmail(file: string, message: EmailOptions): Promise<{
-    url?: string | false;
-  }> {
+  async send(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(file);
-      if (!svc) {
-        throw new Error('Node mailer support is missing');
-      }
-
+      const svc = await this.service();
       const info = await svc.send<{ host?: string } & SentEmail>(message);
       console.log('Sent email', { to });
 
-      const senderConfig = await EditorConfig.getSenderConfig(file);
-      return senderConfig.host?.includes('ethereal.email') ? {
+      return this.ethereal ? {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
         url: (await import('nodemailer')).getTestMessageUrl(info as any)
       } : {};

package/support/bin/types.ts

@@ -0,0 +1,28 @@
+export type EditorRequest =
+  { type: 'configure', file: string } |
+  { type: 'compile', file: string } |
+  { type: 'send', file: string, from?: string, to?: string };
+
+export type EditorResponse =
+  { type: 'configured', file: string } |
+  { type: 'sent', to: string, file: string, url?: string | false } |
+  { type: 'compiled', file: string, content: Record<'html' | 'subject' | 'text', string> } |
+  { type: 'sent-failed', message: string, stack: Error['stack'], to: string, file: string } |
+  { type: 'compiled-failed', message: string, stack: Error['stack'], file: string } |
+  { type: 'init' };
+
+export type EditorSender = {
+  port?: number;
+  host?: string;
+  auth?: {
+    user?: string;
+    pass?: string;
+  };
+};
+
+export interface EditorConfigType {
+  to: string;
+  from: string;
+  context?: Record<string, unknown>;
+  sender?: EditorSender;
+}

package/support/cli.email_compile.ts

@@ -1,6 +1,7 @@
 import { RootRegistry } from '@travetto/registry';
 import { CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
 import { Env } from '@travetto/base';
+import { RuntimeContext } from '@travetto/manifest';
 
 import { EmailCompiler } from '../src/compiler';
 
@@ -15,6 +16,7 @@ export class EmailCompileCommand implements CliCommandShape {
 
   preMain(): void {
     Env.DEBUG.set(false);
+    Env.TRV_ROLE.set('build');
     Env.TRV_DYNAMIC.set(this.watch);
   }
 
@@ -25,11 +27,10 @@ export class EmailCompileCommand implements CliCommandShape {
     const all = await EmailCompiler.compileAll();
     console!.log(cliTpl`Successfully compiled ${{ param: `${all.length}` }} templates`);
     for (const el of all) {
-      console!.log(cliTpl`  * ${{ param: el }}`);
+      console!.log(cliTpl`  * ${{ param: el.replace(`${RuntimeContext.workspace.path}/`, '') }}`);
     }
 
     if (this.watch) {
-
       for await (const _ of EmailCompiler.watchCompile()) {
         // Iterate until done
       }

package/support/cli.email_editor.ts

@@ -1,9 +1,9 @@
 import { Env } from '@travetto/base';
 import { CliCommand, CliUtil } from '@travetto/cli';
 import { RootRegistry } from '@travetto/registry';
+import { DependencyRegistry } from '@travetto/di';
 
-import { EditorState } from './bin/editor';
-import { EmailCompilationManager } from './bin/manager';
+import { EditorService } from './bin/editor';
 
 /** The email editor compilation service and output serving */
 @CliCommand({ addEnv: true })
@@ -11,6 +11,7 @@ export class EmailEditorCommand {
 
   preMain(): void {
     Env.TRV_DYNAMIC.set(true);
+    Env.TRV_ROLE.set('build');
   }
 
   async main(): Promise<void> {
@@ -19,6 +20,7 @@ export class EmailEditorCommand {
     }
 
     await RootRegistry.init();
-    await new EditorState(await EmailCompilationManager.createInstance()).init();
+    const service = await DependencyRegistry.getInstance(EditorService);
+    await service.listen();
   }
 }

package/support/cli.email_test.ts

@@ -1,12 +1,10 @@
 import { path } from '@travetto/manifest';
 import { RootRegistry } from '@travetto/registry';
 import { CliCommandShape, CliCommand } from '@travetto/cli';
+import { DependencyRegistry } from '@travetto/di';
+import { Env } from '@travetto/base';
 
-import { EmailCompilationManager } from './bin/manager';
-import { EditorConfig } from './bin/config';
-import { EditorSendService } from './bin/send';
-
-import { EmailCompiler } from '../src/compiler';
+import { EditorService } from './bin/editor';
 
 /**
  * CLI Entry point for running the email server
@@ -14,15 +12,14 @@ import { EmailCompiler } from '../src/compiler';
 @CliCommand({ addEnv: true })
 export class EmailTestCommand implements CliCommandShape {
 
+  preMain(): void {
+    Env.TRV_ROLE.set('build');
+  }
+
   async main(file: string, to: string): Promise<void> {
     file = path.resolve(file);
     await RootRegistry.init();
-    await EmailCompiler.compile(file, true);
-
-    const mgr = await EmailCompilationManager.createInstance();
-    const cfg = await EditorConfig.get(file);
-    const content = await mgr.resolveCompiledTemplate(file, await EditorConfig.getContext(file));
-
-    await EditorSendService.sendEmail(file, { from: cfg.from, to, ...content, });
+    const editor = await DependencyRegistry.getInstance(EditorService);
+    await editor.sendFile(file, to);
   }
 }

package/support/bin/manager.ts

@@ -1,60 +0,0 @@
-import fs from 'node:fs/promises';
-
-import { type MailInterpolator, type EmailCompiled } from '@travetto/email';
-import { DependencyRegistry } from '@travetto/di';
-import { TypedObject } from '@travetto/base';
-import { MailInterpolatorTarget } from '@travetto/email/src/internal/types';
-
-import { EmailCompiler } from '../../src/compiler';
-
-/**
- *
- */
-export class EmailCompilationManager {
-
-  static async createInstance(): Promise<EmailCompilationManager> {
-    return new EmailCompilationManager(
-      await DependencyRegistry.getInstance<MailInterpolator>(MailInterpolatorTarget),
-    );
-  }
-
-  engine: MailInterpolator;
-
-  constructor(engine: MailInterpolator) {
-    this.engine = engine;
-  }
-
-  /**
-   * Resolve template
-   */
-  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(() => { })));
-
-    if (missing.some(x => x === undefined)) {
-      await EmailCompiler.compile(file, true);
-    }
-
-    const parts = await Promise.all(
-      TypedObject.entries(files).map(
-        ([key, partFile]) => fs.readFile(partFile, 'utf8')
-          .then(content => [key, content] as const)
-      )
-    );
-    return TypedObject.fromEntries<keyof EmailCompiled, string>(parts);
-  }
-
-  /**
-   * Render
-   * @param rel
-   */
-  async resolveCompiledTemplate(rel: string, context: Record<string, unknown>): Promise<EmailCompiled> {
-    const { MailUtil } = await import('@travetto/email');
-    const { html, text, subject } = await this.resolveTemplateParts(rel);
-
-    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) };
-  }
-}