@decohere/crucible 0.0.1-dev.4 → 0.0.1-dev.40

package/es6/src/services/crucible.js

@@ -0,0 +1,155 @@
+import { getMeta, isArrayType, isConstructable, ReflectionMeta } from "@decohere/nexus/reflection";
+import { scribe } from "@decohere/scribe";
+import { CrucibleMeta, LifetimeScopeToken, Scopes } from "../const.js";
+import { RegistrationKey } from "../models/registration-key.model.js";
+import { DuplicateScopeError, ResolveError } from "../types/errors.js";
+import { ServiceRegistry } from "./service-registry.js";
+export class Crucible {
+    key;
+    instances = new Map();
+    serviceRegistry;
+    rootScope;
+    scopes = new Map();
+    logger = scribe.logger(Crucible.name);
+    isDisposed = false;
+    constructor(options){
+        this.key = options?.key;
+        this.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);
+        this.registerLifetimeScope();
+        this.rootScope = options?.rootScope ?? this;
+    }
+    resolveMany(resolveRequest) {
+        const key = new RegistrationKey(resolveRequest);
+        const registrations = this.getRegistrationFrom(key) ?? [];
+        const services = Array.of();
+        for (const registration of registrations){
+            const service = this.resolveRegistration(registration);
+            services.push(service);
+        }
+        return services;
+    }
+    resolve(resolveRequest) {
+        const key = new RegistrationKey(resolveRequest);
+        const registration = this.getRegistrationFrom(key);
+        if (registration == null) {
+            this.logger.warn(`Cannot resolve dependency ${key.toString()}`);
+            return null;
+        }
+        if (registration.length > 1) {
+            throw new ResolveError(`There are multiple services registered with key ${key.toString()}. Use resolveMany to resolve all implementations.`);
+        }
+        const service = this.resolveRegistration(registration[0]);
+        return service;
+    }
+    beginScope(name) {
+        if (this.scopes.has(name)) {
+            throw new DuplicateScopeError(`Cannot create duplicate scope. Scope with ${name} is already created and has not been disposed.`);
+        }
+        const scope = new Crucible({
+            key: name,
+            serviceRegistry: this.serviceRegistry,
+            rootScope: this
+        });
+        this.scopes.set(name, scope);
+        return scope;
+    }
+    [Symbol.dispose]() {
+        if (this.isDisposed) {
+            return;
+        }
+        this.disposeSync();
+    }
+    async [Symbol.asyncDispose]() {
+        if (this.isDisposed) {
+            return;
+        }
+        await this.disposeAsync();
+    }
+    disposeSync() {
+        if (this.isDisposed) {
+            return;
+        }
+        this.isDisposed = true;
+        for (const [, inst] of this.instances){
+            if (inst === this) {
+                continue;
+            }
+            inst[Symbol.dispose]?.();
+        }
+    }
+    async disposeAsync() {
+        if (this.isDisposed) {
+            return;
+        }
+        this.isDisposed = true;
+        for (const [, inst] of this.instances){
+            if (inst === this) {
+                continue;
+            }
+            if (Symbol.asyncDispose in inst) {
+                await inst[Symbol.asyncDispose]();
+            } else {
+                inst[Symbol.dispose]?.();
+            }
+        }
+    }
+    getRegistrationFrom(key) {
+        const registration = this.serviceRegistry.getRegistration(key.value);
+        return registration;
+    }
+    resolveRegistration(registration) {
+        const { scope } = registration;
+        switch(scope){
+            case Scopes.transient:
+                return this.createInstance(registration);
+            case Scopes.singleton:
+                return this.rootScope.getOrCreateInstance(registration);
+            case Scopes.request:
+                return this.getOrCreateInstance(registration);
+        }
+    }
+    getOrCreateInstance(registration) {
+        if (this.isDisposed) {
+            throw new Error("This continer has been disposed");
+        }
+        const { key, type, isInstance } = registration;
+        const cacheKey = isInstance ? key.value : type;
+        const existingInstance = this.instances.get(cacheKey);
+        if (existingInstance != null) {
+            return existingInstance;
+        }
+        const instance = isInstance ? type : this.createInstance(registration);
+        this.instances.set(cacheKey, instance);
+        return instance;
+    }
+    createInstance(registration) {
+        const type = registration.type;
+        const canConstruct = isConstructable(type);
+        const deps = this.resolveDependencies(type);
+        const inst = canConstruct ? new type(...deps) : type();
+        return inst;
+    }
+    resolveDependencies(type) {
+        const params = getMeta(ReflectionMeta.paramtypes, type) ?? [];
+        const injectTokens = getMeta(CrucibleMeta.injecttoken, type) ?? new Map();
+        //TODO: put a try catch here so we can throw the name of the service
+        let resolved = [];
+        for(let i = 0; i < params.length; i++){
+            const token = injectTokens.get(i)?.key ?? params[i].name;
+            const dep = isArrayType(params[i]) ? this.resolveMany(token) : this.resolve(token);
+            resolved = [
+                ...resolved,
+                dep
+            ];
+        }
+        return resolved;
+    }
+    registerLifetimeScope() {
+        this.serviceRegistry.registerType(Scopes.request, {
+            typeOrKey: LifetimeScopeToken,
+            typeOrInstance: this
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/crucible/src/services/crucible.ts"],"sourcesContent":["import {\n\ttype Constructable,\n\ttype FunctionType,\n\tgetMeta,\n\tisArrayType,\n\tisConstructable,\n\tReflectionMeta,\n} from \"@decohere/nexus/reflection\";\nimport { scribe } from \"@decohere/scribe\";\nimport { CrucibleMeta, LifetimeScopeToken, Scopes } from \"../const.js\";\nimport type { InjectionMetadata } from \"../decorators/inject.decorator.js\";\nimport { RegistrationKey } from \"../models/registration-key.model.js\";\nimport type { ServiceRegistration } from \"../models/service-registration.model.js\";\nimport { DuplicateScopeError, ResolveError } from \"../types/errors.js\";\nimport type { IContainer, LifetimeScope, ResolveRequest } from \"../types/types.js\";\nimport { ServiceRegistry } from \"./service-registry.js\";\n\ntype CrucibleOptions = {\n\tkey?: string;\n\trootScope?: Crucible;\n\tserviceRegistry: ServiceRegistry;\n};\n\nexport class Crucible implements IContainer {\n\tpublic key: string;\n\tprotected instances = new Map<unknown, object>();\n\tprivate serviceRegistry: ServiceRegistry;\n\tprivate rootScope: Crucible;\n\tprivate scopes = new Map<string, LifetimeScope>();\n\tprivate logger = scribe.logger(Crucible.name);\n\tprivate isDisposed = false;\n\tpublic constructor(options?: CrucibleOptions) {\n\t\tthis.key = options?.key;\n\t\tthis.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);\n\t\tthis.registerLifetimeScope();\n\t\tthis.rootScope = options?.rootScope ?? this;\n\t}\n\n\tpublic resolveMany<T extends object = object>(resolveRequest: ResolveRequest<T>): T[] {\n\t\tconst key = new RegistrationKey(resolveRequest);\n\t\tconst registrations = this.getRegistrationFrom(key) ?? [];\n\n\t\tconst services = Array.of<T>();\n\t\tfor (const registration of registrations) {\n\t\t\tconst service = this.resolveRegistration<T>(registration);\n\t\t\tservices.push(service);\n\t\t}\n\t\treturn services;\n\t}\n\n\tpublic resolve<T extends object | object[]>(resolveRequest: ResolveRequest<T>): T {\n\t\tconst key = new RegistrationKey(resolveRequest);\n\t\tconst registration = this.getRegistrationFrom(key);\n\t\tif (registration == null) {\n\t\t\tthis.logger.warn(`Cannot resolve dependency ${key.toString()}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tif (registration.length > 1) {\n\t\t\tthrow new ResolveError(\n\t\t\t\t`There are multiple services registered with key ${key.toString()}. Use resolveMany to resolve all implementations.`,\n\t\t\t);\n\t\t}\n\n\t\tconst service = this.resolveRegistration<T>(registration[0]);\n\t\treturn service;\n\t}\n\n\tpublic beginScope(name?: string) {\n\t\tif (this.scopes.has(name)) {\n\t\t\tthrow new DuplicateScopeError(\n\t\t\t\t`Cannot create duplicate scope. Scope with ${name} is already created and has not been disposed.`,\n\t\t\t);\n\t\t}\n\n\t\tconst scope = new Crucible({\n\t\t\tkey: name,\n\t\t\tserviceRegistry: this.serviceRegistry,\n\t\t\trootScope: this,\n\t\t});\n\n\t\tthis.scopes.set(name, scope);\n\t\treturn scope;\n\t}\n\n\tpublic [Symbol.dispose]() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposeSync();\n\t}\n\n\tpublic async [Symbol.asyncDispose]() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\t\tawait this.disposeAsync();\n\t}\n\n\tprivate disposeSync() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.isDisposed = true;\n\t\tfor (const [, inst] of this.instances) {\n\t\t\tif (inst === this) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tinst[Symbol.dispose]?.();\n\t\t}\n\t}\n\n\tprivate async disposeAsync() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.isDisposed = true;\n\t\tfor (const [, inst] of this.instances) {\n\t\t\tif (inst === this) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (Symbol.asyncDispose in inst) {\n\t\t\t\tawait (inst as AsyncDisposable)[Symbol.asyncDispose]();\n\t\t\t} else {\n\t\t\t\t(inst as Partial<Disposable>)[Symbol.dispose]?.();\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getRegistrationFrom(key: RegistrationKey) {\n\t\tconst registration = this.serviceRegistry.getRegistration(key.value);\n\t\treturn registration;\n\t}\n\n\tprivate resolveRegistration<T extends object>(registration: ServiceRegistration): T {\n\t\tconst { scope } = registration;\n\t\tswitch (scope) {\n\t\t\tcase Scopes.transient:\n\t\t\t\treturn this.createInstance(registration);\n\t\t\tcase Scopes.singleton:\n\t\t\t\treturn this.rootScope.getOrCreateInstance(registration);\n\t\t\tcase Scopes.request:\n\t\t\t\treturn this.getOrCreateInstance(registration);\n\t\t}\n\t}\n\n\tprivate getOrCreateInstance<T extends object>(registration: ServiceRegistration): T {\n\t\tif (this.isDisposed) {\n\t\t\tthrow new Error(\"This continer has been disposed\");\n\t\t}\n\t\tconst { key, type, isInstance } = registration;\n\t\tconst cacheKey = isInstance ? key.value : type;\n\t\tconst existingInstance = this.instances.get(cacheKey);\n\t\tif (existingInstance != null) {\n\t\t\treturn existingInstance as T;\n\t\t}\n\n\t\tconst instance = isInstance ? (type as T) : this.createInstance<T>(registration);\n\t\tthis.instances.set(cacheKey, instance);\n\t\treturn instance;\n\t}\n\n\tprivate createInstance<T extends object>(registration: ServiceRegistration): T {\n\t\tconst type = registration.type as Constructable | FunctionType;\n\t\tconst canConstruct = isConstructable(type);\n\t\tconst deps = this.resolveDependencies(type);\n\t\tconst inst = (canConstruct ? new type(...deps) : type()) as T;\n\t\treturn inst;\n\t}\n\n\tprivate resolveDependencies(type: Constructable | FunctionType): unknown[] {\n\t\tconst params = getMeta<Array<Constructable>>(ReflectionMeta.paramtypes, type) ?? [];\n\n\t\tconst injectTokens =\n\t\t\tgetMeta<InjectionMetadata>(CrucibleMeta.injecttoken, type) ?? new Map();\n\n\t\t//TODO: put a try catch here so we can throw the name of the service\n\t\tlet resolved = [];\n\t\tfor (let i = 0; i < params.length; i++) {\n\t\t\tconst token = injectTokens.get(i)?.key ?? params[i].name;\n\t\t\tconst dep = isArrayType(params[i]) ? this.resolveMany(token) : this.resolve(token);\n\t\t\tresolved = [...resolved, dep];\n\t\t}\n\t\treturn resolved;\n\t}\n\n\tprivate registerLifetimeScope() {\n\t\tthis.serviceRegistry.registerType(Scopes.request, {\n\t\t\ttypeOrKey: LifetimeScopeToken,\n\t\t\ttypeOrInstance: this,\n\t\t});\n\t}\n}\n"],"names":["getMeta","isArrayType","isConstructable","ReflectionMeta","scribe","CrucibleMeta","LifetimeScopeToken","Scopes","RegistrationKey","DuplicateScopeError","ResolveError","ServiceRegistry","Crucible","key","instances","Map","serviceRegistry","rootScope","scopes","logger","name","isDisposed","options","registerLifetimeScope","resolveMany","resolveRequest","registrations","getRegistrationFrom","services","Array","of","registration","service","resolveRegistration","push","resolve","warn","toString","length","beginScope","has","scope","set","Symbol","dispose","disposeSync","asyncDispose","disposeAsync","inst","getRegistration","value","transient","createInstance","singleton","getOrCreateInstance","request","Error","type","isInstance","cacheKey","existingInstance","get","instance","canConstruct","deps","resolveDependencies","params","paramtypes","injectTokens","injecttoken","resolved","i","token","dep","registerType","typeOrKey","typeOrInstance"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/crucible",
-  "version": "0.0.1-dev.4",
+  "version": "0.0.1-dev.40",
   "description": "Lightweight dependency injection container with decorator-based wiring",
   "keywords": [
     "typescript",
@@ -30,8 +30,8 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.4",
-    "@decohere/scribe": "0.0.1-dev.4"
+    "@decohere/nexus": "0.0.1-dev.40",
+    "@decohere/scribe": "0.0.1-dev.40"
   },
   "devDependencies": {}
 }

package/types/src/const.d.ts

@@ -0,0 +1,9 @@
+export declare const LifetimeScopeToken: unique symbol;
+export declare const CrucibleMeta: {
+    injecttoken: string;
+};
+export declare const Scopes: {
+    request: "request";
+    singleton: "single-instance";
+    transient: "transient";
+};

package/types/src/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./inject.decorator.js";
+export * from "./injectable.dectorator.js";

package/types/src/decorators/inject.decorator.d.ts

@@ -0,0 +1,5 @@
+export type InjectionMetadata = Map<number, InjectionToken>;
+export type InjectionToken = {
+    key: string | symbol;
+};
+export declare function inject(key: string | symbol): (target: object, _propertyKey: string | symbol | undefined, idx: number) => void;

package/types/src/decorators/injectable.dectorator.d.ts

@@ -0,0 +1 @@
+export declare function injectable(): ClassDecorator;

package/types/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./const.js";
+export * from "./services/index.js";
+export * from "./types/index.js";

package/types/src/models/registration-key.model.d.ts

@@ -0,0 +1,7 @@
+import type { Constructable } from "@decohere/nexus/reflection";
+export declare class RegistrationKey {
+    constructor(key: string | symbol | Constructable);
+    value: string;
+    private getValue;
+    toString(): string;
+}

package/types/src/models/service-registration.model.d.ts

@@ -0,0 +1,11 @@
+import type { Constructable, FunctionType } from "@decohere/nexus/reflection";
+import type { Scope } from "../types/types.js";
+import type { RegistrationKey } from "./registration-key.model.js";
+export declare class ServiceRegistration {
+    key: RegistrationKey;
+    scope: Scope;
+    type: Constructable | FunctionType | object;
+    isInstance: boolean;
+    constructor(key: RegistrationKey, type: Constructable | FunctionType | object, scope: Scope, isInstance: boolean);
+    isEqual(other: ServiceRegistration): boolean;
+}

package/types/src/services/crucible-builder.d.ts

@@ -0,0 +1,26 @@
+import type { Constructable, FunctionType } from "@decohere/nexus/reflection";
+import type { ServiceRegistration } from "../models/service-registration.model.js";
+import type { ContainerBuilder, Scope } from "../types/types.js";
+import { Crucible } from "./crucible.js";
+import { ServiceRegistry } from "./service-registry.js";
+type ContainerBuilderOptions = {
+    serviceRegistry: ServiceRegistry;
+};
+export declare class CrucibleBuilder implements ContainerBuilder {
+    private serviceRegistry;
+    constructor(options?: ContainerBuilderOptions);
+    registerType(type: Constructable, scope?: Scope): ServiceRegistration;
+    registerTypes(...types: Constructable[]): ServiceRegistration[];
+    registerTypes(scope: Scope, ...types: Constructable[]): ServiceRegistration[];
+    registerTransient(key: string | symbol, type: Constructable | FunctionType): ServiceRegistration;
+    registerTransient(type: Constructable): ServiceRegistration;
+    registerSingleton(key: string | symbol | Constructable | object, instance: object): ServiceRegistration;
+    registerSingleton(key: string | symbol, type: Constructable): ServiceRegistration;
+    registerSingleton(type: Constructable): ServiceRegistration;
+    registerRequestScoped<T>(type: () => T): ServiceRegistration;
+    registerRequestScoped<T>(key: string | symbol, type: () => T): ServiceRegistration;
+    registerRequestScoped(key: string | symbol, type: Constructable): ServiceRegistration;
+    registerRequestScoped(type: Constructable): ServiceRegistration;
+    build(): Crucible;
+}
+export {};

package/types/src/services/crucible.d.ts

@@ -0,0 +1,31 @@
+import type { IContainer, ResolveRequest } from "../types/types.js";
+import { ServiceRegistry } from "./service-registry.js";
+type CrucibleOptions = {
+    key?: string;
+    rootScope?: Crucible;
+    serviceRegistry: ServiceRegistry;
+};
+export declare class Crucible implements IContainer {
+    key: string;
+    protected instances: Map<unknown, object>;
+    private serviceRegistry;
+    private rootScope;
+    private scopes;
+    private logger;
+    private isDisposed;
+    constructor(options?: CrucibleOptions);
+    resolveMany<T extends object = object>(resolveRequest: ResolveRequest<T>): T[];
+    resolve<T extends object | object[]>(resolveRequest: ResolveRequest<T>): T;
+    beginScope(name?: string): Crucible;
+    [Symbol.dispose](): void;
+    [Symbol.asyncDispose](): Promise<void>;
+    private disposeSync;
+    private disposeAsync;
+    private getRegistrationFrom;
+    private resolveRegistration;
+    private getOrCreateInstance;
+    private createInstance;
+    private resolveDependencies;
+    private registerLifetimeScope;
+}
+export {};

package/types/src/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./crucible.js";
+export * from "./crucible-builder.js";

package/types/src/services/service-registry.d.ts

@@ -0,0 +1,16 @@
+import type { Constructable, FunctionType } from "@decohere/nexus/reflection";
+import { ServiceRegistration } from "../models/service-registration.model.js";
+import type { Scope } from "../types/types.js";
+export type RegisterTypeOptions = {
+    typeOrKey: string | symbol | Constructable | FunctionType;
+    typeOrInstance?: Constructable | FunctionType | object;
+};
+export declare class ServiceRegistry {
+    private readonly registrations;
+    constructor(parent?: ServiceRegistry);
+    registerType(scope: Scope, options: RegisterTypeOptions): ServiceRegistration;
+    getRegistration(key: string | symbol | Constructable): ServiceRegistration[];
+    private createRegistrationFrom;
+    private getRegistrations;
+    private setRegistration;
+}

package/types/src/types/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class ResolveError extends Error {
+}
+export declare class DuplicateScopeError extends Error {
+}
+export declare class RegistrationError extends Error {
+}

package/types/src/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./types.js";

package/types/src/types/types.d.ts

@@ -0,0 +1 @@
+export type { ContainerBuilder, IContainer, LifetimeScope, ResolveRequest, Scope, ServiceProvider, } from "@decohere/nexus/composition";

package/src/services/crucible.js

@@ -1,133 +0,0 @@
-import { getMeta, isArrayType, isConstructable, ReflectionMeta } from "../../../nexus/src/reflection/index.js";
-import { scribe } from "../../../scribe/scribe/src/index.js";
-import { CrucibleMeta, LifetimeScopeToken, Scopes } from "../const.js";
-import { RegistrationKey } from "../models/registration-key.model.js";
-import { DuplicateScopeError, ResolveError } from "../types/errors.js";
-import { ServiceRegistry } from "./service-registry.js";
-export class Crucible {
-    key;
-    instances = new Map();
-    serviceRegistry;
-    rootScope;
-    scopes = new Map();
-    logger = scribe.logger(Crucible.name);
-    isDisposed = false;
-    constructor(options){
-        this.key = options?.key;
-        this.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);
-        this.registerLifetimeScope();
-        this.rootScope = options?.rootScope ?? this;
-    }
-    resolveMany(resolveRequest) {
-        const key = new RegistrationKey(resolveRequest);
-        const registrations = this.getRegistrationFrom(key) ?? [];
-        const services = Array.of();
-        for (const registration of registrations){
-            const service = this.resolveRegistration(registration);
-            services.push(service);
-        }
-        return services;
-    }
-    resolve(resolveRequest) {
-        const key = new RegistrationKey(resolveRequest);
-        const registration = this.getRegistrationFrom(key);
-        if (registration == null) {
-            this.logger.warn(`Cannot resolve dependency ${key.toString()}`);
-            return null;
-        }
-        if (registration.length > 1) {
-            throw new ResolveError(`There are multiple services registered with key ${key.toString()}. Use resolveMany to resolve all implementations.`);
-        }
-        const service = this.resolveRegistration(registration[0]);
-        return service;
-    }
-    beginScope(name) {
-        if (this.scopes.has(name)) {
-            throw new DuplicateScopeError(`Cannot create duplicate scope. Scope with ${name} is already created and has not been disposed.`);
-        }
-        const scope = new Crucible({
-            key: name,
-            serviceRegistry: this.serviceRegistry,
-            rootScope: this
-        });
-        this.scopes.set(name, scope);
-        return scope;
-    }
-    [Symbol.dispose]() {
-        if (this.isDisposed) {
-            return;
-        }
-        this.dispose();
-    }
-    dispose() {
-        if (this.isDisposed) {
-            return;
-        }
-        this.isDisposed = true;
-        for (const [, inst] of this.instances){
-            if (inst === this) {
-                continue;
-            }
-            inst[Symbol.dispose]?.();
-        }
-    }
-    getRegistrationFrom(key) {
-        const registration = this.serviceRegistry.getRegistration(key.value);
-        return registration;
-    }
-    resolveRegistration(registration) {
-        const { scope } = registration;
-        switch(scope){
-            case Scopes.transient:
-                return this.createInstance(registration);
-            case Scopes.singleton:
-                return this.rootScope.getOrCreateInstance(registration);
-            case Scopes.request:
-                return this.getOrCreateInstance(registration);
-        }
-    }
-    getOrCreateInstance(registration) {
-        if (this.isDisposed) {
-            throw new Error("This continer has been disposed");
-        }
-        const { key, type, isInstance } = registration;
-        const cacheKey = isInstance ? key.value : type;
-        const existingInstance = this.instances.get(cacheKey);
-        if (existingInstance != null) {
-            return existingInstance;
-        }
-        const instance = isInstance ? type : this.createInstance(registration);
-        this.instances.set(cacheKey, instance);
-        return instance;
-    }
-    createInstance(registration) {
-        const type = registration.type;
-        const canConstruct = isConstructable(type);
-        const deps = this.resolveDependencies(type);
-        const inst = canConstruct ? new type(...deps) : type();
-        return inst;
-    }
-    resolveDependencies(type) {
-        const params = getMeta(ReflectionMeta.paramtypes, type) ?? [];
-        const injectTokens = getMeta(CrucibleMeta.injecttoken, type) ?? new Map();
-        //TODO: put a try catch here so we can throw the name of the service
-        let resolved = [];
-        for(let i = 0; i < params.length; i++){
-            const token = injectTokens.get(i)?.key ?? params[i].name;
-            const dep = isArrayType(params[i]) ? this.resolveMany(token) : this.resolve(token);
-            resolved = [
-                ...resolved,
-                dep
-            ];
-        }
-        return resolved;
-    }
-    registerLifetimeScope() {
-        this.serviceRegistry.registerType(Scopes.request, {
-            typeOrKey: LifetimeScopeToken,
-            typeOrInstance: this
-        });
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/crucible/src/services/crucible.ts"],"sourcesContent":["import {\n\ttype Constructable,\n\ttype FunctionType,\n\tgetMeta,\n\tisArrayType,\n\tisConstructable,\n\tReflectionMeta,\n} from \"@decohere/nexus/reflection\";\nimport { scribe } from \"@decohere/scribe\";\nimport { CrucibleMeta, LifetimeScopeToken, Scopes } from \"../const.js\";\nimport type { InjectionMetadata } from \"../decorators/inject.decorator.js\";\nimport { RegistrationKey } from \"../models/registration-key.model.js\";\nimport type { ServiceRegistration } from \"../models/service-registration.model.js\";\nimport { DuplicateScopeError, ResolveError } from \"../types/errors.js\";\nimport type { IContainer, LifetimeScope, ResolveRequest } from \"../types/types.js\";\nimport { ServiceRegistry } from \"./service-registry.js\";\n\ntype CrucibleOptions = {\n\tkey?: string;\n\trootScope?: Crucible;\n\tserviceRegistry: ServiceRegistry;\n};\n\nexport class Crucible implements IContainer {\n\tpublic key: string;\n\tprotected instances = new Map<unknown, object>();\n\tprivate serviceRegistry: ServiceRegistry;\n\tprivate rootScope: Crucible;\n\tprivate scopes = new Map<string, LifetimeScope>();\n\tprivate logger = scribe.logger(Crucible.name);\n\tprivate isDisposed = false;\n\tpublic constructor(options?: CrucibleOptions) {\n\t\tthis.key = options?.key;\n\t\tthis.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);\n\t\tthis.registerLifetimeScope();\n\t\tthis.rootScope = options?.rootScope ?? this;\n\t}\n\n\tpublic resolveMany<T extends object = object>(resolveRequest: ResolveRequest<T>): T[] {\n\t\tconst key = new RegistrationKey(resolveRequest);\n\t\tconst registrations = this.getRegistrationFrom(key) ?? [];\n\n\t\tconst services = Array.of<T>();\n\t\tfor (const registration of registrations) {\n\t\t\tconst service = this.resolveRegistration<T>(registration);\n\t\t\tservices.push(service);\n\t\t}\n\t\treturn services;\n\t}\n\n\tpublic resolve<T extends object | object[]>(resolveRequest: ResolveRequest<T>): T {\n\t\tconst key = new RegistrationKey(resolveRequest);\n\t\tconst registration = this.getRegistrationFrom(key);\n\t\tif (registration == null) {\n\t\t\tthis.logger.warn(`Cannot resolve dependency ${key.toString()}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tif (registration.length > 1) {\n\t\t\tthrow new ResolveError(\n\t\t\t\t`There are multiple services registered with key ${key.toString()}. Use resolveMany to resolve all implementations.`,\n\t\t\t);\n\t\t}\n\n\t\tconst service = this.resolveRegistration<T>(registration[0]);\n\t\treturn service;\n\t}\n\n\tpublic beginScope(name?: string) {\n\t\tif (this.scopes.has(name)) {\n\t\t\tthrow new DuplicateScopeError(\n\t\t\t\t`Cannot create duplicate scope. Scope with ${name} is already created and has not been disposed.`,\n\t\t\t);\n\t\t}\n\n\t\tconst scope = new Crucible({\n\t\t\tkey: name,\n\t\t\tserviceRegistry: this.serviceRegistry,\n\t\t\trootScope: this,\n\t\t});\n\n\t\tthis.scopes.set(name, scope);\n\t\treturn scope;\n\t}\n\n\tpublic [Symbol.dispose]() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.dispose();\n\t}\n\n\tprivate dispose() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.isDisposed = true;\n\t\tfor (const [, inst] of this.instances) {\n\t\t\tif (inst === this) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tinst[Symbol.dispose]?.();\n\t\t}\n\t}\n\n\tprivate getRegistrationFrom(key: RegistrationKey) {\n\t\tconst registration = this.serviceRegistry.getRegistration(key.value);\n\t\treturn registration;\n\t}\n\n\tprivate resolveRegistration<T extends object>(registration: ServiceRegistration): T {\n\t\tconst { scope } = registration;\n\t\tswitch (scope) {\n\t\t\tcase Scopes.transient:\n\t\t\t\treturn this.createInstance(registration);\n\t\t\tcase Scopes.singleton:\n\t\t\t\treturn this.rootScope.getOrCreateInstance(registration);\n\t\t\tcase Scopes.request:\n\t\t\t\treturn this.getOrCreateInstance(registration);\n\t\t}\n\t}\n\n\tprivate getOrCreateInstance<T extends object>(registration: ServiceRegistration): T {\n\t\tif (this.isDisposed) {\n\t\t\tthrow new Error(\"This continer has been disposed\");\n\t\t}\n\t\tconst { key, type, isInstance } = registration;\n\t\tconst cacheKey = isInstance ? key.value : type;\n\t\tconst existingInstance = this.instances.get(cacheKey);\n\t\tif (existingInstance != null) {\n\t\t\treturn existingInstance as T;\n\t\t}\n\n\t\tconst instance = isInstance ? (type as T) : this.createInstance<T>(registration);\n\t\tthis.instances.set(cacheKey, instance);\n\t\treturn instance;\n\t}\n\n\tprivate createInstance<T extends object>(registration: ServiceRegistration): T {\n\t\tconst type = registration.type as Constructable | FunctionType;\n\t\tconst canConstruct = isConstructable(type);\n\t\tconst deps = this.resolveDependencies(type);\n\t\tconst inst = (canConstruct ? new type(...deps) : type()) as T;\n\t\treturn inst;\n\t}\n\n\tprivate resolveDependencies(type: Constructable | FunctionType): unknown[] {\n\t\tconst params = getMeta<Array<Constructable>>(ReflectionMeta.paramtypes, type) ?? [];\n\n\t\tconst injectTokens =\n\t\t\tgetMeta<InjectionMetadata>(CrucibleMeta.injecttoken, type) ?? new Map();\n\n\t\t//TODO: put a try catch here so we can throw the name of the service\n\t\tlet resolved = [];\n\t\tfor (let i = 0; i < params.length; i++) {\n\t\t\tconst token = injectTokens.get(i)?.key ?? params[i].name;\n\t\t\tconst dep = isArrayType(params[i]) ? this.resolveMany(token) : this.resolve(token);\n\t\t\tresolved = [...resolved, dep];\n\t\t}\n\t\treturn resolved;\n\t}\n\n\tprivate registerLifetimeScope() {\n\t\tthis.serviceRegistry.registerType(Scopes.request, {\n\t\t\ttypeOrKey: LifetimeScopeToken,\n\t\t\ttypeOrInstance: this,\n\t\t});\n\t}\n}\n"],"names":["getMeta","isArrayType","isConstructable","ReflectionMeta","scribe","CrucibleMeta","LifetimeScopeToken","Scopes","RegistrationKey","DuplicateScopeError","ResolveError","ServiceRegistry","Crucible","key","instances","Map","serviceRegistry","rootScope","scopes","logger","name","isDisposed","options","registerLifetimeScope","resolveMany","resolveRequest","registrations","getRegistrationFrom","services","Array","of","registration","service","resolveRegistration","push","resolve","warn","toString","length","beginScope","has","scope","set","Symbol","dispose","inst","getRegistration","value","transient","createInstance","singleton","getOrCreateInstance","request","Error","type","isInstance","cacheKey","existingInstance","get","instance","canConstruct","deps","resolveDependencies","params","paramtypes","injectTokens","injecttoken","resolved","i","token","dep","registerType","typeOrKey","typeOrInstance"],"mappings":"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"}