nestjs-dynamic-providers/dist/index.js

Inject dynamic providers

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/service/resolve-file.service.ts
var _constants = require('@nestjs/common/constants');
var _glob = require('glob');

// src/utils/function/is-object.ts
function IsObject(instance) {
  return typeof instance === "object" ? instance !== null : typeof instance === "function";
}
__name(IsObject, "IsObject");

// src/service/resolve-file.service.ts
var _path = require('path'); var path = _interopRequireWildcard(_path);
var _ResolveFileService = class _ResolveFileService {
  async resolveByGlobPattern(startupPath, options) {
    const classesList = await Promise.all(options.map(({ pattern, exportProviders, filterPredicate, scope }) => _glob.glob.call(void 0, pattern, {
      cwd: startupPath
    }).then(async (pathToFiles) => {
      const types = (await this.getClasses(startupPath, pathToFiles)).flat();
      if (!filterPredicate) filterPredicate = /* @__PURE__ */ __name((type) => IsObject(type) && Reflect.hasOwnMetadata(_constants.SCOPE_OPTIONS_METADATA, type), "filterPredicate");
      return {
        types: types.filter(filterPredicate),
        exportProviders,
        scope
      };
    })));
    return classesList.flat();
  }
  getClasses(startupPath, pathToFiles) {
    return Promise.all(pathToFiles.map(async (pathToFile) => {
      const resolvedPath = path.resolve(startupPath, pathToFile);
      const resolvedClass = await Promise.resolve().then(() => _interopRequireWildcard(require(resolvedPath)));
      return Object.values(resolvedClass);
    }));
  }
};
__name(_ResolveFileService, "ResolveFileService");
var ResolveFileService = _ResolveFileService;

// src/definition/guard/is-dynamic-provider-options.ts
function isDynamicProviderOptions(param) {
  return typeof param[0] === "object";
}
__name(isDynamicProviderOptions, "isDynamicProviderOptions");

// src/definition/guard/is-pattern.ts
function isPattern(param) {
  return typeof param[0] === "string";
}
__name(isPattern, "isPattern");

// src/decorator/inject-dynamic-providers.ts
var _process = require('process'); var process = _interopRequireWildcard(_process);
var store = [];
function InjectDynamicProviders(...options) {
  return (target) => {
    if (isDynamicProviderOptions(options)) store.push({
      target,
      options
    });
    if (isPattern(options)) store.push({
      target,
      options: options.map((pattern) => ({
        pattern
      }))
    });
    return target;
  };
}
__name(InjectDynamicProviders, "InjectDynamicProviders");
async function resolveDynamicProviders(startupPath = process.cwd()) {
  const resolveFileService = new ResolveFileService();
  await Promise.all(store.map(async ({ target, options }) => {
    const resolvedProviders = await resolveFileService.resolveByGlobPattern(startupPath, options);
    resolvedProviders.forEach(({ types, exportProviders, scope }) => {
      mergeProviders(target, types, scope);
      if (exportProviders) {
        mergeExportedProviders(target, types);
      }
    });
  }));
}
__name(resolveDynamicProviders, "resolveDynamicProviders");
function mergeProviders(target, newProviderTypes, scope) {
  var _a;
  const currentProviders = (_a = Reflect.getMetadata("providers", target)) != null ? _a : [];
  const newProviders = scope ? newProviderTypes.map((newClassType) => ({
    provide: newClassType,
    useClass: newClassType,
    scope
  })) : newProviderTypes;
  Reflect.defineMetadata("providers", [
    ...currentProviders,
    ...newProviders
  ], target);
}
__name(mergeProviders, "mergeProviders");
function mergeExportedProviders(target, newExportedProviders) {
  var _a;
  const currentExportedProviders = (_a = Reflect.getMetadata("exports", target)) != null ? _a : [];
  Reflect.defineMetadata("exports", [
    ...currentExportedProviders,
    ...newExportedProviders
  ], target);
}
__name(mergeExportedProviders, "mergeExportedProviders");




exports.InjectDynamicProviders = InjectDynamicProviders; exports.IsObject = IsObject; exports.resolveDynamicProviders = resolveDynamicProviders;
//# sourceMappingURL=index.js.map