@gapi/cli 1.8.124 → 1.8.125

package/dist/core/helpers/mkdirp.d.ts

@@ -0,0 +1,2 @@
+export declare function mkdirp(p?: any, opts?: any, f?: any, made?: any): void;
+export declare function mkdirpSync(p?: any, opts?: any, made?: any): any;

package/dist/core/helpers/mkdirp.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkdirpSync = exports.mkdirp = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const _0777 = parseInt('0777', 8);
+function mkdirp(p, opts, f, made) {
+    if (typeof opts === 'function') {
+        f = opts;
+        opts = {};
+    }
+    else if (!opts || typeof opts !== 'object') {
+        opts = { mode: opts };
+    }
+    let mode = opts.mode;
+    if (mode === undefined) {
+        mode = _0777 & ~process.umask();
+    }
+    if (!made)
+        made = null;
+    const cb = f ||
+        function () {
+            //
+        };
+    p = path_1.resolve(p);
+    fs_1.mkdir(p, mode, function (er) {
+        if (!er) {
+            made = made || p;
+            return cb(null, made);
+        }
+        switch (er.code) {
+            case 'ENOENT':
+                mkdirp(path_1.dirname(p), opts, function (er, made) {
+                    if (er)
+                        cb(er, made);
+                    else
+                        mkdirp(p, opts, cb, made);
+                });
+                break;
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                fs_1.stat(p, function (er2, stat) {
+                    // if the stat fails, then that's super weird.
+                    // let the original error be the failure reason.
+                    if (er2 || !stat.isDirectory())
+                        cb(er, made);
+                    else
+                        cb(null, made);
+                });
+                break;
+        }
+    });
+}
+exports.mkdirp = mkdirp;
+function mkdirpSync(p, opts, made) {
+    if (!opts || typeof opts !== 'object') {
+        opts = { mode: opts };
+    }
+    let mode = opts.mode;
+    if (mode === undefined) {
+        mode = _0777 & ~process.umask();
+    }
+    if (!made)
+        made = null;
+    p = path_1.resolve(p);
+    try {
+        fs_1.mkdirSync(p, mode);
+        made = made || p;
+    }
+    catch (err0) {
+        switch (err0.code) {
+            case 'ENOENT':
+                made = mkdirpSync(path_1.dirname(p), opts, made);
+                mkdirpSync(p, opts, made);
+                break;
+            // In the case of any other error, just see if there's a dir
+            // there already.  If so, then hooray!  If not, then something
+            // is borked.
+            default:
+                let stat;
+                try {
+                    stat = fs_1.statSync(p);
+                }
+                catch (err1) {
+                    throw err0;
+                }
+                if (!stat.isDirectory())
+                    throw err0;
+                break;
+        }
+    }
+    return made;
+}
+exports.mkdirpSync = mkdirpSync;

package/dist/core/services/file.d.ts

@@ -0,0 +1,12 @@
+import { Observable } from 'rxjs';
+export declare class FileService {
+    writeFile(folder: string, fileName: any, moduleName: any, file: any): Observable<unknown>;
+    writeFileAsync(folder: string, fileName: any, moduleName: any, file: any): Observable<string>;
+    writeFileSync(folder: any, file: any): any;
+    readFile(file: string): any;
+    isPresent(path: string): boolean;
+    writeFileAsyncP(folder: any, fileName: any, content: any): Observable<unknown>;
+    mkdirp(folder: any): Observable<boolean>;
+    fileWalker(dir: string, exclude?: string): Observable<string[]>;
+    private filewalker;
+}

package/dist/core/services/file.js

@@ -0,0 +1,109 @@
+"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.FileService = void 0;
+const core_1 = require("@rxdi/core");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const mkdirp_1 = require("../helpers/mkdirp");
+let FileService = class FileService {
+    writeFile(folder, fileName, moduleName, file) {
+        return this.mkdirp(folder).pipe(operators_1.tap(() => {
+            console.log(`Bootstrap: @Service('${moduleName}'): Saved inside ${folder}`);
+        }), operators_1.switchMap(() => this.writeFileAsyncP(folder, fileName, file)));
+    }
+    writeFileAsync(folder, fileName, moduleName, file) {
+        return this.mkdirp(folder).pipe(operators_1.switchMap(() => this.writeFileAsyncP(folder, fileName, file)), operators_1.map(() => {
+            console.log(`Bootstrap: external @Module('${moduleName}') namespace: Saved inside ${folder}`);
+            return `${folder}/${fileName}`;
+        }));
+    }
+    writeFileSync(folder, file) {
+        return fs_1.writeFileSync.bind(null)(folder, JSON.stringify(file, null, 2) + '\n', { encoding: 'utf-8' });
+    }
+    readFile(file) {
+        return JSON.parse(fs_1.readFileSync.bind(null)(file, { encoding: 'utf-8' }));
+    }
+    isPresent(path) {
+        return fs_1.existsSync(path);
+    }
+    writeFileAsyncP(folder, fileName, content) {
+        return new rxjs_1.Observable((o) => fs_1.writeFile(`${folder}/${fileName}`, content, () => o.next(true)));
+    }
+    mkdirp(folder) {
+        return new rxjs_1.Observable((observer) => {
+            mkdirp_1.mkdirp(folder, (err) => {
+                if (err) {
+                    console.error(err);
+                    observer.error(false);
+                }
+                else {
+                    observer.next(true);
+                }
+                observer.complete();
+            });
+        });
+    }
+    fileWalker(dir, exclude = 'node_modules') {
+        return new rxjs_1.Observable((observer) => {
+            this.filewalker(dir, (err, result) => {
+                if (err) {
+                    observer.error(err);
+                }
+                else {
+                    observer.next(result);
+                }
+                observer.complete();
+            }, exclude);
+        });
+    }
+    filewalker(dir, done, exclude = 'node_modules') {
+        let results = [];
+        const fileWalker = this.filewalker.bind(this);
+        fs_1.readdir(dir, (err, list) => {
+            if (err) {
+                return done(err);
+            }
+            let pending = list.length;
+            if (!pending) {
+                return done(null, results);
+            }
+            list.forEach((file) => {
+                file = path_1.resolve(dir, file);
+                fs_1.stat(file, (err, stat) => {
+                    if (stat && stat.isDirectory()) {
+                        results.push(file);
+                        if (!file.includes(exclude)) {
+                            fileWalker(file, (err, res) => {
+                                results = results.concat(res);
+                                if (!--pending) {
+                                    done(null, results);
+                                }
+                            }, exclude);
+                        }
+                        else if (!--pending) {
+                            done(null, results);
+                        }
+                    }
+                    else {
+                        results.push(file);
+                        if (!--pending) {
+                            done(null, results);
+                        }
+                    }
+                });
+            });
+        });
+    }
+};
+FileService = __decorate([
+    core_1.Service()
+], FileService);
+exports.FileService = FileService;

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

@@ -1,4 +1,4 @@
-import { FileService } from '@rxdi/core';
+import { FileService } from '../../../core/services/file';
 import { ILinkListType } from '../../api-introspection';
 import { ChildService } from './child.service';
 import { ListService } from './list.service';

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

@@ -25,6 +25,7 @@ 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 gapi_cli_config_template_1 = require("../templates/gapi-cli-config.template");
 const child_service_1 = require("./child.service");
@@ -101,6 +102,6 @@ DaemonService = __decorate([
     core_1.Service(),
     __metadata("design:paramtypes", [list_service_1.ListService,
         child_service_1.ChildService,
-        core_1.FileService])
+        file_1.FileService])
 ], DaemonService);
 exports.DaemonService = DaemonService;

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

@@ -0,0 +1,32 @@
+import { Config } from './external-importer-systemjs';
+export declare class ExternalImporterConfig {
+    link: string;
+    fileName?: string;
+    typings?: string;
+    typingsFileName?: string;
+    namespace?: string;
+    extension?: string;
+    crypto?: {
+        cyperKey: string;
+        cyperIv: string;
+        algorithm: string;
+    };
+    SystemJsConfig?: Config;
+    outputFolder?: string | '/node_modules/';
+}
+export declare class ExternalImporterIpfsConfig {
+    provider: string;
+    hash: string;
+}
+export interface NpmPackageConfig {
+    name: string;
+    version: string;
+}
+export interface ExternalModuleConfiguration {
+    name: string;
+    version: string;
+    typings: string;
+    module: string;
+    dependencies?: Array<any>;
+    packages?: NpmPackageConfig[];
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalImporterIpfsConfig = exports.ExternalImporterConfig = void 0;
+class ExternalImporterConfig {
+}
+exports.ExternalImporterConfig = ExternalImporterConfig;
+class ExternalImporterIpfsConfig {
+}
+exports.ExternalImporterIpfsConfig = ExternalImporterIpfsConfig;

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

@@ -0,0 +1,185 @@
+export declare type ModuleFormat = 'esm' | 'cjs' | 'amd' | 'global' | 'register';
+export interface MetaConfig {
+    /**
+     * Sets in what format the module is loaded.
+     */
+    format?: ModuleFormat;
+    /**
+     * For the global format, when automatic detection of exports is not enough, a custom exports meta value can be set.
+     * This tells the loader what global name to use as the module's export value.
+     */
+    exports?: string;
+    /**
+     * Dependencies to load before this module. Goes through regular paths and map normalization.
+     * Only supported for the cjs, amd and global formats.
+     */
+    deps?: string[];
+    /**
+     * A map of global names to module names that should be defined only for the execution of this module.
+     * Enables use of legacy code that expects certain globals to be present.
+     * Referenced modules automatically becomes dependencies. Only supported for the cjs and global formats.
+     */
+    globals?: string;
+    /**
+     * Set a loader for this meta path.
+     */
+    loader?: string;
+    /**
+     * For plugin transpilers to set the source map of their transpilation.
+     */
+    sourceMap?: any;
+    /**
+     * Load the module using <script> tag injection.
+     */
+    scriptLoad?: boolean;
+    /**
+     * The nonce attribute to use when loading the script as a way to enable CSP.
+     * This should correspond to the 'nonce-' attribute set in the Content-Security-Policy header.
+     */
+    nonce?: string;
+    /**
+     * The subresource integrity attribute corresponding to the script integrity,
+     * describing the expected hash of the final code to be executed.
+     * For example, System.config({ meta: { 'src/example.js': { integrity: 'sha256-e3b0c44...' }});
+     * would throw an error if the translated source of src/example.js doesn't match the expected hash.
+     */
+    integrity?: string;
+    /**
+     * When scripts are loaded from a different domain (e.g. CDN) the global error handler (window.onerror)
+     * has very limited information about errors to prevent unintended leaking. In order to mitigate this,
+     * the <script> tags need to set crossorigin attribute and the server needs to enable CORS.
+     * The valid values are 'anonymous' and 'use-credentials'.
+     */
+    crossOrigin?: string;
+    /**
+     * When loading a module that is not an ECMAScript Module, we set the module as the default export,
+     * but then also iterate the module object and copy named exports for it a well.
+     * Use this option to disable this iteration and copying of the exports.
+     */
+    esmExports?: boolean;
+    /**
+     * To ignore resources that shouldn't be traced as part of the build.
+     * Use with the SystemJS Builder. (https://github.com/systemjs/builder#ignore-resources)
+     */
+    build?: boolean;
+    /**
+     * A truthy value enables sending credentials to the server on every request. Additionally, a string value adds
+     * an 'Authorization' header with that value to all requests.
+     */
+    authorization?: string | boolean;
+}
+export interface PackageConfig {
+    /**
+     * The main entry point of the package (so import 'local/package' is equivalent to import 'local/package/index.js')
+     */
+    main?: string;
+    /**
+     * The module format of the package. See Module Formats.
+     */
+    format?: ModuleFormat;
+    /**
+     * The default extension to add to modules requested within the package. Takes preference over defaultJSExtensions.
+     * Can be set to defaultExtension: false to optionally opt-out of extension-adding when defaultJSExtensions is enabled.
+     */
+    defaultExtension?: boolean | string;
+    /**
+     * Local and relative map configurations scoped to the package. Apply for subpaths as well.
+     */
+    map?: ConfigMap;
+    /**
+     * Module meta provides an API for SystemJS to understand how to load modules correctly.
+     * Package-scoped meta configuration with wildcard support. Modules are subpaths within the package path.
+     * This also provides an opt-out mechanism for defaultExtension, by adding modules here that should skip extension adding.
+     */
+    meta?: ConfigMeta;
+}
+export declare type ConfigMeta = PackageList<MetaConfig>;
+export interface ModulesList {
+    [bundleName: string]: string[];
+}
+export interface PackageList<T> {
+    [packageName: string]: T;
+}
+export declare type ConfigMap = PackageList<string | PackageList<string>>;
+export declare type Transpiler = 'plugin-traceur' | 'plugin-babel' | 'plugin-typescript' | 'traceur' | 'babel' | 'typescript' | false;
+export interface TraceurOptions {
+    properTailCalls?: boolean;
+    symbols?: boolean;
+    arrayComprehension?: boolean;
+    asyncFunctions?: boolean;
+    asyncGenerators?: any;
+    forOn?: boolean;
+    generatorComprehension?: boolean;
+}
+export interface Config {
+    /**
+     * For custom config names
+     */
+    [customName: string]: any;
+    /**
+     * The baseURL provides a special mechanism for loading modules relative to a standard reference URL.
+     */
+    baseURL?: string;
+    /**
+     * Set the Babel transpiler options when System.transpiler is set to babel.
+     */
+    babelOptions?: any;
+    /**
+     * undles allow a collection of modules to be downloaded together as a package whenever any module from that collection is requested.
+     * Useful for splitting an application into sub-modules for production. Use with the SystemJS Builder.
+     */
+    bundles?: ModulesList;
+    /**
+     * Backwards-compatibility mode for the loader to automatically add '.js' extensions when not present to module requests.
+     * This allows code written for SystemJS 0.16 or less to work easily in the latest version:
+     */
+    defaultJSExtensions?: boolean;
+    /**
+     * An alternative to bundling providing a solution to the latency issue of progressively loading dependencies.
+     * When a module specified in depCache is loaded, asynchronous loading of its pre-cached dependency list begins in parallel.
+     */
+    depCache?: ModulesList;
+    /**
+     * The map option is similar to paths, but acts very early in the normalization process.
+     * It allows you to map a module alias to a location or package:
+     */
+    map?: ConfigMap;
+    /**
+     * Module meta provides an API for SystemJS to understand how to load modules correctly.
+     * Meta is how we set the module format of a module, or know how to shim dependencies of a global script.
+     */
+    meta?: ConfigMeta;
+    /**
+     * Packages provide a convenience for setting meta and map configuration that is specific to a common path.
+     * In addition packages allow for setting contextual map configuration which only applies within the package itself.
+     * This allows for full dependency encapsulation without always needing to have all dependencies in a global namespace.
+     */
+    packages?: PackageList<PackageConfig>;
+    /**
+     * The ES6 Module Loader paths implementation, applied after normalization and supporting subpaths via wildcards.
+     * It is usually advisable to use map configuration over paths unless you need strict control over normalized module names.
+     */
+    paths?: PackageList<string>;
+    /**
+     * Set the Traceur compilation options.
+     */
+    traceurOptions?: TraceurOptions;
+    /**
+     * Sets the module name of the transpiler to be used for loading ES6 modules.
+     */
+    transpiler?: Transpiler;
+    trace?: boolean;
+    /**
+     * Sets the TypeScript transpiler options.
+     */
+    typescriptOptions?: {
+        /**
+         * A boolean flag which instructs the plugin to load configuration from 'tsconfig.json'.
+         * To override the location of the file set this option to the path of the configuration file,
+         * which will be resolved using normal SystemJS resolution.
+         * Note: This setting is specific to plugin-typescript.
+         */
+        tsconfig?: boolean | string;
+        [key: string]: any;
+    };
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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";

package/dist/tasks/daemon.js

@@ -33,6 +33,7 @@ const helpers_1 = require("../core/helpers");
 const ps_list_1 = require("../core/helpers/ps-list");
 const stringEnum_1 = require("../core/helpers/stringEnum");
 const daemon_executor_service_1 = require("../core/services/daemon-executor/daemon-executor.service");
+const file_1 = require("../core/services/file");
 const daemon_config_1 = require("../daemon-server/daemon.config");
 const bootstrap_1 = require("./bootstrap");
 exports.DaemonTasks = stringEnum_1.strEnum([
@@ -334,6 +335,6 @@ let DaemonTask = class DaemonTask {
 };
 DaemonTask = __decorate([
     core_2.Service(),
-    __metadata("design:paramtypes", [core_2.FileService])
+    __metadata("design:paramtypes", [file_1.FileService])
 ], DaemonTask);
 exports.DaemonTask = DaemonTask;

package/dist/tasks/schema.js

@@ -16,19 +16,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaTask = void 0;
+const compressor_1 = require("@rxdi/compressor");
 const core_1 = require("@rxdi/core");
 const fs_1 = require("fs");
+const node_fetch_1 = require("node-fetch");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const util_1 = require("util");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const mkdirp_1 = require("../core/helpers/mkdirp");
 const args_service_1 = require("../core/services/args.service");
 const config_service_1 = require("../core/services/config.service");
 const exec_service_1 = require("../core/services/exec.service");
 const daemon_config_1 = require("../daemon-server/daemon.config");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { mkdirp } = require('@rxdi/core/dist/services/file/dist');
-const compressor_1 = require("@rxdi/compressor");
-const node_fetch_1 = require("node-fetch");
 let SchemaTask = class SchemaTask {
     constructor() {
         this.execService = core_1.Container.get(exec_service_1.ExecService);
@@ -73,9 +73,9 @@ let SchemaTask = class SchemaTask {
     createDir() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!(yield util_1.promisify(fs_1.exists)(this.folder))) {
-                yield util_1.promisify(mkdirp)(this.folder);
+                yield util_1.promisify(mkdirp_1.mkdirp)(this.folder);
             }
-            yield util_1.promisify(mkdirp)(daemon_config_1.GAPI_DAEMON_CACHE_FOLDER);
+            yield util_1.promisify(mkdirp_1.mkdirp)(daemon_config_1.GAPI_DAEMON_CACHE_FOLDER);
         });
     }
     collectFragments() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gapi/cli",
-  "version": "1.8.124",
+  "version": "1.8.125",
   "description": "Gapi command line interface",
   "main": "./dist/main.js",
   "types": "./dist/main.d.ts",
@@ -34,9 +34,9 @@
   "author": "Kristiyan Tachev (@Stradivario)",
   "license": "MIT",
   "dependencies": {
-    "@gapi/core": "^1.8.123",
+    "@gapi/core": "^1.8.124",
     "graphql": "^14.6.0",
-    "@gapi/schematics": "^1.8.123",
+    "@gapi/schematics": "^1.8.124",
     "node-fetch": "^2.1.2",
     "@zeit/ncc": "^0.22.1",
     "apollo-codegen": "0.20.2",
@@ -45,9 +45,9 @@
     "cli-spinner": "0.2.8",
     "commander": "8.2.0",
     "figlet": "1.2.1",
-    "@rxdi/compressor": "^0.7.114",
+    "@rxdi/compressor": "^0.7.134",
     "graphql-document-collector": "0.2.1",
-    "humps": "2.0.1",
+    "systemjs": "0.21.4",
     "node-emoji": "1.10.0",
     "node-notifier": "^5.4.0",
     "parcel-bundler": "1.12.3",