wardens 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 
+## [0.4.1] - 2023-01-14
+
+### Fixed
+
+- Newer versions of TypeScript complained about signatures in `bindContext(...)`.
+
+## [0.4.0] - 2022-06-19
+
+### Added
+
+- Support for provisioning resources through async functions instead of `Resource` subclasses. This offers better type safety around null conditions.
+- A new `Resource` utility type is exported. The new functional API expects you to return this interface.
+
+### Removed
+
+- The `Resource` abstract class was removed. Use async functions instead.
+- The `Controls<...>` utility type was removed. Import the type you need from the module instead.
+
 ## [0.3.0] - 2022-06-04
 
 ### Changed
@@ -42,7 +60,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - `mount`/`unmount` hooks to provision resources
 - `allocate`/`deallocate` for creating hierarchies of resources
 
-[Unreleased]: https://github.com/PsychoLlama/wardens/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/PsychoLlama/wardens/compare/v0.4.1...HEAD
+[0.4.1]: https://github.com/PsychoLlama/wardens/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/PsychoLlama/wardens/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/PsychoLlama/wardens/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/PsychoLlama/wardens/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/PsychoLlama/wardens/releases/tag/v0.1.0

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
   <h1>Wardens</h1>
   <p>A tiny framework for managing resources.</p>
-  <img alt="Build status" src="https://img.shields.io/github/workflow/status/PsychoLlama/wardens/Test/main" />
+  <img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/PsychoLlama/wardens/test.yml?branch=main" />
   <img alt="TypeScript" src="https://img.shields.io/npm/types/wardens" />
   <img alt="npm version" src="https://img.shields.io/npm/v/wardens" />
 </div>
@@ -13,43 +13,36 @@ This library is designed for applications that dynamically provision and dealloc
 Here's an example: let's say you've got a thread pool, one per CPU. Each thread gets a `Resource`, a small wrapper that hooks into setup and teardown controls.
 
 ```typescript
-class Worker extends Resource<Thread> {
-  thread!: Thread;
+async function Worker() {
+  const thread = await spawn();
 
-  // Called when the resource is created
-  async create() {
-    this.thread = await spawn()
-  }
+  return {
+    // The value returned after initialization completes
+    value: thread,
 
-  // Called when the resource is destroyed
-  async destroy() {
-    this.thread.close()
-  }
-
-  // The value returned after initialization completes
-  exports = () => this.thread
+    // Called when the resource is destroyed
+    destroy: () => thread.close(),
+  };
 }
 ```
 
 Now define a pool that creates and manages workers:
 
 ```typescript
-class WorkerPool extends Resource<Controls> {
-  threads!: Array<Thread> = [];
-
-  async create({ poolSize }: Config) {
-    const promises = Array.from({ length: poolSize }, () => {
-      return this.allocate(Worker)
-    })
-
-    this.threads = await Promise.all(promises)
-  }
-
-  // ... External API goes here ...
-  exports = (): Controls => ({
-    doSomeWork() {},
-    doSomethingElse() {},
-  })
+async function WorkerPool(
+  { create }: ResourceContext,
+  config: { poolSize: number },
+) {
+  const promises = Array(config.poolSize).fill(Worker).map(create);
+  const threads = await Promise.all(promises);
+
+  return {
+    // ... External API goes here ...
+    value: {
+      doSomeWork() {},
+      doSomethingElse() {},
+    },
+  };
 }
 ```
 
@@ -58,17 +51,17 @@ Finally, create the pool:
 ```typescript
 const pool = await create(WorkerPool, {
   poolSize: cpus().length,
-})
+});
 
 // Provisioned and ready to go!
-pool.doSomeWork()
-pool.doSomethingElse()
+pool.doSomeWork();
+pool.doSomethingElse();
 ```
 
 The magic of this framework is that resources never outlive their owners. If you tear down the pool, it will deallocate everything beneath it first:
 
 ```typescript
-await destroy(pool)
+await destroy(pool);
 
 // [info] closing worker
 // [info] closing worker

package/dist/wardens.mjs

@@ -0,0 +1,87 @@
+var p = Object.defineProperty;
+var x = (n, e, t) => e in n ? p(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var a = (n, e, t) => (x(n, typeof e != "symbol" ? e + "" : e, t), t), f = (n, e, t) => {
+  if (!e.has(n))
+    throw TypeError("Cannot " + t);
+};
+var i = (n, e, t) => (f(n, e, "read from private field"), t ? t.call(n) : e.get(n)), y = (n, e, t) => {
+  if (e.has(n))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(n) : e.set(n, t);
+}, l = (n, e, t, o) => (f(n, e, "write to private field"), o ? o.call(n, t) : e.set(n, t), t);
+function g(n) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return new Proxy(n, {
+    get(t, o) {
+      const r = Reflect.get(t, o, t);
+      if (typeof r == "function") {
+        if (e.has(r) === !1) {
+          const c = r.bind(t);
+          Object.defineProperties(
+            c,
+            Object.getOwnPropertyDescriptors(r)
+          ), e.set(r, c);
+        }
+        return e.get(r);
+      }
+      return r;
+    },
+    set(t, o, r) {
+      return Reflect.set(t, o, r, t);
+    }
+  });
+}
+const u = /* @__PURE__ */ new WeakMap();
+function m(n) {
+  return Proxy.revocable(n, {});
+}
+var s;
+class v {
+  constructor(e) {
+    y(this, s, void 0);
+    /** Provision an owned resource and make sure it doesn't outlive us. */
+    a(this, "create", async (e, ...t) => {
+      const o = await P(e, ...t);
+      return i(this, s).add(o), o;
+    });
+    /**
+     * Tear down a resource. Happens automatically when resource owners are
+     * deallocated.
+     */
+    a(this, "destroy", async (e) => {
+      if (!i(this, s).has(e))
+        throw new Error("You do not own this resource.");
+      try {
+        await w(e);
+      } finally {
+        i(this, s).delete(e);
+      }
+    });
+    l(this, s, e);
+  }
+}
+s = new WeakMap();
+async function P(n, ...e) {
+  const t = /* @__PURE__ */ new Set(), o = new v(t), r = await n(o, ...e), c = r.value, { proxy: d, revoke: h } = m(c);
+  return u.set(d, {
+    resource: r,
+    children: t,
+    revoke: h
+  }), d;
+}
+async function w(n) {
+  const e = u.get(n);
+  if (e) {
+    u.delete(n), e.revoke();
+    const t = Array.from(e.children).map(w), o = await Promise.allSettled(t);
+    e.resource.destroy && await e.resource.destroy(), o.forEach((r) => {
+      if (r.status === "rejected")
+        throw r.reason;
+    });
+  }
+}
+export {
+  g as bindContext,
+  P as create,
+  w as destroy
+};

package/dist/wardens.umd.js

@@ -1 +1 @@
-var v=(e,t,i)=>{if(!t.has(e))throw TypeError("Cannot "+i)};var f=(e,t,i)=>(v(e,t,"read from private field"),i?i.call(e):t.get(e)),h=(e,t,i)=>{if(t.has(e))throw TypeError("Cannot add the same private member more than once");t instanceof WeakSet?t.add(e):t.set(e,i)};(function(e,t){typeof exports=="object"&&typeof module!="undefined"?t(exports):typeof define=="function"&&define.amd?define(["exports"],t):(e=typeof globalThis!="undefined"?globalThis:e||self,t(e.wardens={}))})(this,function(e){var a,d;"use strict";const t=new WeakMap,i=new WeakMap;function y(s){return Proxy.revocable(s,{})}async function w(s,...n){const o=new s;p(o)&&await o.create(...n);const c=o.exports(),{proxy:r,revoke:u}=y(c);return t.set(r,{resource:o,revoke:u}),r}async function l(s){const n=t.get(s);if(n){t.delete(s),n.revoke();const o=i.get(n.resource);i.delete(n.resource);const c=o.map(u=>l(u)),r=await Promise.allSettled(c);b(n.resource)&&await n.resource.destroy(),r.forEach(u=>{if(u.status==="rejected")throw u.reason})}}function p(s){return"create"in s}function b(s){return"destroy"in s}class m{constructor(){h(this,a,new WeakSet);h(this,d,[]);i.set(this,f(this,d))}async allocate(n,...o){const c=await w(n,...o);return f(this,a).add(c),f(this,d).push(c),c}async deallocate(n){if(!f(this,a).has(n))throw new Error("You do not own this resource.");return l(n)}}a=new WeakMap,d=new WeakMap;function g(s){const n=new WeakMap;return new Proxy(s,{get(o,c){const r=Reflect.get(o,c,o);if(typeof r=="function"){if(n.has(r)===!1){const u=r.bind(o);Object.defineProperties(u,Object.getOwnPropertyDescriptors(r)),n.set(r,u)}return n.get(r)}return r},set(o,c,r){return Reflect.set(o,c,r,o)}})}e.Resource=m,e.bindContext=g,e.create=w,e.destroy=l,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});
+var P=Object.defineProperty;var g=(e,t,n)=>t in e?P(e,t,{enumerable:!0,configurable:!0,writable:!0,value:n}):e[t]=n;var l=(e,t,n)=>(g(e,typeof t!="symbol"?t+"":t,n),n),p=(e,t,n)=>{if(!t.has(e))throw TypeError("Cannot "+n)};var f=(e,t,n)=>(p(e,t,"read from private field"),n?n.call(e):t.get(e)),b=(e,t,n)=>{if(t.has(e))throw TypeError("Cannot add the same private member more than once");t instanceof WeakSet?t.add(e):t.set(e,n)},m=(e,t,n,d)=>(p(e,t,"write to private field"),d?d.call(e,n):t.set(e,n),n);(function(e,t){typeof exports=="object"&&typeof module<"u"?t(exports):typeof define=="function"&&define.amd?define(["exports"],t):(e=typeof globalThis<"u"?globalThis:e||self,t(e.wardens={}))})(this,function(e){var a;"use strict";function t(c){const o=new WeakMap;return new Proxy(c,{get(s,i){const r=Reflect.get(s,i,s);if(typeof r=="function"){if(o.has(r)===!1){const u=r.bind(s);Object.defineProperties(u,Object.getOwnPropertyDescriptors(r)),o.set(r,u)}return o.get(r)}return r},set(s,i,r){return Reflect.set(s,i,r,s)}})}const n=new WeakMap;function d(c){return Proxy.revocable(c,{})}class x{constructor(o){b(this,a,void 0);l(this,"create",async(o,...s)=>{const i=await h(o,...s);return f(this,a).add(i),i});l(this,"destroy",async o=>{if(!f(this,a).has(o))throw new Error("You do not own this resource.");try{await y(o)}finally{f(this,a).delete(o)}});m(this,a,o)}}a=new WeakMap;async function h(c,...o){const s=new Set,i=new x(s),r=await c(i,...o),u=r.value,{proxy:w,revoke:v}=d(u);return n.set(w,{resource:r,children:s,revoke:v}),w}async function y(c){const o=n.get(c);if(o){n.delete(c),o.revoke();const s=Array.from(o.children).map(y),i=await Promise.allSettled(s);o.resource.destroy&&await o.resource.destroy(),i.forEach(r=>{if(r.status==="rejected")throw r.reason})}}e.bindContext=t,e.create=h,e.destroy=y,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})});

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "wardens",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A framework for resource management",
   "main": "./dist/wardens.umd.js",
   "module": "./dist/wardens.es.js",
+  "types": "./src/index.ts",
   "repository": "git@github.com:PsychoLlama/wardens.git",
   "author": "Jesse Gibson <JesseTheGibson@gmail.com>",
   "license": "MIT",
@@ -31,7 +32,7 @@
   "exports": {
     ".": {
       "require": "./dist/wardens.umd.js",
-      "import": "./dist/wardens.es.js"
+      "import": "./dist/wardens.mjs"
     }
   },
   "husky": {
@@ -82,17 +83,16 @@
     "preset": "ts-jest"
   },
   "devDependencies": {
-    "@types/jest": "28.1.0",
-    "@typescript-eslint/eslint-plugin": "5.27.0",
-    "@typescript-eslint/parser": "5.27.0",
-    "eslint": "8.17.0",
-    "husky": "8.0.1",
-    "jest": "28.1.0",
-    "lint-staged": "13.0.0",
-    "prettier": "2.6.2",
-    "ts-jest": "28.0.4",
-    "typescript": "4.7.3",
-    "vite": "2.9.9",
-    "vite-dts": "1.0.4"
+    "@types/jest": "29.2.5",
+    "@typescript-eslint/eslint-plugin": "5.48.1",
+    "@typescript-eslint/parser": "5.48.1",
+    "eslint": "8.31.0",
+    "husky": "8.0.3",
+    "jest": "29.3.1",
+    "lint-staged": "13.1.0",
+    "prettier": "2.8.3",
+    "ts-jest": "29.0.5",
+    "typescript": "4.9.4",
+    "vite": "4.0.4"
   }
 }

package/src/__tests__/allocation.test.ts

@@ -1,32 +1,28 @@
-import Resource from '../resource';
+import type ResourceContext from '../resource-context';
 import { create, destroy } from '../allocation';
 
 describe('allocation', () => {
   describe('create', () => {
     it('allocates the resource', async () => {
       const config = { test: 'init-args' };
-      const spy = jest.fn((config: { test: string }) => {
-        config;
-      });
-
-      class Test extends Resource<{ test: boolean }> {
-        exports = () => ({ test: true });
-        create = spy;
-      }
-
-      await expect(create(Test, config)).resolves.toEqual({ test: true });
-      expect(spy).toHaveBeenCalledWith(config);
+      const Test = jest.fn(
+        async (_resource: ResourceContext, config: { test: string }) => ({
+          value: config,
+        }),
+      );
+
+      await expect(create(Test, config)).resolves.toEqual(config);
+      expect(Test).toHaveBeenCalledWith(expect.anything(), config);
     });
   });
 
   describe('destroy', () => {
     it('deallocates the resource', async () => {
       const spy = jest.fn<void, []>();
-
-      class Test extends Resource<Array<string>> {
-        exports = () => [];
-        destroy = spy;
-      }
+      const Test = async () => ({
+        value: {},
+        destroy: spy,
+      });
 
       const test = await create(Test);
 
@@ -36,9 +32,7 @@ describe('allocation', () => {
     });
 
     it('survives if the resource is already deallocated', async () => {
-      class Test extends Resource<Array<number>> {
-        exports = () => [];
-      }
+      const Test = async () => ({ value: [] });
 
       const test = await create(Test);
       await destroy(test);
@@ -48,16 +42,10 @@ describe('allocation', () => {
 
     it('automatically unmounts all children', async () => {
       const spy = jest.fn();
-      class Child extends Resource<number[]> {
-        exports = () => [];
-        destroy = spy;
-      }
-
-      class Parent extends Resource<string[]> {
-        exports = () => [];
-        async create() {
-          await this.allocate(Child);
-        }
+      const Child = async () => ({ value: [], destroy: spy });
+      async function Parent(resource: ResourceContext) {
+        await resource.create(Child);
+        return { value: [] };
       }
 
       const parent = await create(Parent);
@@ -68,19 +56,17 @@ describe('allocation', () => {
 
     it('throws an error if any of the children fail to close', async () => {
       const error = new Error('Testing resource destruction errors');
-      class Child extends Resource<number[]> {
-        exports = () => [];
-        async destroy() {
+      const Child = async () => ({
+        value: [],
+        destroy() {
           throw error;
-        }
-      }
+        },
+      });
 
-      class Parent extends Resource<string[]> {
-        exports = () => [];
-        async create() {
-          await this.allocate(Child);
-        }
-      }
+      const Parent = async (resource: ResourceContext) => {
+        await resource.create(Child);
+        return { value: [] };
+      };
 
       const parent = await create(Parent);
       await expect(destroy(parent)).rejects.toThrow(error);

package/src/__tests__/resource-context.test.ts

@@ -0,0 +1,63 @@
+import ResourceContext from '../resource-context';
+import { create } from '../allocation';
+
+describe('ResourceContext', () => {
+  async function Test() {
+    return { value: {} };
+  }
+
+  it('can spawn children of its own', async () => {
+    const Child = async () => ({
+      value: { child: true },
+    });
+
+    const Parent = async (resource: ResourceContext) => {
+      return { value: await resource.create(Child) };
+    };
+
+    await expect(create(Parent)).resolves.toEqual({ child: true });
+  });
+
+  it('can deallocate child resources on demand', async () => {
+    const spy = jest.fn();
+
+    const Child = async () => ({
+      value: { child: true },
+      destroy: spy,
+    });
+
+    const Parent = async (resource: ResourceContext) => {
+      const child = await resource.create(Child);
+      await resource.destroy(child);
+
+      return {
+        value: { parent: true },
+      };
+    };
+
+    await expect(create(Parent)).resolves.toEqual({ parent: true });
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('fails to destroy resources owned by someone else', async () => {
+    const test = await create(Test);
+
+    const Sneaky = async (resource: ResourceContext) => {
+      await resource.destroy(test);
+      return { value: {} };
+    };
+
+    await expect(create(Sneaky)).rejects.toThrow(/do not own/i);
+  });
+
+  it('binds create/destroy handlers to the class instance', async () => {
+    async function Allocator({ create, destroy }: ResourceContext) {
+      const test = await create(Test);
+      await destroy(test);
+
+      return { value: [] };
+    }
+
+    await expect(create(Allocator)).resolves.not.toThrow();
+  });
+});

package/src/allocation.ts

@@ -1,27 +1,28 @@
-import type Resource from './resource';
-import { resources, ownership } from './state';
+import { resources } from './state';
 import wrap from './proxy';
-import { MountableResource, UnmountableResource } from './types';
+import ResourceContext from './resource-context';
+import { ResourceFactory, ParametrizedResourceFactory } from './types';
 
 /** Provision a resource and return its external API. */
 export async function create<
   Controls extends object,
   Args extends Array<unknown>,
 >(
-  Entity: new () => MountableResource<Controls, Args> | Resource<Controls>,
+  provision:
+    | ParametrizedResourceFactory<Controls, Args>
+    | ResourceFactory<Controls>,
   ...args: Args
 ): Promise<Controls> {
-  const resource = new Entity();
+  const children: Set<object> = new Set();
+  const context = new ResourceContext(children);
+  const resource = await provision(context, ...args);
 
-  if (mountable(resource)) {
-    await resource.create(...args);
-  }
-
-  const controls = resource.exports();
+  const controls = resource.value;
   const { proxy, revoke } = wrap(controls);
 
   resources.set(proxy, {
     resource,
+    children,
     revoke,
   });
 
@@ -44,15 +45,12 @@ export async function destroy(controls: object) {
     // Free all references.
     entry.revoke();
 
-    const children = ownership.get(entry.resource)!;
-    ownership.delete(entry.resource);
-
     // Recursively close out the children first...
-    const recursiveUnmounts = children.map((controls) => destroy(controls));
+    const recursiveUnmounts = Array.from(entry.children).map(destroy);
     const results = await Promise.allSettled(recursiveUnmounts);
 
     // Then close the parent.
-    if (unmountable(entry.resource)) {
+    if (entry.resource.destroy) {
       await entry.resource.destroy();
     }
 
@@ -64,15 +62,3 @@ export async function destroy(controls: object) {
     });
   }
 }
-
-function mountable(
-  resource: MountableResource<object, Array<unknown>> | Resource<object>,
-): resource is MountableResource<object, Array<unknown>> {
-  return 'create' in resource;
-}
-
-function unmountable(
-  resource: UnmountableResource<object> | Resource<object>,
-): resource is UnmountableResource<object> {
-  return 'destroy' in resource;
-}

package/src/bind-context.ts

@@ -15,7 +15,7 @@
  *
  */
 export default function bindContext<T extends object>(value: T) {
-  const methodBindings = new WeakMap<Fn, Fn>();
+  const methodBindings = new WeakMap<object, AnyMethod>();
 
   return new Proxy(value, {
     get(target, property) {
@@ -48,5 +48,4 @@ export default function bindContext<T extends object>(value: T) {
   });
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Fn = (...args: any) => any;
+type AnyMethod = (...args: Array<unknown>) => unknown;

package/src/index.ts

@@ -1,4 +1,4 @@
-export { default as Resource } from './resource';
 export { default as bindContext } from './bind-context';
 export { create, destroy } from './allocation';
-export type { Controls } from './types';
+export type { Resource } from './types';
+export type { default as ResourceContext } from './resource-context';

package/src/resource-context.ts

@@ -0,0 +1,44 @@
+import { create, destroy } from './allocation';
+import { ResourceFactory, ParametrizedResourceFactory } from './types';
+
+/**
+ * An instance of this class is passed to resources as they're being
+ * provisioned. It allows them to provision other resources while keeping
+ * track of ownership and lifetimes.
+ */
+export default class ResourceContext {
+  #resources: Set<object>;
+
+  constructor(ownedResources: Set<object>) {
+    this.#resources = ownedResources;
+  }
+
+  /** Provision an owned resource and make sure it doesn't outlive us. */
+  public create = async <Controls extends object, Args extends Array<unknown>>(
+    factory:
+      | ParametrizedResourceFactory<Controls, Args>
+      | ResourceFactory<Controls>,
+    ...args: Args
+  ): Promise<Controls> => {
+    const controls = await create(factory, ...args);
+    this.#resources.add(controls);
+
+    return controls;
+  };
+
+  /**
+   * Tear down a resource. Happens automatically when resource owners are
+   * deallocated.
+   */
+  public destroy = async (resource: object) => {
+    if (!this.#resources.has(resource)) {
+      throw new Error('You do not own this resource.');
+    }
+
+    try {
+      await destroy(resource);
+    } finally {
+      this.#resources.delete(resource);
+    }
+  };
+}

package/src/state.ts

@@ -1,8 +1,11 @@
-import type Resource from './resource';
+import type { Resource } from './types';
 
 interface RevokableResource {
   resource: Resource<object>;
 
+  /** All the resources this resource personally allocated. */
+  children: Set<object>;
+
   /**
    * Destroys outer references to the API and frees the object for garbage
    * collection.
@@ -12,6 +15,3 @@ interface RevokableResource {
 
 /** Maps an external API back to the resource that created it. */
 export const resources = new WeakMap<object, RevokableResource>();
-
-/** Maps a resource to all the other resources it provisioned. */
-export const ownership = new WeakMap<Resource<object>, Array<object>>();

package/src/types.ts

@@ -1,19 +1,26 @@
-import type Resource from './resource';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type ResourceContext from './resource-context';
 
-/** The `exports` type for a resource. */
-export type Controls<ArbitraryResource extends Resource<object>> =
-  ArbitraryResource extends Resource<infer Controls> ? Controls : never;
+/**
+ * Represents an arbitrary stateful resource that is asynchronously provisioned
+ * and destroyed. Resources can own other resources, and destroying a parent
+ * first tears down the children.
+ */
+export interface ResourceFactory<Controls extends object> {
+  (resource: ResourceContext): Promise<Resource<Controls>>;
+}
 
-export interface MountableResource<
+export interface ParametrizedResourceFactory<
   Controls extends object,
-  InitArgs extends Array<unknown>,
-> extends Resource<Controls> {
-  /** A hook that gets called when the resource is created. */
-  create(...args: InitArgs): Promise<void>;
+  Args extends Array<unknown>,
+> {
+  (resource: ResourceContext, ...args: Args): Promise<Resource<Controls>>;
 }
 
-export interface UnmountableResource<Controls extends object>
-  extends Resource<Controls> {
+export interface Resource<Value extends object> {
+  /** The resource value returned by `create(...)`. */
+  value: Value;
+
   /** A hook that gets called when the resource is destroyed. */
-  destroy(): Promise<void>;
+  destroy?(): Promise<unknown> | unknown;
 }

package/dist/wardens.es.d.ts

@@ -1 +0,0 @@
-export * from "../src/index"

package/dist/wardens.es.js

@@ -1,99 +0,0 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var _resources, _children;
-const resources = /* @__PURE__ */ new WeakMap();
-const ownership = /* @__PURE__ */ new WeakMap();
-function wrapWithProxy(value) {
-  return Proxy.revocable(value, {});
-}
-async function create(Entity, ...args) {
-  const resource = new Entity();
-  if (mountable(resource)) {
-    await resource.create(...args);
-  }
-  const controls = resource.exports();
-  const { proxy, revoke } = wrapWithProxy(controls);
-  resources.set(proxy, {
-    resource,
-    revoke
-  });
-  return proxy;
-}
-async function destroy(controls) {
-  const entry = resources.get(controls);
-  if (entry) {
-    resources.delete(controls);
-    entry.revoke();
-    const children = ownership.get(entry.resource);
-    ownership.delete(entry.resource);
-    const recursiveUnmounts = children.map((controls2) => destroy(controls2));
-    const results = await Promise.allSettled(recursiveUnmounts);
-    if (unmountable(entry.resource)) {
-      await entry.resource.destroy();
-    }
-    results.forEach((result) => {
-      if (result.status === "rejected") {
-        throw result.reason;
-      }
-    });
-  }
-}
-function mountable(resource) {
-  return "create" in resource;
-}
-function unmountable(resource) {
-  return "destroy" in resource;
-}
-class Resource {
-  constructor() {
-    __privateAdd(this, _resources, /* @__PURE__ */ new WeakSet());
-    __privateAdd(this, _children, []);
-    ownership.set(this, __privateGet(this, _children));
-  }
-  async allocate(Child, ...args) {
-    const controls = await create(Child, ...args);
-    __privateGet(this, _resources).add(controls);
-    __privateGet(this, _children).push(controls);
-    return controls;
-  }
-  async deallocate(resource) {
-    if (!__privateGet(this, _resources).has(resource)) {
-      throw new Error("You do not own this resource.");
-    }
-    return destroy(resource);
-  }
-}
-_resources = new WeakMap();
-_children = new WeakMap();
-function bindContext(value) {
-  const methodBindings = /* @__PURE__ */ new WeakMap();
-  return new Proxy(value, {
-    get(target, property) {
-      const value2 = Reflect.get(target, property, target);
-      if (typeof value2 === "function") {
-        if (methodBindings.has(value2) === false) {
-          const methodBinding = value2.bind(target);
-          Object.defineProperties(methodBinding, Object.getOwnPropertyDescriptors(value2));
-          methodBindings.set(value2, methodBinding);
-        }
-        return methodBindings.get(value2);
-      }
-      return value2;
-    },
-    set(target, property, newValue) {
-      return Reflect.set(target, property, newValue, target);
-    }
-  });
-}
-export { Resource, bindContext, create, destroy };

package/dist/wardens.umd.d.ts

@@ -1 +0,0 @@
-export * from "../src/index"

package/src/__tests__/resource.test.ts

@@ -1,61 +0,0 @@
-import Resource from '../resource';
-import { create } from '../allocation';
-import { Controls } from '../types';
-
-describe('Resource', () => {
-  class Test extends Resource<Record<string, never>> {
-    exports = () => ({});
-  }
-
-  it('can spawn children of its own', async () => {
-    class Child extends Resource<{ child: boolean }> {
-      exports = () => ({ child: true });
-    }
-
-    class Parent extends Resource<Controls<Child>> {
-      exports = () => this.child;
-      child!: Controls<Child>;
-
-      async create() {
-        this.child = await this.allocate(Child);
-      }
-    }
-
-    await expect(create(Parent)).resolves.toEqual({ child: true });
-  });
-
-  it('can deallocate child resources on demand', async () => {
-    const spy = jest.fn();
-
-    class Child extends Resource<{ child: boolean }> {
-      exports = () => ({ child: true });
-      destroy = spy;
-    }
-
-    class Parent extends Resource<{ parent: boolean }> {
-      exports = () => ({ parent: true });
-      child!: Controls<Child>;
-
-      async create() {
-        const child = await this.allocate(Child);
-        await this.deallocate(child);
-      }
-    }
-
-    await expect(create(Parent)).resolves.toEqual({ parent: true });
-    expect(spy).toHaveBeenCalled();
-  });
-
-  it('fails to destroy resources owned by someone else', async () => {
-    const test = await create(Test);
-
-    class Sneaky extends Resource<string[]> {
-      exports = () => [];
-      async create() {
-        await this.deallocate(test);
-      }
-    }
-
-    await expect(create(Sneaky)).rejects.toThrow(/do not own/i);
-  });
-});

package/src/resource.ts

@@ -1,49 +0,0 @@
-import { create, destroy } from './allocation';
-import { ownership } from './state';
-import { MountableResource } from './types';
-
-/**
- * Represents an arbitrary stateful resource that is asynchronously provisioned
- * and destroyed. Resources can own other resources, and destroying a parent
- * first tears down the children.
- */
-export default abstract class Resource<Controls extends object> {
-  #resources = new WeakSet<object>();
-  #children: Array<object> = [];
-
-  constructor() {
-    ownership.set(this, this.#children);
-  }
-
-  /** Provision an owned resource and make sure it doesn't outlive us. */
-  protected async allocate<
-    ChildControls extends object,
-    ChildArgs extends Array<unknown>,
-  >(
-    Child: new () =>
-      | MountableResource<ChildControls, ChildArgs>
-      | Resource<ChildControls>,
-    ...args: ChildArgs
-  ): Promise<ChildControls> {
-    const controls: ChildControls = await create(Child, ...args);
-    this.#resources.add(controls);
-    this.#children.push(controls);
-
-    return controls;
-  }
-
-  /**
-   * Tear down a resource. Happens automatically when resource owners are
-   * deallocated.
-   */
-  protected async deallocate(resource: object) {
-    if (!this.#resources.has(resource)) {
-      throw new Error('You do not own this resource.');
-    }
-
-    return destroy(resource);
-  }
-
-  /** Returns an external API to the parent resource. */
-  abstract exports(): Controls;
-}