nestjs-dynamic-providers/dist/index.mjs

Inject dynamic providers

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/service/resolve-file.service.ts
import { SCOPE_OPTIONS_METADATA } from "@nestjs/common/constants";
import { glob } from "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
import * as path from "path";
var _ResolveFileService = class _ResolveFileService {
  async resolveByGlobPattern(startupPath, options) {
    const classesList = await Promise.all(options.map(({ pattern, exportProviders, filterPredicate, scope }) => glob(pattern, {
      cwd: startupPath
    }).then(async (pathToFiles) => {
      const types = (await this.getClasses(startupPath, pathToFiles)).flat();
      if (!filterPredicate) filterPredicate = /* @__PURE__ */ __name((type) => IsObject(type) && Reflect.hasOwnMetadata(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 import(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
import * as process from "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");
export {
  InjectDynamicProviders,
  IsObject,
  resolveDynamicProviders
};
//# sourceMappingURL=index.mjs.map