@romikus/dimpl 1.0.0

package/README.md

@@ -0,0 +1,608 @@
+# dimpl
+
+Simple dependency injection for TypeScript and JavaScript.
+
+- Works with functions and classes.
+- Dependencies stay visible in plain code.
+- No decorators.
+- No metadata reflection.
+- No class-only container model.
+
+`dimpl` treats a function or class as the dependency key. The first time you ask for it, the container creates an instance and caches it. Every later lookup in the same container returns the same instance.
+
+```ts
+import { dimpl } from "dimpl";
+
+const di = dimpl();
+
+const Config = () => ({
+  dbUrl: process.env.DATABASE_URL ?? "postgres://localhost/app",
+});
+
+const Db = (config = di.get(Config)) => {
+  return connect(config.dbUrl);
+};
+
+const Users = ({ db } = di.deps({ db: Db })) => {
+  return {
+    findById(id: string) {
+      return db.user.findUnique({ where: { id } });
+    },
+  };
+};
+
+const users = di.get(Users);
+```
+
+## Installation
+
+```sh
+npm install @romikus/dimpl
+```
+
+## Motivation
+
+With `dimpl`, dependencies are just default parameters:
+
+```ts
+const UsersService = (
+  { db, logger } = di.deps({
+    db: Db,
+    logger: Logger,
+  }),
+) => {
+  return {
+    list() {
+      logger.info("Listing users");
+      return db.query("select * from users");
+    },
+  };
+};
+```
+
+Single dependency:
+
+```ts
+const StripeClient = (config = di.get(Config)) => {
+  return new Stripe(config.stripeSecretKey);
+};
+```
+
+Class dependency:
+
+```ts
+class Clock {
+  now() {
+    return new Date();
+  }
+}
+
+const Tokens = ({ clock } = di.deps({ clock: Clock })) => {
+  return {
+    issue() {
+      return { issuedAt: clock.now() };
+    },
+  };
+};
+```
+
+Startup side effects:
+
+```ts
+const app = di.get(App);
+
+di.wire(HealthController, AuthController, UsersController);
+
+serve({ fetch: app.fetch, port: 3000 });
+```
+
+Controllers can register routes when they are instantiated. Services can stay lazy until something needs them.
+
+## request-scoped lifetime
+
+`dimpl` is designed only around a singleton runtime. Every dependency resolved by a container is cached as one instance for that container.
+
+Disregarding of a DI library, `AsyncLocalStorage` is a much more convenient way of handling request-scoped or more granular scoped dependencies anyway.
+
+You can use a `dimpl` singleton instance of `AsyncLocalStorage` to retrieve request-scoped dependencies from it.
+
+For example, imagine a pino logger is request-scoped. When a request starts, you create a child logger with `userId`. Services use that child logger without becoming request-scoped themselves.
+
+```ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import pino, { type Logger } from "pino";
+
+type RequestScope = {
+  logger: Logger;
+};
+
+const RootLogger = () => pino();
+
+const RequestScope = () => {
+  return new AsyncLocalStorage<RequestScope>();
+};
+
+const RequestLogger = (
+  { rootLogger, requestScope } = di.deps({
+    rootLogger: RootLogger,
+    requestScope: RequestScope,
+  }),
+) => {
+  return {
+    get() {
+      return requestScope.getStore()?.logger ?? rootLogger;
+    },
+  };
+};
+
+const OrdersService = (
+  { logger } = di.deps({
+    logger: RequestLogger,
+  }),
+) => {
+  return {
+    createOrder(userId: string) {
+      logger.get().info({ userId }, "Creating order");
+      // ...
+    },
+  };
+};
+
+const requestScope = di.get(RequestScope);
+const rootLogger = di.get(RootLogger);
+const ordersService = di.get(OrdersService);
+
+app.use(async (req, res, next) => {
+  const userId = await getUserId(req);
+  const logger = rootLogger.child({ userId });
+
+  requestScope.run({ logger }, () => {
+    next();
+  });
+});
+
+app.post("/orders", async (req, res) => {
+  const userId = await getUserId(req);
+  ordersService.createOrder(userId);
+  res.sendStatus(201);
+});
+```
+
+The container still has singleton services. The request-specific value lives in `AsyncLocalStorage`, and services read it at call time.
+
+## Async Constructors
+
+`dimpl` does not support async constructors in any special way for now. This keeps the library simple, and async dependency construction is rare enough that it may not be worth adding container-level machinery for it.
+
+When a dependency must be awaited before use, do that in your app setup and seed the resolved instance with `di.set`.
+
+For example, imagine an AMQP library requires an async connection before anything can publish messages:
+
+```ts
+import { connect, type Channel } from "amqplib";
+
+export const Amqp = (): Channel => {
+  throw new Error("amqp instance must be set in the setup");
+};
+
+export const NotificationsService = (amqp = di.get(Amqp)) => {
+  return {
+    async sendWelcomeEmail(userId: string) {
+      await amqp.sendToQueue("emails", Buffer.from(JSON.stringify({ type: "welcome", userId })));
+    },
+  };
+};
+
+export async function setup() {
+  const connection = await connect(process.env.AMQP_URL);
+  const channel = await connection.createChannel();
+
+  di.set(Amqp, channel);
+
+  return {
+    notificationsService: di.get(NotificationsService),
+  };
+}
+```
+
+The throwing factory is just the dependency key and type source. If setup forgets to provide the real instance, the app fails with a clear error.
+
+## Unit Testing
+
+Because dependencies are normal function parameters, the simplest test does not need a container at all. Pass every dependency explicitly.
+
+```ts
+import { describe, expect, it, vi } from "vitest";
+
+const AuthService = (
+  { users, tokens } = di.deps({
+    users: UsersRepo,
+    tokens: TokenService,
+  }),
+) => {
+  return {
+    async login(email: string, password: string) {
+      const user = await users.verifyPassword(email, password);
+      return tokens.sign(user.id);
+    },
+  };
+};
+
+it("logs in a user", async () => {
+  const users = {
+    verifyPassword: vi.fn().mockResolvedValue({ id: "user_1" }),
+  };
+
+  const tokens = {
+    sign: vi.fn().mockReturnValue("jwt"),
+  };
+
+  const auth = AuthService({ users, tokens });
+
+  await expect(auth.login("a@example.com", "secret")).resolves.toBe("jwt");
+  expect(users.verifyPassword).toHaveBeenCalledWith("a@example.com", "secret");
+  expect(tokens.sign).toHaveBeenCalledWith("user_1");
+});
+```
+
+Use `di.set` when you want most of the dependency graph to stay real, but one or two dependencies should be mocked. `di.deps` will keep resolving everything normally, and the dependencies you seeded with `di.set` will be returned instead of being created.
+
+```ts
+it("uses a real dependency graph with one mocked dependency", async () => {
+  const di = dimpl();
+
+  const Db = () => connect(process.env.DATABASE_URL);
+
+  const Logger = () => ({
+    info: vi.fn(),
+  });
+
+  const UsersRepo = (
+    { db, logger } = di.deps({
+      db: Db,
+      logger: Logger,
+    }),
+  ) => ({
+    async findById(id: string) {
+      logger.info(`Loading user ${id}`);
+      return db.users.findById(id);
+    },
+  });
+
+  const fakeDb = {
+    users: {
+      findById: vi.fn().mockResolvedValue({ id: "user_1" }),
+    },
+  };
+
+  di.set(Db, fakeDb);
+
+  const users = di.get(UsersRepo);
+
+  await expect(users.findById("user_1")).resolves.toEqual({ id: "user_1" });
+  expect(fakeDb.users.findById).toHaveBeenCalledWith("user_1");
+  expect(di.get(Logger).info).toHaveBeenCalledWith("Loading user user_1");
+});
+```
+
+## Example App
+
+See [`example/`](./example) for a sample API using `dimpl`.
+
+It shows:
+
+- `example/src/di.ts`: exporting one app container.
+- `example/src/server.ts`: getting the app and wiring controllers.
+- `example/src/modules/auth/auth.controller.ts`: injecting multiple dependencies with `di.deps`.
+- `example/src/infrastructure/db.ts`: injecting a single dependency with `di.get`.
+
+```ts
+import { dimpl } from "dimpl";
+```
+
+## Creating a Container
+
+```ts
+import { dimpl } from "dimpl";
+
+export const di = dimpl();
+```
+
+Each call to `dimpl()` creates an independent container with its own cache.
+
+```ts
+const appDi = dimpl();
+const testDi = dimpl();
+
+const Db = () => ({ connected: true });
+
+appDi.get(Db) === appDi.get(Db); // true
+appDi.get(Db) === testDi.get(Db); // false
+```
+
+Use this when:
+
+- You want one container for the whole app.
+- You want a fresh container per test.
+- You want distinct containers for multiple apps, tenants, workers, or integration-test scenarios.
+
+## API
+
+### `dimpl()`
+
+Creates a new DI container.
+
+```ts
+const di = dimpl();
+```
+
+The returned container has four methods:
+
+- `get`
+- `deps`
+- `set`
+- `wire`
+
+It also owns its own instance cache. No state is shared between containers.
+
+### `di.get(fnOrClass)`
+
+Creates or returns the cached instance for one dependency.
+
+```ts
+const Config = () => ({ port: 3000 });
+
+const config = di.get(Config);
+```
+
+Use `get` when:
+
+- You need one dependency.
+- You are bootstrapping the app.
+- A factory depends on one other dependency.
+
+With classes:
+
+```ts
+class Logger {
+  info(message: string) {
+    console.log(message);
+  }
+}
+
+const logger = di.get(Logger);
+```
+
+`get` is lazy. The function or class is called only once per container, then cached.
+
+### `di.deps({ name: fnOrClass })`
+
+Creates or returns multiple dependencies as a typed object.
+
+```ts
+const Service = (
+  { db, logger } = di.deps({
+    db: Db,
+    logger: Logger,
+  }),
+) => {
+  return {
+    run() {
+      logger.info("Running");
+      return db.query("select 1");
+    },
+  };
+};
+```
+
+Use `deps` when:
+
+- A factory needs more than one dependency.
+- You want a readable dependency list at the top of a function.
+- You want TypeScript to infer a named object of dependency instances.
+
+The object keys are yours. The values are dependency factories or classes. The returned object has the same keys, but each value is the resolved instance.
+
+`deps` can also handle circular dependencies when access is delayed until after construction. See [Circular Dependencies](#circular-dependencies).
+
+### `di.set(fnOrClass, instance)`
+
+Stores an instance for a dependency key.
+
+```ts
+const fakeLogger = {
+  info() {},
+};
+
+di.set(Logger, fakeLogger);
+
+di.get(Logger) === fakeLogger; // true
+```
+
+Use `set` when:
+
+- You want to override a dependency in a test.
+- You already created an instance yourself.
+- You want to provide an adapter from outside the container.
+
+Call `set` before the dependency is resolved if you want consumers to receive the override.
+
+### `di.wire(...fnOrClass)`
+
+Eagerly instantiates dependencies and returns nothing.
+
+```ts
+di.wire(HealthController, AuthController, ProductsController);
+```
+
+Use `wire` when:
+
+- A dependency exists for side effects.
+- Controllers register routes during construction.
+- Startup should fail immediately if a dependency cannot be created.
+
+`wire` uses the same cache as `get` and `deps`. If something was already created, it will not be created again.
+
+### `dimplCircularDepError`
+
+`dimplCircularDepError` is exported for code that wants to recognize container-level circular dependency failures.
+
+```ts
+import { dimplCircularDepError } from "dimpl";
+```
+
+Most application code does not need to catch it. Prefer structuring circular references so they are accessed lazily through methods or getters.
+
+## Circular Dependencies
+
+If two services depend on each other, `di.get` inside those services will not work. It tries to resolve the dependency immediately, so the container detects that the first service is still being created and throws a `dimplCircularDepError`.
+
+```ts
+const A = (b = di.get(B)) => ({
+  name: "a",
+  b,
+});
+
+const B = (a = di.get(A)) => ({
+  name: "b",
+  a,
+});
+
+di.get(A); // throws dimplCircularDepError
+```
+
+Use `di.deps` for circular dependencies, and keep access lazy. A service cannot read a dependency that is still being constructed. That includes destructuring it or reading it in the factory body.
+
+```ts
+const A = (deps = di.deps({ b: B })) => {
+  return {
+    name: "a",
+    getB() {
+      return deps.b;
+    },
+  };
+};
+
+const B = (deps = di.deps({ a: A })) => {
+  deps.a; // throws: A is not ready yet
+
+  return {
+    name: "b",
+  };
+};
+```
+
+Access the circular dependency later from a method or getter:
+
+```ts
+const A = (deps = di.deps({ b: B })) => ({
+  name: "a",
+  getB() {
+    return deps.b;
+  },
+});
+
+const B = (deps = di.deps({ a: A })) => ({
+  name: "b",
+  getA() {
+    return deps.a;
+  },
+});
+
+const a = di.get(A);
+const b = di.get(B);
+
+a.getB() === b; // true
+b.getA() === a; // true
+```
+
+For circular dependencies, avoid destructuring the circular dependency in the parameter list:
+
+```ts
+// Avoid this for circular dependencies.
+const B = ({ a } = di.deps({ a: A })) => ({
+  useA() {
+    return a;
+  },
+});
+```
+
+Destructuring reads `a` during construction. Keep the `deps` object and read `deps.a` later.
+
+## Patterns
+
+### Export One App Container
+
+```ts
+// di.ts
+import { dimpl } from "dimpl";
+
+export const di = dimpl();
+```
+
+Then import it from factories:
+
+```ts
+import { di } from "./di";
+
+export const Orders = ({ db, payments } = di.deps({ db: Db, payments: Payments })) => {
+  return {
+    create() {
+      // ...
+    },
+  };
+};
+```
+
+### Prefer Default Parameters
+
+Default parameters make production code automatic and tests explicit.
+
+```ts
+export const Orders = (
+  { db, payments } = di.deps({
+    db: Db,
+    payments: Payments,
+  }),
+) => {
+  // ...
+};
+```
+
+In production:
+
+```ts
+const orders = di.get(Orders);
+```
+
+In tests:
+
+```ts
+const orders = Orders({ db: fakeDb, payments: fakePayments });
+```
+
+### Keep Constructors Simple
+
+Classes are supported, but `dimpl` constructs them without arguments.
+
+```ts
+class Ids {
+  create() {
+    return crypto.randomUUID();
+  }
+}
+
+di.get(Ids);
+```
+
+If a dependency needs other dependencies, a factory function with default parameters is usually clearer.
+
+```ts
+const Orders = ({ db, ids } = di.deps({ db: Db, ids: Ids })) => {
+  // ...
+};
+```
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+declare class dimplCircularDepError extends Error {
+  functionName: string;
+  constructor(message: string, functionName: string);
+}
+interface Fn<T> {
+  (...args: any[]): T;
+}
+interface Class<T> {
+  new (...args: any[]): T;
+}
+type Constructor<T> = Fn<T> | Class<T>;
+type Instance<T> = T extends (new (...args: any[]) => infer R) ? R : T extends ((...args: any[]) => infer R) ? R : never;
+declare const dimpl: () => {
+  get: <T>(fn: Constructor<T>) => T;
+  set<T>(fn: Constructor<T>, instance: T): void;
+  deps: <T extends {
+    [K: string]: Constructor<unknown>;
+  }>(obj: T) => { [K in keyof T]: Instance<T[K]> };
+  wire: (...args: Constructor<unknown>[]) => void;
+};
+export { dimpl, dimplCircularDepError };

package/dist/index.js

@@ -0,0 +1,76 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var dimplCircularDepError = class extends Error {
+	functionName;
+	constructor(message, functionName) {
+		super(message);
+		this.functionName = functionName;
+	}
+};
+const dimpl = () => {
+	const instances = /* @__PURE__ */ new Map();
+	const delayedDeps = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Set();
+	const isClass = (fn) => {
+		return Object.getOwnPropertyDescriptor(fn, "prototype")?.writable === false;
+	};
+	const get = (fn) => {
+		let instance = instances.get(fn);
+		if (!instance) {
+			if (pending.has(fn)) throw new dimplCircularDepError("Cannot resolve a circular dependency", fn.name);
+			pending.add(fn);
+			instance = isClass(fn) ? new fn() : fn();
+			instances.set(fn, instance);
+			const delayedDependents = delayedDeps.get(fn);
+			if (delayedDependents) for (const [deps, keys] of delayedDependents.entries()) for (const key of keys) Object.defineProperty(deps, key, {
+				configurable: true,
+				enumerable: true,
+				value: instance
+			});
+			pending.delete(fn);
+		}
+		return instance;
+	};
+	return {
+		get,
+		set(fn, instance) {
+			instances.set(fn, instance);
+		},
+		deps: (obj) => {
+			const res = {};
+			for (const key in obj) {
+				const fn = obj[key];
+				try {
+					res[key] = get(fn);
+				} catch (e) {
+					if (!(e instanceof dimplCircularDepError)) throw e;
+					Object.defineProperty(res, key, {
+						configurable: true,
+						enumerable: true,
+						get() {
+							throw new Error(`Cannot access property ${key} yet due to a circular dependency`);
+						}
+					});
+					let delayedDependents = delayedDeps.get(fn);
+					if (!delayedDependents) {
+						delayedDependents = /* @__PURE__ */ new Map();
+						delayedDeps.set(fn, delayedDependents);
+					}
+					let keys = delayedDependents.get(res);
+					if (!keys) {
+						keys = [];
+						delayedDependents.set(res, keys);
+					}
+					keys.push(key);
+				}
+			}
+			return res;
+		},
+		wire: (...args) => {
+			for (const fn of args) get(fn);
+		}
+	};
+};
+exports.dimpl = dimpl;
+exports.dimplCircularDepError = dimplCircularDepError;
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export class dimplCircularDepError extends Error {\n  constructor(\n    message: string,\n    public functionName: string,\n  ) {\n    super(message);\n  }\n}\n\ninterface Fn<T> {\n  (...args: any[]): T;\n}\n\ninterface Class<T> {\n  new (...args: any[]): T;\n}\n\ntype Constructor<T> = Fn<T> | Class<T>;\ntype Instance<T> = T extends new (...args: any[]) => infer R\n  ? R\n  : T extends (...args: any[]) => infer R\n    ? R\n    : never;\n\nexport const dimpl = () => {\n  const instances = new Map<unknown, unknown>();\n  const delayedDeps = new Map<unknown, Map<{ [K: string]: unknown }, string[]>>();\n  const pending = new Set<Constructor<unknown>>();\n\n  const isClass = (fn: Constructor<unknown>): fn is Class<unknown> => {\n    return Object.getOwnPropertyDescriptor(fn, \"prototype\")?.writable === false;\n  };\n\n  const get = <T>(fn: Constructor<T>): T => {\n    let instance = instances.get(fn);\n    if (!instance) {\n      if (pending.has(fn)) {\n        throw new dimplCircularDepError(\"Cannot resolve a circular dependency\", fn.name);\n      }\n      pending.add(fn);\n\n      instance = isClass(fn) ? new fn() : fn();\n      instances.set(fn, instance);\n\n      const delayedDependents = delayedDeps.get(fn);\n      if (delayedDependents) {\n        for (const [deps, keys] of delayedDependents.entries()) {\n          for (const key of keys) {\n            Object.defineProperty(deps, key, {\n              configurable: true,\n              enumerable: true,\n              value: instance,\n            });\n          }\n        }\n      }\n\n      pending.delete(fn);\n    }\n\n    return instance as never;\n  };\n\n  return {\n    get,\n\n    set<T>(fn: Constructor<T>, instance: T): void {\n      instances.set(fn, instance);\n    },\n\n    deps: <T extends { [K: string]: Constructor<unknown> }>(\n      obj: T,\n    ): {\n      [K in keyof T]: Instance<T[K]>;\n    } => {\n      const res: { [K: string]: unknown } = {};\n\n      for (const key in obj) {\n        const fn = obj[key];\n\n        try {\n          res[key] = get(fn);\n        } catch (e) {\n          if (!(e instanceof dimplCircularDepError)) {\n            throw e;\n          }\n\n          Object.defineProperty(res, key, {\n            configurable: true,\n            enumerable: true,\n            get() {\n              throw new Error(`Cannot access property ${key} yet due to a circular dependency`);\n            },\n          });\n\n          let delayedDependents = delayedDeps.get(fn);\n          if (!delayedDependents) {\n            delayedDependents = new Map();\n            delayedDeps.set(fn, delayedDependents);\n          }\n\n          let keys = delayedDependents.get(res);\n          if (!keys) {\n            keys = [];\n            delayedDependents.set(res, keys);\n          }\n\n          keys.push(key);\n        }\n      }\n\n      return res as never;\n    },\n\n    wire: (...args: Constructor<unknown>[]): void => {\n      for (const fn of args) {\n        get(fn);\n      }\n    },\n  };\n};\n"],"mappings":";AAAA,IAAa,wBAAb,cAA2C,MAAM;CAGtC;CAFT,YACE,SACA,cACA;EACA,MAAM,OAAO;EAFN,KAAA,eAAA;CAGT;AACF;AAiBA,MAAa,cAAc;CACzB,MAAM,4BAAY,IAAI,IAAsB;CAC5C,MAAM,8BAAc,IAAI,IAAsD;CAC9E,MAAM,0BAAU,IAAI,IAA0B;CAE9C,MAAM,WAAW,OAAmD;EAClE,OAAO,OAAO,yBAAyB,IAAI,WAAW,CAAC,EAAE,aAAa;CACxE;CAEA,MAAM,OAAU,OAA0B;EACxC,IAAI,WAAW,UAAU,IAAI,EAAE;EAC/B,IAAI,CAAC,UAAU;GACb,IAAI,QAAQ,IAAI,EAAE,GAChB,MAAM,IAAI,sBAAsB,wCAAwC,GAAG,IAAI;GAEjF,QAAQ,IAAI,EAAE;GAEd,WAAW,QAAQ,EAAE,IAAI,IAAI,GAAG,IAAI,GAAG;GACvC,UAAU,IAAI,IAAI,QAAQ;GAE1B,MAAM,oBAAoB,YAAY,IAAI,EAAE;GAC5C,IAAI,mBACF,KAAK,MAAM,CAAC,MAAM,SAAS,kBAAkB,QAAQ,GACnD,KAAK,MAAM,OAAO,MAChB,OAAO,eAAe,MAAM,KAAK;IAC/B,cAAc;IACd,YAAY;IACZ,OAAO;GACT,CAAC;GAKP,QAAQ,OAAO,EAAE;EACnB;EAEA,OAAO;CACT;CAEA,OAAO;EACL;EAEA,IAAO,IAAoB,UAAmB;GAC5C,UAAU,IAAI,IAAI,QAAQ;EAC5B;EAEA,OACE,QAGG;GACH,MAAM,MAAgC,CAAC;GAEvC,KAAK,MAAM,OAAO,KAAK;IACrB,MAAM,KAAK,IAAI;IAEf,IAAI;KACF,IAAI,OAAO,IAAI,EAAE;IACnB,SAAS,GAAG;KACV,IAAI,EAAE,aAAa,wBACjB,MAAM;KAGR,OAAO,eAAe,KAAK,KAAK;MAC9B,cAAc;MACd,YAAY;MACZ,MAAM;OACJ,MAAM,IAAI,MAAM,0BAA0B,IAAI,kCAAkC;MAClF;KACF,CAAC;KAED,IAAI,oBAAoB,YAAY,IAAI,EAAE;KAC1C,IAAI,CAAC,mBAAmB;MACtB,oCAAoB,IAAI,IAAI;MAC5B,YAAY,IAAI,IAAI,iBAAiB;KACvC;KAEA,IAAI,OAAO,kBAAkB,IAAI,GAAG;KACpC,IAAI,CAAC,MAAM;MACT,OAAO,CAAC;MACR,kBAAkB,IAAI,KAAK,IAAI;KACjC;KAEA,KAAK,KAAK,GAAG;IACf;GACF;GAEA,OAAO;EACT;EAEA,OAAO,GAAG,SAAuC;GAC/C,KAAK,MAAM,MAAM,MACf,IAAI,EAAE;EAEV;CACF;AACF"}

package/dist/index.mjs

@@ -0,0 +1,74 @@
+var dimplCircularDepError = class extends Error {
+	functionName;
+	constructor(message, functionName) {
+		super(message);
+		this.functionName = functionName;
+	}
+};
+const dimpl = () => {
+	const instances = /* @__PURE__ */ new Map();
+	const delayedDeps = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Set();
+	const isClass = (fn) => {
+		return Object.getOwnPropertyDescriptor(fn, "prototype")?.writable === false;
+	};
+	const get = (fn) => {
+		let instance = instances.get(fn);
+		if (!instance) {
+			if (pending.has(fn)) throw new dimplCircularDepError("Cannot resolve a circular dependency", fn.name);
+			pending.add(fn);
+			instance = isClass(fn) ? new fn() : fn();
+			instances.set(fn, instance);
+			const delayedDependents = delayedDeps.get(fn);
+			if (delayedDependents) for (const [deps, keys] of delayedDependents.entries()) for (const key of keys) Object.defineProperty(deps, key, {
+				configurable: true,
+				enumerable: true,
+				value: instance
+			});
+			pending.delete(fn);
+		}
+		return instance;
+	};
+	return {
+		get,
+		set(fn, instance) {
+			instances.set(fn, instance);
+		},
+		deps: (obj) => {
+			const res = {};
+			for (const key in obj) {
+				const fn = obj[key];
+				try {
+					res[key] = get(fn);
+				} catch (e) {
+					if (!(e instanceof dimplCircularDepError)) throw e;
+					Object.defineProperty(res, key, {
+						configurable: true,
+						enumerable: true,
+						get() {
+							throw new Error(`Cannot access property ${key} yet due to a circular dependency`);
+						}
+					});
+					let delayedDependents = delayedDeps.get(fn);
+					if (!delayedDependents) {
+						delayedDependents = /* @__PURE__ */ new Map();
+						delayedDeps.set(fn, delayedDependents);
+					}
+					let keys = delayedDependents.get(res);
+					if (!keys) {
+						keys = [];
+						delayedDependents.set(res, keys);
+					}
+					keys.push(key);
+				}
+			}
+			return res;
+		},
+		wire: (...args) => {
+			for (const fn of args) get(fn);
+		}
+	};
+};
+export { dimpl, dimplCircularDepError };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export class dimplCircularDepError extends Error {\n  constructor(\n    message: string,\n    public functionName: string,\n  ) {\n    super(message);\n  }\n}\n\ninterface Fn<T> {\n  (...args: any[]): T;\n}\n\ninterface Class<T> {\n  new (...args: any[]): T;\n}\n\ntype Constructor<T> = Fn<T> | Class<T>;\ntype Instance<T> = T extends new (...args: any[]) => infer R\n  ? R\n  : T extends (...args: any[]) => infer R\n    ? R\n    : never;\n\nexport const dimpl = () => {\n  const instances = new Map<unknown, unknown>();\n  const delayedDeps = new Map<unknown, Map<{ [K: string]: unknown }, string[]>>();\n  const pending = new Set<Constructor<unknown>>();\n\n  const isClass = (fn: Constructor<unknown>): fn is Class<unknown> => {\n    return Object.getOwnPropertyDescriptor(fn, \"prototype\")?.writable === false;\n  };\n\n  const get = <T>(fn: Constructor<T>): T => {\n    let instance = instances.get(fn);\n    if (!instance) {\n      if (pending.has(fn)) {\n        throw new dimplCircularDepError(\"Cannot resolve a circular dependency\", fn.name);\n      }\n      pending.add(fn);\n\n      instance = isClass(fn) ? new fn() : fn();\n      instances.set(fn, instance);\n\n      const delayedDependents = delayedDeps.get(fn);\n      if (delayedDependents) {\n        for (const [deps, keys] of delayedDependents.entries()) {\n          for (const key of keys) {\n            Object.defineProperty(deps, key, {\n              configurable: true,\n              enumerable: true,\n              value: instance,\n            });\n          }\n        }\n      }\n\n      pending.delete(fn);\n    }\n\n    return instance as never;\n  };\n\n  return {\n    get,\n\n    set<T>(fn: Constructor<T>, instance: T): void {\n      instances.set(fn, instance);\n    },\n\n    deps: <T extends { [K: string]: Constructor<unknown> }>(\n      obj: T,\n    ): {\n      [K in keyof T]: Instance<T[K]>;\n    } => {\n      const res: { [K: string]: unknown } = {};\n\n      for (const key in obj) {\n        const fn = obj[key];\n\n        try {\n          res[key] = get(fn);\n        } catch (e) {\n          if (!(e instanceof dimplCircularDepError)) {\n            throw e;\n          }\n\n          Object.defineProperty(res, key, {\n            configurable: true,\n            enumerable: true,\n            get() {\n              throw new Error(`Cannot access property ${key} yet due to a circular dependency`);\n            },\n          });\n\n          let delayedDependents = delayedDeps.get(fn);\n          if (!delayedDependents) {\n            delayedDependents = new Map();\n            delayedDeps.set(fn, delayedDependents);\n          }\n\n          let keys = delayedDependents.get(res);\n          if (!keys) {\n            keys = [];\n            delayedDependents.set(res, keys);\n          }\n\n          keys.push(key);\n        }\n      }\n\n      return res as never;\n    },\n\n    wire: (...args: Constructor<unknown>[]): void => {\n      for (const fn of args) {\n        get(fn);\n      }\n    },\n  };\n};\n"],"mappings":"AAAA,IAAa,wBAAb,cAA2C,MAAM;CAGtC;CAFT,YACE,SACA,cACA;EACA,MAAM,OAAO;EAFN,KAAA,eAAA;CAGT;AACF;AAiBA,MAAa,cAAc;CACzB,MAAM,4BAAY,IAAI,IAAsB;CAC5C,MAAM,8BAAc,IAAI,IAAsD;CAC9E,MAAM,0BAAU,IAAI,IAA0B;CAE9C,MAAM,WAAW,OAAmD;EAClE,OAAO,OAAO,yBAAyB,IAAI,WAAW,CAAC,EAAE,aAAa;CACxE;CAEA,MAAM,OAAU,OAA0B;EACxC,IAAI,WAAW,UAAU,IAAI,EAAE;EAC/B,IAAI,CAAC,UAAU;GACb,IAAI,QAAQ,IAAI,EAAE,GAChB,MAAM,IAAI,sBAAsB,wCAAwC,GAAG,IAAI;GAEjF,QAAQ,IAAI,EAAE;GAEd,WAAW,QAAQ,EAAE,IAAI,IAAI,GAAG,IAAI,GAAG;GACvC,UAAU,IAAI,IAAI,QAAQ;GAE1B,MAAM,oBAAoB,YAAY,IAAI,EAAE;GAC5C,IAAI,mBACF,KAAK,MAAM,CAAC,MAAM,SAAS,kBAAkB,QAAQ,GACnD,KAAK,MAAM,OAAO,MAChB,OAAO,eAAe,MAAM,KAAK;IAC/B,cAAc;IACd,YAAY;IACZ,OAAO;GACT,CAAC;GAKP,QAAQ,OAAO,EAAE;EACnB;EAEA,OAAO;CACT;CAEA,OAAO;EACL;EAEA,IAAO,IAAoB,UAAmB;GAC5C,UAAU,IAAI,IAAI,QAAQ;EAC5B;EAEA,OACE,QAGG;GACH,MAAM,MAAgC,CAAC;GAEvC,KAAK,MAAM,OAAO,KAAK;IACrB,MAAM,KAAK,IAAI;IAEf,IAAI;KACF,IAAI,OAAO,IAAI,EAAE;IACnB,SAAS,GAAG;KACV,IAAI,EAAE,aAAa,wBACjB,MAAM;KAGR,OAAO,eAAe,KAAK,KAAK;MAC9B,cAAc;MACd,YAAY;MACZ,MAAM;OACJ,MAAM,IAAI,MAAM,0BAA0B,IAAI,kCAAkC;MAClF;KACF,CAAC;KAED,IAAI,oBAAoB,YAAY,IAAI,EAAE;KAC1C,IAAI,CAAC,mBAAmB;MACtB,oCAAoB,IAAI,IAAI;MAC5B,YAAY,IAAI,IAAI,iBAAiB;KACvC;KAEA,IAAI,OAAO,kBAAkB,IAAI,GAAG;KACpC,IAAI,CAAC,MAAM;MACT,OAAO,CAAC;MACR,kBAAkB,IAAI,KAAK,IAAI;KACjC;KAEA,KAAK,KAAK,GAAG;IACf;GACF;GAEA,OAAO;EACT;EAEA,OAAO,GAAG,SAAuC;GAC/C,KAAK,MAAM,MAAM,MACf,IAAI,EAAE;EAEV;CACF;AACF"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@romikus/dimpl",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Simple dependency-injection library",
+  "keywords": [
+    "di",
+    "dependency injection"
+  ],
+  "license": "ISC",
+  "author": "Roman Kushyn",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/romeerez/dimpl.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "default": "./dist/index.js",
+        "types": "./dist/index.d.ts"
+      },
+      "import": {
+        "default": "./dist/index.mjs",
+        "types": "./dist/index.d.ts"
+      }
+    }
+  },
+  "devDependencies": {
+    "oxfmt": "0.53.0",
+    "oxlint": "1.68.0",
+    "rimraf": "^6.1.3",
+    "rolldown": "^1.1.0",
+    "rolldown-plugin-dts": "^0.25.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "lint": "oxlint --ignore-path=.gitignore .",
+    "fmt": "oxfmt --write --ignore-path=.gitignore .",
+    "fmt:check": "oxfmt --check --ignore-path=.gitignore .",
+    "build": "rimraf ./dist/ && rolldown -c ./rolldown.config.mjs",
+    "prepublish": "pnpm build"
+  }
+}