New decoupled way to associated EdgeDB types to our Resources

This was causing problems with TS.
TS would follow/compute these DB types for inheritance and our Relations object,
which was extra work that we didn't need.
It also caused problems with inheritance, which we tried to solve with `abstractType()`

This new way allows us to map from Resources to EdgeDB types, without
TS needing to consider those DB types when evaluating our Resource types.

Author: CarsonF

src/common/resource.dto.ts

@@ -4,7 +4,7 @@ import { LazyGetter as Once } from 'lazy-get-decorator';
 import { DateTime } from 'luxon';
 import { keys as keysOf } from 'ts-transformer-keys';
 import { inspect } from 'util';
-import type { ResourceMap } from '~/core';
+import type { ResourceDBMap, ResourceMap } from '~/core';
 import { $, abstractType, e } from '~/core/edgedb/reexports';
 import { ScopedRole } from '../components/authorization';
 import { CalculatedSymbol } from './calculated.decorator';
@@ -85,6 +85,9 @@ export type ResourceRelationsShape = ResourceShape<any>['Relations'];
  * A helper class to query the static info of a resource in a typed way.
  */
 export class EnhancedResource<T extends ResourceShape<any>> {
+  /** @internal */
+  static readonly dbTypes = new WeakMap<ResourceShape<any>, $.$expr_PathNode>();
+
   private constructor(readonly type: T) {}
   private static readonly refs = new WeakMap<
     ResourceShape<any>,
@@ -240,16 +243,16 @@ export class EnhancedResource<T extends ResourceShape<any>> {
     return new Set(props);
   }
 
-  get db(): T['DB'] & {} {
-    const type = this.type.DB;
+  get db(): DBType<T> {
+    const type = EnhancedResource.dbTypes.get(this.type);
     if (!type) {
       throw new ServerException(`No DB type defined for ${this.name}`);
     }
-    return type;
+    return type as any;
   }
 
-  get dbFQN(): (T['DB'] & {})['__element__']['__name__'] {
-    return this.db.__element__.__name__;
+  get dbFQN(): DBType<T>['__element__']['__name__'] {
+    return this.db.__element__.__name__ as any;
   }
 
   @Once()
@@ -295,6 +298,13 @@ export type ResourceName<TResourceStatic extends ResourceShape<any>> =
       }[keyof ResourceMap] &
         string;
 
+export type DBType<TResourceStatic extends ResourceShape<any>> =
+  ResourceName<TResourceStatic> extends keyof ResourceDBMap
+    ? ResourceDBMap[ResourceName<TResourceStatic>] extends infer T extends $.$expr_PathNode
+      ? T
+      : never
+    : never;
+
 export type MaybeUnsecuredInstance<TResourceStatic extends ResourceShape<any>> =
   MaybeSecured<InstanceType<TResourceStatic>>;
 

src/core/resources/map.ts

@@ -14,3 +14,6 @@
 export interface ResourceMap {
   // Use interface merging to add to this interface in the owning module.
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ResourceDBMap {}

src/core/resources/resource.decorator.ts

@@ -1,14 +1,16 @@
-import { ResourceShape } from '~/common';
+import { EnhancedResource, ResourceShape } from '~/common';
+import type { $ } from '../edgedb';
 import { __privateDontUseThis } from './resource-map-holder';
 
 /**
  * Register a resource for dynamic usage across the codebase.
  * Be sure to add the type to the type map as well.
  * See {@link import('./map').ResourceMap} for details on that.
  */
-export const RegisterResource = () => {
+export const RegisterResource = ({ db }: { db?: $.$expr_PathNode } = {}) => {
   return <T extends ResourceShape<any>>(target: T) => {
     __privateDontUseThis[target.name] = target;
+    db && EnhancedResource.dbTypes.set(target, db);
     return target;
   };
 };