@solidxai/core 0.0.2

package/src/seeders/module-test-data.service.ts

@@ -0,0 +1,461 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { getDataSourceToken } from '@nestjs/typeorm';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { DataSource } from 'typeorm';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import solidCoreMetadata from './seed-data/solid-core-metadata.json';
+import { CreateModuleMetadataDto } from 'src/dtos/create-module-metadata.dto';
+import { CreateModelMetadataDto } from 'src/dtos/create-model-metadata.dto';
+import { getDynamicModuleNamesBasedOnMetadata } from 'src/helpers/module.helper';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+
+@Injectable()
+export class ModuleTestDataService {
+  private readonly logger = new Logger(ModuleTestDataService.name);
+
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly discoveryService: DiscoveryService,
+    private readonly solidRegistry: SolidRegistry,
+  ) {}
+
+  async setupTestData(modulesToTest?: string[]): Promise<void> {
+    const testDataFiles = this.testDataFiles;
+    const filteredFiles = modulesToTest?.length ? testDataFiles.filter((file) => modulesToTest.includes(file.moduleMetadata?.name)) : testDataFiles;
+
+    if (filteredFiles.length === 0) {
+      this.logger.warn('No modules matched the provided modulesToTest list.');
+      console.log('No modules matched the provided modulesToTest list.');
+      return;
+    }
+
+    for (const overallMetadata of filteredFiles) {
+      const moduleName = overallMetadata?.moduleMetadata?.name ?? 'unknown';
+      this.logger.log(`Processing test data for module: ${moduleName}`);
+      console.log(`Processing test data for module: ${moduleName}`);
+      await this.seedTestData(overallMetadata);
+      console.log(`✔ Test data setup complete for module: ${moduleName}`);
+    }
+  }
+
+  async createTestDatasources(): Promise<void> {
+    const manifestPath = path.join(process.cwd(), '.solidx-test-manifest');
+    if (fs.existsSync(manifestPath)) {
+      console.log('Existing .solidx-test-manifest found; skipping test datasource creation.');
+      return;
+    }
+
+    const dbRunName = this.generateDbRunName();
+    const timestamp = this.getTimestamp();
+    const envPath = path.join(process.cwd(), '.env');
+    if (!fs.existsSync(envPath)) {
+      throw new Error(`Base .env file not found at ${envPath}`);
+    }
+
+    const datasourceNames = this.solidRegistry
+      .getSolidDatabaseModules()
+      .map((wrapper) => wrapper.instance?.name?.())
+      .filter(Boolean)
+      .map((name) => name.toLowerCase()) as string[];
+
+    if (datasourceNames.length === 0) {
+      throw new Error('No solid database modules registered; cannot create test datasources.');
+    }
+
+    const dbNameByDatasource = new Map<string, string>();
+    for (const dsName of datasourceNames) {
+      dbNameByDatasource.set(dsName, `${dsName}_${timestamp}_${dbRunName}`);
+    }
+
+    const newEnvContents = this.buildTestEnvContents(
+      fs.readFileSync(envPath, 'utf-8'),
+      dbNameByDatasource,
+    );
+
+    const backupEnvPath = path.join(process.cwd(), `.env.backup.${dbRunName}`);
+    fs.copyFileSync(envPath, backupEnvPath);
+    fs.writeFileSync(envPath, newEnvContents);
+    console.log(`Backed up .env to ${path.basename(backupEnvPath)} and applied new test datasource names to .env.`);
+
+    this.updateTestManifest(dbRunName, timestamp, dbNameByDatasource);
+
+    await this.createTestDatabaseObjects(dbNameByDatasource);
+
+    const dbList = Array.from(dbNameByDatasource.entries())
+      .map(([dsName, dbName]) => `- ${dsName}: ${dbName}`)
+      .join('\n');
+
+    const instructions = [
+      '',
+      '============================================================',
+      '  TEST DATASOURCE ENVIRONMENT CREATED',
+      '------------------------------------------------------------',
+      `  Run name : ${dbRunName}`,
+      `  Env backup : ${path.basename(backupEnvPath)}`,
+      '',
+      '  Test databases/schemas created:',
+      dbList || '  (none)',
+      '',
+      '  Next steps:',
+      '  1) Using updated .env with test datasource names',
+      '  2) Run solid seed as usual',
+      '  3) Proceed with the next steps in the workflow',
+      '============================================================',
+      '',
+    ].join('\n');
+
+    console.log(instructions);
+  }
+
+  async deleteTestDatasources(): Promise<void> {
+    const manifestPath = path.join(process.cwd(), '.solidx-test-manifest');
+    if (!fs.existsSync(manifestPath)) {
+      this.logger.log('No .solidx-test-manifest found; nothing to delete.');
+      console.log('No .solidx-test-manifest found; nothing to delete.');
+      return;
+    }
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as {
+      runs?: Record<string, { databases?: Record<string, string>; createdAt?: string }>;
+    };
+    const runs = manifest?.runs ?? {};
+    const runNames = Object.keys(runs);
+    if (runNames.length === 0) {
+      fs.unlinkSync(manifestPath);
+      return;
+    }
+
+    const latestRunName = runNames
+      .slice()
+      .sort((a, b) => {
+        const aCreated = runs[a]?.createdAt ?? '';
+        const bCreated = runs[b]?.createdAt ?? '';
+        return aCreated.localeCompare(bCreated);
+      })
+      .pop();
+    if (latestRunName) {
+      const backupEnvPath = path.join(process.cwd(), `.env.backup.${latestRunName}`);
+      if (fs.existsSync(backupEnvPath)) {
+        fs.copyFileSync(backupEnvPath, path.join(process.cwd(), '.env'));
+        console.log(`Restored .env from ${path.basename(backupEnvPath)}.`);
+        fs.unlinkSync(backupEnvPath);
+      }
+    }
+
+    for (const runName of runNames) {
+      const envFileName = `.env.${runName}`;
+      const envPath = path.join(process.cwd(), envFileName);
+      if (fs.existsSync(envPath)) {
+        fs.unlinkSync(envPath);
+      }
+    }
+
+    for (const runName of runNames) {
+      const databases = runs[runName]?.databases ?? {};
+      await this.dropTestDatabaseObjects(databases);
+    }
+
+    fs.unlinkSync(manifestPath);
+    console.log('✔ Test datasource env files and manifest deleted; test databases dropped.');
+  }
+
+  private get testDataFiles(): any[] {
+    const typedSolidCoreMetadata = structuredClone(solidCoreMetadata);
+    const testDataFiles = [typedSolidCoreMetadata];
+    const enabledModules = getDynamicModuleNamesBasedOnMetadata();
+    for (const enabledModule of enabledModules) {
+      const enabledModuleSeedFile = `module-metadata/${enabledModule}/${enabledModule}-metadata.json`;
+      const fullPath = path.join(process.cwd(), enabledModuleSeedFile);
+
+      if (fs.existsSync(fullPath)) {
+        const overallMetadata = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+        testDataFiles.push(overallMetadata);
+      }
+    }
+
+    return testDataFiles;
+  }
+
+  private async seedTestData(overallMetadata: any): Promise<void> {
+    const moduleMetadata: CreateModuleMetadataDto = overallMetadata.moduleMetadata;
+    if (!moduleMetadata) {
+      throw new Error('Module metadata missing from test data payload.');
+    }
+
+    const testData: Array<{ modelUserKey: string; data: Record<string, any> }> = overallMetadata.testData ?? [];
+    if (testData.length === 0) {
+      this.logger.debug(`No test data found for ${moduleMetadata.name}`);
+      return;
+    }
+
+    const modelsByName = new Map<string, CreateModelMetadataDto>(
+      (moduleMetadata.models ?? []).map((m) => [m.singularName, m]),
+    );
+
+    for (const entry of testData) {
+      const modelUserKey = entry.modelUserKey;
+      const modelDef = modelsByName.get(modelUserKey);
+      if (!modelDef) {
+        throw new Error(`Test data modelUserKey not found in metadata: ${modelUserKey}`);
+      }
+
+      const entityRepo = this.resolveRepository(modelUserKey);
+      const payload: Record<string, any> = { ...(entry.data ?? {}) };
+
+      for (const field of modelDef.fields ?? []) {
+        if (field.type === 'relation' && field.relationType === 'many-to-one') {
+          const userKeyProp = `${field.name}UserKey`;
+          if (!(userKeyProp in payload)) {
+            continue;
+          }
+
+          const userKeyValue = payload[userKeyProp];
+          if (userKeyValue === null || userKeyValue === undefined || userKeyValue === '') {
+            delete payload[userKeyProp];
+            continue;
+          }
+
+          const coModelName = field.relationCoModelSingularName;
+          const coModelDef = coModelName ? modelsByName.get(coModelName) : null;
+          if (!coModelDef) {
+            throw new Error(`Test data relation model ${coModelName} not found in metadata, when attempting to resolve field ${modelDef.singularName}.${field.name}`);
+          }
+          const coUserKeyField = coModelDef.userKeyFieldUserKey;
+          if (!coUserKeyField) {
+            throw new Error(`Test data relation model ${coModelName} is missing userKeyFieldUserKey, when attempting to resolve field ${modelDef.singularName}.${field.name}`);
+          }
+
+          const coRepo = this.resolveRepository(coModelName);
+          const related = typeof coRepo.findOneByUserKey === 'function'
+            ? await coRepo.findOneByUserKey(userKeyValue)
+            : await coRepo.findOne({ where: { [coUserKeyField]: userKeyValue } });
+          if (!related) {
+            throw new Error(`Test data relation not found: ${coModelName}.${coUserKeyField}=${userKeyValue}`);
+          }
+
+          payload[field.name] = related;
+          delete payload[userKeyProp];
+        }
+      }
+
+      const userKeyField = modelDef.userKeyFieldUserKey;
+      if (userKeyField && payload[userKeyField] !== undefined) {
+        const existing = await entityRepo.findOne({
+          where: { [userKeyField]: payload[userKeyField] },
+        });
+        if (existing) {
+          await entityRepo.save(entityRepo.merge(existing, payload));
+          continue;
+        }
+      }
+
+      await entityRepo.save(entityRepo.create(payload));
+    }
+  }
+
+  private resolveRepository(modelUserKey: string): any {
+    const repoName = `${classify(modelUserKey)}Repository`;
+    const providers = this.discoveryService.getProviders();
+    const wrapper = providers.find((provider) => provider.name === repoName);
+    const repo = wrapper?.instance;
+    if (repo) {
+      return repo;
+    }
+
+    try {
+      const resolved = this.moduleRef.get(repoName as any, { strict: false });
+      if (resolved) {
+        return resolved;
+      }
+    } catch {
+      // fall through
+    }
+
+    throw new Error(`Repository not found for model ${modelUserKey}. Expected provider: ${repoName}`);
+  }
+
+  private generateDbRunName(): string {
+    const adjectives = [
+      'brave', 'bright', 'calm', 'clever', 'curious', 'gentle', 'jolly', 'lively', 'mighty', 'nimble',
+      'proud', 'quick', 'quiet', 'sharp', 'sly', 'steady', 'swift', 'wise', 'witty', 'zesty',
+    ];
+    const animals = [
+      'lion', 'tiger', 'panther', 'eagle', 'falcon', 'otter', 'wolf', 'fox', 'bear', 'badger',
+      'monkey', 'panda', 'leopard', 'whale', 'dolphin', 'rhino', 'giraffe', 'camel', 'koala', 'lynx',
+    ];
+    const adjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+    const animal = animals[Math.floor(Math.random() * animals.length)];
+    return `${adjective}_${animal}`;
+  }
+
+  private getTimestamp(): string {
+    const now = new Date();
+    const pad = (value: number) => value.toString().padStart(2, '0');
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  }
+
+  private buildTestEnvContents(baseEnv: string, dbNameByDatasource: Map<string, string>): string {
+    const datasourceNameSet = new Set(Array.from(dbNameByDatasource.keys()));
+    const lines = baseEnv.split(/\r?\n/);
+    return lines
+      .map((line) => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) {
+          return line;
+        }
+        const [rawKey, ...rest] = line.split('=');
+        const key = rawKey.trim();
+        if (!key.endsWith('_DATABASE_NAME')) {
+          return line;
+        }
+        const prefix = key.replace(/_DATABASE_NAME$/, '').toLowerCase();
+        const matchedDatasource = Array.from(datasourceNameSet).find((name) => name === prefix);
+        if (!matchedDatasource) {
+          return line;
+        }
+        const dbName = dbNameByDatasource.get(matchedDatasource);
+        if (!dbName) {
+          return line;
+        }
+        return `${key}=${dbName}`;
+      })
+      .join('\n');
+  }
+
+  private async createTestDatabaseObjects(dbNameByDatasource: Map<string, string>): Promise<void> {
+    for (const [dsName, dbName] of dbNameByDatasource.entries()) {
+      const dataSource = this.resolveDataSourceByName(dsName);
+      if (!dataSource.isInitialized) {
+        await dataSource.initialize();
+      }
+
+      console.log(`Creating test database/schema "${dbName}" on datasource "${dsName}"...`);
+
+      const queryRunner = dataSource.createQueryRunner();
+      try {
+        const type = dataSource.options.type;
+        if (type === 'postgres') {
+          await queryRunner.query(`CREATE DATABASE "${dbName}"`);
+        } else if (type === 'mssql') {
+          await queryRunner.query(
+            `IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '${dbName}') EXEC('CREATE SCHEMA [${dbName}]')`,
+          );
+        } else if (type === 'mysql' || type === 'mariadb') {
+          await queryRunner.query(`CREATE DATABASE IF NOT EXISTS \`${dbName}\``);
+        } else {
+          throw new Error(`Unsupported database type for test data creation: ${type}`);
+        }
+      } finally {
+        await queryRunner.release();
+      }
+    }
+  }
+
+  private resolveDataSourceByName(datasourceName: string): DataSource {
+    const token = datasourceName ? getDataSourceToken(datasourceName) : getDataSourceToken();
+    try {
+      const ds = this.moduleRef.get<DataSource>(token, { strict: false });
+      if (!ds) {
+        throw new Error(`No DataSource found for "${datasourceName}"`);
+      }
+      return ds;
+    } catch (err: any) {
+      throw new Error(`Failed to resolve DataSource "${datasourceName}": ${err?.message ?? err}`);
+    }
+  }
+
+  private updateTestManifest(
+    dbRunName: string,
+    timestamp: string,
+    dbNameByDatasource: Map<string, string>,
+  ): void {
+    const manifestPath = path.join(process.cwd(), '.solidx-test-manifest');
+    let manifest: Record<string, any> = {};
+    if (fs.existsSync(manifestPath)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        if (parsed && typeof parsed === 'object') {
+          manifest = parsed;
+        }
+      } catch {
+        // fall through with empty manifest
+      }
+    }
+
+    if (!manifest.runs || typeof manifest.runs !== 'object') {
+      manifest.runs = {};
+    }
+
+    const databases: Record<string, string> = {};
+    for (const [dsName, dbName] of dbNameByDatasource.entries()) {
+      databases[dsName] = dbName;
+    }
+
+    manifest.runs[dbRunName] = {
+      createdAt: timestamp,
+      databases,
+    };
+
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+
+  private async dropTestDatabaseObjects(databases: Record<string, string>): Promise<void> {
+    const entries = Object.entries(databases);
+    for (const [dsName, dbName] of entries) {
+      const dataSource = this.resolveDataSourceByName(dsName);
+      if (!dataSource.isInitialized) {
+        await dataSource.initialize();
+      }
+
+      console.log(`Dropping test database/schema "${dbName}" on datasource "${dsName}"...`);
+
+      const queryRunner = dataSource.createQueryRunner();
+      try {
+        const type = dataSource.options.type;
+        if (type === 'postgres') {
+          await queryRunner.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+        } else if (type === 'mssql') {
+          await this.dropMssqlSchema(queryRunner, dbName);
+        } else if (type === 'mysql' || type === 'mariadb') {
+          await queryRunner.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+        } else {
+          throw new Error(`Unsupported database type for test data deletion: ${type}`);
+        }
+      } finally {
+        await queryRunner.release();
+      }
+    }
+  }
+
+  private async dropMssqlSchema(queryRunner: ReturnType<DataSource['createQueryRunner']>, schemaName: string): Promise<void> {
+    const foreignKeys: Array<{ fk_name: string; table_name: string }> = await queryRunner.query(
+      `SELECT fk.name AS fk_name, t.name AS table_name
+       FROM sys.foreign_keys fk
+       INNER JOIN sys.tables t ON fk.parent_object_id = t.object_id
+       INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+       WHERE s.name = '${schemaName}'`,
+    );
+    for (const fk of foreignKeys) {
+      await queryRunner.query(`ALTER TABLE [${schemaName}].[${fk.table_name}] DROP CONSTRAINT [${fk.fk_name}]`);
+    }
+
+    const tables: Array<{ TABLE_NAME: string }> = await queryRunner.query(
+      `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${schemaName}'`,
+    );
+    for (const table of tables) {
+      await queryRunner.query(`DROP TABLE [${schemaName}].[${table.TABLE_NAME}]`);
+    }
+
+    const views: Array<{ TABLE_NAME: string }> = await queryRunner.query(
+      `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_SCHEMA = '${schemaName}'`,
+    );
+    for (const view of views) {
+      await queryRunner.query(`DROP VIEW [${schemaName}].[${view.TABLE_NAME}]`);
+    }
+
+    await queryRunner.query(`DROP SCHEMA [${schemaName}]`);
+  }
+}

package/src/seeders/permission-metadata-seeder.service.ts

@@ -0,0 +1,66 @@
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { PermissionMetadata } from '../entities/permission-metadata.entity';
+import { RoleMetadataService } from '../services/role-metadata.service';
+import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
+
+@Injectable()
+export class PermissionMetadataSeederService {
+  private readonly logger = new Logger(PermissionMetadataSeederService.name);
+
+  constructor(
+    // @InjectRepository(PermissionMetadata)
+    // private readonly permissionRepo: Repository<PermissionMetadata>,
+    private readonly permissionRepo: PermissionMetadataRepository,
+    private readonly solidRegistry: SolidRegistry,
+    @Inject(forwardRef(() => RoleMetadataService))
+    private readonly roleService: RoleMetadataService,
+  ) { }
+
+  async seed() {
+
+    const controllers = this.solidRegistry.getControllers();
+
+    // Loop over the countries and create them.
+    for (let id = 0; id < controllers.length; id++) {
+      try {
+        const controller = controllers[id];
+        // this.logger.log(`Resolving controller: ${controller.name}`);
+
+        const methods = controller.methods;
+        for (let mId = 0; mId < methods.length; mId++) {
+
+          const methodName = methods[mId];
+          const permissionName = `${controller.name}.${methodName}`;
+
+          const existingPermission = await this.permissionRepo.findOne({
+            where: {
+              name: permissionName
+            }
+          });
+
+          if (existingPermission) {
+            this.logger.log(`Permission ${permissionName} already exists.`);
+          }
+          else {
+            this.logger.log(`Permission ${permissionName} does not exist, creating new.`);
+
+            const newPermission = this.permissionRepo.create({
+              name: permissionName
+            });
+            await this.permissionRepo.save(newPermission);
+
+          }
+        }
+
+      } catch (error) {
+        this.logger.error(error);
+      }
+    }
+
+    // Associate the Admin role with all existing permissions. 
+    await this.roleService.addAllPermissionsToRole("Admin");
+  }
+}

package/src/seeders/seed-data/email-templates/email-on-signup.handlebars.html

@@ -0,0 +1,155 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="UTF-8" />
+    <title>Welcome to {{ solidAppName }}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+    <style>
+        @import url("https://fonts.googleapis.com/css?family=Nunito+Sans:400,700&display=swap");
+
+        body {
+            margin: 0;
+            padding: 0;
+            background-color: #f4f4f7;
+            font-family: "Nunito Sans", Helvetica, Arial, sans-serif;
+            color: #333;
+        }
+
+        .email-wrapper {
+            max-width: 600px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+
+        .logo {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+
+        .logo img {
+            height: 50px;
+        }
+
+        .content-box {
+            background-color: #ffffff;
+            padding: 40px;
+            border-radius: 8px;
+        }
+
+        .title {
+            font-size: 22px;
+            margin-bottom: 10px;
+        }
+
+        .intro {
+            font-size: 16px;
+            line-height: 1.6;
+            margin: 0 0 12px 0;
+        }
+
+        .credentials {
+            background-color: #f9f9f9;
+            padding: 15px;
+            border-radius: 5px;
+            margin: 18px 0;
+            font-size: 16px;
+        }
+
+        .button-container {
+            text-align: center;
+            margin: 24px 0 30px 0;
+        }
+
+        .button {
+            display: inline-block;
+            padding: 12px 24px;
+            background-color: #722ED1;
+            color: #ffffff;
+            text-decoration: none;
+            font-weight: bold;
+            border-radius: 4px;
+        }
+
+        .footer {
+            text-align: center;
+            font-size: 12px;
+            color: #6b6e76;
+            margin-top: 40px;
+        }
+
+        @media only screen and (max-width: 600px) {
+            .email-wrapper {
+                width: 100% !important;
+                padding: 20px 0 !important;
+                margin: 0;
+            }
+
+            .content-box {
+                padding: 20px !important;
+                border-radius: 0;
+            }
+
+            .title {
+                font-size: 18px !important;
+            }
+
+            .button {
+                padding: 10px !important;
+                font-size: 14px;
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <div class="email-wrapper">
+        {{#if companyLogoUrl}}
+        <div class="logo">
+            <img src="{{companyLogoUrl}}" alt="Company Logo" />
+        </div>
+        {{/if}}
+
+        <div class="content-box">
+            <h2 class="title">Welcome, {{ fullName }}!</h2>
+            <p class="intro">
+                We’re excited to have you on <strong>{{ solidAppName }}</strong>. Your account has been created and is
+                ready to use.
+            </p>
+            <div class="credentials">
+                <p><strong>Username:</strong> {{ userName }}</p>
+                <p><strong>Email:</strong> {{ email }}</p>
+            </div>
+            {{#if frontendLoginPageUrl}}
+            <div class="button-container">
+                <a class="button" href="{{ frontendLoginPageUrl }}" target="_blank" rel="noopener">Go to Login</a>
+            </div>
+            {{/if}}
+            <div class="credentials">
+                <p style="margin:0 0 8px 0;"><strong>How to sign in</strong></p>
+                <p class="intro" style="margin:0 0 8px 0;">
+                    Please check with your system administrator for the login method configured for your account.
+                </p>
+                <ul style="padding-left:20px; margin:0;">
+                    <li class="intro" style="margin-bottom:6px;">If password-based sign-in is enabled, your administrator will share or manage your password separately.</li>
+                    <li class="intro" style="margin-bottom:6px;">If OTP-based sign-in is enabled, you can log in with your email or mobile number and retrieve a one-time code.</li>
+                    <li class="intro" style="margin-bottom:0;">If Google OAuth is enabled, sign in with your Google Workspace credentials.</li>
+                </ul>
+            </div>
+            <p class="intro">
+                If you didn’t request this account, you can safely ignore this email or contact support.
+            </p>
+            <p class="intro">
+                Cheers,<br />
+                The {{ solidAppName }} Team
+            </p>
+        </div>
+
+        <div class="footer">
+            © 2025 <a href="{{ solidAppWebsiteUrl }}" target="_blank">{{ solidAppName }}</a>. All rights reserved.
+        </div>
+    </div>
+</body>
+
+</html>