index.js

"use strict";

class SingletonLifecycle {
  cache = new Map();
  container;
  parent;

  constructor(container, parent) {
    Object.assign(this, {
      container,
      parent,
    });
  }

  get(key) {
    if (this.cache.has(key)) {
      return this.cache.get(key);
    }

    // If the singleton wasn't found, maybe it is available in the parent
    return this.parent?.get(key);
  }

  set(key, instance) {
    if (!this.cache.has(key)) {
      this.cache.set(key, instance);
    }
  }
}

class UniqueLifecycle {
  container;

  constructor(container) {
    this.container = container;
  }

  get() {
    return null;
  }

  set() {}
}

const nullableFacility = {
  suffixes: ["?"],

  beforeResolve(container, key, reg) {
    if (reg) {
      // We don't want to handle non-null instances
      return {
        handled: false,
      };
    } else {
      return {
        handled: true,
        data: null,
      };
    }
  },
};

class FactoryInstance {
  container;
  key;

  constructor(container, key) {
    Object.assign(this, {
      container: container.create(),
      key,
    });
  }

  get(...args) {
    return this.container.get(this.key, ...args);
  }

  use(key, value, lifecycle) {
    this.container.register(key, value, lifecycle);
    return this;
  }
}

class Factory {
  container;
  key;

  constructor(container, key) {
    Object.assign(this, {
      container,
      key,
    });
  }

  get(...args) {
    return new FactoryInstance(this.container, this.key).get(...args);
  }

  use(key, value, lifecycle) {
    return new FactoryInstance(this.container, this.key).use(key, value, lifecycle);
  }
}

const factoryFacility = {
  suffixes: ["Factory", "!"],

  resolve(container, key) {
    return {
      handled: true,
      data: new Factory(container, key),
    };
  },
};

function getFacility(container, key) {
  for (const facilityName in container.facilities) {
    const facility = container.facilities[facilityName];
    for (const suffix of facility.suffixes) {
      if (key.includes(suffix, key.length - suffix.length)) {
        return {
          data: facility,
          key: key.slice(0, key.length - suffix.length),
        };
      }
    }
  }

  return {
    data: null,
    key,
  };
}

function get(container, key, extraInjections) {
  let facility = getFacility(container, key);
  key = facility.key;
  facility = facility.data;

  // Try to find the dependency registration in the current container.
  // If not found, recursively try the parent container.
  let reg;
  let currentContainer = container;
  while (currentContainer) {
    reg = currentContainer.registry.get(key);
    if (!reg) {
      currentContainer = currentContainer.parent;
    } else {
      break;
    }
  }

  if (facility && facility.beforeResolve) {
    const result = facility.beforeResolve(container, key, reg);
    if (result.handled) {
      return result.data;
    }
  }

  if (!currentContainer) {
    throw new Error(`Unknown dependency: ${  key}`);
  }

  if (facility && facility.resolve) {
    const result = facility.resolve(container, key, reg);
    if (result.handled) {
      return result.data;
    }
  }

  // Ask the lifecycle if it already has an instance of this dependency
  let instance = container.lifecycles[reg.lifecycle].get(key);

  if (instance) {
    return instance;
  }

  let returnValue;

  // Lifecycle didn't have an instance, so we need to create it.
  // If the registered value is a function we use it as a constructor.
  // Otherwise, we simply return the registered value.
  if (reg.value instanceof Function) {
    // The registered value is a constructor, so we need to construct the object and inject all the dependencies.
    const injections = reg.value.$inject;
    const resolvedInjections = [];
    if (Array.isArray(injections)) {
      for (const injectionKey of injections) {
        resolvedInjections.push(get(container, injectionKey, []));
      }
    }

    for (const extraInjection of extraInjections) {
      resolvedInjections.push(extraInjection);
    }

    // If the callback returns a function, we consider it to be a custom factory.
    // This factory is then registered under the same key in the child container.
    returnValue = new reg.value(...resolvedInjections);

    if (returnValue instanceof Function) {
      instance = new FactoryInstance(container, key);
      instance.container.register(key, returnValue);

      // Copy any static properties owned by the factory
      for (const propertyName in returnValue) {
        if (Object.prototype.hasOwnProperty.call(returnValue, propertyName)) {
          instance[propertyName] = returnValue[propertyName];
        }
      }

      returnValue = undefined;
    }
  } else {
    // The registered value is an existing instance.
    instance = reg.value;
  }

  container.lifecycles[reg.lifecycle].set(reg.key, returnValue ?? instance);

  // If the returnValue is set, we should return that instead of the instance.
  return returnValue ?? instance;
}

module.exports = class Container {
  registry = new Map();
  parent;
  lifecycles;
  options;
  facilities = {
    nullable: nullableFacility,
    factory: factoryFacility,
  };

  constructor(options, parent) {
    Object.assign(this, {
      parent,
      lifecycles: {
        singleton: new SingletonLifecycle(this, parent?.lifecycles.singleton),
        unique: new UniqueLifecycle(this),
      },
      options: options ?? {},
    });

    this.register("container", this);
  }

  register(key, value, lifecycle) {
    if (getFacility(this, key).data) {
      throw new Error(`Cannot register dependency: ${key}`);
    }

    const registered = this.registry.get(key);

    if (!lifecycle && registered) {
      registered.value = value;
      return;
    }

    this.registry.set(key, {
      key,
      container: this,
      value,
      lifecycle: lifecycle ?? "unique"
    });
  }

  get(key, ...extraInjections) {
    let container = this;
    let value;
    while (container && (value = get(container, key, extraInjections)) === null) {
      container = container.parent;
    }

    return value;
  }

  create(options = {}) {
    return new Container(options, this);
  }
};