create-forgeon 0.3.22 → 0.3.24

package/templates/base/apps/web/src/App.tsx

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { probeDefinitions, type ProbeDefinition, type ProbeResult } from './probes';
+import { probeDefinitions, type ProbeDefinition, type ProbeInputDefinition, type ProbeResult } from './probes';
 import './styles.css';
 
 type ProbeState = {
@@ -8,34 +8,83 @@ 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 [probeState, setProbeState] = useState<Record<string, ProbeState>>({});
+  const [probeInputs, setProbeInputs] = useState<Record<string, ProbeInputState>>({});
+
+  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}`, {
-      ...(probe.request ?? {}),
+    const method = probe.request?.method ?? 'GET';
+    const headers: Record<string, string> = {
+      ...(probe.request?.headers ?? {}),
+    };
+
+    const requestInit: RequestInit = {
+      method,
       cache: 'no-store',
-      headers: {
-        ...(probe.request?.headers ?? {}),
-      },
-    });
-    let body: unknown = null;
+      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}`, requestInit);
+    let responseBody: unknown = null;
 
     try {
-      body = await response.json();
+      responseBody = await response.json();
     } catch {
-      body = { message: 'Non-JSON response' };
+      responseBody = { message: 'Non-JSON response' };
     }
 
     return {
       statusCode: response.status,
-      body,
+      body: responseBody,
     };
   };
 
@@ -87,6 +136,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/base/apps/web/src/probes.ts

@@ -1,11 +1,20 @@
-export type ProbeResult = {
+export type ProbeResult = {
   statusCode: number;
   body: unknown;
 };
 
+export type ProbeInputDefinition = {
+  id: string;
+  label: string;
+  type?: 'text' | 'email';
+  placeholder?: string;
+  defaultValue?: string;
+};
+
 export type ProbeRequest = {
   method?: 'GET' | 'POST';
   headers?: Record<string, string>;
+  body?: unknown;
 };
 
 export type ProbeDefinition = {
@@ -16,6 +25,7 @@ export type ProbeDefinition = {
   resultTitle: string;
   path: string;
   request?: ProbeRequest;
+  inputs?: ProbeInputDefinition[];
 };
 
 const baseProbeDefinitions: ProbeDefinition[] = [

package/templates/base/apps/web/src/styles.css

@@ -104,3 +104,28 @@ select {
     align-items: start;
   }
 }
+
+.probe-inputs {
+  display: grid;
+  gap: 0.75rem;
+}
+
+.probe-input {
+  display: grid;
+  gap: 0.35rem;
+  margin: 0;
+}
+
+.probe-input span {
+  font-size: 0.9rem;
+  font-weight: 600;
+}
+
+.probe-input input {
+  width: 100%;
+  box-sizing: border-box;
+  padding: 0.65rem 0.75rem;
+  border-radius: 0.6rem;
+  border: 1px solid #cbd5e1;
+  background: #ffffff;
+}

package/templates/module-fragments/accounts/20_scope.md

@@ -5,10 +5,11 @@ Implemented scope:
 1. Public installer surface:
    - single umbrella add-module: `accounts`
    - requires `db-adapter`
+   - requires `communications-runtime`
 2. Internal runtime split:
    - `@forgeon/accounts-contracts`
    - `@forgeon/accounts-api`
-   - users core, auth core, auth-jwt, auth-password, email stub port/adapter
+   - users core, auth core, auth-jwt, auth-password
 3. API runtime:
    - `POST /api/auth/register`
    - `POST /api/auth/login`
@@ -16,7 +17,7 @@ Implemented scope:
    - `POST /api/auth/logout`
    - `GET /api/auth/me`
    - `POST /api/auth/change-password`
-   - stub endpoints for verify-email and password reset
+   - stub endpoints for verify-email and password reset confirmation
 4. Users surface:
    - owner-scoped routes under `/api/users/:id`, `/api/users/:id/profile`, `/api/users/:id/settings`
    - `/users/me` is resolved through the same owner-scoped route surface

package/templates/module-fragments/accounts/90_status_implemented.md

@@ -3,6 +3,6 @@
 Status: implemented.
 
 Notes:
-- `accounts` is a hard consumer of the `db-adapter` capability.
+- `accounts` is a hard consumer of the `db-adapter` and `communications-runtime` capabilities.
 - The base accounts schema does not store RBAC roles or permissions.
-- Email verification and password reset are routed through an internal email stub boundary until the public `emails` module is implemented.
+- Registration and password-reset request flows send best-effort communication intents through `CommunicationsService`.

package/templates/module-fragments/accounts/90_status_planned.md

@@ -4,4 +4,4 @@ Status: planned.
 
 Notes:
 - public provider add-modules and DB-backed RBAC authz storage are intentionally deferred
-- the future `emails` module is expected to plug into the existing `AccountsEmailPort`
+- verification and password-reset token lifecycle storage remains a follow-up iteration

package/templates/module-fragments/communications/00_title.md

@@ -0,0 +1 @@
+# {{MODULE_LABEL}}

package/templates/module-fragments/communications/10_overview.md

@@ -0,0 +1,6 @@
+## Overview
+
+- Id: `{{MODULE_ID}}`
+- Category: `{{MODULE_CATEGORY}}`
+- Status: {{MODULE_STATUS}}
+- Description: {{MODULE_DESCRIPTION}}

package/templates/module-fragments/communications/20_scope.md

@@ -0,0 +1,20 @@
+## Scope
+
+Implemented scope:
+
+1. Public installer surface:
+   - single add-module: `communications`
+2. Runtime package:
+   - `@forgeon/communications`
+3. Core behavior:
+   - `CommunicationsService` orchestration
+   - file-based template loading from `resources/communications/*`
+   - simple `$PLACEHOLDER$` rendering
+4. Channel support:
+   - email channel with Gmail SMTP transport configuration
+   - sms stub channel
+   - push stub channel
+5. Module checks:
+   - `GET /api/health/communications`
+   - `POST /api/health/communications`
+   - default web probe with email input + test send

package/templates/module-fragments/communications/90_status_implemented.md

@@ -0,0 +1,8 @@
+## Current State
+
+Status: implemented.
+
+Notes:
+- `communications` is the canonical communication boundary for domain modules.
+- Provider selection is module-owned config, not a runtime request field.
+- Scheduling, queueing, retries, and persistent delivery history are intentionally deferred.

package/templates/module-presets/accounts/packages/accounts-api/package.json

@@ -9,6 +9,7 @@
   },
   "dependencies": {
     "@forgeon/accounts-contracts": "workspace:*",
+    "@forgeon/communications": "workspace:*",
     "@forgeon/db-prisma": "workspace:*",
     "@nestjs/common": "^11.0.1",
     "@nestjs/config": "^4.0.2",

package/templates/module-presets/accounts/packages/accounts-api/src/auth-core.service.ts

@@ -2,16 +2,16 @@ import crypto from 'node:crypto';
 import {
   BadRequestException,
   ConflictException,
-  Inject,
   Injectable,
+  Logger,
   UnauthorizedException,
 } from '@nestjs/common';
+import { CommunicationsService } from '@forgeon/communications';
 import type {
   AuthSessionResponse,
   RegisterRequest,
   UserRecordDto,
 } from '@forgeon/accounts-contracts';
-import { ACCOUNTS_EMAIL_PORT, type AccountsEmailPort } from './accounts-email.port';
 import { AuthJwtService } from './auth-jwt.service';
 import { AuthPasswordService } from './auth-password.service';
 import { AuthStore } from './auth.store';
@@ -29,10 +29,11 @@ const AUTH_ERROR_CODES = {
 
 @Injectable()
 export class AuthCoreService {
+  private readonly logger = new Logger(AuthCoreService.name);
+
   constructor(
     private readonly authStore: AuthStore,
-    @Inject(ACCOUNTS_EMAIL_PORT)
-    private readonly emailPort: AccountsEmailPort,
+    private readonly communicationsService: CommunicationsService,
     private readonly authJwtService: AuthJwtService,
     private readonly authPasswordService: AuthPasswordService,
     private readonly usersService: UsersService,
@@ -66,20 +67,39 @@ export class AuthCoreService {
       },
     });
 
+    const accountDto = toUserRecordDto(account);
     const verificationToken = this.createStubToken('verify', account.id);
     await Promise.all([
-      this.emailPort.sendVerificationEmail({
-        email,
-        token: verificationToken,
-        userId: account.id,
+      this.sendCommunicationSafely({
+        kind: 'email_verification_code',
+        channels: ['email'],
+        recipient: { email },
+        payload: {
+          NAME: accountDto.profile?.name ?? 'there',
+          CODE: verificationToken,
+        },
+        locale: accountDto.settings?.locale ?? undefined,
+        metadata: {
+          USER_ID: account.id,
+          SOURCE: 'accounts.register',
+        },
       }),
-      this.emailPort.sendWelcomeEmail({
-        email,
-        userId: account.id,
+      this.sendCommunicationSafely({
+        kind: 'welcome_email',
+        channels: ['email'],
+        recipient: { email },
+        payload: {
+          NAME: accountDto.profile?.name ?? 'there',
+        },
+        locale: accountDto.settings?.locale ?? undefined,
+        metadata: {
+          USER_ID: account.id,
+          SOURCE: 'accounts.register',
+        },
       }),
     ]);
 
-    return this.issueSession(toUserRecordDto(account));
+    return this.issueSession(accountDto);
   }
 
   async loginWithPassword(emailInput: string, password: string): Promise<AuthSessionResponse> {
@@ -167,16 +187,26 @@ export class AuthCoreService {
     const email = emailInput.trim().toLowerCase();
     const account = await this.authStore.findPasswordAccountByEmail(email);
     if (account) {
-      await this.emailPort.sendPasswordResetEmail({
-        email,
-        token: this.createStubToken('reset', account.id),
-        userId: account.id,
+      const user = toUserRecordDto(account);
+      await this.sendCommunicationSafely({
+        kind: 'password_reset',
+        channels: ['email'],
+        recipient: { email },
+        payload: {
+          NAME: user.profile?.name ?? 'there',
+          TOKEN: this.createStubToken('reset', account.id),
+        },
+        locale: user.settings?.locale ?? undefined,
+        metadata: {
+          USER_ID: account.id,
+          SOURCE: 'accounts.password-reset',
+        },
       });
     }
 
     return {
       status: 'accepted',
-      delivery: 'stub',
+      delivery: 'communications',
     };
   }
 
@@ -188,7 +218,7 @@ export class AuthCoreService {
     return {
       status: 'accepted',
       delivery: 'stub',
-      nextAction: 'emails-module',
+      nextAction: 'accounts-token-flow',
       passwordLength: newPassword.length,
     };
   }
@@ -201,7 +231,7 @@ export class AuthCoreService {
     return {
       status: 'accepted',
       delivery: 'stub',
-      nextAction: 'emails-module',
+      nextAction: 'accounts-token-flow',
     };
   }
 
@@ -215,7 +245,7 @@ export class AuthCoreService {
       status: 'ok',
       feature: 'accounts',
       storage: 'db-prisma',
-      emailDelivery: 'stub',
+      emailDelivery: 'communications',
       selfServiceRoutes: [
         '/api/users/:id',
         '/api/users/:id/profile',
@@ -258,6 +288,16 @@ export class AuthCoreService {
     };
   }
 
+  private async sendCommunicationSafely(input: Parameters<CommunicationsService['send']>[0]): Promise<void> {
+    try {
+      await this.communicationsService.send(input);
+    } catch (error) {
+      this.logger.warn(
+        `accounts.communication_failed kind=${input.kind} channel=${input.channels.join(',')} reason=${error instanceof Error ? error.message : 'unknown'}`,
+      );
+    }
+  }
+
   private assertAccountActive(user: { status: string; deletedAt: Date | null }) {
     if (user.deletedAt || user.status !== 'active') {
       throw new UnauthorizedException({

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

@@ -6,12 +6,12 @@ import {
 } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
+import { ForgeonCommunicationsModule } from '@forgeon/communications';
 import { DbPrismaModule } from '@forgeon/db-prisma';
 import {
   ACCOUNTS_AUTHZ_CLAIMS_RESOLVER,
   NoopAccountsAuthzClaimsResolver,
 } from './accounts-rbac.port';
-import { ACCOUNTS_EMAIL_PORT, StubAccountsEmailAdapter } from './accounts-email.port';
 import { AuthConfigModule } from './auth-config.module';
 import { AuthController } from './auth.controller';
 import { AuthCoreService } from './auth-core.service';
@@ -41,6 +41,7 @@ export class ForgeonAccountsModule {
       imports: [
         AuthConfigModule,
         DbPrismaModule,
+        ForgeonCommunicationsModule.register(),
         PassportModule.register({ defaultStrategy: 'jwt' }),
         JwtModule.register({}),
         ...(options.imports ?? []),
@@ -51,10 +52,6 @@ export class ForgeonAccountsModule {
           provide: USERS_MODULE_OPTIONS,
           useValue: UsersModule.register(options.users ?? {}),
         },
-        {
-          provide: ACCOUNTS_EMAIL_PORT,
-          useClass: StubAccountsEmailAdapter,
-        },
         {
           provide: ACCOUNTS_AUTHZ_CLAIMS_RESOLVER,
           useClass: NoopAccountsAuthzClaimsResolver,
@@ -80,7 +77,6 @@ export class ForgeonAccountsModule {
         UsersService,
         JwtAuthGuard,
         OwnerAccessGuard,
-        ACCOUNTS_EMAIL_PORT,
         ACCOUNTS_AUTHZ_CLAIMS_RESOLVER,
       ],
     };

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

@@ -1,4 +1,3 @@
-export * from './accounts-email.port';
 export * from './accounts-rbac.port';
 export * from './auth-config.loader';
 export * from './auth-config.module';
@@ -21,3 +20,4 @@ export * from './users.controller';
 export * from './users.service';
 export * from './users.store';
 export * from './users.types';
+

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

@@ -0,0 +1,23 @@
+{
+  "name": "@forgeon/communications",
+  "version": "0.1.0",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/config": "^4.0.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "nodemailer": "^6.10.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.7",
+    "@types/nodemailer": "^6.4.17",
+    "typescript": "^5.7.3"
+  }
+}

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

@@ -0,0 +1,58 @@
+import * as path from 'node:path';
+import { registerAs } from '@nestjs/config';
+import { parseCommunicationsEnv } from './communications-env.schema';
+
+export const COMMUNICATIONS_CONFIG_NAMESPACE = 'communications';
+
+export type CommunicationsConfigValues = {
+  templatesRoot: string;
+  email: {
+    provider: 'gmail-smtp';
+    from: string;
+    replyTo: string | null;
+    subjectPrefix: string | null;
+    smtp: {
+      host: string;
+      port: number;
+      secure: boolean;
+      user: string;
+      pass: string;
+    };
+  };
+  sms: {
+    provider: 'stub';
+  };
+  push: {
+    provider: 'stub';
+  };
+};
+
+export const communicationsConfig = registerAs(
+  COMMUNICATIONS_CONFIG_NAMESPACE,
+  (): CommunicationsConfigValues => {
+    const env = parseCommunicationsEnv(process.env as unknown as Record<string, unknown>);
+
+    return {
+      templatesRoot: path.resolve(process.cwd(), env.COMMUNICATIONS_TEMPLATES_ROOT),
+      email: {
+        provider: env.COMMUNICATIONS_EMAIL_PROVIDER,
+        from: env.COMMUNICATIONS_EMAIL_FROM,
+        replyTo: env.COMMUNICATIONS_EMAIL_REPLY_TO || null,
+        subjectPrefix: env.COMMUNICATIONS_EMAIL_SUBJECT_PREFIX || null,
+        smtp: {
+          host: env.COMMUNICATIONS_EMAIL_SMTP_HOST,
+          port: env.COMMUNICATIONS_EMAIL_SMTP_PORT,
+          secure: env.COMMUNICATIONS_EMAIL_SMTP_SECURE,
+          user: env.COMMUNICATIONS_EMAIL_SMTP_USER,
+          pass: env.COMMUNICATIONS_EMAIL_SMTP_PASS,
+        },
+      },
+      sms: {
+        provider: env.COMMUNICATIONS_SMS_PROVIDER,
+      },
+      push: {
+        provider: env.COMMUNICATIONS_PUSH_PROVIDER,
+      },
+    };
+  },
+);

package/templates/module-presets/communications/packages/communications/src/communications-config.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { communicationsConfig } from './communications-config.loader';
+import { CommunicationsConfigService } from './communications-config.service';
+
+@Module({
+  imports: [ConfigModule.forFeature(communicationsConfig)],
+  providers: [CommunicationsConfigService],
+  exports: [ConfigModule, CommunicationsConfigService],
+})
+export class CommunicationsConfigModule {}

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

@@ -0,0 +1,60 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { COMMUNICATIONS_CONFIG_NAMESPACE } from './communications-config.loader';
+
+@Injectable()
+export class CommunicationsConfigService {
+  constructor(private readonly configService: ConfigService) {}
+
+  get templatesRoot(): string {
+    return this.configService.getOrThrow<string>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.templatesRoot`);
+  }
+
+  get emailProvider(): 'gmail-smtp' {
+    return this.configService.getOrThrow<'gmail-smtp'>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.provider`);
+  }
+
+  get emailFrom(): string {
+    return this.configService.getOrThrow<string>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.from`);
+  }
+
+  get emailReplyTo(): string | null {
+    return this.configService.get<string | null>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.replyTo`) ?? null;
+  }
+
+  get emailSubjectPrefix(): string | null {
+    return this.configService.get<string | null>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.subjectPrefix`) ?? null;
+  }
+
+  get emailSmtpHost(): string {
+    return this.configService.getOrThrow<string>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.smtp.host`);
+  }
+
+  get emailSmtpPort(): number {
+    return this.configService.getOrThrow<number>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.smtp.port`);
+  }
+
+  get emailSmtpSecure(): boolean {
+    return this.configService.getOrThrow<boolean>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.smtp.secure`);
+  }
+
+  get emailSmtpUser(): string {
+    return this.configService.getOrThrow<string>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.smtp.user`);
+  }
+
+  get emailSmtpPass(): string {
+    return this.configService.getOrThrow<string>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.email.smtp.pass`);
+  }
+
+  get smsProvider(): 'stub' {
+    return this.configService.getOrThrow<'stub'>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.sms.provider`);
+  }
+
+  get pushProvider(): 'stub' {
+    return this.configService.getOrThrow<'stub'>(`${COMMUNICATIONS_CONFIG_NAMESPACE}.push.provider`);
+  }
+
+  get emailProviderReady(): boolean {
+    return this.emailSmtpUser.trim().length > 0 && this.emailSmtpPass.trim().length > 0;
+  }
+}

package/templates/module-presets/communications/packages/communications/src/communications-env.schema.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+export const communicationsEnvSchema = z
+  .object({
+    COMMUNICATIONS_TEMPLATES_ROOT: z.string().trim().min(1).default('resources/communications'),
+    COMMUNICATIONS_EMAIL_PROVIDER: z.enum(['gmail-smtp']).default('gmail-smtp'),
+    COMMUNICATIONS_EMAIL_FROM: z.string().trim().min(1).default('Forgeon <no-reply@example.com>'),
+    COMMUNICATIONS_EMAIL_REPLY_TO: z.string().trim().default(''),
+    COMMUNICATIONS_EMAIL_SUBJECT_PREFIX: z.string().trim().default('[Forgeon]'),
+    COMMUNICATIONS_EMAIL_SMTP_HOST: z.string().trim().min(1).default('smtp.gmail.com'),
+    COMMUNICATIONS_EMAIL_SMTP_PORT: z.coerce.number().int().min(1).max(65535).default(587),
+    COMMUNICATIONS_EMAIL_SMTP_SECURE: z.coerce.boolean().default(false),
+    COMMUNICATIONS_EMAIL_SMTP_USER: z.string().trim().default(''),
+    COMMUNICATIONS_EMAIL_SMTP_PASS: z.string().trim().default(''),
+    COMMUNICATIONS_SMS_PROVIDER: z.enum(['stub']).default('stub'),
+    COMMUNICATIONS_PUSH_PROVIDER: z.enum(['stub']).default('stub')
+  })
+  .passthrough();
+
+export type CommunicationsEnv = z.infer<typeof communicationsEnvSchema>;
+
+export function parseCommunicationsEnv(input: Record<string, unknown>): CommunicationsEnv {
+  return communicationsEnvSchema.parse(input);
+}

package/templates/module-presets/communications/packages/communications/src/communications.constants.ts

@@ -0,0 +1,3 @@
+export const COMMUNICATIONS_EMAIL_PROVIDER = 'FORGEON_COMMUNICATIONS_EMAIL_PROVIDER';
+export const COMMUNICATIONS_SMS_PROVIDER = 'FORGEON_COMMUNICATIONS_SMS_PROVIDER';
+export const COMMUNICATIONS_PUSH_PROVIDER = 'FORGEON_COMMUNICATIONS_PUSH_PROVIDER';