@webfaas/webfaas-core
Version:
WebFaaS Framework - Core
199 lines • 9.51 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ModuleManagerImport = void 0;
const PackageStoreManager_1 = require("../PackageStoreManager/PackageStoreManager");
const PackageRegistryManager_1 = require("../PackageRegistryManager/PackageRegistryManager");
const ILog_1 = require("../Log/ILog");
const ModuleManagerRequireContextData_1 = require("./ModuleManagerRequireContextData");
const SmallManifest_1 = require("../Manifest/SmallManifest");
const WebFaasError_1 = require("../WebFaasError/WebFaasError");
const SmallSemver_1 = require("../Semver/SmallSemver");
const ModuleNameUtil_1 = require("../Util/ModuleNameUtil");
/**
* manager Module
*/
class ModuleManagerImport {
constructor(moduleManager, log, packageStoreManager) {
this.moduleManager = moduleManager;
this.log = log;
this.semver = new SmallSemver_1.SmallSemver();
if (packageStoreManager) {
this.packageStoreManager = packageStoreManager;
}
else {
this.packageStoreManager = new PackageStoreManager_1.PackageStoreManager(new PackageRegistryManager_1.PackageRegistryManager(this.log), this.log);
}
}
/**
* return semver
*/
getSemver() {
return this.semver;
}
/**
* set semver
* @param semver
*/
setSemver(semver) {
this.semver = semver;
}
/**
* return packageStoreManager
*/
getPackageStoreManager() {
return this.packageStoreManager;
}
/**
* return small manifest
* @param packageName package name
*/
getSmallManifest(packageName) {
return new Promise(async (resolve, reject) => {
try {
var smallManifestResponse = this.moduleManager.getModuleManagerCache().getCompiledObjectFromCache(packageName, "", "smallmanifest");
if (smallManifestResponse) {
resolve(smallManifestResponse);
}
else {
let packageStoreManifest = await this.packageStoreManager.getPackageStore(packageName);
if (packageStoreManifest) {
let manifestResponse = packageStoreManifest.getManifest();
if (manifestResponse) {
smallManifestResponse = new SmallManifest_1.SmallManifest(manifestResponse.name, Object.keys(manifestResponse.versions || {}));
this.moduleManager.getModuleManagerCache().addCompiledObjectToCache(packageName, "", "smallmanifest", smallManifestResponse);
resolve(smallManifestResponse);
}
else {
resolve(null);
}
}
else {
resolve(null);
}
}
}
catch (errTry) {
reject(errTry);
}
});
}
/**
* resolve version semver format
* @param packageName name
* @param packageVersion version
*/
resolveVersion(packageName, packageVersion) {
return new Promise(async (resolve, reject) => {
try {
if (this.getSemver().valid(packageVersion)) {
resolve(packageVersion);
}
else {
var smallManifestResponse = await this.getSmallManifest(packageName);
if (smallManifestResponse) {
var versionTO = this.getSemver().maxSatisfying(smallManifestResponse.versionsArray, packageVersion) || "";
if (versionTO) {
resolve(versionTO);
}
else {
reject(new WebFaasError_1.WebFaasError.NotFoundError(WebFaasError_1.WebFaasError.NotFoundErrorTypeEnum.VERSION, packageName + ":" + packageVersion));
}
}
else {
reject(new WebFaasError_1.WebFaasError.NotFoundError(WebFaasError_1.WebFaasError.NotFoundErrorTypeEnum.MANIFEST, packageName));
}
}
}
catch (errTry) {
reject(errTry);
}
});
}
/**
* import dependencies in package
* @param packageStore
* @param cachePackageStoreDependenciesItem
*/
importDependencies(packageStore, cachePackageStoreDependenciesItem) {
return new Promise(async (resolve, reject) => {
try {
var packageManifestObj = packageStore.getManifest();
if (packageManifestObj && packageManifestObj.dependencies) {
var dependencyKeys = Object.keys(packageManifestObj.dependencies);
for (var i = 0; i < dependencyKeys.length; i++) {
var nameDependency = dependencyKeys[i];
var versionDependency = packageManifestObj.dependencies[nameDependency] || "";
var versionDependencyResolved = await this.resolveVersion(nameDependency, versionDependency);
packageManifestObj.dependencies[nameDependency] = versionDependencyResolved; //resolve version
var packageStoreDependency = await this.packageStoreManager.getPackageStore(nameDependency, versionDependencyResolved);
if (packageStoreDependency) {
//cache
if (cachePackageStoreDependenciesItem) {
cachePackageStoreDependenciesItem.putPackageStore(packageStoreDependency);
}
this.log.write(ILog_1.LogLevelEnum.INFO, "importDependencies", ILog_1.LogCodeEnum.PROCESS.toString(), packageStore.getName(), { nameDependency: nameDependency, versionDependency: versionDependencyResolved }, __filename);
await this.importDependencies(packageStoreDependency, cachePackageStoreDependenciesItem);
}
else {
reject(new WebFaasError_1.WebFaasError.NotFoundError(WebFaasError_1.WebFaasError.NotFoundErrorTypeEnum.DEPENDENCY, packageStore.getName() + " => " + nameDependency + ":" + versionDependencyResolved));
return;
}
}
}
resolve(null);
}
catch (errTry) {
reject(errTry);
}
});
}
/**
* import module
* @param name module name
* @param version module version
* @param etag etag
* @param registryName registry
* @param imediateCleanMemoryCacheModuleFiles clean cache
*/
import(name, version, etag, registryName, imediateCleanMemoryCacheModuleFiles = true) {
return new Promise(async (resolve, reject) => {
try {
var nameParsedObj = ModuleNameUtil_1.ModuleNameUtil.parse(name, "");
var responseModuleObj;
var versionResolved = await this.resolveVersion(nameParsedObj.moduleName, version);
//verify cache
responseModuleObj = this.moduleManager.getModuleManagerCache().getCompiledObjectFromCache(nameParsedObj.fullName, versionResolved, "");
if (responseModuleObj) {
resolve(responseModuleObj);
return;
}
let packageStore = await this.packageStoreManager.getPackageStore(nameParsedObj.moduleName, versionResolved, etag, registryName);
if (packageStore) {
let rootPackageStoreKey = packageStore.getKey();
let cachePackageStoreDependenciesItem = this.moduleManager.getModuleManagerCache().cachePackageStoreBuild();
await this.importDependencies(packageStore, cachePackageStoreDependenciesItem);
//set rootPackageStore in cache
cachePackageStoreDependenciesItem.putPackageStore(packageStore);
let moduleManagerRequireContextData = new ModuleManagerRequireContextData_1.ModuleManagerRequireContextData(rootPackageStoreKey);
//add all files to temporary memory cache
this.moduleManager.getModuleManagerCache().addPackageStoreCacheSyncToCache(rootPackageStoreKey, cachePackageStoreDependenciesItem);
//responseModuleObj = this.requireSync(nameParsedObj.fullName, versionResolved, moduleManagerRequireContextData);
responseModuleObj = await this.moduleManager.requireAsync(nameParsedObj.fullName, versionResolved, moduleManagerRequireContextData);
if (imediateCleanMemoryCacheModuleFiles) {
//remove temporary cache
this.moduleManager.getModuleManagerCache().cleanCachePackageStoreByNameAndVersion(name, version);
}
resolve(responseModuleObj);
}
else {
resolve(null);
}
}
catch (errTry) {
reject(errTry);
}
});
}
}
exports.ModuleManagerImport = ModuleManagerImport;
//# sourceMappingURL=ModuleManagerImport.js.map