forceios 9.2.0

package/shared/oclifAdapter.js

@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2019-present, salesforce.com, inc.
+ * All rights reserved.
+ * Redistribution and use of this software in source and binary forms, with or
+ * without modification, are permitted provided that the following conditions
+ * are met:
+ * - Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * - Neither the name of salesforce.com, inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission of salesforce.com, inc.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+const COLOR = require('./outputColors');
+
+const SDK = require('./constants');
+const configHelper = require('./configHelper');
+const createHelper = require('./createHelper');
+const templateHelper = require('./templateHelper');
+const jsonChecker = require('./jsonChecker');
+const logInfo = require('./utils').logInfo;
+const logError = require('./utils').logError;
+const os = require('os');
+
+const { SfdxError } = require('@salesforce/core');
+const { Command, flags } = require('@oclif/command');
+
+const namespace = 'mobilesdk';
+
+class OclifAdapter extends Command {
+
+    static formatDescription(description, help) {
+        return `${description}${os.EOL}${os.EOL}${help}`;
+    }
+
+    static listTemplates(cli) {
+        const applicableTemplates = templateHelper.getTemplates(cli);
+
+        logInfo('\nAvailable templates:\n', COLOR.cyan);
+        for (let i=0; i<applicableTemplates.length; i++) {
+            const template = applicableTemplates[i];
+            logInfo((i+1) + ') ' + template.description, COLOR.cyan);
+            logInfo('sfdx ' +  [namespace, cli.topic, SDK.commands.createwithtemplate.name].join(':') + ' --' +
+                SDK.args.templateRepoUri.name + '=' + template.path, COLOR.magenta);
+        }
+        logInfo('');
+    }
+
+    static runCommand(cli, commandName, vals) {
+        switch(commandName) {
+            case SDK.commands.create.name:
+            case SDK.commands.createwithtemplate.name:
+                createHelper.createApp(cli, vals);
+                break;
+            case SDK.commands.version.name:
+                configHelper.printVersion(cli);
+                break;
+            case SDK.commands.listtemplates.name:
+                OclifAdapter.listTemplates(cli);
+                process.exit(0);
+                break;
+            case SDK.commands.checkconfig.name:
+                jsonChecker.validateJson(vals.configpath, vals.configtype);
+                break;
+        }
+    }
+
+    // Validation
+    static validateCommand(cli, commandName, vals) {
+        let success = true;
+        const args = configHelper.getArgsExpanded(cli, commandName);
+        for (const arg of args) {
+            const val = vals[arg.name];
+
+            if (typeof arg.validate === 'function' && !arg.validate(val, cli)) {
+                success = false;
+                logError(arg.error(val, cli));
+            }
+        }
+        return success;
+    }
+
+    /**
+     * Convert legacy-style flag declarations to SfdxCommand's updated format.
+     *
+     * @param {Array} flags The legacy flags to convert.
+     */
+    static toFlags(flagContent) {
+        const flagsConfig = {};
+        if (flagContent) {
+            flagContent.forEach(flag => {
+                const { name, char, hidden, required, longDescription, type, values, array } = flag;
+                const description = flag.description || '';
+                const config = {
+                    description,
+                    longDescription,
+                    hidden,
+                    required,
+                    default: flag.default
+                };
+                if (char) {
+                    // oclif types char as a single alpha char, but Flag specifies it as `string`,
+                    // so we use `any` here to get tsc to accept the assignment
+                    config.char = char;
+                }
+                if (values) {
+                    config.options = values;
+                }
+                delete flagContent.hasValue;
+                if (type === 'boolean') {
+                    flagsConfig[name] = flags.boolean(config);
+                }
+                else if (array) {
+                    flagsConfig[name] = flags.array(config);
+                }
+                else if (type === 'string') {
+                    flagsConfig[name] = flags.string(config);
+                }
+                else {
+                    // TODO
+                    throw new Error('oh noes! ' + JSON.stringify(flag));
+                }
+            });
+        }
+        return flagsConfig;
+    }
+
+    execute(cli, klass) {
+        const { flags } = this.parse(klass);
+        if (OclifAdapter.validateCommand(cli, klass.command.name, flags)) {
+            return OclifAdapter.runCommand(cli, klass.command.name, flags);
+        }
+    }
+
+    resolveHerokuContext() {
+        this.stringifyFlags();
+        return {
+            flags: this.flags
+        }
+    }
+
+    /**
+     * Call to stringify parsed flags for backward compatibility.
+     */
+    stringifyFlags() {
+        Object.keys(this.flags).forEach(name => {
+            const flag = this.flags[name];
+            if (flag == null) {
+                return;
+            }
+            const typeOfFlag = typeof this.flags[name];
+            switch (typeOfFlag) {
+                case 'string':
+                case 'number':
+                    this.flags[name] = flag + '';
+                    break;
+                case 'boolean':
+                    break;
+                case 'object':
+                    if (Array.isArray(flag)) {
+                        this.flags[name] = flag.join(',');
+                        break;
+                    } else if (flag instanceof Date) {
+                        this.flags[name] = flag.toISOString();
+                        break;
+                    } else if (flag instanceof Duration) {
+                        this.flags[name] = flag.quantity + '';
+                        break;
+                    } else {
+                        throw new SfdxError(`Unexpected value type for flag ${name}`, 'UnexpectedFlagValueType');
+                    }
+                default:
+                    throw new SfdxError(`Unexpected value type for flag ${name}`, 'UnexpectedFlagValueType');
+            }
+        });
+    }
+}
+
+OclifAdapter.getCommand = function(cli, commandName) {
+    if (!this._command) {
+        this._command = configHelper.getCommandExpanded(cli, commandName);
+    }
+    return this._command;
+};
+
+module.exports = OclifAdapter;

package/shared/outputColors.js

@@ -0,0 +1,9 @@
+module.exports = {
+	'red': '\x1b[31;1m',
+    'green': '\x1b[32;1m',
+    'yellow': '\x1b[33;1m',
+    'blue': '\x1b[34;1m',
+    'magenta': '\x1b[35;1m',
+    'cyan': '\x1b[36;1m',
+    'reset': '\x1b[0m'
+};

package/shared/store.schema.json

@@ -0,0 +1,38 @@
+{
+    "title" : "Store configuration schema",
+    "description" : "Use this schema to validate userstore.json or globalstore.json",
+    "definitions": {
+        "index": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string"
+                },
+                "type": {
+                    "type": "string",
+                    "enum": ["string", "integer", "floating", "json1", "full_text"]
+                }
+            },
+            "required": ["path", "type"]
+        },
+        "soup": {
+            "type": "object",
+            "properties": {
+                "soupName": { "type": "string"},
+                "indexes": {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/index" }
+                }
+            },
+            "required": ["soupName", "indexes"]
+        }
+    },
+    "type": "object",
+    "properties": {
+        "soups": {
+            "type": "array",
+            "items": { "$ref": "#/definitions/soup" }
+        }
+    },
+    "required": ["soups"]
+}

package/shared/syncs.schema.json

@@ -0,0 +1,295 @@
+{
+    "title" : "Syncs configuration schema",
+    "description" : "Use this schema to validate usersyncs.json or globalsyncs.json",
+    "definitions": {
+        "mergeMode": {
+            "type": "string",
+            "enum": ["LEAVE_IF_CHANGED", "OVERWRITE"]
+        },
+        "fieldlist": {
+            "type": "array",
+            "items": { "type": "string"}
+        },
+        "query": {
+            "type": "string"
+        },
+        "sobjectType": {
+            "type": "string"
+        },
+        "sobjectTypePlural": {
+            "type": "string"
+        },
+        "formFactor": {
+            "type": "string",
+            "enum": ["Large", "Medium", "Small"]
+        },
+        "layoutType": {
+            "type": "string",
+            "enum": ["Compact", "Full"]
+        },
+        "mode": {
+            "type": "string",
+            "enum": ["Create", "Edit", "View"]
+        },
+        "recordTypeId": {
+            "type": "string"
+        },
+        "syncName": {
+            "type": "string"
+        },
+        "soupName": {
+            "type": "string"
+        },
+        "fieldName": {
+            "type": "string"
+        },
+        "impl": {
+            "type": "string"
+        },
+        "soqlFilter": {
+            "type": "string"
+        },
+        "maxBatchSize": {
+            "type": "integer"
+        },
+        "relationshipType": {
+            "type": "string",
+            "enum": ["MASTER_DETAIL", "LOOKUP"]
+        },
+        "parentInfo": {
+            "type": "object",
+            "properties": {
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "externalIdFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" },
+                "sobjectType": { "$ref": "#/definitions/sobjectType" },
+                "soupName": { "$ref": "#/definitions/soupName" }
+            },
+            "required": ["sobjectType", "soupName"]
+        },
+        "childrenInfo": {
+            "type": "object",
+            "properties": {
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "externalIdFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" },
+                "sobjectType": { "$ref": "#/definitions/sobjectType" },
+                "soupName": { "$ref": "#/definitions/soupName" },
+                "sobjectTypePlural": { "$ref": "#/definitions/sobjectTypePlural" },
+                "parentIdFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["sobjectType", "soupName", "sobjectTypePlural", "parentIdFieldName"]
+        },
+        "syncDownOptions": {
+            "type": "object",
+            "properties": {
+                "mergeMode": { "$ref": "#/definitions/mergeMode" }
+            },
+            "required": ["mergeMode"]
+        },
+        "syncUpOptions": {
+            "type": "object",
+            "properties": {
+                "mergeMode": { "$ref": "#/definitions/mergeMode" },
+                "fieldlist": { "$ref": "#/definitions/fieldlist" }
+            },
+            "required": ["mergeMode", "fieldlist"]
+        },
+        "soqlSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "soql" },
+                "query": { "$ref": "#/definitions/query" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }, 
+                "maxBatchSize": { "$ref": "#/definitions/maxBatchSize" }
+            },
+            "required": ["type", "query"]
+        },
+        "soslSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "sosl" },
+                "query": { "$ref": "#/definitions/query" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["type", "query"]
+        },
+        "mruSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "mru" },
+                "sobjectType": { "$ref": "#/definitions/sobjectType" },
+                "fieldlist": { "$ref": "#/definitions/fieldlist" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["type", "sobjectType", "fieldlist"]
+        },
+        "refreshSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "refresh" },
+                "sobjectType": { "$ref": "#/definitions/sobjectType" },
+                "fieldlist": { "$ref": "#/definitions/fieldlist" },
+                "soupName": { "$ref": "#/definitions/soupName" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["type", "sobjectType", "fieldlist", "soupName"]
+        },
+        "layoutSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "layout" },
+                "sobjectType": { "$ref": "#/definitions/sobjectType" },
+                "formFactor": { "$ref": "#/definitions/formFactor" },
+                "layoutType": { "$ref": "#/definitions/layoutType" },
+                "mode": { "$ref": "#/definitions/mode" },
+                "recordTypeId": { "$ref": "#/definitions/recordTypeId" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["type", "sobjectType", "layoutType"]
+        },
+        "metadataSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "metadata" },
+                "sobjectType": { "$ref": "#/definitions/sobjectType" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["type", "sobjectType"]
+        },
+        "parentChildrenSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "parent_children" },
+                "parent": { "$ref": "#/definitions/parentInfo" },
+                "parentFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "children": { "$ref": "#/definitions/childrenInfo" },
+                "childrenFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "relationshipType": { "$ref": "#/definitions/relationshipType" },
+                "parentSoqlFilter": { "$ref": "#/definitions/soqlFilter" }
+            },
+            "required": ["type", "parent", "parentFieldlist", "children", "childrenFieldlist", "relationshipType"]
+        },
+        "customSyncDownTarget": {
+            "type": "object",
+            "properties": {
+                "type": { "const": "custom" },
+                "iOSImpl" : { "$ref": "#/definitions/impl" },
+                "androidImpl" : { "$ref": "#/definitions/impl" },
+                "idFieldName": { "$ref": "#/definitions/fieldName" },
+                "modificationDateFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["type", "iOSImpl", "androidImpl"]
+        },
+        "syncDownTarget": {
+            "anyOf": [
+                { "$ref": "#/definitions/soqlSyncDownTarget" },
+                { "$ref": "#/definitions/soslSyncDownTarget" },
+                { "$ref": "#/definitions/mruSyncDownTarget" },
+                { "$ref": "#/definitions/refreshSyncDownTarget" },
+                { "$ref": "#/definitions/layoutSyncDownTarget" },
+                { "$ref": "#/definitions/metadataSyncDownTarget" },
+                { "$ref": "#/definitions/parentChildrenSyncDownTarget" },
+                { "$ref": "#/definitions/customSyncDownTarget" }
+            ]
+        },
+        "noBatchSyncUpTarget": {
+            "type": "object",
+            "properties": {
+                "iOSImpl" : { "const": "SFSyncUpTarget" },
+                "androidImpl": { "const": "com.salesforce.androidsdk.mobilesync.target.SyncUpTarget" },
+                "createFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "updateFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "externalIdFieldName": { "$ref": "#/definitions/fieldName" }
+            },
+            "required": ["iOSImpl", "androidImpl"]            
+        },
+        "batchSyncUpTarget": {
+            "type": "object",
+            "properties": {
+                "createFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "updateFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "externalIdFieldName": { "$ref": "#/definitions/fieldName" }
+            }
+        },
+        "parentChildrenSyncUpTarget": {
+            "type": "object",
+            "properties": {
+                "iOSImpl" : { "const": "SFParentChildrenSyncUpTarget" },
+                "androidImpl": { "const": "com.salesforce.androidsdk.mobilesync.target.ParentChildrenSyncUpTarget" },
+                "parent": { "$ref": "#/definitions/parentInfo" },
+                "createFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "updateFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "children": { "$ref": "#/definitions/childrenInfo" },
+                "childrenCreateFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "childrenUpdateFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "relationshipType": { "$ref": "#/definitions/relationshipType" }
+            },
+            "required": ["iOSImpl", "androidImpl",
+                         "parent", "createFieldlist", "updateFieldlist",
+                         "children", "childrenCreateFieldlist", "childrenUpdateFieldlist",
+                         "relationshipType"]
+        },
+        "customSyncUpTarget": {
+            "type": "object",
+            "properties": {
+                "iOSImpl" : { "$ref": "#/definitions/impl" },
+                "androidImpl" : { "$ref": "#/definitions/impl" },
+                "createFieldlist": { "$ref": "#/definitions/fieldlist" },
+                "updateFieldlist": { "$ref": "#/definitions/fieldlist" }
+            },
+            "required": ["iOSImpl", "androidImpl"]
+        },
+        "syncUpTarget": {
+            "anyOf": [
+                { "$ref": "#/definitions/parentChildrenSyncUpTarget" },
+                { "$ref": "#/definitions/noBatchSyncUpTarget" },
+                { "$ref": "#/definitions/customSyncUpTarget" },
+                { "$ref": "#/definitions/batchSyncUpTarget" }
+            ]
+        },
+        "syncDown": {
+            "type": "object",
+            "properties": {
+                "syncName": { "$ref": "#/definitions/syncName" },
+                "soupName": { "$ref": "#/definitions/soupName" },
+                "syncType": { "const": "syncDown" },
+                "target": { "$ref": "#/definitions/syncDownTarget" },
+                "options": { "$ref": "#/definitions/syncDownOptions"}
+            },
+            "required": ["syncName", "soupName", "syncType", "target", "options"]
+        },
+        "syncUp": {
+            "type": "object",
+            "properties": {
+                "syncName": { "$ref": "#/definitions/syncName" },
+                "soupName": { "$ref": "#/definitions/soupName" },
+                "syncType": { "const": "syncUp" },
+                "target": { "$ref": "#/definitions/syncUpTarget" },
+                "options": { "$ref": "#/definitions/syncUpOptions"}
+            },
+            "required": ["syncName", "soupName", "syncType", "target", "options"]
+        },
+        "sync": {
+            "oneOf": [
+                { "$ref": "#/definitions/syncDown" },
+                { "$ref": "#/definitions/syncUp" }
+            ]
+        }
+    },
+
+    "type": "object",
+    "properties": {
+        "syncs": {
+            "type": "array",
+            "items": { "$ref": "#/definitions/sync" }
+        }
+    },
+    "required": ["syncs"]
+}

package/shared/templateHelper.js

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018-present, salesforce.com, inc.
+ * All rights reserved.
+ * Redistribution and use of this software in source and binary forms, with or
+ * without modification, are permitted provided that the following conditions
+ * are met:
+ * - Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * - Neither the name of salesforce.com, inc. nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission of salesforce.com, inc.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Dependencies
+var path = require('path'),
+    SDK = require('./constants'),
+    utils = require('./utils');
+
+//
+// Helper to prepare template
+// 
+function prepareTemplate(config, templateDir) {
+    var template = require(path.join(templateDir, 'template.js'));
+    return utils.runFunctionThrowError(
+        function() {
+            return template.prepare(config, utils.replaceInFiles, utils.moveFile, utils.removeFile);
+        },
+        templateDir);
+}
+
+//
+// Get templates for the given cli
+//
+function getTemplates(cli) {
+    try {
+
+        // Creating tmp dir for template clone
+        var tmpDir = utils.mkTmpDir();
+
+        // Cloning template repo
+        var repoDir = utils.cloneRepo(tmpDir, SDK.templatesRepoUri);
+
+        // Getting list of templates
+        var templates = require(path.join(repoDir, 'templates.json'));
+
+        // Keeping only applicable templates, adding full template url
+        var applicableTemplates = templates
+            .filter(template => cli.appTypes.includes(template.appType) && cli.platforms.filter(platform => template.platforms.includes(platform)).length > 0);
+
+        // Cleanup
+        utils.removeFile(tmpDir);
+
+        return applicableTemplates;
+    }
+    catch (error) {
+        utils.logError(cli.name + ' failed\n', error);
+        process.exit(1);
+    }
+}
+
+//
+// Get appType for the given template given by its uri
+//
+function getAppTypeFromTemplate(templateRepoUriWithPossiblePath) {
+    var templateUriParsed = utils.separateRepoUrlPathBranch(templateRepoUriWithPossiblePath);
+    var templateRepoUri = templateUriParsed.repo + '#' + templateUriParsed.branch;
+    var templatePath = templateUriParsed.path;
+
+    // Creating tmp dir for template clone
+    var tmpDir = utils.mkTmpDir();
+
+    // Cloning template repo
+    var repoDir = utils.cloneRepo(tmpDir, templateRepoUri);
+
+    // Getting template
+    var appType = require(path.join(repoDir, templatePath, 'template.js')).appType;
+
+    // Cleanup
+    utils.removeFile(tmpDir);
+
+    // Done
+    return appType;
+}
+
+
+module.exports = {
+    prepareTemplate,
+    getTemplates,
+    getAppTypeFromTemplate
+};