it works, now for memory leak testing

Author: NullVoxPopuli

ember-resources/src/intermediate-representation.ts

@@ -4,11 +4,10 @@ import { assert } from '@ember/debug';
 import { associateDestroyableChild, destroy, registerDestructor } from '@ember/destroyable';
 // @ts-ignore
 import { invokeHelper, setHelperManager } from '@ember/helper';
-import { dependencySatisfies, importSync, macroCondition } from '@embroider/macros';
 
 import { ReadonlyCell } from './cell.ts';
 import { ResourceManagerFactory } from './resource-manager.ts';
-import { CURRENT, INTERNAL } from './types.ts';
+import { INTERNAL } from './types.ts';
 import { registerUsable, TYPE_KEY } from './use.ts';
 import { shallowFlat } from './utils.ts';
 
@@ -19,20 +18,10 @@ export const CREATE_KEY = Symbol.for('__configured-resource-key__');
 export const DEBUG_NAME = Symbol.for('DEBUG_NAME');
 export const RESOURCE_CACHE = Symbol.for('__resource_cache__');
 
-let getOwner: (context: unknown) => Owner | undefined;
-let setOwner: (context: unknown, owner: Owner) => void;
-
-if (macroCondition(dependencySatisfies('ember-source', '>=4.12.0'))) {
-  // In no version of ember where `@ember/owner` tried to be imported did it exist
-  // if (macroCondition(false)) {
-  // Using 'any' here because importSync can't lookup types correctly
-  getOwner = (importSync('@ember/owner') as any).getOwner;
-  setOwner = (importSync('@ember/owner') as any).setOwner;
-} else {
-  // Using 'any' here because importSync can't lookup types correctly
-  getOwner = (importSync('@ember/application') as any).getOwner;
-  setOwner = (importSync('@ember/application') as any).setOwner;
-}
+import { compatOwner } from './owner.ts';
+
+const getOwner = compatOwner.getOwner;
+const setOwner = compatOwner.setOwner;
 
 /**
  * The return value from resource()
@@ -71,16 +60,17 @@ export class Builder<Value> {
     this.#fn = fn;
   }
 
-  create(owner: Owner) {
-    return new Resource(this.#fn, owner);
+  create() {
+    return new Resource(this.#fn);
   }
 }
 
 const TYPE = 'function-based';
 
 registerUsable(TYPE, (context: object, config: Builder<unknown>) => {
-  let owner = getOwner(context) || context;
-  let instance = config.create(owner as Owner);
+  let instance = config.create();
+
+  instance.link(context);
 
   return instance[RESOURCE_CACHE];
 });
@@ -90,12 +80,12 @@ registerUsable(TYPE, (context: object, config: Builder<unknown>) => {
  */
 export class Resource<Value> {
   #originalFn: ResourceFunction<Value>;
-  #owner: Owner;
+  #owner: Owner | undefined;
   #previousFn: object | undefined;
   #usableCache = new WeakMap<object, ReturnType<typeof invokeHelper>>();
   #cache: ReturnType<typeof invokeHelper>;
 
-  constructor(fn: ResourceFunction<Value>, owner: Owner) {
+  constructor(fn: ResourceFunction<Value>) {
     /**
      * We have to copy the `fn` in case there are multiple
      * usages or invocations of the function.
@@ -104,7 +94,6 @@ export class Resource<Value> {
      * destroy.
      */
     this.#originalFn = fn.bind(null);
-    this.#owner = owner;
 
     this.#cache = createCache(() => {
       if (this.#previousFn) {
@@ -116,6 +105,11 @@ export class Resource<Value> {
       associateDestroyableChild(this.#originalFn, currentFn);
       this.#previousFn = currentFn;
 
+      assert(
+        `Cannot create a resource without an owner. Must have previously called .link()`,
+        this.#owner,
+      );
+
       let maybeValue = currentFn({
         on: {
           cleanup: (destroyer: Destructor) => {
@@ -161,11 +155,18 @@ export class Resource<Value> {
 
       return maybeValue;
     });
-
-    setOwner(this.#cache, this.#owner);
   }
-  link(owner: Owner) {
+  link(context: object) {
+    let owner = getOwner(context);
+
+    assert(`Cannot link without an owner`, owner);
+
     this.#owner = owner;
+
+    associateDestroyableChild(context, this.#cache);
+    associateDestroyableChild(context, this.#originalFn);
+
+    setOwner(this.#cache, this.#owner);
   }
 
   get [RESOURCE_CACHE](): unknown {

ember-resources/src/owner.ts

@@ -0,0 +1,22 @@
+import { dependencySatisfies, importSync, macroCondition } from '@embroider/macros';
+
+import type Owner from '@ember/owner';
+
+interface CompatOwner {
+  getOwner: (context: unknown) => Owner | undefined;
+  setOwner: (context: unknown, owner: Owner) => void;
+}
+
+export const compatOwner = {} as CompatOwner;
+
+if (macroCondition(dependencySatisfies('ember-source', '>=4.12.0'))) {
+  // In no version of ember where `@ember/owner` tried to be imported did it exist
+  // if (macroCondition(false)) {
+  // Using 'any' here because importSync can't lookup types correctly
+  compatOwner.getOwner = (importSync('@ember/owner') as any).getOwner;
+  compatOwner.setOwner = (importSync('@ember/owner') as any).setOwner;
+} else {
+  // Using 'any' here because importSync can't lookup types correctly
+  compatOwner.getOwner = (importSync('@ember/application') as any).getOwner;
+  compatOwner.setOwner = (importSync('@ember/application') as any).setOwner;
+}

ember-resources/src/resource-manager.ts

@@ -2,9 +2,13 @@ import { assert } from '@ember/debug';
 // @ts-ignore
 import { capabilities as helperCapabilities } from '@ember/helper';
 
+import { compatOwner } from './owner.ts';
+
 import type { Builder, Resource } from './intermediate-representation.ts';
 import type Owner from '@ember/owner';
 
+const setOwner = compatOwner.setOwner;
+
 /**
  * Note, a function-resource receives on object, hooks.
  *    We have to build that manually in this helper manager
@@ -15,14 +19,20 @@ class FunctionResourceManager<Value> {
     hasDestroyable: true,
   });
 
-  constructor(protected owner: Owner) {}
+  constructor(protected owner: Owner) {
+    setOwner(this, owner);
+  }
 
   /**
    * Resources do not take args.
    * However, they can access tracked data
    */
   createHelper(builder: Builder<Value>): Resource<Value> {
-    return builder.create(this.owner);
+    let instance = builder.create();
+
+    instance.link(this);
+
+    return instance;
   }
 
   getValue(state: Resource<Value>) {