Merge pull request #3053 from SeedCompany/edgedb/queries/field-zone

Author: CarsonF

package.json

@@ -104,7 +104,7 @@
     "yaml": "^2.3.3"
   },
   "devDependencies": {
-    "@edgedb/generate": "^0.5.0-canary.20240116T174045",
+    "@edgedb/generate": "^0.5.0-canary.20240117T152712",
     "@nestjs/cli": "^10.2.1",
     "@nestjs/schematics": "^10.0.3",
     "@nestjs/testing": "^10.2.7",

src/common/pagination.input.ts

@@ -1,5 +1,6 @@
 import { PipeTransform, Type } from '@nestjs/common';
 import { Args, ArgsOptions, Field, InputType, Int } from '@nestjs/graphql';
+import { setHas } from '@seedcompany/common';
 import { Matches, Max, Min } from 'class-validator';
 import { stripIndent } from 'common-tags';
 import { DataObject } from './data-object';
@@ -28,6 +29,14 @@ export abstract class PaginationInput extends DataObject {
   readonly page: number = 1;
 }
 
+export const isPaginationInput = (input: unknown): input is PaginationInput =>
+  !!input &&
+  typeof input === 'object' &&
+  'count' in input &&
+  typeof input.count === 'number' &&
+  'page' in input &&
+  typeof input.page === 'number';
+
 @InputType({
   isAbstract: true,
 })
@@ -62,6 +71,16 @@ export interface SortablePaginationInput<SortKey extends string = string>
   order: Order;
 }
 
+export const isSortablePaginationInput = (
+  input: unknown,
+): input is SortablePaginationInput =>
+  isPaginationInput(input) &&
+  'sort' in input &&
+  typeof input.sort === 'string' &&
+  'order' in input &&
+  typeof input.order === 'string' &&
+  setHas(Order.values, input.order);
+
 export const SortablePaginationInput = <SortKey extends string = string>({
   defaultSort,
   defaultOrder,

src/components/field-zone/dto/field-zone.dto.ts

@@ -1,10 +1,9 @@
 import { ObjectType } from '@nestjs/graphql';
 import { keys as keysOf } from 'ts-transformer-keys';
 import { e } from '~/core/edgedb';
-import { RegisterResource } from '~/core/resources';
+import { LinkTo, RegisterResource } from '~/core/resources';
 import {
   DbUnique,
-  ID,
   NameField,
   Resource,
   Secured,
@@ -26,7 +25,7 @@ export class FieldZone extends Resource {
   @DbUnique()
   readonly name: SecuredString;
 
-  readonly director: Secured<ID>;
+  readonly director: Secured<LinkTo<'User'>>;
 }
 
 @ObjectType({

src/components/field-zone/field-zone.edgedb.repository.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { PublicOf } from '~/common';
+import { ChangesOf } from '~/core/database/changes';
+import { e, RepoFor } from '~/core/edgedb';
+import { CreateFieldZone, FieldZone, UpdateFieldZone } from './dto';
+import { FieldZoneRepository } from './field-zone.repository';
+
+@Injectable()
+export class FieldZoneEdgeDBRepository
+  extends RepoFor(FieldZone, {
+    hydrate: (zone) => ({
+      ...zone['*'],
+      director: true,
+    }),
+  }).customize((cls) => {
+    return class extends cls {
+      async create(input: CreateFieldZone) {
+        const created = e.insert(e.FieldZone, {
+          name: input.name,
+          director: e.cast(e.User, e.cast(e.uuid, input.directorId)),
+        });
+        const query = e.select(created, this.hydrate);
+        return await this.db.run(query);
+      }
+
+      async update(
+        { id }: Pick<FieldZone, 'id'>,
+        changes: ChangesOf<FieldZone, UpdateFieldZone>,
+      ) {
+        const zone = e.cast(e.FieldZone, e.cast(e.uuid, id));
+        const updated = e.update(zone, () => ({
+          set: {
+            ...(changes.name && { name: changes.name }),
+            ...(changes.directorId && {
+              director: e.cast(e.User, e.cast(e.uuid, changes.directorId)),
+            }),
+          },
+        }));
+        const query = e.select(updated, this.hydrate);
+        return await this.db.run(query);
+      }
+    };
+  })
+  implements PublicOf<FieldZoneRepository> {}

src/components/field-zone/field-zone.module.ts

@@ -1,6 +1,8 @@
 import { forwardRef, Module } from '@nestjs/common';
+import { splitDb } from '~/core';
 import { AuthorizationModule } from '../authorization/authorization.module';
 import { UserModule } from '../user/user.module';
+import { FieldZoneEdgeDBRepository } from './field-zone.edgedb.repository';
 import { FieldZoneLoader } from './field-zone.loader';
 import { FieldZoneRepository } from './field-zone.repository';
 import { FieldZoneResolver } from './field-zone.resolver';
@@ -14,7 +16,7 @@ import { FieldZoneService } from './field-zone.service';
   providers: [
     FieldZoneResolver,
     FieldZoneService,
-    FieldZoneRepository,
+    splitDb(FieldZoneRepository, FieldZoneEdgeDBRepository),
     FieldZoneLoader,
   ],
   exports: [FieldZoneService],

src/components/field-zone/field-zone.repository.ts

@@ -2,7 +2,14 @@ import { Injectable } from '@nestjs/common';
 import { node, Query, relation } from 'cypher-query-builder';
 import { DateTime } from 'luxon';
 import { ChangesOf } from '~/core/database/changes';
-import { ID, Session, UnsecuredDto } from '../../common';
+import {
+  DuplicateException,
+  ID,
+  SecuredList,
+  ServerException,
+  Session,
+  UnsecuredDto,
+} from '../../common';
 import { DtoRepository } from '../../core';
 import {
   ACTIVE,
@@ -25,6 +32,13 @@ import {
 @Injectable()
 export class FieldZoneRepository extends DtoRepository(FieldZone) {
   async create(input: CreateFieldZone, session: Session) {
+    if (!(await this.isUnique(input.name))) {
+      throw new DuplicateException(
+        'fieldZone.name',
+        'FieldZone with this name already exists.',
+      );
+    }
+
     const initialProps = {
       name: input.name,
       canDelete: true,
@@ -42,7 +56,12 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
       )
       .return<{ id: ID }>('node.id as id');
 
-    return await query.first();
+    const result = await query.first();
+    if (!result) {
+      throw new ServerException('failed to create field zone');
+    }
+
+    return await this.readOne(result.id);
   }
 
   protected hydrate() {
@@ -56,13 +75,13 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
         ])
         .return<{ dto: UnsecuredDto<FieldZone> }>(
           merge('props', {
-            director: 'director.id',
+            director: 'director { .id }',
           }).as('dto'),
         );
   }
 
   async update(
-    existing: FieldZone,
+    existing: Pick<FieldZone, 'id'>,
     changes: ChangesOf<FieldZone, UpdateFieldZone>,
   ) {
     const { directorId, ...simpleChanges } = changes;
@@ -72,6 +91,8 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
     }
 
     await this.updateProperties(existing, simpleChanges);
+
+    return await this.readOne(existing.id);
   }
 
   private async updateDirector(directorId: ID, id: ID) {
@@ -103,6 +124,9 @@ export class FieldZoneRepository extends DtoRepository(FieldZone) {
   }
 
   async list({ filter, ...input }: FieldZoneListInput, session: Session) {
+    if (!this.privileges.forUser(session).can('read')) {
+      return SecuredList.Redacted;
+    }
     const result = await this.db
       .query()
       .match(requestingUser(session))

src/components/field-zone/field-zone.resolver.ts

@@ -62,7 +62,9 @@ export class FieldZoneResolver {
     @Parent() fieldZone: FieldZone,
     @Loader(UserLoader) users: LoaderOf<UserLoader>,
   ): Promise<SecuredUser> {
-    return await mapSecuredValue(fieldZone.director, (id) => users.load(id));
+    return await mapSecuredValue(fieldZone.director, ({ id }) =>
+      users.load(id),
+    );
   }
 
   @Mutation(() => CreateFieldZoneOutput, {

src/components/field-zone/field-zone.service.ts

@@ -1,15 +1,12 @@
 import { Injectable } from '@nestjs/common';
 import {
-  DuplicateException,
   ID,
   ObjectView,
-  SecuredList,
   ServerException,
   Session,
   UnsecuredDto,
 } from '../../common';
 import { HandleIdLookup, ILogger, Logger } from '../../core';
-import { mapListResults } from '../../core/database/results';
 import { Privileges } from '../authorization';
 import {
   CreateFieldZone,
@@ -30,20 +27,8 @@ export class FieldZoneService {
 
   async create(input: CreateFieldZone, session: Session): Promise<FieldZone> {
     this.privileges.for(session, FieldZone).verifyCan('create');
-    if (!(await this.repo.isUnique(input.name))) {
-      throw new DuplicateException(
-        'fieldZone.name',
-        'FieldZone with this name already exists.',
-      );
-    }
-    const result = await this.repo.create(input, session);
-
-    if (!result) {
-      throw new ServerException('failed to create field zone');
-    }
-
-    this.logger.debug(`field zone created`, { id: result.id });
-    return await this.readOne(result.id, session);
+    const dto = await this.repo.create(input, session);
+    return this.secure(dto, session);
   }
 
   @HandleIdLookup(FieldZone)
@@ -58,32 +43,26 @@ export class FieldZoneService {
     });
 
     const result = await this.repo.readOne(id);
-    return await this.secure(result, session);
+    return this.secure(result, session);
   }
 
   async readMany(ids: readonly ID[], session: Session) {
     const fieldZones = await this.repo.readMany(ids);
-    return await Promise.all(
-      fieldZones.map((dto) => this.secure(dto, session)),
-    );
+    return fieldZones.map((dto) => this.secure(dto, session));
   }
 
-  private async secure(
-    dto: UnsecuredDto<FieldZone>,
-    session: Session,
-  ): Promise<FieldZone> {
+  private secure(dto: UnsecuredDto<FieldZone>, session: Session) {
     return this.privileges.for(session, FieldZone).secure(dto);
   }
 
   async update(input: UpdateFieldZone, session: Session): Promise<FieldZone> {
-    const fieldZone = await this.readOne(input.id, session);
+    const fieldZone = await this.repo.readOne(input.id);
 
     const changes = this.repo.getActualChanges(fieldZone, input);
     this.privileges.for(session, FieldZone, fieldZone).verifyChanges(changes);
 
-    await this.repo.update(fieldZone, changes);
-
-    return await this.readOne(input.id, session);
+    const updated = await this.repo.update(fieldZone, changes);
+    return this.secure(updated, session);
   }
 
   async delete(id: ID, session: Session): Promise<void> {
@@ -103,11 +82,10 @@ export class FieldZoneService {
     input: FieldZoneListInput,
     session: Session,
   ): Promise<FieldZoneListOutput> {
-    if (this.privileges.for(session, FieldZone).can('read')) {
-      const results = await this.repo.list(input, session);
-      return await mapListResults(results, (dto) => this.secure(dto, session));
-    } else {
-      return SecuredList.Redacted;
-    }
+    const results = await this.repo.list(input, session);
+    return {
+      ...results,
+      items: results.items.map((dto) => this.secure(dto, session)),
+    };
   }
 }

src/components/file/file.repository.ts

@@ -14,13 +14,7 @@ import { Direction } from 'cypher-query-builder/dist/typings/clauses/order-by';
 import { AnyConditions } from 'cypher-query-builder/dist/typings/clauses/where-utils';
 import { DateTime } from 'luxon';
 import { ID, NotFoundException, ServerException, Session } from '../../common';
-import {
-  CommonRepository,
-  ILogger,
-  Logger,
-  OnIndex,
-  ResourceRef,
-} from '../../core';
+import { CommonRepository, ILogger, LinkTo, Logger, OnIndex } from '../../core';
 import {
   ACTIVE,
   createNode,
@@ -407,7 +401,7 @@ export class FileRepository extends CommonRepository {
     public: isPublic,
     session,
   }: {
-    resource: ResourceRef<any>;
+    resource: LinkTo<any>;
     relation: string;
     name: string;
     public?: boolean;

src/components/prompts/dto/prompt-response.dto.ts

@@ -18,14 +18,14 @@ import {
   UnsecuredDto,
   Variant,
 } from '~/common';
-import { ResourceRef } from '~/core';
+import { LinkToUnknown } from '~/core';
 import { BaseNode } from '~/core/database/results';
 import { User } from '../../user';
 import { Prompt, SecuredPrompt } from './prompt.dto';
 
 @ObjectType()
 export class PromptResponse extends Resource {
-  readonly parent: ResourceRef<any>;
+  readonly parent: LinkToUnknown;
 
   @Field()
   readonly prompt: SecuredPrompt;