create-forgeon 0.3.23 → 0.3.25

package/templates/module-presets/communications/packages/communications/src/sms/sms-channel.service.ts

@@ -0,0 +1,56 @@
+import { BadRequestException, Inject, Injectable, Logger } from '@nestjs/common';
+import { COMMUNICATIONS_SMS_PROVIDER } from '../communications.constants';
+import { TemplateLoaderService } from '../template-loader.service';
+import { TemplateRendererService } from '../template-renderer.service';
+import type { CommunicationMessageInput, CommunicationResult } from '../communications.types';
+import type { SmsProvider } from './sms-provider.port';
+
+const SMS_ERROR_CODES = {
+  missingRecipient: 'COMMUNICATIONS_SMS_RECIPIENT_REQUIRED',
+} as const;
+
+@Injectable()
+export class SmsChannelService {
+  private readonly logger = new Logger(SmsChannelService.name);
+
+  constructor(
+    private readonly templateLoader: TemplateLoaderService,
+    private readonly templateRenderer: TemplateRendererService,
+    @Inject(COMMUNICATIONS_SMS_PROVIDER)
+    private readonly smsProvider: SmsProvider,
+  ) {}
+
+  async send(input: CommunicationMessageInput): Promise<CommunicationResult> {
+    const recipient = input.recipient.phone?.trim();
+    if (!recipient) {
+      throw new BadRequestException({
+        message: 'SMS channel requires a phone recipient',
+        details: {
+          code: SMS_ERROR_CODES.missingRecipient,
+          channel: 'sms',
+        },
+      });
+    }
+
+    const template = await this.templateLoader.loadChannelTemplate('sms', input.kind, input.locale);
+    const text = this.templateRenderer.render(template, {
+      ...(input.payload ?? {}),
+      ...(input.metadata ?? {}),
+    });
+
+    const response = await this.smsProvider.send({ phone: recipient, text });
+    this.logger.warn(`communications.sms kind=${input.kind} provider=${this.smsProvider.providerId} phone=${recipient}`);
+
+    return {
+      kind: input.kind,
+      channel: 'sms',
+      provider: this.smsProvider.providerId,
+      status: response.status,
+      messageId: response.messageId,
+      recipient,
+      metadata: {
+        locale: input.locale ?? null,
+      },
+    };
+  }
+}

package/templates/module-presets/communications/packages/communications/src/sms/sms-provider.port.ts

@@ -0,0 +1,14 @@
+export interface SmsProviderSendInput {
+  phone: string;
+  text: string;
+}
+
+export interface SmsProviderSendResult {
+  status: 'stub' | 'sent';
+  messageId: string | null;
+}
+
+export interface SmsProvider {
+  readonly providerId: string;
+  send(input: SmsProviderSendInput): Promise<SmsProviderSendResult>;
+}

package/templates/module-presets/communications/packages/communications/src/template-loader.service.ts

@@ -0,0 +1,98 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { promises as fsPromises } from 'node:fs';
+import { BadRequestException, Injectable, InternalServerErrorException } from '@nestjs/common';
+import type { CommunicationChannel } from './communications.types';
+import { CommunicationsConfigService } from './communications-config.service';
+
+type TemplateVariant = 'body' | 'subject';
+
+const CHANNEL_EXTENSIONS: Record<CommunicationChannel, string> = {
+  email: '.html',
+  sms: '.txt',
+  push: '.json',
+};
+
+const SUBJECT_EXTENSION = '.subject.txt';
+const TEMPLATE_ERROR_CODES = {
+  invalidKey: 'COMMUNICATIONS_TEMPLATE_INVALID_KEY',
+  missing: 'COMMUNICATIONS_TEMPLATE_MISSING',
+} as const;
+
+@Injectable()
+export class TemplateLoaderService {
+  constructor(private readonly configService: CommunicationsConfigService) {}
+
+  async loadChannelTemplate(
+    channel: CommunicationChannel,
+    kind: string,
+    locale?: string,
+  ): Promise<string> {
+    const relativePath = this.resolveTemplateRelativePath(channel, kind, 'body', locale);
+    return this.readTemplate(relativePath, channel, kind);
+  }
+
+  async loadOptionalEmailSubjectTemplate(kind: string, locale?: string): Promise<string | null> {
+    const relativePath = this.resolveTemplateRelativePath('email', kind, 'subject', locale);
+    const absolutePath = path.join(this.configService.templatesRoot, relativePath);
+    if (!fs.existsSync(absolutePath)) {
+      return null;
+    }
+
+    return fsPromises.readFile(absolutePath, 'utf8');
+  }
+
+  private resolveTemplateRelativePath(
+    channel: CommunicationChannel,
+    kind: string,
+    variant: TemplateVariant,
+    locale?: string,
+  ): string {
+    const safeKind = this.sanitizeSegment(kind, 'kind');
+    const safeLocale = locale ? this.sanitizeSegment(locale, 'locale') : null;
+    const extension = variant === 'subject' ? SUBJECT_EXTENSION : CHANNEL_EXTENSIONS[channel];
+
+    if (safeLocale) {
+      const localizedPath = path.join(channel, `${safeKind}.${safeLocale}${extension}`);
+      const absoluteLocalizedPath = path.join(this.configService.templatesRoot, localizedPath);
+      if (fs.existsSync(absoluteLocalizedPath)) {
+        return localizedPath;
+      }
+    }
+
+    return path.join(channel, `${safeKind}${extension}`);
+  }
+
+  private async readTemplate(relativePath: string, channel: CommunicationChannel, kind: string): Promise<string> {
+    const absolutePath = path.join(this.configService.templatesRoot, relativePath);
+    if (!fs.existsSync(absolutePath)) {
+      throw new InternalServerErrorException({
+        message: 'Communication template was not found',
+        details: {
+          code: TEMPLATE_ERROR_CODES.missing,
+          channel,
+          kind,
+          relativePath,
+        },
+      });
+    }
+
+    return fsPromises.readFile(absolutePath, 'utf8');
+  }
+
+  private sanitizeSegment(value: string, field: 'kind' | 'locale'): string {
+    const normalized = value.trim();
+    if (!/^[a-z0-9._-]+$/i.test(normalized)) {
+      throw new BadRequestException({
+        message: `Communication ${field} contains unsupported characters`,
+        details: {
+          code: TEMPLATE_ERROR_CODES.invalidKey,
+          field,
+          value,
+        },
+      });
+    }
+
+    return normalized;
+  }
+}

package/templates/module-presets/communications/packages/communications/src/template-renderer.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import type { CommunicationPayloadValue } from './communications.types';
+
+@Injectable()
+export class TemplateRendererService {
+  render(template: string, values: Record<string, CommunicationPayloadValue> = {}): string {
+    let output = template;
+
+    for (const [rawKey, rawValue] of Object.entries(values)) {
+      const replacement = this.stringifyValue(rawValue);
+      const normalizedKeys = new Set([rawKey, rawKey.toUpperCase()]);
+
+      for (const key of normalizedKeys) {
+        output = output.split(`$${key}$`).join(replacement);
+      }
+    }
+
+    return output;
+  }
+
+  private stringifyValue(value: CommunicationPayloadValue): string {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value === null || value === undefined) {
+      return '';
+    }
+    return String(value);
+  }
+}

package/templates/module-presets/communications/packages/communications/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.node.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/templates/module-presets/communications/resources/communications/email/communications_probe.html

@@ -0,0 +1,9 @@
+<html>
+  <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #111827;">
+    <h1>Communications Probe</h1>
+    <p>This is a test message from the Forgeon communications module.</p>
+    <p>Recipient: <strong>$EMAIL$</strong></p>
+    <p>Probe id: <strong>$PROBE_ID$</strong></p>
+    <p>Generated at: <strong>$DATE$</strong></p>
+  </body>
+</html>

package/templates/module-presets/communications/resources/communications/email/communications_probe.subject.txt

@@ -0,0 +1 @@
+Communications probe

package/templates/module-presets/communications/resources/communications/email/email_verification_code.html

@@ -0,0 +1,8 @@
+<html>
+  <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #111827;">
+    <h1>Email Verification</h1>
+    <p>Hello $NAME$,</p>
+    <p>Your verification code is <strong>$CODE$</strong>.</p>
+    <p>If you did not request this, you can safely ignore this message.</p>
+  </body>
+</html>

package/templates/module-presets/communications/resources/communications/email/email_verification_code.subject.txt

@@ -0,0 +1 @@
+Verify your email address

package/templates/module-presets/communications/resources/communications/email/password_reset.html

@@ -0,0 +1,8 @@
+<html>
+  <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #111827;">
+    <h1>Password Reset</h1>
+    <p>Hello $NAME$,</p>
+    <p>Use this reset token to continue: <strong>$TOKEN$</strong>.</p>
+    <p>If you did not request a password reset, please ignore this email.</p>
+  </body>
+</html>

package/templates/module-presets/communications/resources/communications/email/password_reset.subject.txt

@@ -0,0 +1 @@
+Reset your password

package/templates/module-presets/communications/resources/communications/email/welcome_email.html

@@ -0,0 +1,8 @@
+<html>
+  <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #111827;">
+    <h1>Welcome</h1>
+    <p>Hello $NAME$,</p>
+    <p>Your account is ready.</p>
+    <p>We are glad to have you here.</p>
+  </body>
+</html>

package/templates/module-presets/communications/resources/communications/email/welcome_email.subject.txt

@@ -0,0 +1 @@
+Welcome to Forgeon

package/templates/module-presets/communications/resources/communications/push/login_alert.json

@@ -0,0 +1,4 @@
+{
+  "title": "Login alert",
+  "message": "A new login was detected on $DATE$"
+}

package/templates/module-presets/communications/resources/communications/sms/phone_verification.txt

@@ -0,0 +1 @@
+Phone verification code: $CODE$

package/templates/module-presets/i18n/apps/web/src/App.tsx

@@ -3,7 +3,7 @@ import { useTranslation } from 'react-i18next';
 import i18n from './i18n';
 import * as i18nWeb from '@forgeon/i18n-web';
 import type { I18nLocale } from '@forgeon/i18n-web';
-import { probeDefinitions, type ProbeDefinition, type ProbeResult } from './probes';
+import { probeDefinitions, type ProbeDefinition, type ProbeInputDefinition, type ProbeResult } from './probes';
 import './styles.css';
 
 type ProbeState = {
@@ -12,17 +12,42 @@ type ProbeState = {
   loading: boolean;
 };
 
+type ProbeInputState = Record<string, string>;
+
 const emptyProbeState: ProbeState = {
   result: null,
   error: null,
   loading: false,
 };
 
+function resolveBodyTemplate(value: unknown, inputs: ProbeInputState): unknown {
+  if (typeof value === 'string') {
+    const match = value.match(/^\$INPUT\.([a-zA-Z0-9_-]+)\$$/);
+    if (match) {
+      return inputs[match[1]] ?? '';
+    }
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => resolveBodyTemplate(item, inputs));
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nestedValue]) => [key, resolveBodyTemplate(nestedValue, inputs)]),
+    );
+  }
+
+  return value;
+}
+
 export default function App() {
   const { t } = useTranslation(['ui']);
   const { I18N_LOCALES, getInitialLocale, persistLocale, toLangQuery } = i18nWeb;
   const [locale, setLocale] = useState<I18nLocale>(getInitialLocale);
   const [probeState, setProbeState] = useState<Record<string, ProbeState>>({});
+  const [probeInputs, setProbeInputs] = useState<Record<string, ProbeInputState>>({});
 
   const changeLocale = (nextLocale: I18nLocale) => {
     setLocale(nextLocale);
@@ -30,15 +55,39 @@ export default function App() {
     void i18n.changeLanguage(nextLocale);
   };
 
+  const getProbeInputValue = (probeId: string, input: ProbeInputDefinition): string => {
+    return probeInputs[probeId]?.[input.id] ?? input.defaultValue ?? '';
+  };
+
+  const updateProbeInput = (probeId: string, inputId: string, value: string) => {
+    setProbeInputs((current) => ({
+      ...current,
+      [probeId]: {
+        ...(current[probeId] ?? {}),
+        [inputId]: value,
+      },
+    }));
+  };
+
   const requestProbe = async (probe: ProbeDefinition): Promise<ProbeResult> => {
-    const response = await fetch(`/api${probe.path}${toLangQuery(locale)}`, {
-      ...(probe.request ?? {}),
+    const method = probe.request?.method ?? 'GET';
+    const headers: Record<string, string> = {
+      ...(probe.request?.headers ?? {}),
+      'Accept-Language': locale,
+    };
+
+    const requestInit: RequestInit = {
+      method,
       cache: 'no-store',
-      headers: {
-        ...(probe.request?.headers ?? {}),
-        'Accept-Language': locale,
-      },
-    });
+      headers,
+    };
+
+    if (method !== 'GET' && probe.request?.body !== undefined) {
+      headers['Content-Type'] = 'application/json';
+      requestInit.body = JSON.stringify(resolveBodyTemplate(probe.request.body, probeInputs[probe.id] ?? {}));
+    }
+
+    const response = await fetch(`/api${probe.path}${toLangQuery(locale)}`, requestInit);
 
     let body: unknown = null;
     try {
@@ -113,6 +162,21 @@ export default function App() {
                   {current.loading ? 'Running...' : probe.buttonLabel}
                 </button>
               </div>
+              {probe.inputs?.length ? (
+                <div className="probe-inputs">
+                  {probe.inputs.map((input) => (
+                    <label key={`${probe.id}-${input.id}`} className="probe-input">
+                      <span>{input.label}</span>
+                      <input
+                        type={input.type ?? 'text'}
+                        value={getProbeInputValue(probe.id, input)}
+                        placeholder={input.placeholder}
+                        onChange={(event) => updateProbeInput(probe.id, input.id, event.target.value)}
+                      />
+                    </label>
+                  ))}
+                </div>
+              ) : null}
               <div className="probe-output">
                 <h3>{probe.resultTitle}</h3>
                 {current.error ? <p className="error">{current.error}</p> : null}

package/templates/module-presets/accounts/packages/accounts-api/src/accounts-email.port.ts

@@ -1,13 +0,0 @@
-export const ACCOUNTS_EMAIL_PORT = 'FORGEON_ACCOUNTS_EMAIL_PORT';
-
-export interface AccountsEmailPort {
-  sendVerificationEmail(input: { email: string; token: string; userId: string }): Promise<void>;
-  sendPasswordResetEmail(input: { email: string; token: string; userId: string }): Promise<void>;
-  sendWelcomeEmail(input: { email: string; userId: string }): Promise<void>;
-}
-
-export class StubAccountsEmailAdapter implements AccountsEmailPort {
-  async sendVerificationEmail(): Promise<void> {}
-  async sendPasswordResetEmail(): Promise<void> {}
-  async sendWelcomeEmail(): Promise<void> {}
-}