Rework ResourceNames

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 { ResourceDBMap, ResourceMap } from '~/core';
+import type { ResourceDBMap, ResourceName } from '~/core';
 import { $, e } from '~/core/edgedb/reexports';
 import { ScopedRole } from '../components/authorization';
 import { CalculatedSymbol } from './calculated.decorator';
@@ -284,23 +284,11 @@ export const isResourceClass = <T>(
 ): cls is ResourceShape<T> =>
   'Props' in cls && Array.isArray(cls.Props) && cls.Props.length > 0;
 
-export type ResourceName<TResourceStatic extends ResourceShape<any>> =
-  ResourceShape<any> extends TResourceStatic
-    ? string // short-circuit non-specific types
-    : {
-        [Name in keyof ResourceMap]: ResourceMap[Name] extends TResourceStatic // Only self or subclasses
-          ? TResourceStatic extends ResourceMap[Name] // Exclude subclasses
-            ? Name
-            : never
-          : never;
-      }[keyof ResourceMap] &
-        string;
-
 export type DBType<TResourceStatic extends ResourceShape<any>> =
   ResourceShape<any> extends TResourceStatic
     ? typeof e.Resource // short-circuit non-specific types
-    : ResourceName<TResourceStatic> extends keyof ResourceDBMap
-    ? ResourceDBMap[ResourceName<TResourceStatic>] extends infer T extends $.$expr_PathNode
+    : ResourceName<TResourceStatic> extends `${infer Name extends keyof ResourceDBMap}`
+    ? ResourceDBMap[Name] extends infer T extends $.$expr_PathNode
       ? T
       : never
     : never;

src/core/resources/index.ts

@@ -2,5 +2,6 @@ export * from './resource-resolver.service';
 export { LoaderFactory } from './loader.registry';
 export * from './resource.loader';
 export * from './resources.host';
+export * from './resource-name.types';
 export * from './resource.decorator';
 export * from './map';

src/core/resources/resource-name.types.ts

@@ -0,0 +1,86 @@
+import { ConditionalKeys, IsAny, LiteralUnion, ValueOf } from 'type-fest';
+import { DBName, ResourceShape } from '~/common';
+import { ResourceDBMap, ResourceMap } from './map';
+
+export type AllResourceNames = keyof ResourceMap;
+export type AllResourceDBNames = DBName<ValueOf<ResourceDBMap>>;
+export type ResourceNameLike = LiteralUnion<AllResourceNames, string>;
+
+//region ResourceName
+/**
+ * Given some sort of identifier for a resource type,
+ * return our resource name if known, otherwise never.
+ *
+ * @example User
+ * "User"           -> "User"
+ * "default::User"  -> "User"
+ * typeof User      -> "User"
+ * User             -> "User"
+ *
+ * @example Including subclasses
+ *
+ * ResourceName<"Engagement", true>
+ *   -> "Engagement" | "LanguageEngagement" | "InternshipEngagement"
+ *
+ * @example Edge Cases
+ * any                  -> string
+ * ResourceShape<any>   -> string
+ * "foo"                -> never
+ * Foo                  -> never
+ */
+export type ResourceName<
+  T,
+  IncludeSubclasses extends boolean = false,
+> = IsAny<T> extends true
+  ? string // short-circuit and prevent many seemly random circular definitions
+  : T extends AllResourceDBNames
+  ? ResourceNameFromStatic<
+      ResourceMap[ResourceNameFromDBName<T>],
+      IncludeSubclasses
+    >
+  : T extends AllResourceNames
+  ? ResourceNameFromStatic<ResourceMap[T], IncludeSubclasses>
+  : T extends ResourceShape<any>
+  ? ResourceNameFromStatic<T, IncludeSubclasses>
+  : ResourceNameFromInstance<T> extends string
+  ? ResourceNameFromInstance<T, IncludeSubclasses> & string
+  : never;
+
+type ResourceNameFromInstance<
+  TResource,
+  IncludeSubclasses extends boolean = false,
+> = {
+  [Name in keyof ResourceMap]: ResourceMap[Name]['prototype'] extends TResource // Only self or subclasses
+    ? IncludeSubclasses extends true
+      ? Name
+      : TResource extends ResourceMap[Name]['prototype'] // Exclude subclasses
+      ? Name
+      : never
+    : never;
+}[keyof ResourceMap];
+
+type ResourceNameFromStatic<
+  TResourceStatic extends ResourceShape<any>,
+  IncludeSubclasses extends boolean = false,
+> = ResourceShape<any> extends TResourceStatic
+  ? string // short-circuit non-specific types
+  : {
+      [Name in keyof ResourceMap]: ResourceMap[Name] extends TResourceStatic // Only self or subclasses
+        ? IncludeSubclasses extends true
+          ? Name
+          : TResourceStatic extends ResourceMap[Name] // Exclude subclasses
+          ? Name
+          : never
+        : never;
+    }[keyof ResourceMap];
+
+type ResourceNameFromDBName<Name extends AllResourceDBNames> =
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  ConditionalKeys<ResourceDBMap, { __element__: { __name__: Name } }>;
+//endregion
+
+export type ResourceStaticFromName<Name> = string extends Name
+  ? ResourceShape<any>
+  : Name extends keyof ResourceMap
+  ? ValueOf<Pick<ResourceMap, Name>>
+  : never;

src/core/resources/resources.host.ts

@@ -3,31 +3,30 @@ import { GraphQLSchemaHost } from '@nestjs/graphql';
 import { CachedByArg, mapKeys } from '@seedcompany/common';
 import { isObjectType } from 'graphql';
 import { mapValues } from 'lodash';
-import { ConditionalKeys, LiteralUnion, ValueOf } from 'type-fest';
+import { ValueOf } from 'type-fest';
 import {
-  DBName,
   EnhancedResource,
   InvalidIdForTypeException,
   ResourceShape,
   ServerException,
 } from '~/common';
-import { ResourceDBMap, ResourceMap } from './map';
+import { ResourceMap } from './map';
 import { __privateDontUseThis } from './resource-map-holder';
+import {
+  AllResourceDBNames,
+  ResourceName,
+  ResourceNameLike,
+  ResourceStaticFromName,
+} from './resource-name.types';
 
 export type EnhancedResourceMap = {
   [K in keyof ResourceMap]: EnhancedResource<ResourceMap[K]>;
 };
 
-type LooseResourceName = LiteralUnion<keyof ResourceMap, string>;
-
 export type ResourceLike =
   | ResourceShape<any>
   | EnhancedResource<any>
-  | LooseResourceName;
-
-type ResourceNameFromDBName<K extends DBName<ValueOf<ResourceDBMap>>> =
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  ConditionalKeys<ResourceDBMap, { __element__: { __name__: K } }>;
+  | ResourceNameLike;
 
 @Injectable()
 export class ResourcesHost {
@@ -66,18 +65,13 @@ export class ResourcesHost {
     return resource;
   }
 
-  getByDynamicName(name: LooseResourceName): EnhancedResource<any> {
+  getByDynamicName(name: ResourceNameLike): EnhancedResource<any> {
     return this.getByName(name as any);
   }
 
-  getByEdgeDB<K extends keyof ResourceMap>(
-    name: K,
-  ): EnhancedResource<ValueOf<Pick<ResourceMap, K>>>;
-  getByEdgeDB<K extends DBName<ValueOf<ResourceDBMap>>>(
-    name: K,
-  ): EnhancedResource<ValueOf<Pick<ResourceMap, ResourceNameFromDBName<K>>>>;
-  getByEdgeDB(name: string): EnhancedResource<any>;
-  getByEdgeDB(name: string) {
+  getByEdgeDB<Name extends ResourceNameLike | AllResourceDBNames>(
+    name: Name,
+  ): EnhancedResource<ResourceStaticFromName<ResourceName<Name>>> {
     const fqnMap = this.edgeDBFQNMap();
     const resByFQN = fqnMap.get(
       name.includes('::') ? name : `default::${name}`,