@streetjs/container 1.0.0

package/ARCHITECTURE.md

@@ -0,0 +1,78 @@
+# Architecture — @streetjs/container
+
+## Purpose
+
+`@streetjs/container` is the StreetJS inversion-of-control core: a small,
+dependency-injection container that other framework layers (controllers,
+services, repositories, CLI kernels) use to wire their dependency graphs. It has
+a single runtime dependency, `reflect-metadata`, and no coupling to HTTP,
+databases, or any other subsystem.
+
+## Design
+
+### A single process-wide singleton
+
+`Container` has a private constructor and a static `instance`. Consumers reach
+it via `Container.getInstance()` or the exported `container` binding. A single
+registry means a resolved dependency is shared everywhere it is injected — the
+framework's services are effectively singletons by default.
+
+Internally the container keeps two maps/sets:
+
+- `singletons: Map<Constructor, object>` — resolved (or pre-registered) instances.
+- `resolving: Set<Constructor>` — the tokens currently on the resolution stack,
+  used for cycle detection.
+
+### Resolution algorithm
+
+`resolve(token)`:
+
+1. Return the cached singleton if present.
+2. If `token` is already in `resolving`, throw a **circular dependency** error
+   annotated with the full resolution chain.
+3. Add `token` to `resolving`, then read its constructor parameter types from
+   the `design:paramtypes` metadata that `emitDecoratorMetadata` emits.
+4. Recursively `resolve` each parameter:
+   - A missing type or `Object` (interfaces, primitives, undecorated unions
+     erase to these) is unresolvable — throw a descriptive error naming the
+     chain and pointing at `emitDecoratorMetadata`/`@Injectable`.
+   - If a nested resolution throws, wrap the message with the chain — unless it
+     is already chain-annotated, in which case it is rethrown unchanged to avoid
+     double-wrapping.
+5. Construct the instance, cache it, and remove `token` from `resolving` in a
+   `finally` so a failed resolution never leaves stale state.
+
+### `@Injectable()`
+
+The decorator writes a marker symbol via `Reflect.defineMetadata`. Its more
+important side effect is enabling TypeScript to emit `design:paramtypes` for the
+class — the metadata the resolver depends on.
+
+### The `Constructor` type
+
+`Constructor<T> = new (...args: any[]) => T` is the token type used throughout.
+It lives here and is re-exported by the `streetjs` framework's `core/types.ts`,
+keeping a single definition (dependency inversion, matching how `IpcMessage` and
+`TelemetrySample` are sourced from their own packages).
+
+## Relationship to core
+
+The framework's `src/core/container.ts` re-exports this package verbatim, and
+`src/core/types.ts` re-exports `Constructor` from it. Core's
+`prebuild`/`prebuild:app` hooks compile this package before core, and the
+Dockerfile builds it and dereferences the workspace symlink into the runtime
+image.
+
+## Testing
+
+The suite runs with no external services: singleton identity, constructor
+injection with shared sub-dependencies, cycle detection (via explicit
+`design:paramtypes` metadata to avoid forward-reference temporal-dead-zones),
+unresolvable-interface errors, failed-construction wrapping, and `reset`
+semantics. Branch coverage is ≥96%.
+
+## Non-goals
+
+- No scopes/lifetimes beyond the process singleton (no request/transient scopes).
+- No property or method injection — constructor injection only.
+- No async factories or conditional bindings.

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to `@streetjs/container` are documented here.
+
+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).
+
+## [1.0.0]
+
+### Added
+
+- Initial standalone release of the StreetJS dependency injection container,
+  extracted verbatim from the `streetjs` core (`src/core/container.ts`).
+- `Container` singleton with `resolve`, `register`, `has`, and `reset`, plus the
+  exported `container` instance and `Container.getInstance()`.
+- Constructor-injection resolution driven by `design:paramtypes` metadata, with
+  singleton caching across the dependency graph.
+- Circular-dependency detection reporting the full resolution chain.
+- Descriptive errors for unresolvable (interface/primitive/undecorated)
+  dependencies, with chain-aware wrapping that avoids double annotation.
+- `@Injectable()` class decorator.
+- `Constructor<T>` type utility (also re-exported by the framework core).
+- `reflect-metadata` as the sole runtime dependency; ESM.
+- ≥96% branch coverage and a runnable integration example.
+
+[1.0.0]: https://github.com/hassanmubiru/StreetJS/releases/tag/container-v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 street contributors
+
+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,93 @@
+# @streetjs/container
+
+The StreetJS dependency injection container: a process-wide singleton IoC
+registry that resolves constructor-injected dependency trees, detects circular
+dependencies, and exposes an `@Injectable()` class decorator. ESM,
+strict-TypeScript, backed by `reflect-metadata`.
+
+This is the standalone home of the container that also backs the `streetjs`
+framework. The framework re-exports this package, so there is a single source of
+truth.
+
+## Install
+
+```bash
+npm install @streetjs/container reflect-metadata
+```
+
+Import `reflect-metadata` **once** at your application entry point, and enable
+decorator metadata in your `tsconfig.json`:
+
+```jsonc
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}
+```
+
+## Usage
+
+```ts
+import 'reflect-metadata';
+import { Injectable, container } from '@streetjs/container';
+
+@Injectable()
+class Database {
+  query(sql: string) { /* ... */ }
+}
+
+@Injectable()
+class UserService {
+  constructor(private readonly db: Database) {}
+}
+
+// Database is constructed once and injected as a singleton.
+const users = container.resolve(UserService);
+```
+
+## API
+
+### `@Injectable()`
+
+Class decorator that marks a class as participating in DI. Applying it also
+triggers TypeScript's `design:paramtypes` metadata emission, which the container
+reads to discover constructor dependencies.
+
+### `container` / `Container`
+
+A single shared `Container` instance is exported as `container`
+(`Container.getInstance()` returns the same singleton).
+
+| Method | Description |
+| ------ | ----------- |
+| `resolve(token)` | Return the singleton for `token`, constructing it and its dependency tree on first use. |
+| `register(token, instance)` | Register a pre-built instance so `resolve(token)` returns it. |
+| `has(token)` | `true` if the token has been resolved or registered. |
+| `reset()` | Clear all instances — primarily for tests. |
+
+### Circular-dependency detection
+
+If resolution re-enters a token already on the resolution stack, `resolve`
+throws with the full chain (`A -> B -> A`) instead of overflowing the stack.
+
+### Unresolvable dependencies
+
+A constructor parameter typed as an interface, a primitive, or an
+un-`@Injectable` value erases to `Object`/undefined in emitted metadata. The
+container throws a clear error naming the resolution chain and suggesting you
+enable `emitDecoratorMetadata` and decorate the dependency.
+
+## Example
+
+A complete runnable example lives in
+[`src/examples/integration.ts`](./src/examples/integration.ts):
+
+```bash
+npm run example -w packages/container
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/container.d.ts

@@ -0,0 +1,23 @@
+import 'reflect-metadata';
+import type { Constructor } from './types.js';
+/** Mark a class as injectable and register its dependencies */
+export declare function Injectable(): ClassDecorator;
+/** Container manages singleton instances and resolves dependency trees */
+export declare class Container {
+    private static readonly instance;
+    private readonly singletons;
+    private readonly resolving;
+    private constructor();
+    static getInstance(): Container;
+    /** Register a pre-built instance */
+    register<T extends object>(token: Constructor<T>, instance: T): void;
+    /** Resolve a class, creating it if not already instantiated */
+    resolve<T extends object>(token: Constructor<T>): T;
+    /** Remove all registered instances (useful in tests) */
+    reset(): void;
+    /** Check if a token has been resolved or registered */
+    has(token: Constructor): boolean;
+}
+/** Global container singleton */
+export declare const container: Container;
+//# sourceMappingURL=container.d.ts.map

package/dist/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"AAGA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI9C,+DAA+D;AAC/D,wBAAgB,UAAU,IAAI,cAAc,CAI3C;AAED,0EAA0E;AAC1E,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAEnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IAEpD,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,SAAS;IAI/B,oCAAoC;IACpC,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;IAIpE,+DAA+D;IAC/D,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;IAkDnD,wDAAwD;IACxD,KAAK,IAAI,IAAI;IAKb,uDAAuD;IACvD,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;CAGjC;AAED,iCAAiC;AACjC,eAAO,MAAM,SAAS,WAA0B,CAAC"}

package/dist/container.js

@@ -0,0 +1,78 @@
+// src/container.ts
+// Dependency injection container with singleton registry and circular dep detection.
+import 'reflect-metadata';
+const INJECTABLE_META = Symbol('street:injectable');
+/** Mark a class as injectable and register its dependencies */
+export function Injectable() {
+    return (target) => {
+        Reflect.defineMetadata(INJECTABLE_META, true, target);
+    };
+}
+/** Container manages singleton instances and resolves dependency trees */
+export class Container {
+    static instance = new Container();
+    singletons = new Map();
+    resolving = new Set();
+    constructor() { }
+    static getInstance() {
+        return Container.instance;
+    }
+    /** Register a pre-built instance */
+    register(token, instance) {
+        this.singletons.set(token, instance);
+    }
+    /** Resolve a class, creating it if not already instantiated */
+    resolve(token) {
+        const existing = this.singletons.get(token);
+        if (existing) {
+            return existing;
+        }
+        if (this.resolving.has(token)) {
+            throw new Error(`Circular dependency detected while resolving: ${token.name}. ` +
+                `Resolution chain: ${[...this.resolving].map((c) => c.name).join(' -> ')} -> ${token.name}`);
+        }
+        this.resolving.add(token);
+        try {
+            const paramTypes = Reflect.getMetadata('design:paramtypes', token) ?? [];
+            const deps = paramTypes.map((dep) => {
+                if (!dep || dep === Object) {
+                    const chain = [...this.resolving].map((c) => c.name);
+                    chain.push(token.name);
+                    throw new Error(`Cannot resolve ${chain.join(' → ')}: got primitive or undefined type. ` +
+                        `Ensure emitDecoratorMetadata is enabled and the dependency is decorated with @Injectable.`);
+                }
+                try {
+                    return this.resolve(dep);
+                }
+                catch (inner) {
+                    const chain = [...this.resolving].map((c) => c.name);
+                    chain.push(dep.name);
+                    const reason = inner instanceof Error ? inner.message : String(inner);
+                    // Only wrap if the message doesn't already contain a chain annotation
+                    if (reason.includes(' → ') || reason.startsWith('Cannot resolve ')) {
+                        throw inner;
+                    }
+                    throw new Error(`Cannot resolve ${chain.join(' → ')}: ${reason}`);
+                }
+            });
+            const instance = new token(...deps);
+            this.singletons.set(token, instance);
+            return instance;
+        }
+        finally {
+            this.resolving.delete(token);
+        }
+    }
+    /** Remove all registered instances (useful in tests) */
+    reset() {
+        this.singletons.clear();
+        this.resolving.clear();
+    }
+    /** Check if a token has been resolved or registered */
+    has(token) {
+        return this.singletons.has(token);
+    }
+}
+/** Global container singleton */
+export const container = Container.getInstance();
+//# sourceMappingURL=container.js.map

package/dist/container.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.js","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @streetjs/container — the StreetJS dependency injection container.
+ *
+ * A process-wide singleton IoC registry that resolves constructor-injected
+ * dependency trees from `design:paramtypes` metadata, detects circular
+ * dependencies, and exposes an `@Injectable()` class decorator. Backed by
+ * `reflect-metadata`.
+ *
+ * ```ts
+ * import 'reflect-metadata';
+ * import { Injectable, container } from '@streetjs/container';
+ *
+ * @Injectable() class Db {}
+ * @Injectable() class UserService { constructor(readonly db: Db) {} }
+ *
+ * const svc = container.resolve(UserService); // db injected as a singleton
+ * ```
+ *
+ * > This is the standalone home of the container that also backs the `streetjs`
+ * > framework; the framework re-exports it, so there is a single implementation.
+ */
+export { Container, Injectable, container } from './container.js';
+export type { Constructor } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * @streetjs/container — the StreetJS dependency injection container.
+ *
+ * A process-wide singleton IoC registry that resolves constructor-injected
+ * dependency trees from `design:paramtypes` metadata, detects circular
+ * dependencies, and exposes an `@Injectable()` class decorator. Backed by
+ * `reflect-metadata`.
+ *
+ * ```ts
+ * import 'reflect-metadata';
+ * import { Injectable, container } from '@streetjs/container';
+ *
+ * @Injectable() class Db {}
+ * @Injectable() class UserService { constructor(readonly db: Db) {} }
+ *
+ * const svc = container.resolve(UserService); // db injected as a singleton
+ * ```
+ *
+ * > This is the standalone home of the container that also backs the `streetjs`
+ * > framework; the framework re-exports it, so there is a single implementation.
+ */
+export { Container, Injectable, container } from './container.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A newable class reference — the token type used throughout the container to
+ * register, resolve, and key singleton instances.
+ */
+export type Constructor<T = object> = new (...args: any[]) => T;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,4 @@
+// src/types.ts
+// Shared type utilities for the DI container.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,8CAA8C"}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@streetjs/container",
+  "version": "1.0.0",
+  "description": "StreetJS dependency injection container: a singleton IoC registry with constructor-injection resolution, circular-dependency detection, and an @Injectable decorator. Backed by reflect-metadata.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.d.ts.map",
+    "!dist/tests/**",
+    "!dist/examples/**",
+    "README.md",
+    "ARCHITECTURE.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "c8": {
+    "include": ["dist/**/*.js"],
+    "exclude": ["dist/tests/**", "dist/examples/**", "dist/types.js"],
+    "reporter": ["text", "lcov"],
+    "all": true,
+    "check-coverage": true,
+    "lines": 90,
+    "functions": 90,
+    "branches": 90,
+    "statements": 90
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test dist/tests/*.test.js",
+    "coverage": "c8 node --test dist/tests/*.test.js",
+    "example": "node dist/examples/integration.js",
+    "lint": "tsc --noEmit",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\""
+  },
+  "keywords": [
+    "streetjs",
+    "street-framework",
+    "dependency-injection",
+    "di",
+    "ioc",
+    "container",
+    "inversion-of-control",
+    "injectable",
+    "reflect-metadata",
+    "typescript",
+    "esm"
+  ],
+  "author": "street contributors",
+  "license": "MIT",
+  "homepage": "https://hassanmubiru.github.io/StreetJS/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hassanmubiru/StreetJS.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hassanmubiru/StreetJS/issues"
+  },
+  "dependencies": {
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "c8": "^11.0.0",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}