@travetto/email-compiler 7.0.0-rc.1 → 7.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/email-compiler",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Email compiling module",
   "keywords": [
     "email",
@@ -26,12 +26,12 @@
     "directory": "module/email-compiler"
   },
   "dependencies": {
-    "@travetto/config": "^7.0.0-rc.1",
-    "@travetto/di": "^7.0.0-rc.1",
-    "@travetto/email": "^7.0.0-rc.1",
-    "@travetto/image": "^7.0.0-rc.1",
-    "@travetto/runtime": "^7.0.0-rc.1",
-    "@travetto/worker": "^7.0.0-rc.1",
+    "@travetto/config": "^7.0.0-rc.3",
+    "@travetto/di": "^7.0.0-rc.3",
+    "@travetto/email": "^7.0.0-rc.3",
+    "@travetto/image": "^7.0.0-rc.3",
+    "@travetto/runtime": "^7.0.0-rc.3",
+    "@travetto/worker": "^7.0.0-rc.3",
     "@types/inline-css": "^3.0.4",
     "html-entities": "^2.6.0",
     "inline-css": "^4.0.3",
@@ -39,7 +39,7 @@
     "sass": "^1.94.2"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.3"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { TypedObject, RuntimeIndex, watchCompiler, Runtime, BinaryUtil } from '@travetto/runtime';
+import { TypedObject, RuntimeIndex, Runtime, BinaryUtil, ExecUtil } from '@travetto/runtime';
 import { EmailCompiled, MailUtil, EmailTemplateImport, EmailTemplateModule } from '@travetto/email';
 
 import { EmailCompileUtil } from './util.ts';
@@ -23,14 +23,14 @@ export class EmailCompiler {
   /**
    * Grab list of all available templates
    */
-  static findAllTemplates(mod?: string): string[] {
+  static findAllTemplates(moduleName?: string): string[] {
     return RuntimeIndex
       .find({
-        module: m => !mod ? m.roles.includes('std') : mod === m.name,
-        folder: f => f === 'support',
-        file: f => EmailCompileUtil.isTemplateFile(f.sourceFile)
+        module: mod => !moduleName ? mod.roles.includes('std') : moduleName === mod.name,
+        folder: folder => folder === 'support',
+        file: file => EmailCompileUtil.isTemplateFile(file.sourceFile)
       })
-      .map(x => x.sourceFile);
+      .map(file => file.sourceFile);
   }
 
   /**
@@ -52,14 +52,14 @@ export class EmailCompiler {
   /**
    * Write template to file
    */
-  static async writeTemplate(file: string, msg: EmailCompiled): Promise<void> {
+  static async writeTemplate(file: string, message: EmailCompiled): Promise<void> {
     const outs = this.getOutputFiles(file);
-    await Promise.all(TypedObject.keys(outs).map(async k => {
-      if (msg[k]) {
-        const content = MailUtil.buildBrand(file, msg[k], 'trv email:compile');
-        await BinaryUtil.bufferedFileWrite(outs[k], content);
+    await Promise.all(TypedObject.keys(outs).map(async key => {
+      if (message[key]) {
+        const content = MailUtil.buildBrand(file, message[key], 'trv email:compile');
+        await BinaryUtil.bufferedFileWrite(outs[key], content);
       } else {
-        await fs.rm(outs[k], { force: true }); // Remove file if data not provided
+        await fs.rm(outs[key], { force: true }); // Remove file if data not provided
       }
     }));
   }
@@ -68,8 +68,8 @@ export class EmailCompiler {
    * Compile a file given a resource provider
    */
   static async compile(file: string): Promise<EmailCompiled> {
-    const tpl = await this.loadTemplate(file);
-    const compiled = await EmailCompileUtil.compile(tpl);
+    const template = await this.loadTemplate(file);
+    const compiled = await EmailCompileUtil.compile(template);
     await this.writeTemplate(file, compiled);
     return compiled;
   }
@@ -79,27 +79,31 @@ export class EmailCompiler {
    */
   static async compileAll(mod?: string): Promise<string[]> {
     const keys = this.findAllTemplates(mod);
-    await Promise.all(keys.map(src => this.compile(src)));
+    await Promise.all(keys.map(key => this.compile(key)));
     return keys;
   }
 
   /**
-   * Watch compilation
+   * Spawn the compiler for a given file
    */
-  static async * watchCompile(signal?: AbortSignal): AsyncIterable<string> {
-    // Watch template files
-    for await (const { file, action } of watchCompiler({ signal })) {
-      const src = RuntimeIndex.getEntry(file);
-      if (!src || !EmailCompileUtil.isTemplateFile(src.sourceFile) || action === 'delete') {
-        continue;
-      }
-      try {
-        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}`);
-      }
+  static async spawnCompile(file: string): Promise<boolean> {
+    if (!EmailCompileUtil.isTemplateFile(file)) {
+      return false;
     }
+
+    const child = ExecUtil.spawnTrv('email:compile', [file], {
+      cwd: Runtime.mainSourcePath,
+      env: { ...process.env },
+    });
+
+    const result = await ExecUtil.getResult(child, { catch: true });
+
+    if (!result.valid) {
+      console.error('Error compiling template', { file, stderr: result.stderr });
+    } else {
+      console.log('Successfully compiled template', { changed: [file] });
+    }
+
+    return result.valid;
   }
 }

package/src/util.ts

@@ -1,9 +1,10 @@
-import util from 'node:util';
 import { buffer as toBuffer } from 'node:stream/consumers';
 import path from 'node:path';
+import type { CompileResult, Options } from 'sass';
 
 import { EmailCompiled, EmailTemplateModule, EmailTemplateResource } from '@travetto/email';
 import { ImageUtil } from '@travetto/image';
+import { RuntimeIndex } from '@travetto/runtime';
 
 type Tokenized = {
   text: string;
@@ -11,11 +12,11 @@ type Tokenized = {
   finalize: (onToken: (token: string) => string) => string;
 };
 
-const SUPPORT_SRC = /(?:support|src)\//;
+const SUPPORT_SOURCE = /(?:support|src)\//;
 
 const HTML_CSS_IMAGE_URLS = [
-  /(?<pre><img[^>]src=\s{0,10}["'])(?<src>[^"{}]{1,1000})/g,
-  /(?<pre>background(?:-image)?:\s{0,10}url[(]['"]?)(?<src>[^"'){}]{1,1000})/g
+  /(?<prefix><img[^>]src=\s{0,10}["'])(?<source>[^"{}]{1,1000})/g,
+  /(?<prefix>background(?:-image)?:\s{0,10}url[(]['"]?)(?<source>[^"'){}]{1,1000})/g
 ];
 
 const EXT = /[.]email[.]tsx$/;
@@ -29,15 +30,15 @@ export class EmailCompileUtil {
    * Is file a template?
    */
   static isTemplateFile(file: string): boolean {
-    return EXT.test(file);
+    return EXT.test(file) && RuntimeIndex.findModuleForArbitraryFile(file) !== undefined;
   }
 
   /**
    * Generate singular output path given a file
    */
   static buildOutputPath(file: string, suffix: string, prefix?: string): string {
-    const res = (SUPPORT_SRC.test(file) ? file.split(SUPPORT_SRC)[1] : file).replace(EXT, suffix);
-    return prefix ? path.join(prefix, res) : res;
+    const location = (SUPPORT_SOURCE.test(file) ? file.split(SUPPORT_SOURCE)[1] : file).replace(EXT, suffix);
+    return prefix ? path.join(prefix, location) : location;
   }
 
   /**
@@ -62,16 +63,16 @@ export class EmailCompileUtil {
     let id = 0;
     const tokens = new Map();
     for (const pattern of patterns) {
-      for (const { [0]: all, groups: { pre, src } = { pre: '', src: '' } } of text.matchAll(pattern)) {
-        if (src.includes('://')) { // No urls
+      for (const { [0]: all, groups: { prefix, source } = { prefix: '', source: '' } } of text.matchAll(pattern)) {
+        if (source.includes('://')) { // No urls
           continue;
         }
         const token = `@@${id += 1}@@`;
-        tokens.set(token, src);
-        text = text.replace(all, `${pre}${token}`);
+        tokens.set(token, source);
+        text = text.replace(all, `${prefix}${token}`);
       }
     }
-    const finalize = (onToken: (token: string) => string): string => text.replace(/@@[^@]{1,100}@@/g, t => onToken(t));
+    const finalize = (onToken: (token: string) => string): string => text.replace(/@@[^@]{1,100}@@/g, token => onToken(token));
 
     return { text, tokens, finalize };
   }
@@ -79,13 +80,21 @@ export class EmailCompileUtil {
   /**
    * Compile SCSS content with roots as search paths for additional assets
    */
-  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,
+  static async compileSass(input: { data: string } | { file: string }, options: EmailTemplateResource): Promise<string> {
+    const { initAsyncCompiler } = await import('sass');
+    const compiler = await initAsyncCompiler();
+    const compilerOptions: Options<'async'> = {
       sourceMap: false,
-      includePaths: opts.loader.searchPaths.slice(0)
-    });
+      quietDeps: true,
+      loadPaths: options.loader.searchPaths.slice(0),
+    };
+
+    let result: CompileResult;
+    if ('data' in input) {
+      result = await compiler.compileStringAsync(input.data, compilerOptions);
+    } else {
+      result = await compiler.compileAsync(input.file, compilerOptions);
+    }
     return result!.css.toString();
   }
 
@@ -133,21 +142,21 @@ export class EmailCompileUtil {
   /**
    * Inline image sources
    */
-  static async inlineImages(html: string, opts: EmailTemplateResource): Promise<string> {
+  static async inlineImages(html: string, options: EmailTemplateResource): Promise<string> {
     const { tokens, finalize } = await this.tokenizeResources(html, HTML_CSS_IMAGE_URLS);
     const pendingImages: [token: string, ext: string, stream: Buffer | Promise<Buffer>][] = [];
 
-    for (const [token, src] of tokens) {
-      const ext = path.extname(src);
+    for (const [token, source] of tokens) {
+      const ext = path.extname(source);
       if (/^[.](jpe?g|png)$/.test(ext)) {
         const output = await ImageUtil.convert(
-          await opts.loader.readStream(src),
+          await options.loader.readStream(source),
           { format: ext === '.png' ? 'png' : 'jpeg' }
         );
         const buffer = await toBuffer(output);
         pendingImages.push([token, ext, buffer]);
       } else {
-        pendingImages.push([token, ext, opts.loader.read(src, true)]);
+        pendingImages.push([token, ext, options.loader.read(source, true)]);
       }
     }
 
@@ -167,7 +176,7 @@ export class EmailCompileUtil {
       .replace(/<(meta|img|link|hr|br)[^>]{0,200}>/g, a => a.replace(/>/g, '/>')) // Fix self closing
       .replace(/&apos;/g, '&#39;') // Fix apostrophes, as outlook hates them
       .replace(/(background(?:-color)?:\s*)([#0-9a-f]{6,8})([^>.#,]+)>/ig,
-        (all, p, col, rest) => `${p}${col}${rest} bgcolor="${col}">`) // Inline bg-color
+        (all, property, color, rest) => `${property}${color}${rest} bgcolor="${color}">`) // Inline bg-color
       .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,
@@ -179,14 +188,16 @@ export class EmailCompileUtil {
   /**
    * Apply styles into a given html document
    */
-  static async applyStyles(html: string, opts: EmailTemplateResource): Promise<string> {
+  static async applyStyles(html: string, options: EmailTemplateResource): Promise<string> {
     const styles = [
-      opts.globalStyles ?? '',
-      await opts.loader.read('/email/main.scss').catch(() => '')
-    ].filter(x => !!x).join('\n');
+      options.globalStyles ?? '',
+      await options.loader.read('/email/main.scss').catch(() => '')
+    ]
+      .filter(line => !!line)
+      .join('\n');
 
     if (styles.length) {
-      const compiled = await this.compileSass({ data: styles }, opts);
+      const compiled = await this.compileSass({ data: styles }, options);
 
       // Remove all unused styles
       const finalStyles = await this.pruneCss(html, compiled);
@@ -198,21 +209,21 @@ export class EmailCompileUtil {
     return html;
   }
 
-  static async compile(src: EmailTemplateModule): Promise<EmailCompiled> {
-    const subject = await this.simplifiedText(await src.subject());
-    const text = await this.simplifiedText(await src.text());
+  static async compile(input: EmailTemplateModule): Promise<EmailCompiled> {
+    const subject = await this.simplifiedText(await input.subject());
+    const text = await this.simplifiedText(await input.text());
 
-    let html = await src.html();
+    let html = await input.html();
 
-    if (src.inlineStyle !== false) {
-      html = await this.applyStyles(html, src);
+    if (input.inlineStyle !== false) {
+      html = await this.applyStyles(html, input);
     }
 
     // Fix up html edge cases
     html = this.handleHtmlEdgeCases(html);
 
-    if (src.inlineImages !== false) {
-      html = await this.inlineImages(html, src);
+    if (input.inlineImages !== false) {
+      html = await this.inlineImages(html, input);
     }
 
     return { html, subject, text };

package/support/bin/editor.ts

@@ -1,6 +1,6 @@
 import { Inject, Injectable } from '@travetto/di';
 import { MailUtil, EmailCompiled, MailInterpolator } from '@travetto/email';
-import { AppError, TypedObject } from '@travetto/runtime';
+import { AppError, TypedObject, watchCompiler } from '@travetto/runtime';
 
 import { EditorSendService } from './send.ts';
 import { EditorConfig } from './config.ts';
@@ -24,10 +24,11 @@ export class EditorService {
     return Promise.resolve(this.engine.render(text, context)).then(MailUtil.purgeBrand);
   }
 
-  async #renderTemplate(rel: string, context: Record<string, unknown>): Promise<EmailCompiled> {
-    const p = await EmailCompiler.compile(rel);
+  async #renderTemplate(templateFile: string, context: Record<string, unknown>): Promise<EmailCompiled> {
+    const email = await EmailCompiler.compile(templateFile);
     return TypedObject.fromEntries(
-      await Promise.all(TypedObject.entries(p).map(([k, v]) => this.#interpolate(v, context).then((t) => [k, t])))
+      await Promise.all(TypedObject.entries(email).map(([key, value]) =>
+        this.#interpolate(value, context).then((result) => [key, result])))
     );
   }
 
@@ -36,24 +37,24 @@ export class EditorService {
     return { content, file };
   }
 
-  async #response<T>(op: Promise<T>, success: (v: T) => EditorResponse, fail?: (err: Error) => EditorResponse): Promise<void> {
+  async #response<T>(operation: Promise<T>, success: (value: T) => EditorResponse, fail?: (error: Error) => EditorResponse): Promise<void> {
     try {
-      const res = await op;
-      if (process.connected) { process.send?.(success(res)); }
-    } catch (err) {
-      if (fail && process.connected && err && err instanceof Error) {
-        process.send?.(fail(err));
+      const response = await operation;
+      if (process.connected) { process.send?.(success(response)); }
+    } catch (error) {
+      if (fail && process.connected && error && error instanceof Error) {
+        process.send?.(fail(error));
       } else {
-        console.error(err);
+        console.error(error);
       }
     }
   }
 
   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, }) };
+    const config = await EditorConfig.get();
+    to ||= config.to;
+    const content = await this.#renderTemplate(file, config.context ?? {});
+    return { to, file, ...await this.sender.send({ from: config.from, to, ...content, }) };
   }
 
   /**
@@ -63,22 +64,22 @@ export class EditorService {
     if (!process.connected || !process.send) {
       throw new AppError('Unable to run email editor, missing ipc channel');
     }
-    process.on('message', async (msg: EditorRequest) => {
-      switch (msg.type) {
+    process.on('message', async (request: EditorRequest) => {
+      switch (request.type) {
         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 })
+          return await this.#response(this.#renderFile(request.file),
+            result => ({ type: 'compiled', ...result }),
+            error => ({ type: 'compiled-failed', message: error.message, stack: error.stack, file: request.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 })
+            this.sendFile(request.file, request.to),
+            result => ({ type: 'sent', ...result }),
+            error => ({ type: 'sent-failed', message: error.message, stack: error.stack, to: request.to!, file: request.file })
           );
         }
       }
@@ -86,11 +87,14 @@ export class EditorService {
 
     process.send({ type: 'init' });
 
-    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 })
-      );
+    // Watch template files
+    for await (const { file } of watchCompiler({ restartOnCompilerExit: true })) {
+      if (await EmailCompiler.spawnCompile(file)) {
+        await this.#response(this.#renderFile(file),
+          result => ({ type: 'compiled', ...result }),
+          error => ({ type: 'compiled-failed', message: error.message, stack: error.stack, file })
+        );
+      }
     }
   }
 }

package/support/bin/send.ts

@@ -33,7 +33,7 @@ export class EditorSendService {
             }
           }
         });
-        Registry.process([{ type: 'added', curr: cls }]);
+        Registry.process([cls]);
 
         this.ethereal = !!senderConfig.host?.includes('ethereal.email');
       } catch {
@@ -41,7 +41,9 @@ export class EditorSendService {
         throw new Error('A mail transport is currently needed to support sending emails.  Please install @travetto/email-nodemailer or any other compatible transport');
       }
     }
-    return await DependencyRegistryIndex.getInstance(MailService);
+    const service = await DependencyRegistryIndex.getInstance(MailService);
+    service.setCacheState(false); // Ensure we don't cache locally
+    return service;
   }
 
   /**
@@ -51,23 +53,23 @@ export class EditorSendService {
     const to = message.to!;
     try {
       console.log('Sending email', { to });
-      const svc = await this.service();
+      const service = await this.service();
       if (this.ethereal) {
         const { getTestMessageUrl } = await import('nodemailer');
         const { default: _smtp } = await import('nodemailer/lib/smtp-transport/index');
         type SendMessage = Parameters<Parameters<(typeof _smtp)['prototype']['send']>[1]>[1];
-        const info = await svc.send<SendMessage>(message);
+        const info = await service.send<SendMessage>(message);
         const url = getTestMessageUrl(info);
         console.log('Sent email', { to, url });
         return { url };
       } else {
-        await svc.send(message);
+        await service.send(message);
         console.log('Sent email', { to });
         return {};
       }
-    } catch (err) {
-      console.warn('Failed to send email', { to, error: err });
-      throw err;
+    } catch (error) {
+      console.warn('Failed to send email', { to, error });
+      throw error;
     }
   }
 }

package/support/cli.email_compile.ts

@@ -1,6 +1,6 @@
 import { Registry } from '@travetto/registry';
 import { CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
-import { Env, Runtime } from '@travetto/runtime';
+import { Env, Runtime, watchCompiler } from '@travetto/runtime';
 
 import { EmailCompiler } from '../src/compiler.ts';
 
@@ -16,22 +16,21 @@ export class EmailCompileCommand implements CliCommandShape {
   preMain(): void {
     Env.DEBUG.set(false);
     Env.TRV_ROLE.set('build');
-    Env.TRV_DYNAMIC.set(this.watch);
   }
 
   async main(): Promise<void> {
     await Registry.init();
 
     // Let the engine template
-    const all = await EmailCompiler.compileAll();
-    console!.log(cliTpl`Successfully compiled ${{ param: `${all.length}` }} templates`);
-    for (const el of all) {
-      console!.log(cliTpl`  * ${{ param: Runtime.stripWorkspacePath(el) }}`);
+    const locations = await EmailCompiler.compileAll();
+    console!.log(cliTpl`Successfully compiled ${{ param: `${locations.length}` }} templates`);
+    for (const location of locations) {
+      console!.log(cliTpl`  * ${{ param: Runtime.stripWorkspacePath(location) }}`);
     }
 
     if (this.watch) {
-      for await (const _ of EmailCompiler.watchCompile()) {
-        // Iterate until done
+      for await (const { file } of watchCompiler({ restartOnCompilerExit: true })) {
+        await EmailCompiler.spawnCompile(file);
       }
     }
   }

package/support/cli.email_editor.ts

@@ -1,5 +1,5 @@
 import { Env } from '@travetto/runtime';
-import { CliCommand, CliUtil } from '@travetto/cli';
+import { CliCommand } from '@travetto/cli';
 import { Registry } from '@travetto/registry';
 import { DependencyRegistryIndex } from '@travetto/di';
 
@@ -10,15 +10,10 @@ import { EditorService } from './bin/editor.ts';
 export class EmailEditorCommand {
 
   preMain(): void {
-    Env.TRV_DYNAMIC.set(true);
     Env.TRV_ROLE.set('build');
   }
 
   async main(): Promise<void> {
-    if (await CliUtil.runWithRestart(this, true)) {
-      return;
-    }
-
     await Registry.init();
     const service = await DependencyRegistryIndex.getInstance(EditorService);
     await service.listen();