Make ESService support static props

.changeset/metal-windows-run.md

@@ -0,0 +1,18 @@
+---
+'@freshgum/typedi': minor
+---
+
+The `ESService` decorator now supports classes with static properties.
+This was an oversight in the original design of the decorator's signature.
+
+This change affects the type parameters consumed by `ESService`; the main difference
+being that there is now a second parameter, `TClass`, which directly pertains to the
+type of the class being decorated (and thus, the type returned by the decorator.)
+
+Therefore, the type parameters of the function have changed from [`T = unknown`][esservice-old-type-params]
+to [`TInstance = unknown, TClass extends Constructable<TInstance> = Constructable<TInstance>`][esservice-new-type-params].
+
+Current code which relies on the type signature of `ESService` will not be affected.
+
+[esservice-old-type-params]: https://github.com/freshgum-bubbles/typedi/blob/4c76133d3a94e119d5b4d44846213df42d3010a5/src/contrib/es/es-service.decorator.mts#L38
+[esservice-new-type-params]: https://github.com/freshgum-bubbles/typedi/blob/a3825b77fadf6143f282e5cf4b68c084076b8369/src/contrib/es/es-service.decorator.mts#L38

src/contrib/es/es-service.decorator.mts

@@ -35,7 +35,9 @@ import { ESClassDecorator } from '../util/es-class-decorator.type.mjs';
  *
  * @returns A decorator which is then used upon a class.
  */
-export function ESService<T = unknown>(dependencies: AnyServiceDependency[]): ESClassDecorator<Constructable<T>>;
+export function ESService<TInstance = unknown, TClass extends Constructable<TInstance> = Constructable<TInstance>>(
+  dependencies: AnyServiceDependency[]
+): ESClassDecorator<TClass>;
 
 /**
  * Marks class as a service that can be injected using Container.
@@ -74,10 +76,10 @@ export function ESService<T = unknown>(dependencies: AnyServiceDependency[]): ES
  *
  * @returns A decorator which is then used upon a class.
  */
-export function ESService<T = unknown>(
-  options: Omit<ServiceOptions<T>, 'dependencies'>,
+export function ESService<TInstance = unknown, TClass extends Constructable<TInstance> = Constructable<TInstance>>(
+  options: Omit<ServiceOptions<TInstance>, 'dependencies'>,
   dependencies: AnyServiceDependency[]
-): ESClassDecorator<Constructable<T>>;
+): ESClassDecorator<TClass>;
 
 /**
  * Marks class as a service that can be injected using Container.
@@ -115,22 +117,25 @@ export function ESService<T = unknown>(
  *
  * @returns A decorator which is then used upon a class.
  */
-export function ESService<T = unknown>(
-  options: ServiceOptionsWithDependencies<Constructable<unknown>>
-): ESClassDecorator<Constructable<T>>;
+export function ESService<TInstance = unknown, TClass extends Constructable<TInstance> = Constructable<TInstance>>(
+  options: ServiceOptionsWithDependencies<TInstance>
+): ESClassDecorator<TClass>;
 
-export function ESService<T = unknown>(
-  optionsOrDependencies: Omit<ServiceOptions<T>, 'dependencies'> | ServiceOptions<T> | AnyServiceDependency[],
+export function ESService<TInstance = unknown, TClass extends Constructable<TInstance> = Constructable<TInstance>>(
+  optionsOrDependencies:
+    | Omit<ServiceOptions<TInstance>, 'dependencies'>
+    | ServiceOptions<TInstance>
+    | AnyServiceDependency[],
   maybeDependencies?: AnyServiceDependency[]
-): ESClassDecorator<Constructable<T>> {
-  return (target: Constructable<T>, context: ClassDecoratorContext) => {
+): ESClassDecorator<TClass> {
+  return (target: TClass, context: ClassDecoratorContext) => {
     // This is probably overcautious.
     if (context.kind !== 'class') {
       throw new Error('@ESService() must only be used to decorate classes.');
     }
 
     Service(
-      optionsOrDependencies as ServiceOptionsWithoutDependencies<T>,
+      optionsOrDependencies as ServiceOptionsWithoutDependencies<TClass>,
       maybeDependencies as AnyServiceDependency[]
     )(target);
   };

test/contrib/es/es-service.spec.ts

@@ -18,4 +18,22 @@ describe('ESService', () => {
     const context = createFakeClassDecoratorContext(MyService);
     expect(() => ESService([])(class {}, context)).not.toThrow();
   });
+
+  it('should support static properties and methods', function () {
+    class ClassWithStaticMethodsAndProperties {
+      static property = true;
+
+      static get getter() {
+        return 'value';
+      }
+
+      static method() {}
+    }
+
+    const context = createFakeClassDecoratorContext(ClassWithStaticMethodsAndProperties);
+
+    // We don't need an expect(...) here as this is a typing issue, not a runtime one.
+    ESService([])(ClassWithStaticMethodsAndProperties, context);
+    expect(true).toBe(true);
+  });
 });

test/decorators/Service.spec.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Container, ContainerInstance, Service, Token } from 'internal:typedi';
 import { WrappedESServiceDecorator } from '../contrib/es/test-utils/es-service-decorator-wrapper.util';
+import { ESService } from 'internal:typedi/contrib/es/es-service.decorator.mjs';
 
 // To ensure conformance between different Service implementations,
 // we wrap some decorators here with stubs which pass them quasi-values.