@stechquick/symphony-cli 0.2.271

package/lib/commands/quick-serve.d.ts

@@ -0,0 +1,17 @@
+import { Command, flags } from '@oclif/command';
+export default class Serve extends Command {
+    private static server;
+    private rootPath;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        path: flags.IOptionFlag<string | undefined>;
+        httpPort: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
+        global: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private createServer;
+    private addServicesToServer;
+    private attachPlugins;
+    private startServer;
+}

package/lib/commands/quick-serve.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const path = tslib_1.__importStar(require("path"));
+const symphony_nanoserver_1 = require("@stechquick/symphony-nanoserver");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+const socketServerHelper_1 = require("../helpers/socketServer/socketServerHelper");
+class Serve extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.rootPath = "";
+    }
+    async run() {
+        var _a;
+        const { flags } = this.parse(Serve);
+        this.rootPath = (_a = flags.path) !== null && _a !== void 0 ? _a : path.resolve(".");
+        this.createServer();
+        this.addServicesToServer();
+        await this.startServer(flags.httpPort);
+        this.attachPlugins(); // attach plugin waits for server start
+    }
+    createServer() {
+        Serve.server = new symphony_nanoserver_1.NanoServer({
+            rootDiskPath: this.rootPath,
+            bindHost: global ? "0.0.0.0" : "127.0.0.1",
+            portSeekOffset: 1000,
+            manageCors: {}
+        });
+    }
+    addServicesToServer() {
+        Serve.server.AddService({
+            PathStart: "/ping",
+            Methods: new Set(["GET"]),
+            Execute: async (options) => options.response.writeResponse(`Hi from symphony-cli quick server.<br> Root path: ${this.rootPath}`)
+        });
+    }
+    attachPlugins() {
+        new socketServerHelper_1.SocketServerHelper(Serve.server).Start();
+    }
+    async startServer(httpPort) {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Server starting..."), timeFormat: "datetime" });
+        Serve.server.Start({
+            port: httpPort || 3000,
+            successCb: () => {
+                log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", `Http listening on: ${Serve.server.GetServerUrl()}`) });
+            }
+        });
+        // Serve.server.StartHttps({
+        //     port: 3030,
+        //     privateKey: fs.readFileSync('key.pem', 'utf8'),
+        //     certificate: fs.readFileSync('cert.pem', 'utf8'),
+        //     successCb: () => {
+        //         //Logger.log({ message: Chalk.create("green.bold", `Https listening on: ${Serve.server.GetServerUrl()}`) });
+        //     }
+        // });
+    }
+}
+exports.default = Serve;
+Serve.description = 'QUICK command for serving your path';
+Serve.examples = [
+    "$ symphony-cli quick-serve",
+    "$ symphony-cli quick-serve -p 3000",
+    "$ symphony-cli quick-serve -g",
+    "$ symphony-cli quick-serve -r C:/MyPathToServe",
+    "$ symphony-cli quick-serve -g -r C:/MyPathToServe"
+];
+Serve.flags = {
+    path: command_1.flags.string({ char: 'r', description: 'Change path to serve' }),
+    httpPort: command_1.flags.integer({ char: 'p', description: 'HTTP port to serve' }),
+    global: command_1.flags.boolean({ char: 'g', description: 'Host/visible for everyone.' })
+};

package/lib/commands/sym-addfunc.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/command';
+export default class AddFunc extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        hidden: boolean;
+    }[];
+    run(): Promise<void>;
+}

package/lib/commands/sym-addfunc.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const initHelper_1 = require("../helpers/initHelper");
+class AddFunc extends command_1.Command {
+    async run() {
+        const { args } = this.parse(AddFunc);
+        new initHelper_1.InitHelper().AddFunc(args["funcname"]);
+    }
+}
+exports.default = AddFunc;
+AddFunc.description = 'Plateau-Symphony command to create a new function';
+AddFunc.examples = [`symphony-cli sym-addfunc havalemenu`];
+AddFunc.args = [
+    {
+        name: 'funcname',
+        required: true,
+        description: 'input function name',
+        hidden: false
+    }
+];

package/lib/commands/sym-build.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/command';
+export default class Build extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        watch: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        skipversion: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    private static versionCheckSetting;
+    run(): Promise<void>;
+    private continueToBuild;
+}

package/lib/commands/sym-build.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const npmHelper_1 = require("../helpers/npmHelper");
+const initHelper_1 = require("../helpers/initHelper");
+const packageHelper_1 = require("../helpers/packageHelper");
+const cli_ux_1 = require("cli-ux");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+class Build extends command_1.Command {
+    async run() {
+        const { flags } = this.parse(Build);
+        //assert in folder control
+        if (!initHelper_1.InitHelper.AssertInFolder()) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", "Command must be executed in app root!"), timeFormat: "datetime" });
+            return;
+        }
+        //version control
+        let bwPackages = [];
+        if (!flags.skipversion) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Version checking, please wait...") });
+            bwPackages = packageHelper_1.PackageHelper.getBackwardPackages(Build.versionCheckSetting);
+        }
+        else {
+            log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Skipping version checking...") });
+        }
+        if (bwPackages.length == 0) {
+            this.continueToBuild(flags.watch);
+            return;
+        }
+        log_1.Logger.log({ message: styling_1.Chalk.create("yellow.bold", "There are backward packages!\n"), additional: bwPackages });
+        cli_ux_1.cli.confirm(styling_1.Chalk.create("yellow.bold", "Do you want to continue? [Y/N]")).then(res => {
+            if (!res) {
+                log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", "Build stopped...") });
+                return;
+            }
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Continue to build. (I hope you are aware of what you are doing...)") });
+            this.continueToBuild(flags.watch);
+        });
+    }
+    continueToBuild(watch) {
+        npmHelper_1.NpmHelper.build({ watch });
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Build finished successfully."), timeFormat: "datetime" });
+    }
+}
+exports.default = Build;
+Build.description = 'Plateau-Symphony command to build the app with/without watch';
+Build.examples = ["$ symphony-cli sym-build", "$ symphony-cli sym-build -w"];
+Build.flags = {
+    watch: command_1.flags.boolean({ char: 'w', description: 'for watch' }),
+    skipversion: command_1.flags.boolean({ char: 's', description: 'skip version checking. Used for Deployment' })
+};
+Build.versionCheckSetting = {
+    packageNames: ["plateau-symphony", "symphony-cli"],
+    packageJsonFilePath: "/templates/init/{{AppName}}/{{remove}}package.json"
+};

package/lib/commands/sym-create-module.d.ts

@@ -0,0 +1,14 @@
+import { Command, flags } from '@oclif/command';
+export default class CreateModule extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    static flags: {
+        desc: flags.IOptionFlag<string>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/sym-create-module.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const initHelper_1 = require("../helpers/initHelper");
+const npmHelper_1 = require("../helpers/npmHelper");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+class CreateModule extends command_1.Command {
+    async run() {
+        const { flags } = this.parse(CreateModule);
+        const { args } = this.parse(CreateModule);
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Module " + args["name"] + " creating. Please wait...") });
+        await new initHelper_1.InitHelper().AddModule(args["name"], `${flags.desc}`);
+        npmHelper_1.NpmHelper.install({ folderName: args["name"] });
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Module " + args["name"] + " created successfully.") });
+    }
+}
+exports.default = CreateModule;
+CreateModule.description = 'Plateau-Symphony command to create a Symphony App';
+CreateModule.examples = [
+    `symphony-cli sym-create-module abm -d="abm module description"`
+];
+CreateModule.args = [
+    {
+        name: 'name',
+        required: true,
+        description: 'input module name',
+    }
+];
+CreateModule.flags = {
+    desc: command_1.flags.string({
+        char: 'd',
+        description: 'description to module',
+        hidden: false,
+        multiple: false,
+        default: '',
+        required: false,
+    }),
+};

package/lib/commands/sym-create.d.ts

@@ -0,0 +1,14 @@
+import { Command, flags } from '@oclif/command';
+export default class CreateApp extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    static flags: {
+        desc: flags.IOptionFlag<string>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/sym-create.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const initHelper_1 = require("../helpers/initHelper");
+const npmHelper_1 = require("../helpers/npmHelper");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+class CreateApp extends command_1.Command {
+    async run() {
+        const { flags } = this.parse(CreateApp);
+        const { args } = this.parse(CreateApp);
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Application " + args["name"] + " creating. Please wait...") });
+        await new initHelper_1.InitHelper().AddApp(args["name"], `${flags.desc}`);
+        npmHelper_1.NpmHelper.install({ folderName: args["name"] });
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Application " + args["name"] + " created successfully.") });
+    }
+}
+exports.default = CreateApp;
+CreateApp.description = 'Plateau-Symphony command to create a Symphony App';
+CreateApp.examples = [
+    `symphony-cli sym-create havale -d="Kanallardan yapılan havale işlemi"`
+];
+CreateApp.args = [
+    {
+        name: 'name',
+        required: true,
+        description: 'input application name',
+    }
+];
+CreateApp.flags = {
+    desc: command_1.flags.string({
+        char: 'd',
+        description: 'description to application',
+        hidden: false,
+        multiple: false,
+        default: '',
+        required: false,
+    }),
+};

package/lib/commands/sym-fn-deploy.d.ts

@@ -0,0 +1,24 @@
+import { Command, flags } from '@oclif/command';
+export default class FnDeploy extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        hidden: boolean;
+        options: string[];
+    }[];
+    static flags: {
+        d_url: flags.IOptionFlag<string>;
+        d_user: flags.IOptionFlag<string>;
+        d_pass: flags.IOptionFlag<string>;
+        f_url: flags.IOptionFlag<string>;
+        node_env: flags.IOptionFlag<string | undefined>;
+    };
+    private static defaultSettings;
+    run(): Promise<void>;
+    private getSettings;
+    private appendEnvIndependentSettings;
+    private getRemoteSettings;
+}

package/lib/commands/sym-fn-deploy.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const fnDeployHelper_1 = require("../helpers/deploy/fnDeployHelper");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+class FnDeploy extends command_1.Command {
+    async run() {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Checking deployment parameters, please wait...") });
+        const deploySettings = this.getSettings();
+        if (!deploySettings) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", "Deploy stopped.") });
+            process.exit(12);
+        }
+        this.appendEnvIndependentSettings(deploySettings);
+        await new fnDeployHelper_1.FnDeployHelper(deploySettings).deploy();
+    }
+    getSettings() {
+        const { args } = this.parse(FnDeploy);
+        switch (args.environment) {
+            case "remote":
+                return this.getRemoteSettings();
+            case "play":
+                return FnDeploy.defaultSettings;
+            case "local":
+                return { environment: "local" };
+        }
+    }
+    appendEnvIndependentSettings(deploySettings) {
+        const { flags } = this.parse(FnDeploy);
+        const nodeEnv = flags.node_env || process.env["NODE_ENV"] || process.env["node_env"];
+        if (!nodeEnv) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Warning: There is no 'environment name'. Defaulting to: default.") });
+        }
+        deploySettings.nodeEnv = nodeEnv;
+    }
+    getRemoteSettings() {
+        const { flags } = this.parse(FnDeploy);
+        const dockerUrl = flags.d_url || process.env["d_url"];
+        if (!dockerUrl) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Warning: There is no 'docker url' definition!") });
+        }
+        const dockerUser = flags.d_user || process.env["d_user"];
+        if (!dockerUser) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Warning: There is no 'docker username' definition!") });
+        }
+        const dockerPass = flags.d_pass || process.env["d_pass"];
+        if (!dockerPass) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Warning: There is no 'docker pasword' definition!") });
+        }
+        const fnUrl = flags.f_url || process.env["f_url"];
+        if (!fnUrl) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Warning: There is no 'fn api url' definition!") });
+        }
+        if (!(dockerUrl && dockerUser && dockerPass && fnUrl)) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Plase check your deployment parameters!") });
+            return;
+        }
+        return {
+            environment: "remote",
+            dockerSettings: {
+                url: dockerUrl,
+                username: dockerUser,
+                password: dockerPass
+            },
+            fnSettings: {
+                apiUrl: fnUrl
+            }
+        };
+    }
+}
+exports.default = FnDeploy;
+FnDeploy.description = 'Plateau-Symphony fn command to deploy the all functions in your app';
+FnDeploy.examples = [
+    'symphony-cli sym-fn-deploy local',
+    'symphony-cli sym-fn-deploy play',
+    'symphony-cli sym-fn-deploy remote',
+    'symphony-cli sym-fn-deploy remote -d MyDockerUrl -u MyDockerUser -p MyDockerPassword -f MyFnApiUrl',
+    'symphony-cli sym-fn-deploy remote --d_url MyDockerUrl --d_user MyDockerUser --d_pass MyDockerPassword --f_url MyFnApiUrl',
+    'symphony-cli sym-fn-deploy remote --d_url="MyDockerUrl" --d_user="MyDockerUser" --d_pass="MyDockerPassword" --f_url="MyFnApiUrl"'
+    // Chalk.create("green", 'symphony-cli sym-deploy local'),
+    // Chalk.create("red", 'symphony-cli sym-deploy play'),
+    // Chalk.create("yellow", 'symphony-cli sym-deploy remote'),
+    // Chalk.create("yellow", 'symphony-cli sym-deploy remote -d MyDockerUrl -u MyDockerUser -p MyDockerPassword -f MyFnApiUrl'),
+    // Chalk.create("yellow", 'symphony-cli sym-deploy remote --d_url MyDockerUrl --d_user MyDockerUser --d_pass MyDockerPassword --f_url MyFnApiUrl'),
+    // Chalk.create("yellow", 'symphony-cli sym-deploy remote --d_url="MyDockerUrl" --d_user="MyDockerUser" --d_pass="MyDockerPassword" --f_url="MyFnApiUrl"')
+];
+FnDeploy.args = [
+    {
+        name: 'environment',
+        required: true,
+        description: `${styling_1.Chalk.create("bold", 'deploy environment: ')} 
+                ${styling_1.Chalk.create("green.bold", '[local: your local]')} 
+                ${styling_1.Chalk.create("red.bold", '[play: playground environment]')} 
+                ${styling_1.Chalk.create("yellow.bold", '[remote: remote server]')}`,
+        hidden: false,
+        options: ["local", "play", "remote"]
+    }
+];
+FnDeploy.flags = {
+    d_url: command_1.flags.string({
+        description: 'docker url to deploy',
+        hidden: false,
+        multiple: false,
+        default: '',
+        required: false,
+        char: 'd',
+    }),
+    d_user: command_1.flags.string({
+        description: 'docker username to deploy',
+        hidden: false,
+        multiple: false,
+        default: '',
+        required: false,
+        char: 'u',
+    }),
+    d_pass: command_1.flags.string({
+        description: 'docker password for this username to deploy',
+        hidden: false,
+        multiple: false,
+        default: '',
+        required: false,
+        char: 'p',
+    }),
+    f_url: command_1.flags.string({
+        description: 'fn api url to deploy',
+        hidden: false,
+        multiple: false,
+        default: '',
+        required: false,
+        char: 'f',
+    }),
+    node_env: command_1.flags.string({
+        description: 'symphony environment name',
+        hidden: false,
+        multiple: false,
+        default: undefined,
+        required: false,
+        char: 'e',
+    }),
+};
+FnDeploy.defaultSettings = {
+    environment: "play",
+    dockerSettings: {
+        url: "",
+        username: "symphonydemo",
+        password: "f40ddfd4-aad6-4a6a-b3a9-fb54847fb60a"
+    },
+    fnSettings: {
+        apiUrl: "http://10.223.2.98:80"
+    }
+};

package/lib/commands/sym-nano-deploy.d.ts

@@ -0,0 +1,11 @@
+import { Command, flags } from '@oclif/command';
+export default class NanoDeploy extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        node_env: flags.IOptionFlag<string | undefined>;
+        imagename: flags.IOptionFlag<string>;
+    };
+    run(): Promise<void>;
+    private appendEnvIndependentSettings;
+}

package/lib/commands/sym-nano-deploy.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const nanoDeployHelper_1 = require("../helpers/deploy/nanoDeployHelper");
+const log_1 = require("@stechquick/symphony-common/lib/log");
+const styling_1 = require("@stechquick/symphony-common/lib/styling");
+class NanoDeploy extends command_1.Command {
+    async run() {
+        log_1.Logger.log({ message: styling_1.Chalk.create("green.bold", "Checking deployment parameters, please wait...") });
+        const { flags } = this.parse(NanoDeploy);
+        const deploySettings = { imageName: flags.imagename };
+        if (!deploySettings) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("red.bold", "Deploy stopped.") });
+            process.exit(12);
+        }
+        this.appendEnvIndependentSettings(deploySettings);
+        await new nanoDeployHelper_1.NanoDeployHelper(deploySettings).deploy();
+    }
+    appendEnvIndependentSettings(deploySettings) {
+        const { flags } = this.parse(NanoDeploy);
+        const nodeEnv = flags.node_env || process.env["NODE_ENV"] || process.env["node_env"];
+        if (!nodeEnv) {
+            log_1.Logger.log({ message: styling_1.Chalk.create("yellow", "Warning: There is no 'environment name'. Defaulting to: default.") });
+        }
+        deploySettings.nodeEnv = nodeEnv;
+    }
+}
+exports.default = NanoDeploy;
+NanoDeploy.description = 'Plateau-Symphony nano command to deploy the all functions in your app';
+NanoDeploy.examples = [
+    'symphony-cli sym-nano-deploy',
+];
+NanoDeploy.flags = {
+    node_env: command_1.flags.string({
+        description: 'symphony environment name',
+        hidden: false,
+        multiple: false,
+        default: undefined,
+        required: false,
+        char: 'e',
+    }),
+    imagename: command_1.flags.string({
+        description: 'image name for docker',
+        hidden: false,
+        multiple: false,
+        default: undefined,
+        required: true,
+        char: 'i',
+    }),
+};

package/lib/commands/sym-start.d.ts

@@ -0,0 +1,14 @@
+import { Command, flags } from '@oclif/command';
+export default class Run extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        debug: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        build: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        http_port: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
+        https_port: import("@oclif/parser/lib/flags").IOptionFlag<number | undefined>;
+        environment: flags.IOptionFlag<string>;
+        hosted_path: flags.IOptionFlag<string | undefined>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/sym-start.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const npmHelper_1 = require("../helpers/npmHelper");
+class Run extends command_1.Command {
+    async run() {
+        const { flags } = this.parse(Run);
+        const runSetting = {
+            debug: flags.debug,
+            build: flags.build,
+            httpPort: flags.http_port,
+            httpsPort: flags.https_port,
+            hostedPath: flags.hosted_path,
+        };
+        npmHelper_1.NpmHelper.run(flags.environment, runSetting);
+    }
+}
+exports.default = Run;
+Run.description = 'Plateau-Symphony command to start your functions with/without debug';
+Run.examples = [`$ symphony-cli sym-start -b -d`];
+Run.flags = {
+    debug: command_1.flags.boolean({ char: 'd', description: 'for debug' }),
+    build: command_1.flags.boolean({ char: 'b', description: 'for build' }),
+    http_port: command_1.flags.integer({ char: 'p', description: 'port to HTTP server' }),
+    https_port: command_1.flags.integer({ char: 'h', description: 'port to HTTPS server' }),
+    environment: command_1.flags.string({ char: 'e', description: 'environment variable', hidden: false, default: 'default', required: false, }),
+    hosted_path: command_1.flags.string({ description: 'application hosted sub path', required: false }),
+};

package/lib/commands/sym-test.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/command';
+export default class UnitTest extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/lib/commands/sym-test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const child_process_1 = require("child_process");
+class UnitTest extends command_1.Command {
+    async run() {
+        child_process_1.execSync("npm test -- --coverage", { stdio: 'inherit' });
+    }
+}
+exports.default = UnitTest;
+UnitTest.description = 'Plateau-Symphony command to run your all test functions with coverage';
+UnitTest.examples = [`$ symphony-cli sym-test`];

package/lib/helpers/deploy/fnDeployHelper.d.ts

@@ -0,0 +1,28 @@
+declare type DeployEnvironment = "local" | "remote" | "play";
+export interface IDockerSettings {
+    url: string;
+    username: string;
+    password: string;
+}
+export interface IFnSettings {
+    apiUrl: string;
+}
+export interface IDeploySettings {
+    environment: DeployEnvironment;
+    nodeEnv?: string;
+    dockerSettings?: IDockerSettings;
+    fnSettings?: IFnSettings;
+}
+export declare class FnDeployHelper {
+    private settings;
+    constructor(settings: IDeploySettings);
+    deploy(): Promise<void>;
+    private getReplaceWords;
+    private getDockerCommandArgs;
+    private getFnCommandArgs;
+    private fnPreRemote;
+    private fnContextDelete;
+    private fnContext;
+    private fnDeploy;
+}
+export {};