@solidstarters/solid-core 1.2.153 → 1.2.155

package/src/repository/chatter-message.repository.ts

@@ -0,0 +1,68 @@
+import { camelize, classify } from "@angular-devkit/core/src/utils/strings";
+import { Injectable } from "@nestjs/common";
+import { ChatterMessage } from "src/entities/chatter-message.entity";
+import { ActiveUserData } from "src/interfaces/active-user-data.interface";
+import { RequestContextService } from "src/services/request-context.service";
+import { DataSource, QueryRunner, SelectQueryBuilder } from "typeorm";
+import { SecurityRuleRepository } from "./security-rule.repository";
+import { SolidBaseRepository } from "./solid-base.repository";
+import {get} from "lodash"
+
+@Injectable()
+export class ChatterMessageRepository extends SolidBaseRepository<ChatterMessage> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ChatterMessage, dataSource, requestContextService, securityRuleRepository);
+    }
+
+    private readonly CO_MODEL_NAME_PATH = 'filters.coModelName.$eq';
+    override createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<ChatterMessage> {
+        const activeUserOrUndefined = this.requestContextService.getActiveUser();
+        let qb = super.createQueryBuilder(alias, queryRunner);
+        if (!activeUserOrUndefined) return qb;
+        
+        //Left join on the associated chatter model entity
+        const [coModelName, coModelAlias] = this.getCoModelNameAndAlias();
+        qb = this.leftJoinCoModel(qb, coModelName);
+        
+        return this.securityRuleRepository.applySecurityRules(
+            qb,
+            coModelName,
+            activeUserOrUndefined as ActiveUserData,
+            coModelAlias
+        );
+    }
+
+    private leftJoinCoModel<ChatterMessage>(
+        qb: SelectQueryBuilder<ChatterMessage>,
+        coModelName: string
+    ) {
+        // const Target = resolveEntityFromCoModelName(coModelName); // your mapping
+        const entityName = classify(coModelName)
+        const meta = this.dataSource.getMetadata(entityName);
+        const alias = camelize(meta.name);
+        qb.leftJoin(
+            entityName,
+            alias,
+            // `${alias}.id = entity.co_model_entity_id`,
+            `${alias}.id = entity.co_model_entity_id AND entity.co_model_name = :model`,
+            { model: coModelName }
+        );
+        return qb;
+        // return qb.leftJoin(Target, alias, `${alias}.id = entity.co_model_entity_id`);
+    }
+
+    // This uses the requestContextService.getRequestFilter method and extracts the coModelName and creates the alias and returns the name and alias tuple
+    private getCoModelNameAndAlias() {
+        const requestFilter = this.requestContextService.getRequestFilter();
+        if (!requestFilter) return [undefined, undefined];
+
+        const coModelName = get(requestFilter, this.CO_MODEL_NAME_PATH);
+        const alias = camelize(coModelName);
+        return [coModelName, alias];
+    }
+
+}

package/src/repository/security-rule.repository.ts

@@ -22,7 +22,7 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
         super(SecurityRule, dataSource.createEntityManager());
     }
 
-    applySecurityRules<T extends CommonEntity>(qb: SelectQueryBuilder<T>, modelSingularName: string, activeUser: ActiveUserData,): SelectQueryBuilder<T> {
+    applySecurityRules<T extends CommonEntity>(qb: SelectQueryBuilder<T>, modelSingularName: string, activeUser: ActiveUserData, securityRuleAlias: string = qb.alias): SelectQueryBuilder<T> {
         // Fetch the security rules for the model and roles
         const securityRules = this.solidRegistry.getSecurityRules(modelSingularName, activeUser.roles);
 
@@ -32,7 +32,7 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
                 // Parse the security rule and call the buildFilter method to build the query from the security rule
                 const parsedRule = JSON.parse(this.resolveSecurityRuleConfig(rule.securityRuleConfig, activeUser)) as SecurityRuleConfig;
                 if (parsedRule && parsedRule.filters) {
-                    this.crudHelperService.buildFilterQuery(qb, parsedRule, qb.alias);
+                    this.crudHelperService.buildFilterQuery(qb, parsedRule, securityRuleAlias);
                 }
             } catch (error) {
                 this.logger.warn(`Error parsing security rule: ${rule.securityRuleConfig}`, error);

package/src/repository/solid-base.repository.ts

@@ -5,7 +5,11 @@ import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { RequestContextService } from 'src/services/request-context.service';
 import {
     DataSource,
+    EntityNotFoundError,
     EntityTarget,
+    FindManyOptions,
+    FindOneOptions,
+    FindOptionsWhere,
     QueryRunner,
     Repository,
     SelectQueryBuilder
@@ -41,5 +45,67 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
         );
     }
 
+    /**
+    * Security-aware findOne: applies FindOneOptions via FindOptionsUtils,
+    * but builds from our security-wrapped QueryBuilder.
+    */
+    override async findOne(options?: FindOneOptions<T>): Promise<T | null> {
+        const alias = this.modelSingularName();
+        const qb = this.createQueryBuilder(alias);
 
+        if (options) {
+            // Apply all standard find options (relations, selects, order, where, etc.)
+            if (options) qb.setFindOptions(options); // <- applies where, relations, select, order, etc.
+        }
+
+        return qb.getOne();
+    }
+
+    /**
+     * Convenience: route findOneBy through the same path so rules apply.
+     */
+    override async findOneBy(where: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<T | null> {
+        return this.findOne({ where });
+    }
+
+    /**
+     * Optional: an OrFail that still honors security rules.
+     */
+    override async findOneOrFail(options?: FindOneOptions<T>): Promise<T> {
+        const entity = await this.findOne(options);
+        if (!entity) {
+            throw new EntityNotFoundError(this.metadata.target, options?.where ?? {});
+        }
+        return entity;
+    }
+
+    /**
+     * Security-aware find(): builds from our secured QB and preserves all FindManyOptions
+     * (where, relations, select, order, take/skip, withDeleted, etc.).
+     */
+    override async find(options?: FindManyOptions<T>): Promise<T[]> {
+        const alias = this.modelSingularName();
+        const qb = this.createQueryBuilder(alias);
+
+        if (options) {
+            qb.setFindOptions(options);
+        }
+
+        return qb.getMany();
+    }
+
+    /**
+     * (Optional) Security-aware findAndCount(): same as find(), plus a total count.
+     * Mirrors Repository.findAndCount semantics.
+     */
+    override async findAndCount(options?: FindManyOptions<T>): Promise<[T[], number]> {
+        const alias = this.modelSingularName();
+        const qb = this.createQueryBuilder(alias);
+
+        if (options) {
+            qb.setFindOptions(options);
+        }
+
+        return qb.getManyAndCount();
+    }
 }

package/src/seeders/seed-data/email-templates/password-changed.handlebars.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="UTF-8" />
+    <title>Welcome Email</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;
+        }
+
+        .credentials {
+            background-color: #f9f9f9;
+            padding: 15px;
+            border-radius: 5px;
+            margin-top: 20px;
+            margin-bottom: 30px;
+        }
+
+        .credentials p {
+            margin: 0 0 10px;
+            font-size: 16px;
+        }
+
+        .button-container {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+
+        .button {
+            display: inline-block;
+            padding: 12px 24px;
+            background-color: #722ED1;
+            color: #ffffff;
+            text-decoration: none;
+            font-weight: bold;
+            border-radius: 5px;
+        }
+
+        .footer-text {
+            font-size: 16px;
+            line-height: 1.6;
+        }
+
+        .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 {
+                /* width: 100% !important; */
+                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">Hi {{ fullName }},</h2>
+            <p class="intro">
+                Your password for <strong>{{ solidAppName }}</strong> has been successfully reset.
+            </p>
+            <p class="intro" style="margin-top: 10px;">
+                If you made this change, no further action is required.  
+                If you did <em>not</em> change your password, please reset it immediately or contact our support team.
+            </p>
+
+            <div class="credentials">
+                <p><strong>Email:</strong> {{ email }}</p>
+                <!-- <p><strong>Temporary Password:</strong> {{ password }}</p> -->
+            </div>
+
+            <!-- <div class="button-container">
+                <a href="{{ frontendLoginPageUrl }}" class="button" target="_blank">
+                    Login to Your Account
+                </a>
+            </div> -->
+            <p class="intro">
+                Regards,
+                <br/ >
+                The {{ solidAppName }} Team.
+            </p>
+        </div>
+
+        <div class="footer">
+            © 2025 <a href="{{ solidAppWebsiteUrl }}" target="_blank">{{ solidAppName }}</a>. All rights reserved.
+        </div>
+    </div>
+</body>
+
+</html>

package/src/seeders/seed-data/solid-core-metadata.json

@@ -12318,6 +12318,15 @@
       "description": "This template is used to send the verification token required by users to reset their password.",
       "active": true,
       "type": "text"
+    },
+    {
+      "name": "password-changed",
+      "displayName": "Default: Password Changed",
+      "body": "password-changed.handlebars.html",
+      "subject": "Your {{solidAppName}} Password Has Been Updated",
+      "description": "This template notifies users that their account password was successfully changed.",
+      "active": true,
+      "type": "text"
     }
   ],
   "smsTemplates": [

package/src/services/ai-interaction.service.ts

@@ -36,19 +36,19 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     readonly repo: Repository<AiInteraction>,
     readonly moduleRef: ModuleRef,
     readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
-    readonly requestContextService: RequestContextService,
+    // readonly requestContextService: RequestContextService,
     readonly mcpToolResponseHandlerFactory: McpToolResponseHandlerFactory,
 
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
   }
 
-  async triggerMcpClientJob(prompt: string, isAutoApply: boolean = false, threadId: string = null): Promise<any> {
-    const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
+  async triggerMcpClientJob(prompt: string, userId: number, isAutoApply: boolean = false, threadId: string = null): Promise<any> {
+    // const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
 
     const aiInteraction = await this.create({
-      userId: activeUser.sub,
-      threadId: threadId ? threadId : `thread-${activeUser.sub}`,
+      userId: userId,
+      threadId: threadId ? threadId : `thread-${userId}`,
       role: 'human',
       message: prompt,
       contentType: '',