Omit thunk in class-based resources when not needed

.changeset/good-donuts-hear.md

@@ -0,0 +1,29 @@
+---
+"ember-resources": minor
+---
+
+Omit thunk arg for class based resources when not needed
+
+When using a `Resource` but not using arguments with reactive parameters, initializing them still required the usage of a thunk, ie:
+
+```ts
+class TestResource extends Resource {
+  foo = 3;
+}
+
+class Test {
+  data = TestResource.from(this, () => []);
+}
+```
+
+... for basically, no reason. This change makes thunks a non-required parameter, leading into cleaner code like so:
+
+```ts
+class TestResource extends Resource {
+  foo = 3;
+}
+
+class Test {
+  data = TestResource.from(this);
+}
+```

ember-resources/src/core/class-based/resource.ts

@@ -42,6 +42,8 @@ type ResourceHelperLike<T, R> = InstanceType<
 
 declare const __ResourceArgs__: unique symbol;
 
+type Context = object;
+
 /**
  * The 'Resource' base class has only one lifecycle hook, `modify`, which is called during
  * instantiation of the resource as well as on every update of any of any consumed args.
@@ -195,6 +197,27 @@ export class Resource<Args = unknown> {
     thunk: AsThunk<ArgsFrom<SomeResource>>
   ): SomeResource;
 
+  /**
+   * For use in the body of a class, without reactive arguments.
+   *
+   * `from` is what allows resources to be used in JS, they hide the reactivity APIs
+   * from the consumer so that the surface API is smaller.
+   *
+   * ```js
+   * import { Resource } from 'ember-resources';
+   *
+   * class SomeResource extends Resource {}
+   *
+   * class MyClass {
+   *   data = SomeResource.from(this);
+   * }
+   * ```
+   */
+  static from<SomeResource extends Resource<any>, _C extends Context>(
+    this: Constructor<SomeResource>,
+    contextOrThunk: _C extends Thunk ? AsThunk<ArgsFrom<SomeResource>> : _C
+  ): SomeResource;
+
   /**
    * For use in the body of a class.
    *
@@ -240,13 +263,13 @@ export class Resource<Args = unknown> {
    */
   static from<SomeResource extends Resource<any>>(
     this: Constructor<SomeResource>,
-    context: unknown,
+    context: Context,
     thunk: AsThunk<ArgsFrom<SomeResource>>
   ): SomeResource;
 
   static from<SomeResource extends Resource<any>>(
     this: Constructor<SomeResource>,
-    contextOrThunk: unknown | AsThunk<ArgsFrom<SomeResource>>,
+    contextOrThunk: Context | AsThunk<ArgsFrom<SomeResource>>,
     thunkOrUndefined?: undefined | AsThunk<ArgsFrom<SomeResource>>
   ): SomeResource {
     /**
@@ -336,7 +359,7 @@ export class Resource<Args = unknown> {
 }
 
 function resourceOf<SomeResource extends Resource<unknown>>(
-  context: unknown,
+  context: Context,
   klass: Constructor<SomeResource>,
   thunk?: Thunk
 ): SomeResource {

test-app/tests/core/class-resource/js-test.ts

@@ -141,6 +141,7 @@ module('Core | (class) Resource | js', function (hooks) {
     }
 
     class Test {
+      data = TestResource.from(this);
       dataArray = TestResource.from(this, () => []);
       // eslint-disable-next-line @typescript-eslint/no-empty-function
       dataVoid = TestResource.from(this, () => {});
@@ -150,6 +151,7 @@ module('Core | (class) Resource | js', function (hooks) {
 
     let foo = new Test();
 
+    assert.strictEqual(foo.data.foo, 3);
     assert.strictEqual(foo.dataArray.foo, 3);
     assert.strictEqual(foo.dataVoid.foo, 3);
     assert.strictEqual(foo.dataOmitted.foo, 3);