wardens 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0]
+
+### Added
+
+- Resource class for modeling asynchronously provisioned resources
+- `mount`/`unmount` hooks to provision resources
+- `allocate`/`deallocate` for creating hierarchies of resources
+
+[Unreleased]: https://github.com/PsychoLlama/wardens/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/PsychoLlama/wardens/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Jesse Gibson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# Wardens
+
+A tiny framework for managing resources.
+
+## Overview
+
+This library is designed for applications that dynamically provision and deallocate hierarchical resources over time.
+
+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;
+
+  // Called when the resource is created
+  async enter() {
+    this.thread = await spawn()
+  }
+
+  // Called when the resource is destroyed
+  async leave() {
+    this.thread.close()
+  }
+
+  // The value returned after initialization completes
+  exports = () => this.thread
+}
+```
+
+Now define a pool that creates and manages workers:
+
+```typescript
+class WorkerPool extends Resource<Controls, Config> {
+  threads!: Array<Thread> = [];
+
+  async enter({ poolSize }: Config) {
+    const promises = Array(poolSize).fill().map(() => {
+      return this.allocate(Worker)
+    })
+
+    this.threads = await Promise.all(promises)
+  }
+
+  // ... External API goes here ...
+  exports = (): Controls => ({
+    doSomeWork() {},
+    doSomethingElse() {},
+  })
+}
+```
+
+Finally, mount it:
+
+```typescript
+const pool = await mount(WorkerPool, {
+  poolSize: cpus().length,
+})
+
+// Provisioned and ready to go!
+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 unmount(pool)
+
+// [info] closing worker
+// [info] closing worker
+// [info] closing worker
+// [info] closing worker
+// [info] closing pool
+```
+
+No more forgotten resources.
+
+## Summary
+
+The framework can be used to manage small pieces of stateful logic in your application, or it can scale to manage your entire server. Use the paradigm as much or as little as you like.
+
+I built this for my own projects. Documentation is a bit sparse, but enough GitHub stars could change that. This is a bribe.

package/dist/wardens.es.d.ts

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

package/dist/wardens.es.js

@@ -0,0 +1,95 @@
+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 mount(Subtype, params) {
+  const resource = new Subtype();
+  await resource.enter(params);
+  const api = resource.exports();
+  const { proxy, revoke } = wrapWithProxy(api);
+  resources.set(proxy, {
+    resource,
+    revoke
+  });
+  return proxy;
+}
+async function unmount(api) {
+  const entry = resources.get(api);
+  if (entry) {
+    resources.delete(api);
+    entry.revoke();
+    const children = ownership.get(entry.resource);
+    ownership.delete(entry.resource);
+    const recursiveUnmounts = children.map((api2) => unmount(api2));
+    const results = await Promise.allSettled(recursiveUnmounts);
+    await entry.resource.leave();
+    results.forEach((result) => {
+      if (result.status === "rejected") {
+        throw result.reason;
+      }
+    });
+  }
+}
+class Resource {
+  constructor() {
+    __privateAdd(this, _resources, /* @__PURE__ */ new WeakSet());
+    __privateAdd(this, _children, []);
+    ownership.set(this, __privateGet(this, _children));
+  }
+  async enter(_params) {
+    return;
+  }
+  async leave() {
+    return;
+  }
+  async allocate(Child, params) {
+    const api = await mount(Child, params);
+    __privateGet(this, _resources).add(api);
+    __privateGet(this, _children).push(api);
+    return api;
+  }
+  async deallocate(api) {
+    if (!__privateGet(this, _resources).has(api)) {
+      throw new Error("You do not own this resource.");
+    }
+    return unmount(api);
+  }
+}
+_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, mount, unmount };

package/dist/wardens.umd.d.ts

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

package/dist/wardens.umd.js

@@ -0,0 +1 @@
+var b=(e,t,c)=>{if(!t.has(e))throw TypeError("Cannot "+c)};var f=(e,t,c)=>(b(e,t,"read from private field"),c?c.call(e):t.get(e)),h=(e,t,c)=>{if(t.has(e))throw TypeError("Cannot add the same private member more than once");t instanceof WeakSet?t.add(e):t.set(e,c)};(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,c=new WeakMap;function w(i){return Proxy.revocable(i,{})}async function p(i,n){const o=new i;await o.enter(n);const s=o.exports(),{proxy:r,revoke:u}=w(s);return t.set(r,{resource:o,revoke:u}),r}async function l(i){const n=t.get(i);if(n){t.delete(i),n.revoke();const o=c.get(n.resource);c.delete(n.resource);const s=o.map(u=>l(u)),r=await Promise.allSettled(s);await n.resource.leave(),r.forEach(u=>{if(u.status==="rejected")throw u.reason})}}class y{constructor(){h(this,a,new WeakSet);h(this,d,[]);c.set(this,f(this,d))}async enter(n){}async leave(){}async allocate(n,o){const s=await p(n,o);return f(this,a).add(s),f(this,d).push(s),s}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 m(i){const n=new WeakMap;return new Proxy(i,{get(o,s){const r=Reflect.get(o,s,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,s,r){return Reflect.set(o,s,r,o)}})}e.Resource=y,e.bindContext=m,e.mount=p,e.unmount=l,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "wardens",
+  "version": "0.1.0",
+  "description": "A framework for resource management",
+  "main": "./dist/wardens.umd.js",
+  "module": "./dist/wardens.es.js",
+  "repository": "git@github.com:PsychoLlama/wardens.git",
+  "author": "Jesse Gibson <JesseTheGibson@gmail.com>",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "prepare": "tsc && vite build",
+    "test": "./bin/run-tests",
+    "test:lint": "eslint src --color",
+    "test:unit": "jest --color",
+    "test:fmt": "prettier --check src --color",
+    "dev": "vite build --watch"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/wardens.umd.js",
+      "import": "./dist/wardens.es.js"
+    }
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.tsx?": [
+      "eslint",
+      "prettier --check"
+    ]
+  },
+  "prettier": {
+    "singleQuote": true,
+    "trailingComma": "all"
+  },
+  "eslintConfig": {
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "sourceType": "module"
+    },
+    "overrides": [
+      {
+        "files": [
+          "./**/__tests__/*.ts{x,}"
+        ],
+        "env": {
+          "jest": true
+        },
+        "rules": {
+          "@typescript-eslint/no-explicit-any": "off"
+        }
+      }
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended"
+    ],
+    "rules": {
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/no-unused-vars": "error",
+      "no-prototype-builtins": "off"
+    }
+  },
+  "jest": {
+    "preset": "ts-jest"
+  },
+  "devDependencies": {
+    "@types/jest": "27.5.1",
+    "@typescript-eslint/eslint-plugin": "5.25.0",
+    "@typescript-eslint/parser": "5.25.0",
+    "eslint": "8.16.0",
+    "husky": "8.0.1",
+    "jest": "28.1.0",
+    "lint-staged": "12.4.1",
+    "prettier": "2.6.2",
+    "ts-jest": "28.0.2",
+    "typescript": "4.6.4",
+    "vite": "2.9.9",
+    "vite-dts": "1.0.4"
+  }
+}

package/src/__tests__/allocation.test.ts

@@ -0,0 +1,87 @@
+import Resource from '../resource';
+import { mount, unmount } from '../allocation';
+
+describe('allocation', () => {
+  describe('mount', () => {
+    it('allocates the resource', async () => {
+      const params = { test: 'init-args' };
+      const enter = jest.fn();
+
+      class Test extends Resource<{ test: boolean }, { test: string }> {
+        exports = () => ({ test: true });
+        enter = enter;
+      }
+
+      await expect(mount(Test, params)).resolves.toEqual({ test: true });
+      expect(enter).toHaveBeenCalledWith(params);
+    });
+  });
+
+  describe('unmount', () => {
+    it('deallocates the resource', async () => {
+      const leave = jest.fn();
+
+      class Test extends Resource<Array<string>> {
+        exports = () => [];
+        leave = leave;
+      }
+
+      const api = await mount(Test, null);
+
+      expect(leave).not.toHaveBeenCalled();
+      await expect(unmount(api)).resolves.not.toThrow();
+      expect(leave).toHaveBeenCalled();
+    });
+
+    it('survives if the resource is already deallocated', async () => {
+      class Test extends Resource<Array<number>> {
+        exports = () => [];
+      }
+
+      const api = await mount(Test, null);
+      await unmount(api);
+
+      await expect(unmount(api)).resolves.not.toThrow();
+    });
+
+    it('automatically unmounts all children', async () => {
+      const leave = jest.fn();
+      class Child extends Resource<number[]> {
+        exports = () => [];
+        leave = leave;
+      }
+
+      class Parent extends Resource<string[]> {
+        exports = () => [];
+        async enter() {
+          await this.allocate(Child, null);
+        }
+      }
+
+      const parent = await mount(Parent, null);
+      await unmount(parent);
+
+      expect(leave).toHaveBeenCalled();
+    });
+
+    it('throws an error if any of the children fail to unmount', async () => {
+      const error = new Error('Testing unmount errors');
+      class Child extends Resource<number[]> {
+        exports = () => [];
+        async leave() {
+          throw error;
+        }
+      }
+
+      class Parent extends Resource<string[]> {
+        exports = () => [];
+        async enter() {
+          await this.allocate(Child, null);
+        }
+      }
+
+      const parent = await mount(Parent, null);
+      await expect(unmount(parent)).rejects.toThrow(error);
+    });
+  });
+});

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

@@ -0,0 +1,47 @@
+import bind from '../bind-context';
+
+describe('Method rebinding', () => {
+  it('redirects getters to the correct `this` value', () => {
+    class PrivateStore {
+      #hidden = 'hidden';
+
+      get value() {
+        return this.#hidden;
+      }
+
+      set value(value: string) {
+        this.#hidden = value;
+      }
+    }
+
+    const store = bind(new PrivateStore());
+    expect(store.value).toBe('hidden');
+    store.value = 'new value';
+    expect(store.value).toBe('new value');
+
+    const set = bind(new Set());
+    expect(set.size).toBe(0);
+  });
+
+  it('rebinds methods to provide correct context', () => {
+    const proxy = bind(new Set<number>());
+    expect(() => proxy.add(5)).not.toThrow();
+    expect(proxy.has(5)).toBe(true);
+  });
+
+  it('maintains function identity for bound methods', () => {
+    const proxy = bind(new Set());
+
+    expect(proxy.add).toBe(proxy.add);
+  });
+
+  it('copies extended function properties', () => {
+    const proxy = bind({ mock: jest.fn() });
+
+    // Mocks use state held on the function itself. This must be added to the
+    // bound functions as well.
+    expect(proxy.mock).not.toHaveBeenCalled();
+    proxy.mock();
+    expect(proxy.mock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/resource.test.ts

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

package/src/allocation.ts

@@ -0,0 +1,57 @@
+import type Resource from './resource';
+import { resources, ownership } from './state';
+import wrap from './proxy';
+
+/** Provision a resource and return its external API. */
+export async function mount<Api extends object, InitArgs>(
+  Subtype: new () => Resource<Api, InitArgs>,
+  params: InitArgs,
+): Promise<Api> {
+  const resource = new Subtype();
+  await resource.enter(params);
+
+  const api = resource.exports();
+  const { proxy, revoke } = wrap(api);
+
+  resources.set(proxy, {
+    resource,
+    revoke,
+  });
+
+  return proxy;
+}
+
+/**
+ * Tear down the resource and all its children, permanently destroying the
+ * reference.
+ *
+ * @todo Add type marker to catch cases where the wrong object is unmounted.
+ */
+export async function unmount(api: object) {
+  const entry = resources.get(api);
+
+  if (entry) {
+    // Instantly delete to prevent race conditions.
+    resources.delete(api);
+
+    // 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((api) => unmount(api));
+    const results = await Promise.allSettled(recursiveUnmounts);
+
+    // Then close the parent.
+    await entry.resource.leave();
+
+    // Fail loudly if any of the children couldn't be deallocated.
+    results.forEach((result) => {
+      if (result.status === 'rejected') {
+        throw result.reason;
+      }
+    });
+  }
+}

package/src/bind-context.ts

@@ -0,0 +1,52 @@
+/**
+ * The framework's usage of proxies can cause havoc on classes that depend on
+ * true private fields, such as Map, Set, and some networking classes in Node's
+ * core library, among others. If you run into those challenges, `bindContext`
+ * can dynamically correct the errors by retargeting the `this` context to the
+ * original value.
+ *
+ * Contexts aren't rebound by default because it has a noticeable side-effect:
+ * method identity is no longer the same. This can be very irritating in unit
+ * tests that assert a stable function identity.
+ *
+ * Example:
+ *
+ *   exports = () => bindContext(new Set())
+ *
+ */
+export default function bindContext<T extends object>(value: T) {
+  const methodBindings = new WeakMap<Fn, Fn>();
+
+  return new Proxy(value, {
+    get(target, property) {
+      const value = Reflect.get(target, property, target);
+
+      // Bind methods to the real `this` context while maintaining
+      // a consistent function identity.
+      if (typeof value === 'function') {
+        if (methodBindings.has(value) === false) {
+          const methodBinding = value.bind(target);
+
+          // Copy static function properties.
+          Object.defineProperties(
+            methodBinding,
+            Object.getOwnPropertyDescriptors(value),
+          );
+
+          methodBindings.set(value, methodBinding);
+        }
+
+        return methodBindings.get(value);
+      }
+
+      return value;
+    },
+
+    set(target, property, newValue) {
+      return Reflect.set(target, property, newValue, target);
+    },
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Fn = (...args: any) => any;

package/src/index.ts

@@ -0,0 +1,3 @@
+export { default as Resource, type ExternalControls } from './resource';
+export { default as bindContext } from './bind-context';
+export { mount, unmount } from './allocation';

package/src/proxy.ts

@@ -0,0 +1,24 @@
+/**
+ * Wrap objects in a revocable proxy. Revocation offers guarantees about
+ * use-after-free and avoids memory leaks. Perhaps more importantly, it
+ * provides a unique identity for each API exposed by a resource, which allows
+ * us to map an API back to the resource that created it. The consequence of
+ * object identity is important.
+ *
+ * Consider: If a resource provisions and re-exports another resource, when
+ * you go to deallocate the parent, the API maps back to the child and
+ * completely misses the parent.
+ *
+ * We magically skirt that issue by wrapping everything in a proxy and thus
+ * assigning a new identity every time. Of course, all magic comes at a price.
+ * The penalty here is `this` binding. Private fields and exotic objects
+ * (`Map`, `Set`, some Node tools) strictly depend on the `this` context being
+ * itself, not a proxy. Methods can throw very confusing errors because they
+ * can't get at private state.
+ *
+ * The bind-context utility is exposed as a workaround. Alternatively, you can
+ * export a wrapping object instead: `{ value: T }`.
+ */
+export default function wrapWithProxy<T extends object>(value: T) {
+  return Proxy.revocable(value, {});
+}

package/src/resource.ts

@@ -0,0 +1,63 @@
+import { mount, unmount } from './allocation';
+import { ownership } from './state';
+
+/**
+ * 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<
+  ExternalApi extends object,
+  InitArgs = void,
+> {
+  #resources = new WeakSet<object>();
+  #children: Array<object> = [];
+
+  constructor() {
+    ownership.set(this, this.#children);
+  }
+
+  /** A hook that gets called when the resource is created. */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async enter(_params: InitArgs) {
+    return;
+  }
+
+  /** A hook that gets called when the resource is destroyed. */
+  async leave() {
+    return;
+  }
+
+  /** Provision an owned resource and make sure it doesn't outlive us. */
+  async allocate<Api extends object, Params>(
+    Child: new () => Resource<Api, Params>,
+    params: Params,
+  ): Promise<Api> {
+    const api = await mount(Child, params);
+    this.#resources.add(api);
+    this.#children.push(api);
+
+    return api;
+  }
+
+  /**
+   * Tear down a resource. Happens automatically when resource owners are
+   * deallocated.
+   */
+  async deallocate(api: object) {
+    if (!this.#resources.has(api)) {
+      throw new Error('You do not own this resource.');
+    }
+
+    return unmount(api);
+  }
+
+  /** Returns an external API to the parent resource. */
+  abstract exports(): ExternalApi;
+}
+
+/** The `exports` type for a resource. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ExternalControls<ArbitraryResource extends Resource<any, any>> =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ArbitraryResource extends Resource<infer Api, any> ? Api : never;

package/src/state.ts

@@ -0,0 +1,20 @@
+import type Resource from './resource';
+
+interface RevokableResource {
+  resource: Resource<object, unknown>;
+
+  /**
+   * Destroys outer references to the API and frees the object for garbage
+   * collection.
+   */
+  revoke(): void;
+}
+
+/** 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, unknown>,
+  Array<object>
+>();