#4284 update transformer and comments

Author: cielbellerose

src/backend/src/prisma-query-args/rules.query-args.ts

@@ -47,11 +47,12 @@ export const getRulePreviewQueryArgs = () =>
     }
   });
 
+export type ProjectRuleQueryArgs = ReturnType<typeof getProjectRuleQueryArgs>;
+
 export const getProjectRuleQueryArgs = () =>
   Prisma.validator<Prisma.Project_RuleDefaultArgs>()({
     include: {
-      rule: getRulePreviewQueryArgs(),
-      project: { select: { projectId: true } }
+      rule: getRulePreviewQueryArgs()
     }
   });
 

src/backend/src/prisma/seed.ts

@@ -4785,7 +4785,7 @@ const performSeed: () => Promise<void> = async () => {
   // project rules
   await RulesService.createProjectRule(batman, ner, ruleT211.ruleId, projectHuskies1Id);
 
-  // mark the leaf rule complete from the project to demonstrate global rule completion
+  // mark the leaf rule complete
   await RulesService.setRuleCompletion(batman, ner, ruleT211.ruleId, true, projectHuskies1Id);
 
   // Technical Rules Section

src/backend/src/services/rules.services.ts

@@ -385,8 +385,7 @@ export default class RulesService {
       throw new HttpException(400, 'This rule is already associated with the project');
     }
 
-    // Walk up the parent chain to assign all ancestors of a rule to the project as well.
-    // visited guards against cycles, which editRule does not currently prevent.
+    // ensure we assign all ancestors of a rule to the project
     const ancestorIds: string[] = [];
     const visited = new Set<string>([ruleId]);
     let currentParentId = rule.parentRuleId;
@@ -397,20 +396,23 @@ export default class RulesService {
         where: { ruleId: currentParentId },
         select: { parentRuleId: true, dateDeleted: true }
       });
-      // Stop if the ancestor is missing or deleted - deleted rules should not be assigned to projects
-      if (!parent || parent.dateDeleted) break;
+      // rule only displays if the full chain to a top-level rule exists, so a missing or deleted
+      // ancestor means this rule would not display - do not assign it OR its ancestors to the project
+      if (!parent) throw new NotFoundException('Rule', currentParentId);
+      if (parent.dateDeleted) throw new DeletedException('Rule', currentParentId);
       ancestorIds.push(currentParentId);
       currentParentId = parent.parentRuleId;
     }
 
-    // Only create ancestors that aren't already assigned to the project to avoid duplicate assignment issues
+    // skip ancestors already assigned to this project
     const existingAncestors = await prisma.project_Rule.findMany({
       where: { projectId, ruleId: { in: ancestorIds }, dateDeleted: null },
       select: { ruleId: true }
     });
     const existingAncestorIds = new Set(existingAncestors.map((projectRule) => projectRule.ruleId));
     const ancestorsToCreate = ancestorIds.filter((id) => !existingAncestorIds.has(id));
 
+    // create all project rules
     await prisma.$transaction([
       ...ancestorsToCreate.map((ancestorId) =>
         prisma.project_Rule.create({
@@ -430,6 +432,7 @@ export default class RulesService {
       })
     ]);
 
+    // return only original project rule being assigned (leaf rule)
     const projectRule = await prisma.project_Rule.findUnique({
       where: { ruleId_projectId: { ruleId, projectId } },
       ...getProjectRuleQueryArgs()
@@ -703,8 +706,8 @@ export default class RulesService {
    * @param submitter the user updating the completion
    * @param organization the organization of the rule
    * @param ruleId the id of the rule to update
-   * @param isComplete whether the rule is complete
-   * @param projectId the project the rule was completed from (optional - omitted for general view)
+   * @param isComplete whether the rule is complete or incomplete
+   * @param projectId the project the rule was completed from (optional - omitted if updated in general view)
    * @returns the rule with updated completion
    */
   static async setRuleCompletion(
@@ -715,7 +718,7 @@ export default class RulesService {
     projectId?: string
   ): Promise<SharedRule> {
     if (!(await userHasPermission(submitter.userId, organization.organizationId, isLeadership))) {
-      throw new AccessDeniedException('You do not have permissions to update a rule completion');
+      throw new AccessDeniedException('You do not have permissions to update rule completion');
     }
 
     const rule = await prisma.rule.findUnique({

src/backend/src/transformers/rules.transformer.ts

@@ -1,6 +1,6 @@
 import { Prisma } from '@prisma/client';
 import { Rule, ProjectRule, Ruleset, RulesetType } from 'shared';
-import { RulesetQueryArgs, RulePreviewQueryArgs } from '../prisma-query-args/rules.query-args';
+import { RulesetQueryArgs, RulePreviewQueryArgs, ProjectRuleQueryArgs } from '../prisma-query-args/rules.query-args.js';
 
 export const ruleTransformer = (rule: Prisma.RuleGetPayload<RulePreviewQueryArgs>): Rule => {
   return {
@@ -36,7 +36,7 @@ export const ruleTransformer = (rule: Prisma.RuleGetPayload<RulePreviewQueryArgs
   };
 };
 
-export const projectRuleTransformer = (projectRule: any): ProjectRule => {
+export const projectRuleTransformer = (projectRule: Prisma.Project_RuleGetPayload<ProjectRuleQueryArgs>): ProjectRule => {
   return {
     projectRuleId: projectRule.projectRuleId,
     rule: ruleTransformer(projectRule.rule),

src/backend/tests/unit/rule.test.ts

@@ -368,15 +368,15 @@ describe('Create Rules Tests', () => {
   });
 
   describe('Create Project Rule', () => {
-    it('Creates project rules for the full ancestor chain when assigning a nested sub-rule', async () => {
-      const root = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
+    it('Creates project rules for all ancestors when assigning deep child rule', async () => {
+      const topLevelRule = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
       const child = await RulesService.createRule(
         batman,
         'T.1.1',
         'Vehicle Requirements',
         rulesetId,
         organization,
-        root.ruleId
+        topLevelRule.ruleId
       );
       const grandchild = await RulesService.createRule(batman, 'T.1.1.1', 'Wheels', rulesetId, organization, child.ruleId);
 
@@ -386,46 +386,46 @@ describe('Create Rules Tests', () => {
 
       const projectRules = await RulesService.getProjectRules(rulesetId, project.projectId, organization);
       const assignedRuleIds = projectRules.map((pr) => pr.rule.ruleId);
-      expect(assignedRuleIds).toHaveLength(3);
-      expect(assignedRuleIds).toEqual(expect.arrayContaining([root.ruleId, child.ruleId, grandchild.ruleId]));
+      expect(assignedRuleIds).toHaveLength(3); // grandchild, child, topLevelRule
+      expect(assignedRuleIds).toEqual(expect.arrayContaining([topLevelRule.ruleId, child.ruleId, grandchild.ruleId]));
     });
 
-    it('Creates project rules for shared ancestors when adding a sibling sub-rule', async () => {
-      const root = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
+    it('Creates project rules for shared ancestors when adding a sibling child rule', async () => {
+      const topLevelRule = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
       const child = await RulesService.createRule(
         batman,
         'T.1.1',
         'Vehicle Requirements',
         rulesetId,
         organization,
-        root.ruleId
+        topLevelRule.ruleId
       );
       const grandchild1 = await RulesService.createRule(batman, 'T.1.1.1', 'Wheels', rulesetId, organization, child.ruleId);
       const grandchild2 = await RulesService.createRule(batman, 'T.1.1.2', 'Brakes', rulesetId, organization, child.ruleId);
 
       const project = await createTestProject(aquaman, orgId, undefined, carId);
 
       await RulesService.createProjectRule(aquaman, organization, grandchild1.ruleId, project.projectId);
-      // Adding a sibling must not error on the already-present parent/root and must not duplicate them.
+      // adding sibling must not error or duplicate the already-present parent/root rules
       await RulesService.createProjectRule(aquaman, organization, grandchild2.ruleId, project.projectId);
 
       const projectRules = await RulesService.getProjectRules(rulesetId, project.projectId, organization);
       const assignedRuleIds = projectRules.map((pr) => pr.rule.ruleId);
-      expect(assignedRuleIds).toHaveLength(4);
+      expect(assignedRuleIds).toHaveLength(4); // grandchild1, grandchild2, child, topLevelRule
       expect(assignedRuleIds).toEqual(
-        expect.arrayContaining([root.ruleId, child.ruleId, grandchild1.ruleId, grandchild2.ruleId])
+        expect.arrayContaining([topLevelRule.ruleId, child.ruleId, grandchild1.ruleId, grandchild2.ruleId])
       );
     });
 
-    it('does not assign descendants of the selected rule', async () => {
-      const root = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
+    it('Creating project rule does not assign descendants of the selected rule', async () => {
+      const topLevelRule = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
       const child = await RulesService.createRule(
         batman,
         'T.1.1',
         'Vehicle Requirements',
         rulesetId,
         organization,
-        root.ruleId
+        topLevelRule.ruleId
       );
       await RulesService.createRule(batman, 'T.1.1.1', 'Wheels', rulesetId, organization, child.ruleId);
 
@@ -435,43 +435,43 @@ describe('Create Rules Tests', () => {
 
       const projectRules = await RulesService.getProjectRules(rulesetId, project.projectId, organization);
       const assignedRuleIds = projectRules.map((pr) => pr.rule.ruleId);
-      expect(assignedRuleIds).toHaveLength(2);
-      expect(assignedRuleIds).toEqual(expect.arrayContaining([root.ruleId, child.ruleId]));
+      expect(assignedRuleIds).toHaveLength(2); // child and topLevelRule, not grandchild
+      expect(assignedRuleIds).toEqual(expect.arrayContaining([topLevelRule.ruleId, child.ruleId]));
     });
 
-    it('does not assign deleted ancestors when assigning a nested sub-rule', async () => {
-      const root = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
+    it('Creating project rule is refused entirely when an ancestor has been deleted', async () => {
+      const topLevelRule = await RulesService.createRule(batman, 'T.1', 'Technical Rules', rulesetId, organization);
       const child = await RulesService.createRule(
         batman,
         'T.1.1',
         'Vehicle Requirements',
         rulesetId,
         organization,
-        root.ruleId
+        topLevelRule.ruleId
       );
       const grandchild = await RulesService.createRule(batman, 'T.1.1.1', 'Wheels', rulesetId, organization, child.ruleId);
 
-      // Soft-delete the immediate parent directly so the grandchild remains assignable
+      // soft-delete an ancestor so the chain to the top-level rule is broken
       await prisma.rule.update({
         where: { ruleId: child.ruleId },
         data: { dateDeleted: new Date(), deletedBy: { connect: { userId: batman.userId } } }
       });
 
       const project = await createTestProject(aquaman, orgId, undefined, carId);
 
-      await RulesService.createProjectRule(aquaman, organization, grandchild.ruleId, project.projectId);
+      // a broken chain means the grandchild could never display, so no rules are assigned to the project and an error is thrown
+      await expect(
+        async () => await RulesService.createProjectRule(aquaman, organization, grandchild.ruleId, project.projectId)
+      ).rejects.toThrow(new DeletedException('Rule', child.ruleId));
 
-      // The walk stops at the deleted ancestor, so neither it nor the root above it are assigned.
+      // nothing should have been assigned (not the grandchild, the deleted parent, or the root)
       const projectRules = await RulesService.getProjectRules(rulesetId, project.projectId, organization);
-      const assignedRuleIds = projectRules.map((pr) => pr.rule.ruleId);
-      expect(assignedRuleIds).toHaveLength(1);
-      expect(assignedRuleIds).toEqual([grandchild.ruleId]);
+      expect(projectRules).toHaveLength(0);
 
-      // getProjectRules hides deleted rules, so assert directly that none was created for the deleted ancestor
-      const deletedAncestorProjectRule = await prisma.project_Rule.findUnique({
-        where: { ruleId_projectId: { ruleId: child.ruleId, projectId: project.projectId } }
+      const grandchildProjectRule = await prisma.project_Rule.findUnique({
+        where: { ruleId_projectId: { ruleId: grandchild.ruleId, projectId: project.projectId } }
       });
-      expect(deletedAncestorProjectRule).toBeNull();
+      expect(grandchildProjectRule).toBeNull();
     });
 
     it('throws when the rule is already associated with the project', async () => {