Automatically convert IDs that are aliases to their target IDs

Author: CarsonF

src/core/edgedb/alias-id-resolver.ts

@@ -0,0 +1,72 @@
+import { Injectable } from '@nestjs/common';
+import { isUUID } from 'class-validator';
+import DataLoader from 'dataloader';
+import LRU from 'lru-cache';
+import { ID, NotFoundException } from '~/common';
+import { IdResolver } from '~/common/validators/short-id.validator';
+import { ILogger, Logger } from '~/core/logger';
+import { EdgeDB } from './edgedb.service';
+import { e } from './reexports';
+
+@Injectable()
+export class AliasIdResolver implements IdResolver {
+  private readonly loader: DataLoader<ID, ID>;
+
+  constructor(
+    private readonly db: EdgeDB,
+    @Logger('alias-resolver') private readonly logger: ILogger,
+  ) {
+    this.loader = new DataLoader((x) => this.loadMany(x), {
+      // Since this loader exists for the lifetime of the process
+      // and there's no cache invalidation, we'll just use an LRU cache
+      cacheMap: new LRU({
+        max: 10_000,
+      }),
+    });
+  }
+
+  async resolve(value: ID): Promise<ID> {
+    try {
+      return await this.loader.load(value);
+    } catch (e) {
+      if (e instanceof NotFoundException) {
+        this.loader.clear(value); // maybe it'll be there next request
+        return value; // assume valid or defer error
+      }
+      throw e;
+    }
+  }
+
+  async loadMany(ids: readonly ID[]): Promise<ReadonlyArray<ID | Error>> {
+    const aliases = ids.filter((id) => {
+      if (isUUID(id)) {
+        return false;
+      }
+      return true;
+    });
+    if (aliases.length === 0) {
+      return ids;
+    }
+
+    this.logger.info('Resolving aliases', { ids: aliases });
+    const foundList = await this.db.run(this.query, { aliasList: aliases });
+    return ids.map((id) => {
+      const found = foundList.find((f) => f.name === id);
+      return found
+        ? found.targetId
+        : !aliases.includes(id)
+        ? id
+        : new NotFoundException();
+    });
+  }
+
+  private readonly query = e.params(
+    { aliasList: e.array(e.str) },
+    ({ aliasList }) =>
+      e.select(e.Alias, (alias) => ({
+        filter: e.op(alias.name, 'in', e.array_unpack(aliasList)),
+        name: true,
+        targetId: alias.target.id,
+      })),
+  );
+}

src/core/edgedb/edgedb.module.ts

@@ -1,7 +1,10 @@
 import { Module, OnModuleDestroy } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { createClient, Duration } from 'edgedb';
+import { IdResolver } from '~/common/validators/short-id.validator';
 import type { ConfigService } from '~/core';
+import { splitDb } from '../database/split-db.provider';
+import { AliasIdResolver } from './alias-id-resolver';
 import { codecs, registerCustomScalarCodecs } from './codecs';
 import { EdgeDBTransactionalMutationsInterceptor } from './edgedb-transactional-mutations.interceptor';
 import { EdgeDB } from './edgedb.service';
@@ -49,8 +52,9 @@ import { TransactionContext } from './transaction.context';
       provide: APP_INTERCEPTOR,
       useClass: EdgeDBTransactionalMutationsInterceptor,
     },
+    splitDb(IdResolver, AliasIdResolver),
   ],
-  exports: [EdgeDB, Client],
+  exports: [EdgeDB, Client, IdResolver],
 })
 export class EdgeDBModule implements OnModuleDestroy {
   constructor(private readonly client: Client) {}

src/core/validation/validation.module.ts

@@ -2,7 +2,6 @@ import { Module } from '@nestjs/common';
 import { APP_PIPE } from '@nestjs/core';
 import { Validator } from 'class-validator';
 import {
-  IdResolver,
   ValidateIdPipe,
   ValidIdConstraint,
 } from '~/common/validators/short-id.validator';
@@ -15,8 +14,7 @@ import { ValidationPipe } from './validation.pipe';
     { provide: APP_PIPE, useExisting: ValidationPipe },
     ValidIdConstraint,
     ValidateIdPipe,
-    IdResolver,
   ],
-  exports: [ValidationPipe, ValidateIdPipe, IdResolver],
+  exports: [ValidationPipe, ValidateIdPipe],
 })
 export class ValidationModule {}