ern-api-gen/dist/generateProject.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = __importDefault(require("path"));
const fs_1 = __importDefault(require("fs"));
const ern_core_1 = require("ern-core");
const index_1 = require("./index");
const Constants_1 = require("./Constants");
exports.GENERATE = [
    ['android', 'ERNAndroid'],
    ['javascript', 'ERNES6'],
    ['IOS', 'ERNSwift'],
];
function generateSwagger(_a, outFolder) {
    var { apiSchemaPath = Constants_1.MODEL_FILE, name, namespace = '' } = _a, optional = __rest(_a, ["apiSchemaPath", "name", "namespace"]);
    return __awaiter(this, void 0, void 0, function* () {
        const inputSpec = path_1.default.resolve(outFolder, apiSchemaPath);
        const shared = Object.assign({ apiPackage: `${namespace}.api`, description: optional.apiDescription, groupId: namespace, inputSpec, modelPackage: `${namespace}.model`, projectVersion: optional.apiVersion, version: optional.apiVersion }, optional);
        for (const [projectName, lang] of exports.GENERATE) {
            const cc = new index_1.CodegenConfigurator(Object.assign(Object.assign({}, shared), { lang, outputDir: outFolder + '/' + projectName, projectName }));
            const opts = yield cc.toClientOptInput();
            new index_1.DefaultGenerator().opts(opts).generate();
        }
    });
}
exports.generateSwagger = generateSwagger;
function generatePackageJson(_a) {
    var { npmScope, reactNativeVersion, apiVersion = '1.0.0', apiDescription, apiAuthor, apiLicense, bridgeVersion = '', packageName } = _a, conf = __rest(_a, ["npmScope", "reactNativeVersion", "apiVersion", "apiDescription", "apiAuthor", "apiLicense", "bridgeVersion", "packageName"]);
    // Reset the apiSchemaPath to schema.json
    // if --schemaPath option is used to create the Api
    const options = Object.assign(Object.assign({}, conf), { apiSchemaPath: Constants_1.MODEL_FILE });
    return JSON.stringify({
        author: apiAuthor,
        dependencies: {
            'react-native-electrode-bridge': `${bridgeVersion.split('.')[0]}.${bridgeVersion.split('.')[1]}.x`,
        },
        description: apiDescription,
        devDependencies: {
            'flow-bin': Constants_1.FLOW_BIN_VERSION,
        },
        ern: {
            message: options,
            moduleType: `${ern_core_1.ModuleTypes.API}`,
        },
        keywords: [`${ern_core_1.ModuleTypes.API}`],
        license: apiLicense,
        main: 'javascript/src/index.js',
        name: npmScope ? `@${npmScope}/${packageName}` : packageName,
        scripts: {
            flow: 'flow',
        },
        version: apiVersion,
    }, null, 2);
}
exports.generatePackageJson = generatePackageJson;
function generateInitialSchema({ namespace, apiSchemaPath, }) {
    return __awaiter(this, void 0, void 0, function* () {
        return apiSchemaPath && fs_1.default.existsSync(apiSchemaPath)
            ? ern_core_1.fileUtils.readFile(apiSchemaPath)
            : `
  {
    "swagger": "2.0",
    "info": {
      "description": "Walmart Item Module",
      "title": "WalmartItem",
      "contact": {
        "name": "ERN Mobile Platform Team"
      }
    },
    "paths": {
      "/items": {
        "get": {
          "tags": [
          "WalmartItem"
          ],
          "description": "Returns all items from the system that the user has access to",
          "operationId": "findItems",
          "parameters": [{
            "name": "limit",
            "in": "query",
            "description": "maximum number of results to return",
            "required": false,
            "type": "integer",
            "format": "int32"
          }],
          "responses": {
            "200": {
              "description": "Item response",
              "schema": {
                "type": "array",
                "items": {
                  "$ref": "#/definitions/Item"
                }
              }
            }
          }
        },
        "post": {
          "tags": [
          "WalmartItem"
          ],
          "description": "Creates a Item in the store.",
          "operationId": "addItem",
          "parameters": [{
            "name": "item",
            "in": "body",
            "description": "Item to add",
            "required": true,
            "schema": {
              "$ref": "#/definitions/Item"
            }
          }],
          "responses": {
            "200": {
              "schema": {
                "type": "boolean"
              }
            }
          }
        }
      },
      "event/itemAdded": {
        "event": {
          "tags": [
          "WalmartItem"
          ],
          "operationId": "itemAdded",
          "parameters": [{
            "name": "itemId",
            "in": "path",
            "description": "Event to notify new item added",
            "required": true,
            "type": "string"
          }]
        }
      }
    },
    "definitions": {
      "Item": {
        "type": "object",
        "required": [
        "name",
        "id"
        ],
        "properties": {
          "id": {
            "type": "integer",
            "format": "int64"
          },
          "name": {
            "type": "string"
          },
          "desc": {
            "type": "string"
          }
        }
      }
    }
  }
  `;
    });
}
exports.generateInitialSchema = generateInitialSchema;
function generateFlowConfig() {
    return `[ignore]

[include]

[libs]

[lints]

[options]
`;
}
exports.generateFlowConfig = generateFlowConfig;
function generateProject(config = {}, outFolder) {
    return __awaiter(this, void 0, void 0, function* () {
        yield ern_core_1.fileUtils.writeFile(path_1.default.join(outFolder, Constants_1.PKG_FILE), generatePackageJson(config));
        yield ern_core_1.fileUtils.writeFile(path_1.default.join(outFolder, Constants_1.MODEL_FILE), yield generateInitialSchema(config));
        yield ern_core_1.fileUtils.writeFile(path_1.default.join(outFolder, Constants_1.FLOW_CONFIG_FILE), generateFlowConfig());
        yield generateSwagger(config, outFolder);
    });
}
exports.default = generateProject;
//# sourceMappingURL=generateProject.js.map