@gapi/cli 1.8.121 → 1.8.125

package/dist/daemon-server/core/services/ipfs/external-importer.d.ts

@@ -0,0 +1,57 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ExternalImporterConfig, ExternalImporterIpfsConfig, ExternalModuleConfiguration } from './external-importer-config';
+import { IPFS_PROVIDERS } from './providers';
+export interface PackagesConfig {
+    dependencies: string[];
+    provider: string;
+}
+export declare class ExternalImporter {
+    defaultJsonFolder: string;
+    defaultTypescriptConfigJsonFolder: string;
+    private requestService;
+    private fileService;
+    private npmService;
+    providers: BehaviorSubject<{
+        name: IPFS_PROVIDERS;
+        link: string;
+    }[]>;
+    defaultProvider: string;
+    defaultNamespaceFolder: string;
+    defaultOutputFolder: string;
+    setDefaultProvider(provider: IPFS_PROVIDERS): void;
+    getProvider(name: IPFS_PROVIDERS): string;
+    setProviders(...args: {
+        name: IPFS_PROVIDERS;
+        link: string;
+    }[]): void;
+    importExternalModule(module: string): Observable<unknown>;
+    validateConfig(config: ExternalImporterConfig): void;
+    isWeb(): boolean;
+    loadTypescriptConfigJson(): {
+        compilerOptions?: {
+            typeRoots?: string[];
+        };
+    };
+    addNamespaceToTypeRoots(namespace: string): Observable<boolean>;
+    writeTypescriptConfigFile(file: any): void;
+    loadPackageJson(): any;
+    loadNpmPackageJson(): any;
+    prepareDependencies(): {
+        name: string;
+        version: any;
+    }[];
+    isModulePresent(hash: any): number;
+    filterUniquePackages(): number;
+    defaultIpfsConfig(): {
+        provider: string;
+        dependencies: any[];
+    }[];
+    addPackageToJson(hash: string): void;
+    downloadIpfsModules(modules: ExternalImporterIpfsConfig[]): Observable<[any]>;
+    downloadIpfsModuleConfig(config: ExternalImporterIpfsConfig): Observable<ExternalModuleConfiguration>;
+    private combineDependencies;
+    private writeFakeIndexIfMultiModule;
+    downloadIpfsModule(config: ExternalImporterIpfsConfig): any;
+    downloadTypings(moduleLink: string, folder: string, fileName: string, config: ExternalImporterConfig): Observable<unknown>;
+    importModule(config: ExternalImporterConfig, token: string, { folderOverride, waitUntil }?: any): Promise<any>;
+}

package/dist/daemon-server/core/services/ipfs/external-importer.js

@@ -0,0 +1,359 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalImporter = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const file_1 = require("../../../../core/services/file");
+const providers_1 = require("./providers");
+const SystemJS = require("systemjs");
+const core_1 = require("@rxdi/core");
+const npm_service_1 = require("./npm-service");
+const request_1 = require("./request");
+let ExternalImporter = class ExternalImporter {
+    constructor() {
+        this.defaultJsonFolder = `${process.cwd()}/package.json`;
+        this.defaultTypescriptConfigJsonFolder = `${process.cwd()}/tsconfig.json`;
+        this.providers = new rxjs_1.BehaviorSubject(providers_1.IPFS_PROVIDERS);
+        this.defaultProvider = this.getProvider('main-ipfs-node');
+        this.defaultNamespaceFolder = '@types';
+        this.defaultOutputFolder = 'node_modules';
+    }
+    setDefaultProvider(provider) {
+        this.defaultProvider = this.getProvider(provider);
+    }
+    getProvider(name) {
+        return this.providers.getValue().filter((p) => p.name === name)[0].link;
+    }
+    setProviders(...args) {
+        this.providers.next([...this.providers.getValue(), ...args]);
+    }
+    importExternalModule(module) {
+        return rxjs_1.from(SystemJS.import(module));
+    }
+    validateConfig(config) {
+        if (!config) {
+            throw new Error('Bootstrap: missing config');
+        }
+    }
+    isWeb() {
+        let value = false;
+        try {
+            if (window) {
+                value = true;
+            }
+        }
+        catch (e) { }
+        return value;
+    }
+    loadTypescriptConfigJson() {
+        let tsConfig = {};
+        try {
+            tsConfig = this.fileService.readFile(this.defaultTypescriptConfigJsonFolder);
+        }
+        catch (e) {
+            console.error(`
+            Error in loading tsconfig.json in ${this.defaultTypescriptConfigJsonFolder}
+            Error: ${e}
+            Fallback to creating tsconfig.json
+            `);
+        }
+        tsConfig.compilerOptions = tsConfig.compilerOptions || {};
+        tsConfig.compilerOptions.typeRoots =
+            tsConfig.compilerOptions.typeRoots || [];
+        return tsConfig;
+    }
+    addNamespaceToTypeRoots(namespace) {
+        const defaultNamespace = `./${this.defaultOutputFolder}/@types/${namespace}`;
+        const tsConfig = this.loadTypescriptConfigJson();
+        const foundNamespace = tsConfig.compilerOptions.typeRoots.filter((t) => t === defaultNamespace).length;
+        if (!foundNamespace) {
+            tsConfig.compilerOptions.typeRoots.push(defaultNamespace);
+            this.writeTypescriptConfigFile(tsConfig);
+        }
+        return rxjs_1.of(true);
+    }
+    writeTypescriptConfigFile(file) {
+        this.fileService.writeFileSync(process.cwd() + '/tsconfig.json', file);
+    }
+    loadPackageJson() {
+        let packageJson;
+        try {
+            packageJson = this.fileService.readFile(this.defaultJsonFolder);
+        }
+        catch (e) {
+            packageJson = {};
+        }
+        return packageJson;
+    }
+    loadNpmPackageJson() {
+        let packageJson;
+        try {
+            packageJson = this.fileService.readFile(`${process.cwd()}/package.json`);
+        }
+        catch (e) {
+            packageJson = {};
+        }
+        return packageJson;
+    }
+    prepareDependencies() {
+        const file = this.loadNpmPackageJson();
+        if (file.dependencies) {
+            return Object.keys(file.dependencies).map((name) => ({
+                name,
+                version: file.dependencies[name],
+            }));
+        }
+        return [];
+    }
+    isModulePresent(hash) {
+        const file = this.loadPackageJson();
+        let ipfsConfig = file.ipfs;
+        const found = [];
+        if (!ipfsConfig) {
+            ipfsConfig = this.defaultIpfsConfig();
+        }
+        ipfsConfig.forEach((c) => {
+            const present = c.dependencies.filter((dep) => dep === hash);
+            if (present.length) {
+                found.push(present[0]);
+            }
+        });
+        return found.length;
+    }
+    filterUniquePackages() {
+        const file = this.loadPackageJson();
+        let ipfsConfig = file.ipfs;
+        let dups = [];
+        if (!ipfsConfig) {
+            ipfsConfig = this.defaultIpfsConfig();
+        }
+        ipfsConfig.forEach((c) => {
+            const uniq = c.dependencies
+                .map((name) => {
+                return { count: 1, name: name };
+            })
+                .reduce((a, b) => {
+                a[b.name] = (a[b.name] || 0) + b.count;
+                return a;
+            }, {});
+            const duplicates = Object.keys(uniq).filter((a) => uniq[a] > 1);
+            dups = [...dups, ...duplicates];
+        });
+        if (dups.length) {
+            throw new Error(`There are packages which are with the same hash ${JSON.stringify(dups)}`);
+        }
+        return dups.length;
+    }
+    defaultIpfsConfig() {
+        return [{ provider: this.defaultProvider, dependencies: [] }];
+    }
+    addPackageToJson(hash) {
+        const file = this.loadPackageJson();
+        let ipfsConfig = file.ipfs;
+        if (!ipfsConfig) {
+            ipfsConfig = this.defaultIpfsConfig();
+        }
+        const packages = this.prepareDependencies();
+        if (packages.length) {
+            file.packages = packages;
+        }
+        if (this.isModulePresent(hash)) {
+            console.log(`Package with hash: ${hash} present and will not be downloaded!`);
+        }
+        else {
+            ipfsConfig[0].dependencies.push(hash);
+            file.ipfs = ipfsConfig;
+        }
+        this.fileService.writeFileSync(this.defaultJsonFolder, file);
+    }
+    downloadIpfsModules(modules) {
+        const latest = modules.map((m) => this.downloadIpfsModule(m));
+        return rxjs_1.combineLatest(latest.length ? latest : rxjs_1.of());
+    }
+    downloadIpfsModuleConfig(config) {
+        return this.requestService.get(config.provider + config.hash).pipe(operators_1.map((r) => {
+            if (!r) {
+                throw new Error('Recieved undefined from provided address' +
+                    config.provider +
+                    config.hash);
+            }
+            let res = r;
+            const metaString = '<!--meta-rxdi-ipfs-module-->';
+            if (res.includes(metaString)) {
+                try {
+                    res = res.split(metaString)[1];
+                }
+                catch (e) { }
+            }
+            return res;
+        }), operators_1.map((r) => {
+            let res = r;
+            try {
+                res = JSON.parse(r);
+            }
+            catch (e) { }
+            return res;
+        }));
+    }
+    combineDependencies(dependencies, config) {
+        return rxjs_1.combineLatest([
+            ...(dependencies.length
+                ? dependencies.map((h) => this.downloadIpfsModule({ provider: config.provider, hash: h }))
+                : [rxjs_1.of('')]),
+        ]);
+    }
+    writeFakeIndexIfMultiModule(folder, nameSpaceFakeIndex) {
+        if (nameSpaceFakeIndex.length === 2) {
+            return this.fileService.writeFileAsyncP(`${folder}${this.defaultNamespaceFolder}/${nameSpaceFakeIndex[0]}`, 'index.d.ts', '');
+        }
+        else {
+            return rxjs_1.of(true);
+        }
+    }
+    downloadIpfsModule(config) {
+        if (!config.provider) {
+            throw new Error(`Missing configuration inside ${config.hash}`);
+        }
+        if (!config.hash) {
+            throw new Error(`Missing configuration inside ${config.provider}`);
+        }
+        let folder;
+        let moduleLink;
+        const configLink = config.provider + config.hash;
+        let moduleTypings;
+        let moduleName;
+        let nameSpaceFakeIndex;
+        let originalModuleConfig;
+        let isNamespace;
+        let isRegular;
+        return this.downloadIpfsModuleConfig(config).pipe(operators_1.tap((res) => {
+            if (!res['module']) {
+                console.log('Todo: create logic to load module which is not from rxdi infrastructure for now can be used useDynamic which will do the same job!');
+            }
+        }), operators_1.filter((res) => !!res.module), operators_1.map((externalModule) => {
+            moduleName = externalModule.name;
+            nameSpaceFakeIndex = moduleName.split('/');
+            folder = `${process.cwd()}/${this.defaultOutputFolder}/`;
+            moduleLink = `${config.provider}${externalModule.module}`;
+            moduleTypings = `${config.provider}${externalModule.typings}`;
+            externalModule.dependencies = externalModule.dependencies || [];
+            externalModule.packages = externalModule.packages || [];
+            originalModuleConfig = externalModule;
+            this.npmService.setPackages(externalModule.packages);
+            isNamespace = moduleName.split('/').length === 2;
+            isRegular = isNamespace ? moduleName : moduleName.split('/')[0];
+            console.log(`Package config for module ${moduleName} downloaded! ${JSON.stringify(externalModule)}`);
+            return externalModule;
+        }), operators_1.switchMap((externalModule) => this.combineDependencies(externalModule.dependencies, config)), operators_1.switchMap(() => {
+            console.log(`--------------------${moduleName}--------------------`);
+            console.log(`\nDownloading... ${configLink} `);
+            console.log(`Config: ${JSON.stringify(originalModuleConfig, null, 2)} \n`);
+            return this.requestService.get(moduleLink);
+        }), operators_1.switchMap((file) => this.fileService.writeFile(folder + moduleName, 'index.js', moduleName, file)), operators_1.switchMap(() => this.requestService.get(moduleTypings)), operators_1.switchMap((file) => this.fileService.writeFile(folder + `${this.defaultNamespaceFolder}/${isRegular}`, 'index.d.ts', moduleName, file)), operators_1.tap(() => {
+            if (process.env.WRITE_FAKE_INDEX) {
+                this.writeFakeIndexIfMultiModule(folder, nameSpaceFakeIndex);
+            }
+        }), operators_1.switchMap(() => this.addNamespaceToTypeRoots(moduleName.split('/')[0])), operators_1.map(() => ({
+            provider: config.provider,
+            hash: config.hash,
+            version: originalModuleConfig.version,
+            name: originalModuleConfig.name,
+            dependencies: originalModuleConfig.dependencies,
+            packages: originalModuleConfig.packages,
+        })), operators_1.tap(() => {
+            if (originalModuleConfig.packages.length) {
+                this.npmService.installPackages();
+            }
+        }));
+    }
+    downloadTypings(moduleLink, folder, fileName, config) {
+        if (!moduleLink) {
+            return rxjs_1.of(true);
+        }
+        return this.requestService.get(moduleLink).pipe(operators_1.take(1), operators_1.map((res) => {
+            console.log(`Done!`);
+            return res;
+        }), operators_1.switchMap((res) => this.fileService.writeFile(folder, fileName, config.typingsFileName, res)));
+    }
+    importModule(config, token, { folderOverride, waitUntil } = {}) {
+        const timer$ = rxjs_1.timer(waitUntil || 20 * 1000);
+        this.validateConfig(config);
+        if (this.isWeb()) {
+            SystemJS.config(Object.assign({
+                map: {
+                    [token]: config.link,
+                },
+            }, config.SystemJsConfig));
+            return SystemJS.import(config.link);
+        }
+        return new rxjs_1.Observable((observer) => {
+            const moduleName = config.fileName;
+            const moduleNamespace = config.namespace;
+            const moduleLink = config.link;
+            const moduleExtension = config.extension;
+            const moduleSystemJsConfig = config.SystemJsConfig || {};
+            const modulesFolder = config.outputFolder || `/${this.defaultOutputFolder}/`;
+            const fileFullPath = `${folderOverride || process.cwd()}${modulesFolder}/${moduleNamespace}/${moduleName}.${moduleExtension}`;
+            const folder = `${folderOverride || process.cwd()}${modulesFolder}${moduleNamespace}`;
+            const fileName = `${moduleName}.${moduleExtension}`;
+            Object.assign(moduleSystemJsConfig, {
+                paths: Object.assign({ [moduleName]: fileFullPath }, moduleSystemJsConfig.paths),
+            });
+            SystemJS.config(moduleSystemJsConfig);
+            if (this.fileService.isPresent(fileFullPath)) {
+                console.log(`Bootstrap -> @Service('${moduleName}'): present inside .${modulesFolder}${moduleNamespace}/${moduleName}.${moduleExtension} folder and loaded from there`);
+                this.importExternalModule(moduleName)
+                    .pipe(operators_1.take(1))
+                    .subscribe((m) => {
+                    observer.next(m);
+                    observer.complete();
+                }, (err) => {
+                    observer.error(err);
+                    observer.complete();
+                });
+            }
+            else {
+                console.log(`Bootstrap -> @Service('${moduleName}'): will be downloaded inside .${modulesFolder}${moduleNamespace}/${moduleName}.${moduleExtension} folder and loaded from there`);
+                console.log(`Bootstrap -> @Service('${moduleName}'): ${moduleLink} downloading...`);
+                this.requestService
+                    .get(moduleLink)
+                    .pipe(operators_1.take(1), operators_1.tap(() => console.log(`Done!`)), operators_1.switchMap((res) => this.fileService.writeFile(folder, fileName, config.fileName, res)), operators_1.switchMap(() => this.downloadTypings(config.typings, folder, fileName, config)), operators_1.switchMap(() => this.importExternalModule(moduleName)))
+                    .subscribe((m) => {
+                    observer.next(m);
+                    observer.complete();
+                }, (err) => {
+                    observer.error(err);
+                    observer.complete();
+                });
+            }
+        })
+            .pipe(operators_1.takeUntil(timer$))
+            .toPromise();
+    }
+};
+__decorate([
+    core_1.Injector(request_1.RequestService),
+    __metadata("design:type", request_1.RequestService)
+], ExternalImporter.prototype, "requestService", void 0);
+__decorate([
+    core_1.Injector(file_1.FileService),
+    __metadata("design:type", file_1.FileService)
+], ExternalImporter.prototype, "fileService", void 0);
+__decorate([
+    core_1.Injector(npm_service_1.NpmService),
+    __metadata("design:type", npm_service_1.NpmService)
+], ExternalImporter.prototype, "npmService", void 0);
+ExternalImporter = __decorate([
+    core_1.Service()
+], ExternalImporter);
+exports.ExternalImporter = ExternalImporter;

package/dist/daemon-server/core/services/ipfs/npm-service.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { BehaviorSubject } from 'rxjs';
+import childProcess = require('child_process');
+import { NpmPackageConfig } from './external-importer-config';
+export declare class NpmService {
+    packagesToDownload: BehaviorSubject<NpmPackageConfig[]>;
+    packages: string[];
+    child: childProcess.ChildProcess;
+    setPackages(packages: NpmPackageConfig[]): void;
+    preparePackages(): void;
+    installPackages(): Promise<unknown>;
+}

package/dist/daemon-server/core/services/ipfs/npm-service.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmService = void 0;
+const rxjs_1 = require("rxjs");
+const childProcess = require("child_process");
+const core_1 = require("@rxdi/core");
+let NpmService = class NpmService {
+    constructor() {
+        this.packagesToDownload = new rxjs_1.BehaviorSubject([]);
+        this.packages = [];
+    }
+    setPackages(packages) {
+        this.packagesToDownload.next([
+            ...this.packagesToDownload.getValue(),
+            ...packages,
+        ]);
+    }
+    preparePackages() {
+        const arr = this.packagesToDownload.getValue() || [];
+        this.packages = [...new Set(arr.map((p) => `${p.name}@${p.version}`))];
+    }
+    installPackages() {
+        return new Promise(() => {
+            this.preparePackages();
+            if (this.child) {
+                this.child.stdout.removeAllListeners('data');
+                this.child.stderr.removeAllListeners('data');
+                this.child.removeAllListeners('exit');
+                this.child.kill();
+            }
+            console.log(`Installing npm packages on child process! ${this.packages.toString()}`);
+            this.child = childProcess.spawn('npm', ['i', ...this.packages]);
+            this.child.stdout.on('data', (data) => process.stdout.write(data));
+            this.child.stderr.on('data', (data) => {
+                process.stdout.write(data);
+                // reject(data)
+            });
+            this.child.on('exit', (code) => {
+                console.log(`Child process exited with code ${code}`);
+                console.log(`Installing npm packages DONE! ${this.packages.toString()}`);
+                this.child = null;
+            });
+        });
+    }
+};
+NpmService = __decorate([
+    core_1.Service()
+], NpmService);
+exports.NpmService = NpmService;

package/dist/daemon-server/core/services/ipfs/providers.d.ts

@@ -0,0 +1,5 @@
+export declare const IPFS_PROVIDERS: {
+    name: IPFS_PROVIDERS;
+    link: string;
+}[];
+export declare type IPFS_PROVIDERS = 'cloudflare' | 'main-ipfs-node' | 'local' | 'infura';

package/dist/daemon-server/core/services/ipfs/providers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPFS_PROVIDERS = void 0;
+exports.IPFS_PROVIDERS = [
+    {
+        name: 'cloudflare',
+        link: 'https://cloudflare-ipfs.com/ipfs/',
+    },
+    {
+        name: 'main-ipfs-node',
+        link: 'https://ipfs.io/ipfs/',
+    },
+    {
+        name: 'infura',
+        link: 'https://ipfs.infura.io/ipfs/',
+    },
+    {
+        name: 'local',
+        link: 'http://127.0.0.1:8080/ipfs/',
+    },
+];

package/dist/daemon-server/core/services/ipfs/request-cache.d.ts

@@ -0,0 +1,7 @@
+import { CacheLayer, CacheLayerItem, CacheService } from '@rxdi/core';
+export declare class RequestCacheService extends CacheService {
+    cacheLayer: CacheLayer<CacheLayerItem<any>>;
+    constructor();
+    put(key: any, data: any): CacheLayerItem<any>;
+    get(key: any): CacheLayerItem<any>;
+}

package/dist/daemon-server/core/services/ipfs/request-cache.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestCacheService = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const core_1 = require("@rxdi/core");
+let RequestCacheService = class RequestCacheService extends core_1.CacheService {
+    constructor() {
+        super(core_1.Container.get(core_1.BootstrapLogger));
+        this.cacheLayer = this.createLayer({ name: 'request-cache-layer' });
+    }
+    put(key, data) {
+        return this.cacheLayer.putItem({ key, data });
+    }
+    get(key) {
+        return this.cacheLayer.getItem(key);
+    }
+};
+RequestCacheService = __decorate([
+    core_1.Service(),
+    __metadata("design:paramtypes", [])
+], RequestCacheService);
+exports.RequestCacheService = RequestCacheService;

package/dist/daemon-server/core/services/ipfs/request.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+export declare class RequestService {
+    private cache;
+    private logger;
+    get(link: string): Observable<any>;
+}

package/dist/daemon-server/core/services/ipfs/request.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestService = void 0;
+const core_1 = require("@rxdi/core");
+const http_1 = require("http");
+const https_1 = require("https");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const request_cache_1 = require("./request-cache");
+let RequestService = class RequestService {
+    get(link) {
+        if (this.cache.cacheLayer.map.has(link)) {
+            this.logger.log(`Item returned from cacahe: ${link}`);
+            return rxjs_1.of(this.cache.cacheLayer.get(link).data);
+        }
+        return new rxjs_1.Observable((o) => {
+            if (link.includes('https://')) {
+                https_1.get(link, (resp) => {
+                    let data = '';
+                    resp.on('data', (chunk) => (data += chunk));
+                    resp.on('end', () => o.next(data));
+                }).on('error', (err) => {
+                    console.error('Error: ' + err.message);
+                    o.error(err);
+                });
+            }
+            else {
+                http_1.get(link, (resp) => {
+                    let data = '';
+                    resp.on('data', (chunk) => (data += chunk));
+                    resp.on('end', () => o.next(data));
+                }).on('error', (err) => {
+                    console.error('Error: ' + err.message);
+                    o.error(err);
+                });
+            }
+        }).pipe(operators_1.tap((res) => this.cache.cacheLayer.putItem({ key: link, data: res })));
+    }
+};
+__decorate([
+    core_1.Injector(request_cache_1.RequestCacheService),
+    __metadata("design:type", request_cache_1.RequestCacheService)
+], RequestService.prototype, "cache", void 0);
+__decorate([
+    core_1.Injector(core_1.BootstrapLogger),
+    __metadata("design:type", core_1.BootstrapLogger)
+], RequestService.prototype, "logger", void 0);
+RequestService = __decorate([
+    core_1.Service()
+], RequestService);
+exports.RequestService = RequestService;

package/dist/daemon-server/core/services/ipfs-hash-map.service.d.ts

@@ -1,4 +1,4 @@
-import { ExternalImporterConfig } from '@gapi/core';
+import { ExternalImporterConfig } from './ipfs/external-importer-config';
 export interface IPFS_MODULE_MAP {
     hash: string;
     module: ExternalImporterConfig;

package/dist/daemon-server/core/services/plugin-loader.service.d.ts

@@ -1,5 +1,7 @@
-import { ExternalImporter, FileService, Metadata } from '@rxdi/core';
+import { Metadata } from '@rxdi/core';
+import { FileService } from '../../../core/services/file';
 import { IpfsHashMapService } from './ipfs-hash-map.service';
+import { ExternalImporter } from './ipfs/external-importer';
 import { PluginWatcherService } from './plugin-watcher.service';
 interface CustomMetadata extends Function {
     metadata: Metadata;

package/dist/daemon-server/core/services/plugin-loader.service.js

@@ -25,8 +25,10 @@ const fs_1 = require("fs");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const util_1 = require("util");
+const file_1 = require("../../../core/services/file");
 const daemon_config_1 = require("../../daemon.config");
 const ipfs_hash_map_service_1 = require("./ipfs-hash-map.service");
+const external_importer_1 = require("./ipfs/external-importer");
 const plugin_watcher_service_1 = require("./plugin-watcher.service");
 let PluginLoader = class PluginLoader {
     constructor(externalImporterService, fileService, pluginWatcherService, ipfsHashMapService) {
@@ -108,8 +110,8 @@ let PluginLoader = class PluginLoader {
 };
 PluginLoader = __decorate([
     core_1.Injectable(),
-    __metadata("design:paramtypes", [core_1.ExternalImporter,
-        core_1.FileService,
+    __metadata("design:paramtypes", [external_importer_1.ExternalImporter,
+        file_1.FileService,
         plugin_watcher_service_1.PluginWatcherService,
         ipfs_hash_map_service_1.IpfsHashMapService])
 ], PluginLoader);

package/dist/tasks/daemon.d.ts

@@ -1,5 +1,5 @@
 import { CoreModuleConfig } from '@gapi/core';
-import { FileService } from '@rxdi/core';
+import { FileService } from '../core/services/file';
 export declare const DaemonTasks: {
     start: "start";
     stop: "stop";