@orieljs/container 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 meeeet-dev
+
+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/dist/index.d.ts

@@ -0,0 +1,63 @@
+import { Container as Container$1, Factory, Abstract, Concrete, OrielError } from '@orieljs/contracts';
+
+type Key = unknown;
+type Lifetime = 'transient' | 'singleton' | 'scoped';
+interface Binding {
+    lifetime: Lifetime;
+    factory: Factory<unknown>;
+}
+type Extender = (instance: unknown, c: Container$1) => unknown;
+type Callback = (instance: unknown, c: Container$1) => void;
+interface SharedState {
+    bindings: Map<Key, Binding>;
+    extenders: Map<Key, Extender[]>;
+    resolving: Map<Key, Callback[]>;
+    resolved: Set<Key>;
+}
+declare class Container implements Container$1 {
+    #private;
+    static getInstance(): Container | undefined;
+    static setInstance(container: Container | undefined): void;
+    protected readonly shared: SharedState;
+    protected readonly root: Container;
+    protected readonly parent: Container | undefined;
+    protected readonly local: Map<unknown, unknown>;
+    constructor(parent?: Container);
+    bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    instance<T>(abstract: Abstract<T>, instance: T): T;
+    make<T>(abstract: Abstract<T>): T;
+    bound(abstract: Abstract<unknown>): boolean;
+    resolved(abstract: Abstract<unknown>): boolean;
+    extend<T>(abstract: Abstract<T>, extender: (instance: T, container: Container$1) => T): void;
+    resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: Container$1) => void): void;
+    forgetInstance(abstract: Abstract<unknown>): void;
+    /** Scopes are always plain Containers (never subclasses such as Application). */
+    createScope(): Container;
+    run<R>(fn: () => R): R;
+    protected build(abstract: Abstract<unknown>, key: Key, binding: Binding): unknown;
+}
+
+declare class BindingResolutionError extends Error implements OrielError {
+    readonly kind: "BindingResolution";
+    readonly name = "BindingResolutionError";
+}
+declare class CircularDependencyError extends Error implements OrielError {
+    readonly chain: string[];
+    readonly kind: "CircularDependency";
+    readonly name = "CircularDependencyError";
+    constructor(chain: string[]);
+}
+declare class ContainerNotAvailableError extends Error implements OrielError {
+    readonly kind: "ContainerNotAvailable";
+    readonly name = "ContainerNotAvailableError";
+    constructor(what: string);
+}
+
+declare function describe(abstract: Abstract<unknown>): string;
+
+declare function currentContainer(): Container$1 | undefined;
+declare function inject<T>(abstract: Abstract<T>): T;
+
+export { BindingResolutionError, CircularDependencyError, Container, ContainerNotAvailableError, currentContainer, describe, inject };

package/dist/index.js

@@ -0,0 +1,211 @@
+// Container.ts
+import { Container as ContainerToken } from "@orieljs/contracts";
+
+// context.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// describe.ts
+function describe(abstract) {
+  return typeof abstract === "function" ? abstract.name || "<anonymous class>" : abstract.description;
+}
+
+// errors.ts
+var BindingResolutionError = class extends Error {
+  kind = "BindingResolution";
+  name = "BindingResolutionError";
+};
+var CircularDependencyError = class extends Error {
+  constructor(chain) {
+    super(`Circular dependency detected: ${chain.join(" -> ")}`);
+    this.chain = chain;
+  }
+  chain;
+  kind = "CircularDependency";
+  name = "CircularDependencyError";
+};
+var ContainerNotAvailableError = class extends Error {
+  kind = "ContainerNotAvailable";
+  name = "ContainerNotAvailableError";
+  constructor(what) {
+    super(
+      `Cannot resolve [${what}]: no container is available. inject(), helpers and facades only work while the application is running (inside a request, job, command, provider or app.run()). Don't call them at module top level.`
+    );
+  }
+};
+
+// context.ts
+var ALS_KEY = /* @__PURE__ */ Symbol.for("oriel:container.als");
+var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("oriel:container.instance");
+var BUILDING_KEY = /* @__PURE__ */ Symbol.for("oriel:container.building");
+var g = globalThis;
+var storage = g[ALS_KEY] ??= new AsyncLocalStorage();
+var building = g[BUILDING_KEY] ??= {
+  keys: [],
+  names: [],
+  containers: []
+};
+function currentContainer() {
+  return building.containers.at(-1) ?? storage.getStore() ?? g[GLOBAL_KEY];
+}
+function inject(abstract) {
+  const container = currentContainer();
+  if (!container) throw new ContainerNotAvailableError(describe(abstract));
+  return container.make(abstract);
+}
+
+// Container.ts
+var globals = globalThis;
+var keyOf = (abstract) => typeof abstract === "function" ? abstract : abstract.id;
+var isClass = (fn) => typeof fn === "function" && /^class[\s{]/.test(Function.prototype.toString.call(fn));
+var Container = class _Container {
+  static getInstance() {
+    return globals[GLOBAL_KEY];
+  }
+  static setInstance(container) {
+    globals[GLOBAL_KEY] = container;
+  }
+  shared;
+  root;
+  parent;
+  local = /* @__PURE__ */ new Map();
+  constructor(parent) {
+    this.parent = parent;
+    this.root = parent?.root ?? this;
+    this.shared = parent?.shared ?? { bindings: /* @__PURE__ */ new Map(), extenders: /* @__PURE__ */ new Map(), resolving: /* @__PURE__ */ new Map(), resolved: /* @__PURE__ */ new Set() };
+    this.local.set(keyOf(ContainerToken), this);
+    this.local.set(_Container, this);
+  }
+  bind(abstract, concrete) {
+    this.#assertRoot("bind");
+    this.#addBinding(abstract, concrete, "transient");
+  }
+  singleton(abstract, concrete) {
+    this.#assertRoot("singleton");
+    this.#addBinding(abstract, concrete, "singleton");
+  }
+  scoped(abstract, concrete) {
+    this.#assertRoot("scoped");
+    this.#addBinding(abstract, concrete, "scoped");
+  }
+  instance(abstract, instance) {
+    const key = keyOf(abstract);
+    this.local.set(key, instance);
+    if (this === this.root) this.shared.resolved.add(key);
+    return instance;
+  }
+  make(abstract) {
+    const key = keyOf(abstract);
+    const owner = this.#owning(key);
+    if (owner) return owner.local.get(key);
+    const binding = this.shared.bindings.get(key) ?? this.#implicitBinding(abstract);
+    if (binding.lifetime === "scoped" && this === this.root) {
+      throw new BindingResolutionError(
+        `Scoped binding [${describe(abstract)}] was resolved outside a scope. Resolve it inside app.createScope().run(...), and don't inject scoped services into singletons.`
+      );
+    }
+    const builder = binding.lifetime === "singleton" ? this.root : this;
+    const instance = builder.build(abstract, key, binding);
+    if (binding.lifetime === "singleton") this.root.local.set(key, instance);
+    if (binding.lifetime === "scoped") this.local.set(key, instance);
+    return instance;
+  }
+  bound(abstract) {
+    const key = keyOf(abstract);
+    return this.shared.bindings.has(key) || this.#owning(key) !== void 0;
+  }
+  resolved(abstract) {
+    const key = keyOf(abstract);
+    return this.shared.resolved.has(key) || this.#owning(key) !== void 0;
+  }
+  extend(abstract, extender) {
+    this.#assertRoot("extend");
+    const key = keyOf(abstract);
+    const list = this.shared.extenders.get(key) ?? [];
+    list.push(extender);
+    this.shared.extenders.set(key, list);
+    if (this.local.has(key)) this.local.set(key, extender(this.local.get(key), this));
+  }
+  resolving(abstract, callback) {
+    this.#assertRoot("resolving");
+    const key = keyOf(abstract);
+    const list = this.shared.resolving.get(key) ?? [];
+    list.push(callback);
+    this.shared.resolving.set(key, list);
+  }
+  forgetInstance(abstract) {
+    this.local.delete(keyOf(abstract));
+  }
+  /** Scopes are always plain Containers (never subclasses such as Application). */
+  createScope() {
+    return new _Container(this);
+  }
+  run(fn) {
+    return storage.run(this, fn);
+  }
+  /** The nearest container in this -> parent scopes -> root that holds an instance for the key. */
+  #owning(key) {
+    if (this.local.has(key)) return this;
+    return this.parent === void 0 ? void 0 : this.parent.#owning(key);
+  }
+  /** Bindings, extenders and callbacks are app-wide state: a request scope must never write them. */
+  #assertRoot(method) {
+    if (this !== this.root) {
+      throw new Error(
+        `Cannot register bindings on a request scope (${method}). Register them on the application in a service provider; use instance() for per-request values.`
+      );
+    }
+  }
+  #addBinding(abstract, concrete, lifetime) {
+    const key = keyOf(abstract);
+    let factory;
+    if (concrete === void 0) {
+      if (typeof abstract !== "function") throw new TypeError(`bind(${describe(abstract)}) needs a concrete: tokens can't be constructed`);
+      factory = () => new abstract();
+    } else if (isClass(concrete)) {
+      factory = () => new concrete();
+    } else {
+      factory = concrete;
+    }
+    this.shared.bindings.set(key, { lifetime, factory });
+    this.local.delete(key);
+  }
+  #implicitBinding(abstract) {
+    if (typeof abstract === "function") {
+      return { lifetime: "transient", factory: () => new abstract() };
+    }
+    throw new BindingResolutionError(
+      `Target [${abstract.description}] is not bound. Is its service provider registered in bootstrap/providers.ts?`
+    );
+  }
+  build(abstract, key, binding) {
+    const stackIndex = building.keys.indexOf(key);
+    if (stackIndex !== -1) {
+      const chain = [...building.names.slice(stackIndex), describe(abstract)];
+      throw new CircularDependencyError(chain);
+    }
+    building.keys.push(key);
+    building.names.push(describe(abstract));
+    building.containers.push(this);
+    try {
+      let instance = binding.factory(this);
+      for (const extender of this.shared.extenders.get(key) ?? []) instance = extender(instance, this);
+      for (const callback of this.shared.resolving.get(key) ?? []) callback(instance, this);
+      this.shared.resolved.add(key);
+      return instance;
+    } finally {
+      building.keys.pop();
+      building.names.pop();
+      building.containers.pop();
+    }
+  }
+};
+export {
+  BindingResolutionError,
+  CircularDependencyError,
+  Container,
+  ContainerNotAvailableError,
+  currentContainer,
+  describe,
+  inject
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../Container.ts","../context.ts","../describe.ts","../errors.ts"],"sourcesContent":["import { Container as ContainerToken, type Abstract, type Concrete, type Container as ContainerContract, type Factory } from '@orieljs/contracts'\nimport { building, GLOBAL_KEY, storage } from './context'\nimport { describe } from './describe'\nimport { BindingResolutionError, CircularDependencyError } from './errors'\n\ntype Key = unknown\ntype Lifetime = 'transient' | 'singleton' | 'scoped'\ninterface Binding { lifetime: Lifetime; factory: Factory<unknown> }\ntype Extender = (instance: unknown, c: ContainerContract) => unknown\ntype Callback = (instance: unknown, c: ContainerContract) => void\n\ninterface SharedState {\n  bindings: Map<Key, Binding>\n  extenders: Map<Key, Extender[]>\n  resolving: Map<Key, Callback[]>\n  resolved: Set<Key>\n}\n\nconst globals = globalThis as unknown as Record<symbol, Container | undefined>\n\nconst keyOf = (abstract: Abstract<unknown>): Key => (typeof abstract === 'function' ? abstract : abstract.id)\nconst isClass = (fn: unknown): fn is new () => unknown =>\n  typeof fn === 'function' && /^class[\\s{]/.test(Function.prototype.toString.call(fn))\n\nexport class Container implements ContainerContract {\n  static getInstance(): Container | undefined {\n    return globals[GLOBAL_KEY]\n  }\n  static setInstance(container: Container | undefined): void {\n    globals[GLOBAL_KEY] = container\n  }\n\n  protected readonly shared: SharedState\n  protected readonly root: Container\n  protected readonly parent: Container | undefined\n  protected readonly local = new Map<Key, unknown>()\n\n  constructor(parent?: Container) {\n    this.parent = parent\n    this.root = parent?.root ?? this\n    this.shared = parent?.shared ?? { bindings: new Map(), extenders: new Map(), resolving: new Map(), resolved: new Set() }\n    // Every container (root or scope) resolves \"the container\" as itself, by token and by class.\n    this.local.set(keyOf(ContainerToken), this)\n    this.local.set(Container, this)\n  }\n\n  bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void {\n    this.#assertRoot('bind')\n    this.#addBinding(abstract, concrete, 'transient')\n  }\n  singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void {\n    this.#assertRoot('singleton')\n    this.#addBinding(abstract, concrete, 'singleton')\n  }\n  scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void {\n    this.#assertRoot('scoped')\n    this.#addBinding(abstract, concrete, 'scoped')\n  }\n\n  instance<T>(abstract: Abstract<T>, instance: T): T {\n    const key = keyOf(abstract)\n    this.local.set(key, instance)\n    // A scope's instances are its own business: only the root records them in the shared resolved set.\n    if (this === this.root) this.shared.resolved.add(key)\n    return instance\n  }\n\n  make<T>(abstract: Abstract<T>): T {\n    const key = keyOf(abstract)\n    const owner = this.#owning(key)\n    if (owner) return owner.local.get(key) as T\n\n    const binding = this.shared.bindings.get(key) ?? this.#implicitBinding(abstract)\n    if (binding.lifetime === 'scoped' && this === this.root) {\n      throw new BindingResolutionError(\n        `Scoped binding [${describe(abstract)}] was resolved outside a scope. Resolve it inside app.createScope().run(...), and don't inject scoped services into singletons.`,\n      )\n    }\n    const builder = binding.lifetime === 'singleton' ? this.root : this\n    const instance = builder.build(abstract, key, binding)\n\n    if (binding.lifetime === 'singleton') this.root.local.set(key, instance)\n    if (binding.lifetime === 'scoped') this.local.set(key, instance)\n    return instance as T\n  }\n\n  bound(abstract: Abstract<unknown>): boolean {\n    const key = keyOf(abstract)\n    return this.shared.bindings.has(key) || this.#owning(key) !== undefined\n  }\n\n  resolved(abstract: Abstract<unknown>): boolean {\n    const key = keyOf(abstract)\n    return this.shared.resolved.has(key) || this.#owning(key) !== undefined\n  }\n\n  extend<T>(abstract: Abstract<T>, extender: (instance: T, container: ContainerContract) => T): void {\n    this.#assertRoot('extend')\n    const key = keyOf(abstract)\n    const list = this.shared.extenders.get(key) ?? []\n    list.push(extender as Extender)\n    this.shared.extenders.set(key, list)\n    if (this.local.has(key)) this.local.set(key, extender(this.local.get(key) as T, this))\n  }\n\n  resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: ContainerContract) => void): void {\n    this.#assertRoot('resolving')\n    const key = keyOf(abstract)\n    const list = this.shared.resolving.get(key) ?? []\n    list.push(callback as Callback)\n    this.shared.resolving.set(key, list)\n  }\n\n  forgetInstance(abstract: Abstract<unknown>): void {\n    this.local.delete(keyOf(abstract))\n  }\n\n  /** Scopes are always plain Containers (never subclasses such as Application). */\n  createScope(): Container {\n    return new Container(this)\n  }\n\n  run<R>(fn: () => R): R {\n    return storage.run(this, fn)\n  }\n\n  /** The nearest container in this -> parent scopes -> root that holds an instance for the key. */\n  #owning(key: Key): Container | undefined {\n    if (this.local.has(key)) return this\n    return this.parent === undefined ? undefined : this.parent.#owning(key)\n  }\n\n  /** Bindings, extenders and callbacks are app-wide state: a request scope must never write them. */\n  #assertRoot(method: string): void {\n    if (this !== this.root) {\n      throw new Error(\n        `Cannot register bindings on a request scope (${method}). Register them on the application in a service provider; use instance() for per-request values.`,\n      )\n    }\n  }\n\n  #addBinding(abstract: Abstract<unknown>, concrete: Concrete<unknown> | undefined, lifetime: Lifetime): void {\n    const key = keyOf(abstract)\n    let factory: Factory<unknown>\n    if (concrete === undefined) {\n      if (typeof abstract !== 'function') throw new TypeError(`bind(${describe(abstract)}) needs a concrete: tokens can't be constructed`)\n      factory = () => new (abstract as new () => unknown)()\n    } else if (isClass(concrete)) {\n      factory = () => new concrete()\n    } else {\n      factory = concrete as Factory<unknown>\n    }\n    this.shared.bindings.set(key, { lifetime, factory })\n    this.local.delete(key)\n  }\n\n  #implicitBinding(abstract: Abstract<unknown>): Binding {\n    if (typeof abstract === 'function') {\n      return { lifetime: 'transient', factory: () => new (abstract as new () => unknown)() }\n    }\n    throw new BindingResolutionError(\n      `Target [${abstract.description}] is not bound. Is its service provider registered in bootstrap/providers.ts?`,\n    )\n  }\n\n  protected build(abstract: Abstract<unknown>, key: Key, binding: Binding): unknown {\n    const stackIndex = building.keys.indexOf(key)\n    if (stackIndex !== -1) {\n      const chain = [...building.names.slice(stackIndex), describe(abstract)]\n      throw new CircularDependencyError(chain)\n    }\n    building.keys.push(key)\n    building.names.push(describe(abstract))\n    building.containers.push(this)\n    try {\n      let instance = binding.factory(this)\n      for (const extender of this.shared.extenders.get(key) ?? []) instance = extender(instance, this)\n      for (const callback of this.shared.resolving.get(key) ?? []) callback(instance, this)\n      this.shared.resolved.add(key)\n      return instance\n    } finally {\n      building.keys.pop()\n      building.names.pop()\n      building.containers.pop()\n    }\n  }\n}\n","import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { Abstract, Container } from '@orieljs/contracts'\nimport { describe } from './describe'\nimport { ContainerNotAvailableError } from './errors'\n\nconst ALS_KEY = Symbol.for('oriel:container.als')\nexport const GLOBAL_KEY = Symbol.for('oriel:container.instance')\nconst BUILDING_KEY = Symbol.for('oriel:container.building')\nconst g = globalThis as unknown as Record<symbol, unknown>\n\n/** One AsyncLocalStorage per process, even if @orieljs/container is installed twice. */\nexport const storage: AsyncLocalStorage<Container> = (g[ALS_KEY] ??= new AsyncLocalStorage<Container>()) as AsyncLocalStorage<Container>\n\n/** Synchronous build stack. Shared through globalThis so duplicate package copies share the same stack. */\nexport const building = (g[BUILDING_KEY] ??= {\n  keys: [] as unknown[],\n  names: [] as string[],\n  containers: [] as Container[],\n}) as { keys: unknown[]; names: string[]; containers: Container[] }\n\nexport function currentContainer(): Container | undefined {\n  return building.containers.at(-1) ?? storage.getStore() ?? (g[GLOBAL_KEY] as Container | undefined)\n}\n\nexport function inject<T>(abstract: Abstract<T>): T {\n  const container = currentContainer()\n  if (!container) throw new ContainerNotAvailableError(describe(abstract))\n  return container.make(abstract)\n}\n","import type { Abstract } from '@orieljs/contracts'\n\nexport function describe(abstract: Abstract<unknown>): string {\n  return typeof abstract === 'function' ? abstract.name || '<anonymous class>' : abstract.description\n}\n","import type { OrielError } from '@orieljs/contracts'\n\nexport class BindingResolutionError extends Error implements OrielError {\n  readonly kind = 'BindingResolution' as const\n  override readonly name = 'BindingResolutionError'\n}\n\nexport class CircularDependencyError extends Error implements OrielError {\n  readonly kind = 'CircularDependency' as const\n  override readonly name = 'CircularDependencyError'\n  constructor(readonly chain: string[]) {\n    super(`Circular dependency detected: ${chain.join(' -> ')}`)\n  }\n}\n\nexport class ContainerNotAvailableError extends Error implements OrielError {\n  readonly kind = 'ContainerNotAvailable' as const\n  override readonly name = 'ContainerNotAvailableError'\n  constructor(what: string) {\n    super(\n      `Cannot resolve [${what}]: no container is available. inject(), helpers and facades only work while the ` +\n        `application is running (inside a request, job, command, provider or app.run()). ` +\n        `Don't call them at module top level.`,\n    )\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@orieljs/container",
+  "version": "0.1.0-alpha.0",
+  "description": "The Oriel IoC container: bindings, request scopes and inject().",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orieljs/framework.git",
+    "directory": "src/Oriel/Container"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@orieljs/contracts": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "build": "tsup"
+  }
+}