Add abstraction to update one-to-many relations (#2892)

Author: CarsonF

src/core/database/common.repository.ts

@@ -2,17 +2,19 @@ import { Inject, Injectable, Optional } from '@nestjs/common';
 import { node, relation } from 'cypher-query-builder';
 import { DateTime } from 'luxon';
 import {
+  EnhancedResource,
   getDbClassLabels,
   getDbPropertyUnique,
   ID,
   isIdLike,
+  NotFoundException,
   ResourceShape,
   ServerException,
   Session,
 } from '../../common';
 import { DatabaseService } from './database.service';
 import { createUniqueConstraint } from './indexer';
-import { ACTIVE } from './query';
+import { ACTIVE, updateRelationList } from './query';
 import { BaseNode } from './results';
 
 /**
@@ -90,6 +92,33 @@ export class CommonRepository {
       .run();
   }
 
+  async updateRelationList({
+    id,
+    label,
+    relation,
+    newList,
+  }: {
+    id: ID;
+    label?: string | EnhancedResource<any> | ResourceShape<any>;
+    relation: string;
+    newList: readonly ID[];
+  }) {
+    const resolvedLabel = !label
+      ? 'BaseNode'
+      : typeof label === 'string'
+      ? label
+      : EnhancedResource.of(label).dbLabel;
+    const node = await this.db
+      .query()
+      .matchNode('node', resolvedLabel, { id })
+      .apply(updateRelationList({ relation, newList }))
+      .return('node')
+      .first();
+    if (!node) {
+      throw new NotFoundException();
+    }
+  }
+
   async checkDeletePermission(id: ID, session: Session | ID) {
     return await this.db.checkDeletePermission(id, session);
   }

src/core/database/dto.repository.ts

@@ -4,7 +4,6 @@ import { LazyGetter as Once } from 'lazy-get-decorator';
 import { lowerCase } from 'lodash';
 import {
   EnhancedResource,
-  getDbClassLabels,
   getDbPropertyUnique,
   ID,
   NotFoundException,
@@ -93,7 +92,7 @@ export const DtoRepository = <
     async readMany(ids: readonly ID[], ...args: HydrateArgs) {
       return await this.db
         .query()
-        .matchNode('node', getDbClassLabels(resource)[0])
+        .matchNode('node', this.resource.dbLabel)
         .where({ 'node.id': inArray(ids) })
         .apply(this.hydrate(...args))
         .map('dto')
@@ -124,10 +123,19 @@ export const DtoRepository = <
         otherLabel,
         id,
         otherId,
-        getDbClassLabels(resource)[0],
+        this.resource.dbLabel,
       );
     }
 
+    async updateRelationList(
+      options: Parameters<CommonRepository['updateRelationList']>[0],
+    ) {
+      await super.updateRelationList({
+        label: resource,
+        ...options,
+      });
+    }
+
     /**
      * Given a `(node:TBaseNode)` output `dto` as `UnsecuredDto<TResource>`
      *

src/core/database/query/index.ts

@@ -7,6 +7,7 @@ export {
   defaultPermanentAfter,
 } from './properties/update-property';
 export * from './properties/update-properties';
+export * from './properties/update-relation-list';
 export * from './create-relationships';
 export * from './cypher-expression';
 export * from './cypher-functions';

src/core/database/query/properties/update-relation-list.ts

@@ -0,0 +1,78 @@
+import { node, Query, relation } from 'cypher-query-builder';
+import { DateTime } from 'luxon';
+import { ID } from '~/common';
+import { exp, variable, Variable } from '../index';
+
+export interface UpdateRelationListOptions {
+  node?: Variable;
+  relation: string | Variable;
+  newList: readonly ID[] | Variable;
+}
+
+export const updateRelationList =
+  (options: UpdateRelationListOptions) =>
+  <R>(query: Query<R>) => {
+    const nodeName = options.node ?? variable('node');
+    const now = query.params.addParam(DateTime.now(), 'now');
+    const relName =
+      options.relation instanceof Variable
+        ? options.relation
+        : variable(
+            query.params.addParam(options.relation, 'relationName').toString(),
+          );
+    const newList =
+      options.newList instanceof Variable
+        ? options.newList
+        : variable(
+            query.params.addParam(options.newList, 'newList').toString(),
+          );
+
+    query.comment(
+      `updateListProperty(${String(nodeName)}, ${String(relName)})`,
+    );
+    return query.subQuery([nodeName, relName, newList], (sub) =>
+      sub
+        .with([
+          `${String(nodeName)} as parent`,
+          `${String(relName)} as relName`,
+          `${String(newList)} as childIds`,
+        ])
+        .subQuery(['parent', 'relName', 'childIds'], (sub) =>
+          sub
+            .match([
+              node('parent'),
+              relation('out', 'r'), // ACTIVE
+              node('child', 'BaseNode'),
+            ])
+            .raw(`where type(r) = relName and not child.id in childIds`)
+            .delete('r')
+            // soft delete, cant usage without "permanentAfter" logic
+            // .setVariables({
+            //   'r.active': 'false',
+            //   'r.deletedAt': String(now),
+            // })
+            .return('count(child) as deletedCount'),
+        )
+        .subQuery(['parent', 'relName', 'childIds'], (q) =>
+          q
+            .raw('unwind childIds as childId')
+            .matchNode('child', 'BaseNode', { id: variable('childId') })
+            .raw(
+              `call apoc.merge.relationship(
+                parent,
+                relName,
+                {}, // { active: true },
+                { createdAt: ${String(now)} },
+                child
+              ) yield rel`,
+            )
+            .return('count(child) as totalCount'),
+        )
+        .return(
+          exp({
+            deletedCount: 'deletedCount',
+            totalCount: 'totalCount',
+          }).as('stats'),
+        ),
+    );
+  };