@gapi/cli 1.8.121 → 1.8.125

package/bash/gql2ts/index.js

@@ -1,68 +1,95 @@
 #!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
 'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-const program = require("commander");
-const fs = require("fs");
-const util_1 = require("./util/dist");
-const from_schema_1 = require("./from-schema/dist");
-const from_query_1 = require("./from-query/dist");
+Object.defineProperty(exports, '__esModule', { value: true });
+const { program } = require('commander');
+const fs = require('fs');
+const util_1 = require('./util/dist');
+const from_schema_1 = require('./from-schema/dist');
+const from_query_1 = require('./from-query/dist');
 // tslint:disable-next-line no-require-imports no-var-requires
 // const { version } = require('../package.json');
 program
-    .version('1.7.0')
-    .usage('[options] <schema.json | schema.gql> <query.gql>')
-    .option('-o --output-file [outputFile]', 'name for output file, will use stdout if not specified')
-    .option('-n --namespace [namespace]', 'name for the namespace, defaults to "GQL"', 'GQL')
-    .option('-i --ignored-types <ignoredTypes>', 'names of types to ignore (comma delimited)', v => v.split(','), [])
-    .option('-l --legacy', 'Use TypeScript 1.x annotation', false)
-    .option('-e --external-options [externalOptions]', 'ES Module with method overwrites')
-    .option('--ignore-type-name-declaration', 'Whether to exclude __typename', false)
-    .option('--exclude-deprecated-fields', 'Whether to exclude deprecated fields', false)
-    .parse(process.argv);
+  .version('1.7.0')
+  .usage('[options] <schema.json | schema.gql> <query.gql>')
+  .option(
+    '-o, --output-file <outputFile>',
+    'name for output file, will use stdout if not specified'
+  )
+  .option(
+    '-n, --namespace [namespace]',
+    'name for the namespace, defaults to "GQL"',
+    'GQL'
+  )
+  .option(
+    '-i, --ignored-types <ignoredTypes>',
+    'names of types to ignore (comma delimited)',
+    (v) => v.split(','),
+    []
+  )
+  .option('-l, --legacy', 'Use TypeScript 1.x annotation', false)
+  .option(
+    '-e --external-options [externalOptions]',
+    'ES Module with method overwrites'
+  )
+  .option(
+    '--ignore-type-name-declaration',
+    'Whether to exclude __typename',
+    false
+  )
+  .option(
+    '--exclude-deprecated-fields',
+    'Whether to exclude deprecated fields',
+    false
+  )
+  .parse(process.argv);
 const run = (schema, options) => {
-    let defaultOverrides = {};
-    if (program.externalOptions) {
-        // tslint:disable-next-line no-require-imports no-var-requires
-        const externalFile = require(program.externalOptions);
-        defaultOverrides = externalFile.default || externalFile;
-    }
-    if (program.args[1]) {
-        const queryFile = program.args[1];
-        const query = fs.readFileSync(queryFile).toString();
-        const info = from_query_1.default(schema, query, {}, defaultOverrides);
-        const toWrite = info.map(inf => inf.result).join('\n\n');
-        if (options.outputFile) {
-            util_1.writeToFile(options.outputFile, toWrite);
-        }
-        else {
-            console.log(toWrite);
-        }
-        return;
-    }
-    let namespace = from_schema_1.generateNamespace(options.namespace, schema, options, defaultOverrides);
+  let defaultOverrides = {};
+  if (program.externalOptions) {
+    // tslint:disable-next-line no-require-imports no-var-requires
+    const externalFile = require(program.externalOptions);
+    defaultOverrides = externalFile.default || externalFile;
+  }
+  if (program.args[1]) {
+    const queryFile = program.args[1];
+    const query = fs.readFileSync(queryFile).toString();
+    const info = from_query_1.default(schema, query, {}, defaultOverrides);
+    const toWrite = info.map((inf) => inf.result).join('\n\n');
     if (options.outputFile) {
-        util_1.writeToFile(options.outputFile, namespace);
-    }
-    else {
-        console.log(namespace);
+      util_1.writeToFile(options.outputFile, toWrite);
+    } else {
+      console.log(toWrite);
     }
+    return;
+  }
+  const namespace = from_schema_1.generateNamespace(
+    options.namespace,
+    schema,
+    options,
+    defaultOverrides
+  );
+
+  if (options.outputFile) {
+    util_1.writeToFile(options.outputFile, namespace);
+  } else {
+    console.log(namespace);
+  }
 };
 const fileName = program.args[0];
+
 if (fileName) {
-    const schema = util_1.readFile(fileName);
-    run(schema, program);
-}
-else if (!process.stdin.isTTY) {
-    let input = '';
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (data) => {
-        input += data;
-    });
-    process.stdin.on('end', () => run(util_1.safeJSONParse(input), program));
-}
-else {
-    console.error('No input specified. Please use stdin or a file name.');
-    program.outputHelp();
+  const schema = util_1.readFile(fileName);
+  run(schema, program._optionValues);
+} else if (!process.stdin.isTTY) {
+  let input = '';
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (data) => {
+    input += data;
+  });
+  process.stdin.on('end', () => run(util_1.safeJSONParse(input), program));
+} else {
+  console.error('No input specified. Please use stdin or a file name.');
+  program.outputHelp();
 }
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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 });