Merge pull request #2887 from SeedCompany/media-1.1

Author: CarsonF

src/common/create-and-inject.ts

@@ -0,0 +1,18 @@
+import { ModuleRef } from '@nestjs/core';
+import { pickBy } from 'lodash';
+import { Class } from 'type-fest';
+
+/**
+ * A helper to create an instance of a class and inject dependencies.
+ */
+export async function createAndInject<T extends Class<any>>(
+  moduleRef: ModuleRef,
+  type: T,
+  ...input: ConstructorParameters<T>
+): Promise<InstanceType<T>> {
+  const injection = await moduleRef.resolve(type);
+  const injectionProps = pickBy(injection);
+  const object = new type(...input);
+  Object.assign(object, injectionProps);
+  return object;
+}

src/common/index.ts

@@ -3,6 +3,7 @@ export { Many, many, maybeMany, JsonSet, ArrayItem } from '@seedcompany/common';
 export * from './temporal';
 export * from './calculated.decorator';
 export * from './context.type';
+export * from './create-and-inject';
 export * from './data-object';
 export * from './date-filter.input';
 export { DbLabel } from './db-label.decorator';
@@ -26,6 +27,7 @@ export * from './pagination.input';
 export * from './pagination-list';
 export * from './parent-id.middleware';
 export * from './parent-types';
+export * from './poll';
 export * from './resource.dto';
 export * from './role.dto';
 export * from './secured-list';

src/common/poll.ts

@@ -0,0 +1,124 @@
+import { setOf } from '@seedcompany/common';
+
+export class PollResults<T> {
+  constructor(protected readonly data: PollData<T>) {}
+
+  /** Returns true if there were any votes */
+  get anyVotes() {
+    return this.numberOfVotes > 0;
+  }
+
+  /** Returns true if there were no votes */
+  get noVotes() {
+    return this.numberOfVotes === 0;
+  }
+
+  get numberOfVotes() {
+    return [...this.data.votes.values()].reduce((total, cur) => total + cur, 0);
+  }
+
+  get vetoed() {
+    return this.data.vetoed;
+  }
+
+  /** Returns if there was a tie for the highest votes */
+  get tie() {
+    const [highest, second] = this.sorted;
+    return highest && second ? highest[1] === second[1] : false;
+  }
+
+  /** Returns the largest minority vote (could be majority too), if there was one */
+  get plurality() {
+    const [highest, second] = this.sorted;
+    if (!highest) {
+      return undefined;
+    }
+    return highest[1] > (second?.[1] ?? 0) ? highest[0] : undefined;
+  }
+
+  /** Returns the majority vote (>50%), if there was one */
+  get majority() {
+    const [first] = this.sorted;
+    if (!first) {
+      return undefined;
+    }
+    return first[1] > this.numberOfVotes / 2 ? first[0] : undefined;
+  }
+
+  /** Returns the unanimous vote, if there was one */
+  get unanimous() {
+    const all = this.sorted;
+    return all.length === 1 ? all[0][0] : undefined;
+  }
+
+  /** Returns all votes sorted by most voted first (ties are unaccounted for) */
+  get allVotes() {
+    return setOf(this.sorted.map(([vote]) => vote));
+  }
+
+  private get sorted() {
+    return [...this.data.votes].sort((a, b) => b[1] - a[1]);
+  }
+}
+
+/**
+ * @example
+ * const poll = new Poll();
+ *
+ * poll.noVotes; // true
+ * poll.vote(true);
+ * poll.unanimous; // true
+ * poll.anyVotes; // true
+ *
+ * poll.vote(false);
+ * poll.unanimous; // undefined
+ * poll.tie; // true
+ * poll.majority; // undefined
+ * poll.plurality; // undefined
+ *
+ * poll.vote(true);
+ * poll.majority; // true
+ * poll.plurality; // true
+ */
+export class Poll<T = boolean> extends PollResults<T> implements PollVoter<T> {
+  // Get a view of this poll, with results hidden.
+  readonly voter: PollVoter<T> = this;
+  // Get a readonly view of this poll's results.
+  readonly results: PollResults<T> = this;
+
+  constructor() {
+    super(new PollData<T>());
+  }
+
+  vote(vote: T) {
+    this.data.votes.set(vote, (this.data.votes.get(vote) ?? 0) + 1);
+  }
+
+  veto() {
+    this.data.vetoed = true;
+  }
+}
+
+/**
+ * The mutations available for a poll.
+ */
+export abstract class PollVoter<T> {
+  /** Cast a vote. */
+  abstract vote(vote: T): void;
+
+  /**
+   * Veto the poll all together.
+   * Multiple vetoes are allowed and are functionally the same.
+   * Consider using this instead of throwing an exception, for when you want to
+   * "cancel" the poll / override all other votes.
+   * Exceptions are for unexpected errors, where this veto would be a logical
+   * expectation, so throwing is not the best way to handle it.
+   * This could be enhanced in future to allow a reason for the veto.
+   */
+  abstract veto(): void;
+}
+
+class PollData<T> {
+  votes = new Map<T, number>();
+  vetoed = false;
+}

src/components/file/media/events/can-update-event.ts

@@ -0,0 +1,29 @@
+import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
+import { CachedByArg as Once } from '@seedcompany/common';
+import { PollVoter } from '~/common';
+import { ResourceResolver, ResourcesHost } from '~/core';
+import { AnyMedia, MediaUserMetadata } from '../media.dto';
+
+/**
+ * An attempt to update the media metadata.
+ * Vote with `allowUpdate` to control whether the update is allowed.
+ */
+@Injectable({ scope: Scope.TRANSIENT })
+export class CanUpdateMediaUserMetadataEvent {
+  @Inject() private readonly resourceHost: ResourcesHost;
+  @Inject() private readonly resourceResolver: ResourceResolver;
+
+  constructor(
+    @Optional() readonly media: AnyMedia,
+    @Optional() readonly input: MediaUserMetadata,
+    @Optional() readonly allowUpdate: PollVoter<boolean>,
+  ) {}
+
+  @Once() async getAttachedResource() {
+    const attachedResName = this.resourceResolver.resolveTypeByBaseNode(
+      this.media.attachedTo[0],
+    );
+    const attachedResource = await this.resourceHost.getByName(attachedResName);
+    return attachedResource;
+  }
+}

src/components/file/media/media.dto.ts

@@ -20,6 +20,8 @@ import {
   ServerException,
   simpleSwitch,
 } from '~/common';
+import { BaseNode } from '~/core/database/results';
+import { RegisterResource } from '~/core/resources';
 import { FileVersion } from '../dto';
 
 export type AnyMedia = Image | Video | Audio;
@@ -67,6 +69,7 @@ export class MediaUserMetadata extends DataObject {
 @InterfaceType({
   resolveType: resolveMedia,
 })
+@RegisterResource()
 export class Media extends MediaUserMetadata {
   static readonly Props: string[] = keysOf<Media>();
   static readonly SecuredProps: string[] = keysOf<SecuredProps<Media>>();
@@ -78,6 +81,9 @@ export class Media extends MediaUserMetadata {
 
   readonly file: IdOf<FileVersion>;
 
+  /** The resource that holds the root file node that this media is attached to */
+  readonly attachedTo: [resource: BaseNode, relation: string];
+
   @Field(() => String)
   readonly mimeType: string;
 }
@@ -137,3 +143,9 @@ export class Audio extends TemporalMedia {
 
   declare __typename: 'Audio';
 }
+
+declare module '~/core/resources/map' {
+  interface ResourceMap {
+    Media: typeof Media;
+  }
+}

src/components/file/media/media.loader.ts

@@ -1,10 +1,10 @@
 import { DataLoaderStrategy } from '@seedcompany/data-loader';
 import { ID } from '~/common';
 import { LoaderFactory } from '~/core/resources';
-import { AnyMedia } from './media.dto';
+import { AnyMedia, Media } from './media.dto';
 import { MediaRepository } from './media.repository';
 
-@LoaderFactory()
+@LoaderFactory(() => Media)
 export class MediaLoader implements DataLoaderStrategy<AnyMedia, ID> {
   constructor(private readonly repo: MediaRepository) {}
 

src/components/file/media/media.module.ts

@@ -2,6 +2,7 @@ import { forwardRef, Module } from '@nestjs/common';
 import { FileModule } from '../file.module';
 import { DetectExistingMediaMigration } from './detect-existing-media.migration';
 import { DimensionsResolver } from './dimensions.resolver';
+import { CanUpdateMediaUserMetadataEvent } from './events/can-update-event';
 import { MediaByFileVersionLoader } from './media-by-file-version.loader';
 import { MediaDetector } from './media-detector.service';
 import { MediaLoader } from './media.loader';
@@ -20,6 +21,7 @@ import { MediaService } from './media.service';
     MediaResolver,
     MediaService,
     DetectExistingMediaMigration,
+    CanUpdateMediaUserMetadataEvent,
   ],
   exports: [MediaService],
 })

src/components/file/media/media.repository.ts

@@ -1,13 +1,29 @@
 import { Injectable } from '@nestjs/common';
 import { inArray, node, or, Query, relation } from 'cypher-query-builder';
-import { RequireAtLeastOne } from 'type-fest';
-import { EnhancedResource, generateId, ID, ServerException } from '~/common';
+import { Except, RequireAtLeastOne } from 'type-fest';
+import {
+  EnhancedResource,
+  generateId,
+  ID,
+  NotFoundException,
+  ServerException,
+} from '~/common';
 import { CommonRepository } from '~/core';
 import { ACTIVE, apoc, merge } from '~/core/database/query';
 import { AnyMedia, MediaUserMetadata, resolveMedia } from './media.dto';
 
 @Injectable()
 export class MediaRepository extends CommonRepository {
+  async readOne(input: RequireAtLeastOne<Pick<AnyMedia, 'id' | 'file'>>) {
+    const [media] = await this.readMany(
+      input.id ? { mediaIds: [input.id] } : { fvIds: [input.file!] },
+    );
+    if (!media) {
+      throw new NotFoundException('Media not found');
+    }
+    return media;
+  }
+
   async readMany(
     input: RequireAtLeastOne<Record<'fvIds' | 'mediaIds', readonly ID[]>>,
   ) {
@@ -31,20 +47,39 @@ export class MediaRepository extends CommonRepository {
 
   protected hydrate() {
     return (query: Query) =>
-      query.return<{ dto: AnyMedia }>(
-        merge('node', {
-          __typename: 'node.type',
-          file: 'fv.id',
-          dimensions: {
-            width: 'node.width',
-            height: 'node.height',
-          },
-        }).as('dto'),
-      );
+      query
+        .subQuery('fv', (sub) =>
+          sub
+            .comment('Find root file node')
+            .subQuery('fv', (sub2) =>
+              sub2
+                .raw('MATCH p=(fv)-[:parent*]->(node:FileNode)')
+                .return('node as root')
+                .orderBy('length(p)', 'DESC')
+                .raw('LIMIT 1'),
+            )
+            .comment('Get resource holding root file node')
+            .raw('MATCH (resource:BaseNode)-[rel]->(root)')
+            .raw('WHERE not resource:FileNode')
+            .return('[resource, type(rel)] as attachedTo')
+            .raw('LIMIT 1'),
+        )
+        .return<{ dto: AnyMedia }>(
+          merge('node', {
+            __typename: 'node.type',
+            file: 'fv.id',
+            dimensions: {
+              width: 'node.width',
+              height: 'node.height',
+            },
+            attachedTo: 'attachedTo',
+          }).as('dto'),
+        );
   }
 
   async save(
-    input: RequireAtLeastOne<Pick<AnyMedia, 'id' | 'file'>> & Partial<AnyMedia>,
+    input: RequireAtLeastOne<Pick<AnyMedia, 'id' | 'file'>> &
+      Partial<Except<AnyMedia, 'attachedTo'>>,
   ) {
     const res = input.__typename
       ? EnhancedResource.of(resolveMedia(input as AnyMedia))
@@ -119,10 +154,24 @@ export class MediaRepository extends CommonRepository {
       .apply(this.hydrate());
 
     const result = await query.first();
-    if (!result) {
-      throw new ServerException('Failed to save media info');
+    if (result) {
+      return result.dto;
+    }
+    if (input.file) {
+      const exists = await this.getBaseNode(input.file, 'FileVersion');
+      if (!exists) {
+        throw new NotFoundException(
+          'Media could not be saved to nonexistent file',
+        );
+      }
+    }
+    if (input.id) {
+      const exists = await this.getBaseNode(input.id, 'Media');
+      if (!exists) {
+        throw new NotFoundException('Media could not be found');
+      }
     }
-    return result.dto;
+    throw new ServerException('Failed to save media info');
   }
 }