kourou 0.21.0 → 0.23.0

package/README.md

@@ -26,7 +26,7 @@ $ npm install -g kourou
 $ kourou COMMAND
 running command...
 $ kourou (-v|--version|version)
-kourou/0.21.0 linux-x64 node-v16.13.2
+kourou/0.23.0 linux-x64 node-v14.18.2
 $ kourou --help [COMMAND]
 USAGE
   $ kourou COMMAND
@@ -129,6 +129,7 @@ All other arguments and options will be passed as-is to the `sdk:query` method.
 * [`kourou api-key:create USER`](#kourou-api-keycreate-user)
 * [`kourou api-key:delete USER ID`](#kourou-api-keydelete-user-id)
 * [`kourou api-key:search USER`](#kourou-api-keysearch-user)
+* [`kourou app:debug-proxy`](#kourou-appdebug-proxy)
 * [`kourou app:scaffold DESTINATION`](#kourou-appscaffold-destination)
 * [`kourou app:start-services`](#kourou-appstart-services)
 * [`kourou autocomplete [SHELL]`](#kourou-autocomplete-shell)
@@ -155,9 +156,10 @@ All other arguments and options will be passed as-is to the `sdk:query` method.
 * [`kourou instance:list`](#kourou-instancelist)
 * [`kourou instance:logs`](#kourou-instancelogs)
 * [`kourou instance:spawn`](#kourou-instancespawn)
-* [`kourou paas:init USERNAME NAMESPACE`](#kourou-paasinit-username-namespace)
+* [`kourou paas:deploy ENVIRONMENT IMAGE`](#kourou-paasdeploy-environment-image)
+* [`kourou paas:init PROJECT`](#kourou-paasinit-project)
 * [`kourou paas:login`](#kourou-paaslogin)
-* [`kourou paas:publish PROJECT IMAGE`](#kourou-paaspublish-project-image)
+* [`kourou paas:logs ENVIRONMENT APPLICATION`](#kourou-paaslogs-environment-application)
 * [`kourou profile:export`](#kourou-profileexport)
 * [`kourou profile:import PATH`](#kourou-profileimport-path)
 * [`kourou realtime:subscribe INDEX COLLECTION [FILTERS]`](#kourou-realtimesubscribe-index-collection-filters)
@@ -287,6 +289,41 @@ OPTIONS
 
 _See code: [src/commands/api-key/search.ts](src/commands/api-key/search.ts)_
 
+## `kourou app:debug-proxy`
+
+Create a Proxy Server that allows Chrome to debug Kuzzle remotely using the DebugController
+
+```
+USAGE
+  $ kourou app:debug-proxy
+
+OPTIONS
+  --api-key=api-key          Kuzzle user api-key
+  --as=as                    Impersonate a user
+  --forwardPort=forwardPort  [default: 9222] Port of the forwarding server
+  --help                     show CLI help
+  --host=host                [default: localhost] Kuzzle server host
+
+  --nonoAutoEnableDebugger   True if Kourou should not enable and disable the Debugger automatically before and after
+                             usage
+
+  --password=password        Kuzzle user password
+
+  --port=port                [default: 7512] Kuzzle server port
+
+  --protocol=protocol        [default: ws] Kuzzle protocol (http or ws)
+
+  --showDebuggerEvents       Verbose mode to display events sent to the Chrome Debugger
+
+  --showDebuggerPayloads     Verbose mode to display payloads sent by and to the Chrome Debugger
+
+  --ssl                      Use SSL to connect to Kuzzle
+
+  --username=username        [default: anonymous] Kuzzle username (local strategy)
+```
+
+_See code: [src/commands/app/debug-proxy.ts](src/commands/app/debug-proxy.ts)_
+
 ## `kourou app:scaffold DESTINATION`
 
 Scaffolds a new Kuzzle application
@@ -341,7 +378,7 @@ EXAMPLES
   $ kourou autocomplete --refresh-cache
 ```
 
-_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v1.2.0/src/commands/autocomplete/index.ts)_
+_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v1.3.0/src/commands/autocomplete/index.ts)_
 
 ## `kourou collection:create INDEX COLLECTION [BODY]`
 
@@ -602,9 +639,12 @@ USAGE
 OPTIONS
   --batch-size=batch-size  [default: 1000] How many documents to move in batch per operation
   --dest=dest              (required) Destination Elasticsearch server URL
+  --dry-run                Print witch collections will be migrated
   --help                   show CLI help
   --no-interactive         Skip confirmation interactive prompts (perfect for scripting)
+  --pattern=pattern        Pattern to match indices to migrate
   --reset                  Reset destination Elasticsearch server
+  --scroll=scroll          [default: 30s] Scroll duration for Elasticsearch scrolling
   --src=src                (required) Source Elasticsearch server URL
 
 EXAMPLES
@@ -915,17 +955,36 @@ OPTIONS
 
 _See code: [src/commands/instance/spawn.ts](src/commands/instance/spawn.ts)_
 
-## `kourou paas:init USERNAME NAMESPACE`
+## `kourou paas:deploy ENVIRONMENT IMAGE`
 
-Initialize a PaaS namespace in current directory
+Deploy a new version of the application in the PaaS
+
+```
+USAGE
+  $ kourou paas:deploy ENVIRONMENT IMAGE
+
+ARGUMENTS
+  ENVIRONMENT  Project environment name
+  IMAGE        Image name and hash as myimage:mytag
+
+OPTIONS
+  --help             show CLI help
+  --project=project  Current PaaS project
+  --token=token      Authentication token
+```
+
+_See code: [src/commands/paas/deploy.ts](src/commands/paas/deploy.ts)_
+
+## `kourou paas:init PROJECT`
+
+Initialize a PaaS project in current directory
 
 ```
 USAGE
-  $ kourou paas:init USERNAME NAMESPACE
+  $ kourou paas:init PROJECT
 
 ARGUMENTS
-  USERNAME   Username
-  NAMESPACE  Namespace
+  PROJECT  Kuzzle PaaS project name
 
 OPTIONS
   --help  show CLI help
@@ -935,39 +994,38 @@ _See code: [src/commands/paas/init.ts](src/commands/paas/init.ts)_
 
 ## `kourou paas:login`
 
-Login for a PaaS namespace
+Login for a PaaS project
 
 ```
 USAGE
   $ kourou paas:login
 
 OPTIONS
-  --help                 show CLI help
-  --namespace=namespace  Current PaaS namespace
-  --username=username    PaaS username
+  --help               show CLI help
+  --project=project    Current PaaS project
+  --username=username  PaaS username
 ```
 
 _See code: [src/commands/paas/login.ts](src/commands/paas/login.ts)_
 
-## `kourou paas:publish PROJECT IMAGE`
+## `kourou paas:logs ENVIRONMENT APPLICATION`
 
-Deploy a new version of the application in the PaaS
+Show logs of the targeted application
 
 ```
 USAGE
-  $ kourou paas:publish PROJECT IMAGE
+  $ kourou paas:logs ENVIRONMENT APPLICATION
 
 ARGUMENTS
-  PROJECT  Project name
-  IMAGE    Image name and hash
+  ENVIRONMENT  Kuzzle PaaS environment
+  APPLICATION  Kuzzle PaaS application
 
 OPTIONS
-  --help                 show CLI help
-  --namespace=namespace  Current PaaS namespace
-  --token=token          Authentication token
+  --help             show CLI help
+  --project=project  Current PaaS project
 ```
 
-_See code: [src/commands/paas/publish.ts](src/commands/paas/publish.ts)_
+_See code: [src/commands/paas/logs.ts](src/commands/paas/logs.ts)_
 
 ## `kourou profile:export`
 

package/lib/commands/api-key/check.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeyCheck extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static examples: string[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeyCheck;

package/lib/commands/api-key/check.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeyCheck extends common_1.Kommand {
+    async runSafe() {
+        const { valid } = await this.sdk.auth.checkToken(this.args.token);
+        if (valid) {
+            this.logOk('API key is still valid');
+        }
+        else {
+            this.logKo('API key is not valid');
+        }
+    }
+}
+ApiKeyCheck.description = 'Checks an API key validity';
+ApiKeyCheck.flags = Object.assign({ help: command_1.flags.help() }, kuzzle_1.kuzzleFlags);
+ApiKeyCheck.args = [
+    { name: 'token', description: 'API key token', required: true },
+];
+ApiKeyCheck.examples = [
+    'kourou api-key:check eyJhbG...QxfQrc'
+];
+exports.default = ApiKeyCheck;

package/lib/commands/api-key/create.d.ts

@@ -0,0 +1,26 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeyCreate extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        description: flags.IOptionFlag<string>;
+        id: flags.IOptionFlag<string | undefined>;
+        expire: flags.IOptionFlag<string>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeyCreate;

package/lib/commands/api-key/create.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeyCreate extends common_1.Kommand {
+    async runSafe() {
+        const apiKey = await this.sdk.security.createApiKey(this.args.user, this.flags.description, {
+            _id: this.flags.id,
+            expiresIn: this.flags.expire
+        });
+        this.logOk(`Successfully created API Key "${apiKey._id}" for user "${this.args.user}"`);
+        this.log(apiKey._source.token);
+    }
+}
+ApiKeyCreate.description = 'Creates a new API Key for a user';
+ApiKeyCreate.flags = Object.assign({ help: command_1.flags.help(), description: command_1.flags.string({
+        char: 'd',
+        description: 'API Key description',
+        required: true,
+    }), id: command_1.flags.string({
+        description: 'API Key unique ID',
+    }), expire: command_1.flags.string({
+        description: 'API Key validity',
+        default: '-1',
+    }) }, kuzzle_1.kuzzleFlags);
+ApiKeyCreate.args = [
+    { name: 'user', description: 'User kuid', required: true },
+];
+exports.default = ApiKeyCreate;

package/lib/commands/api-key/delete.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeyDelete extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static examples: string[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeyDelete;

package/lib/commands/api-key/delete.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeyDelete extends common_1.Kommand {
+    async runSafe() {
+        await this.sdk.security.deleteApiKey(this.args.user, this.args.id);
+        this.logOk(`Successfully deleted API Key "${this.args.id}" of user "${this.args.user}"`);
+    }
+}
+ApiKeyDelete.description = 'Deletes an API key.';
+ApiKeyDelete.flags = Object.assign({ help: command_1.flags.help() }, kuzzle_1.kuzzleFlags);
+ApiKeyDelete.args = [
+    { name: 'user', description: 'User kuid', required: true },
+    { name: 'id', description: 'API Key unique ID', required: true },
+];
+ApiKeyDelete.examples = [
+    'kourou vault:delete sigfox-gateway 1k-BF3EBjsXdvA2PR8x'
+];
+exports.default = ApiKeyDelete;

package/lib/commands/api-key/search.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+declare class ApiKeySearch extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        filter: flags.IOptionFlag<string | undefined>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+}
+export default ApiKeySearch;

package/lib/commands/api-key/search.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+class ApiKeySearch extends common_1.Kommand {
+    async runSafe() {
+        let query = {};
+        if (this.flags.filter) {
+            query = {
+                match: {
+                    description: this.flags.filter,
+                },
+            };
+        }
+        const result = await this.sdk.security.searchApiKeys(this.args.user, query, {
+            from: 0,
+            size: 100
+        });
+        this.logOk(`${result.total} API Keys found for user ${this.args.user}`);
+        if (result.total !== 0) {
+            this.log('');
+            for (const { _id, _source } of result.hits) {
+                this.log(` - Key "${_id}"`);
+                this.log(`    Description: ${_source.description}`);
+                this.log(`    Fingerprint: ${_source.fingerprint}`);
+                this.log(`    Expires at: ${_source.expiresAt}`);
+            }
+        }
+    }
+}
+ApiKeySearch.description = 'Lists a user\'s API Keys.';
+ApiKeySearch.flags = Object.assign({ help: command_1.flags.help(), filter: command_1.flags.string({
+        description: 'Filter to match the API Key descriptions',
+    }) }, kuzzle_1.kuzzleFlags);
+ApiKeySearch.args = [
+    { name: 'user', description: 'User kuid', required: true },
+];
+exports.default = ApiKeySearch;

package/lib/commands/app/debug-proxy.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class DebugProxy extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        forwardPort: import("@oclif/parser/lib/flags").IOptionFlag<number>;
+        nonoAutoEnableDebugger: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        showDebuggerEvents: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        showDebuggerPayloads: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    static sdkOptions: {
+        protocol: string;
+    };
+    runSafe(): Promise<void>;
+}

package/lib/commands/app/debug-proxy.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+const http_1 = tslib_1.__importDefault(require("http"));
+const ws_1 = tslib_1.__importDefault(require("ws"));
+// Add the proper headers and send the body in the response
+function sendResponse(response, bodyObject) {
+    response.setHeader('Content-Type', 'application/json; charset=UTF-8');
+    response.setHeader('Cache-Control', 'no-cache');
+    const body = JSON.stringify(bodyObject);
+    response.setHeader('Content-Length', Buffer.byteLength(body));
+    response.writeHead(200);
+    response.end(body);
+}
+class DebugProxy extends common_1.Kommand {
+    async runSafe() {
+        const nodeVersionResponse = await this.sdk.query({
+            controller: 'debug',
+            action: 'nodeVersion'
+        });
+        this.logInfo(`Connected to Kuzzle node: ${nodeVersionResponse.node}`);
+        /**
+         * To allow the Chrome Debugger to see the proxy server we must implement the following routes:
+         * - /json/version
+         * - /json
+         */
+        const server = http_1.default.createServer((request, response) => {
+            if (request.url === '/json/version') {
+                sendResponse(response, {
+                    Browser: `node.js/${nodeVersionResponse.result}`,
+                    "Protocol-Version": "1.1"
+                });
+                return;
+            }
+            else if (request.url === '/json') {
+                // Here we send a bunch of information about the Remote Target to the Chrome Debugger
+                // Those are the informations that the Chrome Debugger uses to know how to connect to Remote Target
+                // We give the Chrome Inspector our own Websocket endpoint so that it can connect to our proxy server
+                sendResponse(response, [{
+                        description: 'node.js instance',
+                        devtoolsFrontendUrl: `devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=${request.headers.host}/kuzzle-debugger`,
+                        devtoolsFrontendUrlCompat: `devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=${request.headers.host}/kuzzle-debugger`,
+                        faviconUrl: 'https://nodejs.org/static/images/favicons/favicon.ico',
+                        id: 'kuzzle-debugger',
+                        title: `Kuzzle Debugger - ${this.flags.host}:${this.flags.port}`,
+                        type: 'node',
+                        webSocketDebuggerUrl: `ws://${request.headers.host}/kuzzle-debugger`
+                    }]);
+                return;
+            }
+            response.writeHead(404);
+        });
+        const closeServer = async () => {
+            this.logInfo('Connection closed.');
+            if (!this.flags.noAutoEnableDebugger) {
+                await this.sdk.query({
+                    controller: 'debug',
+                    action: 'disable'
+                });
+            }
+            this.sdk.disconnect();
+            server.close();
+        };
+        const wss = new ws_1.default.Server({
+            server
+        });
+        if (!this.flags.noAutoEnableDebugger) {
+            await this.sdk.query({
+                controller: 'debug',
+                action: 'enable'
+            });
+        }
+        // Listen to all events emitted by the Debug Controller
+        await this.sdk.query({
+            controller: 'debug',
+            action: 'addListener',
+            body: {
+                event: '*'
+            }
+        });
+        wss.on('connection', ws => {
+            this.logInfo('Connection established.');
+            /**
+             * Listen to the room were events from the DebugController are sent
+             * and only forward events from the Chrome  Devtools Protocol
+             */
+            this.sdk.sdk.protocol.on('kuzzle-debugger-event', (payload) => {
+                if (!payload.event || payload.event.startsWith('Kuzzle')) {
+                    return;
+                }
+                if (this.flags.showDebuggerEvents) {
+                    this.logInfo(JSON.stringify(payload.result, null, 2));
+                }
+                ws.send(JSON.stringify(payload.result));
+            });
+            // When receiving message from Chrome Devtools Protocol, we forward it to the DebugController
+            ws.on('message', async (message) => {
+                try {
+                    const json = JSON.parse(message.toString());
+                    if (json.id === undefined || json.method === undefined) {
+                        return;
+                    }
+                    if (this.flags.showDebuggerPayloads) {
+                        this.logInfo(JSON.stringify({
+                            method: json.method,
+                            params: json.params,
+                        }, null, 2));
+                    }
+                    const response = await this.sdk.query({
+                        controller: 'debug',
+                        action: 'post',
+                        body: {
+                            method: json.method,
+                            params: json.params,
+                        }
+                    });
+                    if (this.flags.showDebuggerPayloads) {
+                        this.logInfo(JSON.stringify({
+                            id: json.id,
+                            result: response.result
+                        }, null, 2));
+                    }
+                    // Send back the response using the same ID received
+                    ws.send(JSON.stringify({
+                        id: json.id,
+                        result: response.result
+                    }));
+                }
+                catch (e) {
+                    this.logKo(`${e}`);
+                }
+            });
+            ws.on('close', closeServer);
+        });
+        server.on('error', async (err) => {
+            this.logKo(err.message);
+            this.logKo(err.stack);
+            await closeServer();
+        });
+        server.listen(this.flags.forwardPort, () => {
+            this.logOk(`Listening on port ${this.flags.forwardPort}, forwarding to Kuzzle at ${this.flags.host}:${this.flags.port}`);
+            this.logInfo(`Showing to Chrome Debugger as "Kuzzle Debugger - ${this.flags.host}:${this.flags.port}"`);
+            this.logInfo('Waiting for Chrome Debugger to connect...');
+        });
+        let resolve;
+        const promise = new Promise(res => {
+            resolve = res;
+        });
+        server.on('close', () => {
+            resolve();
+        });
+        await promise;
+    }
+}
+exports.default = DebugProxy;
+DebugProxy.description = 'Create a Proxy Server that allows Chrome to debug Kuzzle remotely using the DebugController';
+DebugProxy.flags = Object.assign({ help: command_1.flags.help(), forwardPort: command_1.flags.integer({
+        description: 'Port of the forwarding server',
+        default: 9222
+    }), nonoAutoEnableDebugger: command_1.flags.boolean({
+        description: 'True if Kourou should not enable and disable the Debugger automatically before and after usage',
+        default: true
+    }), showDebuggerEvents: command_1.flags.boolean({
+        description: 'Verbose mode to display events sent to the Chrome Debugger',
+        default: false,
+    }), showDebuggerPayloads: command_1.flags.boolean({
+        description: 'Verbose mode to display payloads sent by and to the Chrome Debugger',
+        default: false,
+    }) }, kuzzle_1.kuzzleFlags);
+// Force the usage of Websocket otherwise each request might end up executed on a different Kuzzle Node
+DebugProxy.sdkOptions = {
+    protocol: 'ws'
+};

package/lib/commands/app/scaffold.d.ts

@@ -0,0 +1,17 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class AppScaffold extends Kommand {
+    static initSdk: boolean;
+    static description: string;
+    static flags: {
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        flavor: flags.IOptionFlag<string>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+    cloneTemplate(flavor: string, destination: string): Promise<void>;
+}

package/lib/commands/app/scaffold.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const listr_1 = tslib_1.__importDefault(require("listr"));
+const common_1 = require("../../common");
+const execute_1 = require("../../support/execute");
+class AppScaffold extends common_1.Kommand {
+    async runSafe() {
+        const destination = this.args.destination;
+        const flavor = this.flags.flavor;
+        const tasks = new listr_1.default([
+            {
+                title: 'Creating and rendering application files',
+                task: async () => this.cloneTemplate(flavor, destination)
+            },
+        ]);
+        await tasks.run();
+        this.log('');
+        this.logOk(`Scaffolding complete! Use ${chalk_1.default.grey(`cd ${destination} && npm run docker npm install`)} install dependencies and then ${chalk_1.default.grey(`npm run docker:dev`)} to run your application!`);
+    }
+    async cloneTemplate(flavor, destination) {
+        await (0, execute_1.execute)('git', 'clone', '--depth=1', 'https://github.com/kuzzleio/project-templates', '--branch', flavor, '--single-branch');
+        await (0, execute_1.execute)('mv', `project-templates/${flavor}`, `${destination}/`);
+        await (0, execute_1.execute)('rm', '-rf', 'project-templates/');
+    }
+}
+exports.default = AppScaffold;
+AppScaffold.initSdk = false;
+AppScaffold.description = 'Scaffolds a new Kuzzle application';
+AppScaffold.flags = {
+    help: command_1.flags.help(),
+    flavor: command_1.flags.string({
+        default: 'generic',
+        description: 'Template flavor ("generic", "iot-platform")'
+    })
+};
+AppScaffold.args = [
+    { name: 'destination', description: 'Directory to scaffold the app', required: true },
+];