@decohere/crucible 0.0.1-dev.119 → 0.0.1-dev.12

package/es6/src/services/container.js

@@ -1,197 +0,0 @@
-import { getMeta, isArrayType, isConstructable, ReflectionMeta } from "@decohere/core/reflection";
-import { ContainerMeta, LifetimeScopeToken, Scopes } from "../const.js";
-import { describeKey } from "../models/service-key.js";
-import { DuplicateScopeError, ResolveError } from "../types/errors.js";
-import { ServiceRegistry } from "./service-registry.js";
-function describePath(path, last) {
-    const keys = path.map((registration)=>registration.key);
-    return [
-        ...keys,
-        ...last == null ? [] : [
-            last
-        ]
-    ].map(describeKey).join(" → ");
-}
-export class Container {
-    key;
-    instances = new Map();
-    serviceRegistry;
-    parent;
-    rootScope;
-    scopes = new Map();
-    isDisposed = false;
-    constructor(options){
-        this.key = options?.key;
-        this.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);
-        this.registerLifetimeScope();
-        this.parent = options?.parent;
-        this.rootScope = options?.parent?.rootScope ?? this;
-    }
-    resolveMany(resolveRequest) {
-        return this.resolveAll(resolveRequest, []);
-    }
-    /** Throws {@link ResolveError} when nothing is registered for the key. */ resolve(resolveRequest) {
-        return this.resolveOne(resolveRequest, [], false);
-    }
-    resolveAll(key, path) {
-        const registrations = this.serviceRegistry.getRegistration(key) ?? [];
-        return registrations.map((registration)=>this.resolveRegistration(registration, path));
-    }
-    resolveOne(key, path, optional) {
-        const registrations = this.serviceRegistry.getRegistration(key);
-        if (registrations == null || registrations.length === 0) {
-            if (optional) return undefined;
-            const requiredBy = path.length === 0 ? "" : ` (required by ${describePath(path, key)})`;
-            throw new ResolveError(`Nothing is registered for ${describeKey(key)}${requiredBy}. Register it, or mark the parameter @optional().`);
-        }
-        if (registrations.length > 1) {
-            throw new ResolveError(`There are multiple services registered with key ${describeKey(key)}. Use resolveMany to resolve all implementations.`);
-        }
-        return this.resolveRegistration(registrations[0], path);
-    }
-    beginScope(name) {
-        if (this.isDisposed) {
-            throw new Error("This container has been disposed");
-        }
-        if (name != null && 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 Container({
-            key: name,
-            serviceRegistry: this.serviceRegistry,
-            parent: this
-        });
-        if (name != null) {
-            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;
-        this.parent?.releaseScope(this.key);
-        this.scopes.clear();
-        // Reverse creation order: dependents are cleaned up before what they depend on.
-        for (const inst of [
-            ...this.instances.values()
-        ].reverse()){
-            if (inst === this) {
-                continue;
-            }
-            inst[Symbol.dispose]?.();
-        }
-    }
-    async disposeAsync() {
-        if (this.isDisposed) {
-            return;
-        }
-        this.isDisposed = true;
-        this.parent?.releaseScope(this.key);
-        this.scopes.clear();
-        // Reverse creation order: dependents are cleaned up before what they depend on.
-        for (const inst of [
-            ...this.instances.values()
-        ].reverse()){
-            if (inst === this) {
-                continue;
-            }
-            if (Symbol.asyncDispose in inst) {
-                await inst[Symbol.asyncDispose]();
-            } else {
-                inst[Symbol.dispose]?.();
-            }
-        }
-    }
-    resolveRegistration(registration, path) {
-        this.assertNoCycle(registration, path);
-        this.assertNotCaptive(registration, path);
-        const { scope } = registration;
-        switch(scope){
-            case Scopes.transient:
-                return this.createInstance(registration, path);
-            case Scopes.singleton:
-                return this.rootScope.getOrCreateInstance(registration, path);
-            case Scopes.request:
-                return this.getOrCreateInstance(registration, path);
-        }
-    }
-    assertNoCycle(registration, path) {
-        if (!path.includes(registration)) return;
-        throw new ResolveError(`Circular dependency: ${describePath(path, registration.key)}. Break the cycle, e.g. by resolving one side lazily from the LifetimeScope.`);
-    }
-    /**
-	 * A singleton lives for the whole process, so a request-scoped service it depends on (directly
-	 * or through transients) would be created once and then shared by every request, e.g. one
-	 * QueryRunner for the life of the process. The container's own lifetime scope is exempt: a
-	 * singleton asking for it gets the root, which is the scope it lives in.
-	 */ assertNotCaptive(registration, path) {
-        if (registration.scope !== Scopes.request || registration.key === LifetimeScopeToken) return;
-        const singleton = path.find((owner)=>owner.scope === Scopes.singleton);
-        if (singleton == null) return;
-        throw new ResolveError(`Singleton ${describeKey(singleton.key)} depends on request-scoped ${describeKey(registration.key)} (${describePath(path, registration.key)}). A singleton would keep the first request's instance forever: make ${describeKey(singleton.key)} request-scoped, or resolve ${describeKey(registration.key)} per request from the LifetimeScope.`);
-    }
-    getOrCreateInstance(registration, path) {
-        if (this.isDisposed) {
-            throw new Error("This container has been disposed");
-        }
-        const { type, isInstance } = registration;
-        // One cache entry per registration: an instance registration is its own entry.
-        const cacheKey = type;
-        const existingInstance = this.instances.get(cacheKey);
-        if (existingInstance != null) {
-            return existingInstance;
-        }
-        const instance = isInstance ? type : this.createInstance(registration, path);
-        this.instances.set(cacheKey, instance);
-        return instance;
-    }
-    createInstance(registration, path) {
-        const type = registration.type;
-        const canConstruct = isConstructable(type);
-        const deps = this.resolveDependencies(type, [
-            ...path,
-            registration
-        ]);
-        const inst = canConstruct ? new type(...deps) : type();
-        return inst;
-    }
-    resolveDependencies(type, path) {
-        const params = getMeta(ReflectionMeta.paramtypes, type) ?? [];
-        const injectTokens = getMeta(ContainerMeta.injecttoken, type) ?? new Map();
-        return params.map((param, index)=>{
-            const token = injectTokens.get(index);
-            const key = token?.key ?? param;
-            if (key == null || key === Object || token?.key == null && isArrayType(param)) {
-                if (token?.optional) return undefined;
-                throw new ResolveError(`Cannot tell what to inject for constructor parameter ${index} of ${describePath(path)}: its type is not a class at run time (an interface, an array, or a type-only import). Add @inject(token) to the parameter.`);
-            }
-            return isArrayType(param) ? this.resolveAll(key, path) : this.resolveOne(key, path, token?.optional === true);
-        });
-    }
-    releaseScope(name) {
-        if (name == null) {
-            return;
-        }
-        this.scopes.delete(name);
-    }
-    registerLifetimeScope() {
-        this.serviceRegistry.replaceType(Scopes.request, {
-            typeOrKey: LifetimeScopeToken,
-            typeOrInstance: this
-        });
-    }
-}

package/es6/src/services/service-container-builder.js

@@ -1,57 +0,0 @@
-import { Scopes } from "../const.js";
-import { Container } from "./container.js";
-import { ServiceRegistry } from "./service-registry.js";
-export class ServiceContainerBuilder {
-    serviceRegistry;
-    constructor(options){
-        this.serviceRegistry = options?.serviceRegistry ?? new ServiceRegistry();
-    }
-    get override() {
-        return this.createRegistrar(true);
-    }
-    registerType(type, scope = Scopes.transient) {
-        return this.register(false)(scope)(type, type);
-    }
-    registerTypes(scopeOrType, ...types) {
-        return this.registerMany(false, scopeOrType, types);
-    }
-    registerTransient(typeOrKey, type) {
-        return this.register(false)(Scopes.transient)(typeOrKey, type);
-    }
-    registerSingleton(typeOrKey, typeOrInstance) {
-        return this.register(false)(Scopes.singleton)(typeOrKey, typeOrInstance);
-    }
-    registerRequestScoped(typeOrKey, type) {
-        return this.register(false)(Scopes.request)(typeOrKey, type);
-    }
-    build() {
-        return new Container({
-            serviceRegistry: this.serviceRegistry
-        });
-    }
-    register = (override)=>(scope)=>(typeOrKey, typeOrInstance)=>this.serviceRegistry.registerType(scope, {
-                    typeOrKey,
-                    typeOrInstance,
-                    override
-                });
-    registerMany(override, scopeOrType, types) {
-        const bind = this.register(override);
-        const isScope = typeof scopeOrType !== "function";
-        const scope = isScope ? scopeOrType : Scopes.transient;
-        const allTypes = isScope ? types : [
-            scopeOrType,
-            ...types
-        ];
-        return allTypes.map((type)=>bind(scope)(type, type));
-    }
-    createRegistrar(override) {
-        const bind = this.register(override);
-        return {
-            registerType: (type, scope = Scopes.transient)=>bind(scope)(type, type),
-            registerTypes: (scopeOrType, ...types)=>this.registerMany(override, scopeOrType, types),
-            registerTransient: (typeOrKey, type)=>bind(Scopes.transient)(typeOrKey, type),
-            registerSingleton: (typeOrKey, typeOrInstance)=>bind(Scopes.singleton)(typeOrKey, typeOrInstance),
-            registerRequestScoped: (typeOrKey, type)=>bind(Scopes.request)(typeOrKey, type)
-        };
-    }
-}

package/types/src/models/service-key.d.ts

@@ -1,9 +0,0 @@
-import type { Constructable, FunctionType } from "@decohere/core/reflection";
-/**
- * What a service is registered and resolved under, compared by identity: the class (or factory)
- * itself, a symbol, or a string. A string never matches a class with that name, and two symbols
- * with the same description are different keys.
- */
-export type ServiceKey = string | symbol | Constructable | FunctionType;
-/** A readable name for a key, for error messages. */
-export declare function describeKey(key: ServiceKey): string;