diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavascriptFlowtypedCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavascriptFlowtypedCodegen.java new file mode 100644 index 0000000000000000000000000000000000000000..f05092e1ef86b786056a40853055fb87ddca69bc --- /dev/null +++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavascriptFlowtypedCodegen.java @@ -0,0 +1,259 @@ +package org.openapitools.codegen.languages; + +import org.openapitools.codegen.*; +import io.swagger.models.Info; +import io.swagger.models.ModelImpl; +import io.swagger.models.Swagger; +import io.swagger.models.properties.*; +import org.apache.commons.lang3.StringUtils; + +import java.text.SimpleDateFormat; +import java.util.*; + +public class JavascriptFlowtypedCodegen extends AbstractTypeScriptClientCodegen { + private static final SimpleDateFormat SNAPSHOT_SUFFIX_FORMAT = new SimpleDateFormat("yyyyMMddHHmm"); + + public static final String NPM_NAME = "npmName"; + public static final String NPM_VERSION = "npmVersion"; + public static final String NPM_REPOSITORY = "npmRepository"; + public static final String SNAPSHOT = "snapshot"; + + protected String npmName = null; + protected String npmVersion = "1.0.0"; + protected String npmRepository = null; + + public JavascriptFlowtypedCodegen() { + super(); + + // clear import mapping (from default generator) as TS does not use it + // at the moment + importMapping.clear(); + + setReservedWordsLowerCase(Arrays.asList( + // local variable names used in API methods (endpoints) + "varLocalPath", "queryParameters", "headerParams", "formParams", "useFormData", "varLocalDeferred", + "requestOptions", + // Typescript reserved words + "abstract", "arguments", "boolean", "break", "byte", + "case", "catch", "char", "class", "const", + "continue", "debugger", "default", "delete", "do", + "double", "else", "enum", "eval", "export", + "extends", "false", "final", "finally", "float", + "for", "function", "goto", "if", "implements", + "import", "in", "instanceof", "int", "interface", + "let", "long", "native", "new", "null", + "package", "private", "protected", "public", "return", + "short", "static", "super", "switch", "synchronized", + "this", "throw", "throws", "transient", "true", + "try", "typeof", "var", "void", "volatile", + "while", "with", "yield", + "Array", "Date", "eval", "function", "hasOwnProperty", + "Infinity", "isFinite", "isNaN", "isPrototypeOf", + "Math", "NaN", "Number", "Object", + "prototype", "String", "toString", "undefined", "valueOf")); + + languageSpecificPrimitives = new HashSet<String>( + Arrays.asList("string", "Boolean", "number", "Array", "Object", "Date", "File", "Blob") + ); + + instantiationTypes.put("array", "Array"); + instantiationTypes.put("list", "Array"); + instantiationTypes.put("map", "Object"); + typeMapping.clear(); + typeMapping.put("array", "Array"); + typeMapping.put("map", "Object"); + typeMapping.put("List", "Array"); + typeMapping.put("boolean", "Boolean"); + typeMapping.put("string", "string"); + typeMapping.put("int", "number"); + typeMapping.put("float", "number"); + typeMapping.put("number", "number"); + typeMapping.put("DateTime", "Date"); + typeMapping.put("date", "Date"); + typeMapping.put("long", "number"); + typeMapping.put("short", "number"); + typeMapping.put("char", "string"); + typeMapping.put("double", "number"); + typeMapping.put("object", "Object"); + typeMapping.put("integer", "number"); + // binary not supported in JavaScript client right now, using String as a workaround + typeMapping.put("binary", "string"); + typeMapping.put("ByteArray", "string"); + typeMapping.put("UUID", "string"); + + defaultIncludes = new HashSet<String>(languageSpecificPrimitives); + outputFolder = "generated-code/javascript-flowtyped"; + embeddedTemplateDir = templateDir = "Javascript-Flowtyped"; + + this.cliOptions.add(new CliOption(NPM_NAME, "The name under which you want to publish generated npm package")); + this.cliOptions.add(new CliOption(NPM_VERSION, "The version of your npm package")); + this.cliOptions.add(new CliOption(NPM_REPOSITORY, "Use this property to set an url your private npmRepo in the package.json")); + this.cliOptions.add(new CliOption(SNAPSHOT, "When setting this property to true the version will be suffixed with -SNAPSHOT.yyyyMMddHHmm", BooleanProperty.TYPE).defaultValue(Boolean.FALSE.toString())); + + } + + @Override + public CodegenType getTag() { + return CodegenType.CLIENT; + } + + @Override + protected void addAdditionPropertiesToCodeGenModel(CodegenModel codegenModel, ModelImpl swaggerModel) { + codegenModel.additionalPropertiesType = getTypeDeclaration(swaggerModel.getAdditionalProperties()); + addImport(codegenModel, codegenModel.additionalPropertiesType); + } + + @Override + public void processOpts() { + super.processOpts(); + supportingFiles.add(new SupportingFile("index.mustache", "src", "index.js")); + supportingFiles.add(new SupportingFile("api.mustache", "src", "api.js")); + supportingFiles.add(new SupportingFile("configuration.mustache", "src", "configuration.js")); + supportingFiles.add(new SupportingFile("gitignore", "", ".gitignore")); + + addNpmPackageGeneration(); + } + + @Override + public String getTypeDeclaration(Property p) { + Property inner; + if(p instanceof ArrayProperty) { + ArrayProperty ap = (ArrayProperty)p; + inner = ap.getItems(); + return this.getSwaggerType(p) + "<" + this.getTypeDeclaration(inner) + ">"; + } else if(p instanceof MapProperty) { + MapProperty mp = (MapProperty)p; + inner = mp.getAdditionalProperties(); + return "{ [key: string]: " + this.getTypeDeclaration(inner) + "; }"; + } else if(p instanceof FileProperty || p instanceof ObjectProperty) { + return "any"; + } else { + return super.getTypeDeclaration(p); + } + } + + private void addNpmPackageGeneration() { + if (additionalProperties.containsKey(NPM_NAME)) { + this.setNpmName(additionalProperties.get(NPM_NAME).toString()); + } + + if (additionalProperties.containsKey(NPM_VERSION)) { + this.setNpmVersion(additionalProperties.get(NPM_VERSION).toString()); + } + + if (additionalProperties.containsKey(SNAPSHOT) && Boolean.valueOf(additionalProperties.get(SNAPSHOT).toString())) { + this.setNpmVersion(npmVersion + "-SNAPSHOT." + SNAPSHOT_SUFFIX_FORMAT.format(new Date())); + } + additionalProperties.put(NPM_VERSION, npmVersion); + + if (additionalProperties.containsKey(NPM_REPOSITORY)) { + this.setNpmRepository(additionalProperties.get(NPM_REPOSITORY).toString()); + } + + //Files for building our lib + supportingFiles.add(new SupportingFile("README.mustache", "", "README.md")); + supportingFiles.add(new SupportingFile("package.mustache", "", "package.json")); + supportingFiles.add(new SupportingFile("flowconfig.mustache", "", ".flowconfig")); + supportingFiles.add(new SupportingFile("babelrc", "", ".babelrc")); + } + + @Override + public void preprocessSwagger(Swagger swagger) { + if (swagger.getInfo() != null) { + Info info = swagger.getInfo(); + if (StringUtils.isBlank(npmName) && info.getTitle() != null) { + // when projectName is not specified, generate it from info.title + npmName = sanitizeName(dashize(info.getTitle())); + } + if (StringUtils.isBlank(npmVersion)) { + // when projectVersion is not specified, use info.version + npmVersion = escapeUnsafeCharacters(escapeQuotationMark(info.getVersion())); + } + } + + // default values + if (StringUtils.isBlank(npmName)) { + npmName = "swagger-js-client"; + } + if (StringUtils.isBlank(npmVersion)) { + npmVersion = "1.0.0"; + } + + additionalProperties.put(NPM_NAME, npmName); + additionalProperties.put(NPM_VERSION, npmVersion); + additionalProperties.put(CodegenConstants.API_PACKAGE, apiPackage); + } + + @Override + public Map<String, Object> postProcessModels(Map<String, Object> objs) { + // process enum in models + List<Object> models = (List<Object>) postProcessModelsEnum(objs).get("models"); + for (Object _mo : models) { + Map<String, Object> mo = (Map<String, Object>) _mo; + CodegenModel cm = (CodegenModel) mo.get("model"); + cm.imports = new TreeSet(cm.imports); + // name enum with model name, e.g. StatusEnum => Pet.StatusEnum + for (CodegenProperty var : cm.vars) { + if (Boolean.TRUE.equals(var.isEnum)) { + var.datatypeWithEnum = var.datatypeWithEnum.replace(var.enumName, cm.classname + "" + var.enumName); + } + } + if (cm.parent != null) { + for (CodegenProperty var : cm.allVars) { + if (Boolean.TRUE.equals(var.isEnum)) { + var.datatypeWithEnum = var.datatypeWithEnum + .replace(var.enumName, cm.classname + "" + var.enumName); + } + } + } + } + + return objs; + } + + @Override + public String escapeQuotationMark(String input) { + // remove ', " to avoid code injection + return input.replace("\"", "").replace("'", ""); + } + + @Override + public String escapeUnsafeCharacters(String input) { + return input.replace("*/", "*_/").replace("/*", "/_*"); + } + + @Override + public String getName() { + return "javascript-flowtyped"; + } + + @Override + public String getHelp() { + return "Generates a Javascript client library using Flow types and Fetch API."; + } + + public String getNpmName() { + return npmName; + } + + public void setNpmName(String npmName) { + this.npmName = npmName; + } + + public String getNpmVersion() { + return npmVersion; + } + + public void setNpmVersion(String npmVersion) { + this.npmVersion = npmVersion; + } + + public String getNpmRepository() { + return npmRepository; + } + + public void setNpmRepository(String npmRepository) { + this.npmRepository = npmRepository; + } + +} diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/README.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/README.mustache new file mode 100644 index 0000000000000000000000000000000000000000..f13c6322bb978f0ff42e74b0203d0e6e0a105ce5 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/README.mustache @@ -0,0 +1,41 @@ +## {{npmName}}@{{npmVersion}} + +This generator creates Flow typed JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments: + +Environment +* Node.js +* Webpack +* Browserify + +Language level +* ES6 + +Module system +* ES6 module system + +### Building + +To build an compile the flow typed sources to javascript use: +``` +npm install +npm run build +``` + +### Publishing + +First build the package then run ```npm publish``` + +### Consuming + +navigate to the folder of your consuming project and run one of the following commands. + +_published:_ + +``` +npm install {{npmName}}@{{npmVersion}} --save +``` + +_unPublished (not recommended):_ + +``` +npm install PATH_TO_GENERATED_PACKAGE --save diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/api.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/api.mustache new file mode 100644 index 0000000000000000000000000000000000000000..0d5bfc94e42d2c54c0b77b656ac245b4e5358687 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/api.mustache @@ -0,0 +1,266 @@ +// @flow +/* eslint-disable no-use-before-define */ +{{>licenseInfo}} + +import * as url from "url"; +import * as portableFetch from "portable-fetch"; +import { Configuration } from "./configuration"; + +const BASE_PATH: string = "{{{basePath}}}".replace(/\/+$/, ""); + +/** + * + * @export + */ +export const COLLECTION_FORMATS = { + csv: ",", + ssv: " ", + tsv: "\t", + pipes: "|", +}; + +/** + * + * @export + */ +export type FetchAPI = { + (url: string, init?: any): Promise<Response>; +} + +/** + * + * @export + */ +export type FetchArgs = { + url: string; + options: {}; +} + + +/** + * + * @export + */ +export type RequestOptions = { + headers?: {}; + query?: {}; + body?: string | FormData; +} + +/** + * * @export + * @class RequiredError + * @extends {Error} + */ +export class RequiredError extends Error { + name:string = "RequiredError" + constructor(field: string, msg?: string) { + super(msg); + } +} + +{{#models}} +{{#model}}{{#isEnum}}{{>modelEnum}}{{/isEnum}}{{^isEnum}}{{>modelGeneric}}{{/isEnum}}{{/model}} +{{/models}} + +{{#apiInfo}}{{#apis}}{{#operations}} +/** + * {{classname}} - fetch parameter creator{{#description}} + * {{&description}}{{/description}} + * @export + */ +export const {{classname}}FetchParamCreator = function (configuration?: Configuration) { + return { + {{#operation}} + /** + * {{¬es}} + {{#summary}} + * @summary {{&summary}} + {{/summary}} + * @throws {RequiredError} + */ + {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options: RequestOptions): FetchArgs { + {{#allParams}} + {{#required}} + // verify required parameter '{{paramName}}' is not null or undefined + if ({{paramName}} === null || {{paramName}} === undefined) { + throw new RequiredError('{{paramName}}','Required parameter {{paramName}} was null or undefined when calling {{nickname}}.'); + } + {{/required}} + {{/allParams}} + const localVarPath = `{{{path}}}`{{#pathParams}} + .replace(`{${"{{baseName}}"}}`, encodeURIComponent(String({{paramName}}))){{/pathParams}}; + const localVarUrlObj = url.parse(localVarPath, true); + const localVarRequestOptions: RequestOptions = Object.assign({}, { method: '{{httpMethod}}' }, options); + const localVarHeaderParameter = {}; + const localVarQueryParameter = {}; + {{#hasFormParams}} + const localVarFormParams = new FormData(); + {{/hasFormParams}} + + {{#authMethods}} + // authentication {{name}} required + {{#isApiKey}} + {{#isKeyInHeader}} + if (configuration && configuration.apiKey) { + const localVarApiKeyValue = typeof configuration.apiKey === 'function' + ? configuration.apiKey("{{keyParamName}}") + : configuration.apiKey; + localVarHeaderParameter["{{keyParamName}}"] = localVarApiKeyValue; + } + {{/isKeyInHeader}} + {{#isKeyInQuery}} + if (configuration && configuration.apiKey) { + const localVarApiKeyValue = typeof configuration.apiKey === 'function' + ? configuration.apiKey("{{keyParamName}}") + : configuration.apiKey; + localVarQueryParameter["{{keyParamName}}"] = localVarApiKeyValue; + } + {{/isKeyInQuery}} + {{/isApiKey}} + {{#isBasic}} + // http basic authentication required + if (configuration && (configuration.username || configuration.password)) { + localVarHeaderParameter["Authorization"] = "Basic " + btoa(configuration.username + ":" + configuration.password); + } + {{/isBasic}} + {{#isOAuth}} + // oauth required + if (configuration && configuration.accessToken) { + const localVarAccessTokenValue = typeof configuration.accessToken === 'function' + ? configuration.accessToken("{{name}}", [{{#scopes}}"{{{scope}}}"{{^-last}}, {{/-last}}{{/scopes}}]) + : configuration.accessToken; + localVarHeaderParameter["Authorization"] = "Bearer " + localVarAccessTokenValue; + } + {{/isOAuth}} + + {{/authMethods}} + {{#queryParams}} + {{#isListContainer}} + if ({{paramName}}) { + {{#isCollectionFormatMulti}} + localVarQueryParameter['{{baseName}}'] = {{paramName}}; + {{/isCollectionFormatMulti}} + {{^isCollectionFormatMulti}} + localVarQueryParameter['{{baseName}}'] = {{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]); + {{/isCollectionFormatMulti}} + } + {{/isListContainer}} + {{^isListContainer}} + if ({{paramName}} !== undefined) { + {{#isDateTime}} + localVarQueryParameter['{{baseName}}'] = (({{paramName}}:any):Date).toISOString(); + {{/isDateTime}} + {{^isDateTime}} + {{#isDate}} + localVarQueryParameter['{{baseName}}'] = (({{paramName}}:any):Date).toISOString(); + {{/isDate}} + {{^isDate}} + localVarQueryParameter['{{baseName}}'] = (({{paramName}}:any):string); + {{/isDate}} + {{/isDateTime}} + } + {{/isListContainer}} + + {{/queryParams}} + {{#headerParams}} + {{#isListContainer}} + if ({{paramName}}) { + localVarHeaderParameter['{{baseName}}'] = {{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]); + } + {{/isListContainer}} + {{^isListContainer}} + if ({{paramName}} !== undefined && {{paramName}} !== null) { + localVarHeaderParameter['{{baseName}}'] = (({{paramName}}:any):string); + } + {{/isListContainer}} + + {{/headerParams}} + {{#formParams}} + {{#isListContainer}} + if ({{paramName}}) { + {{#isCollectionFormatMulti}} + {{paramName}}.forEach((element) => { + localVarFormParams.append('{{baseName}}', element); + }) + {{/isCollectionFormatMulti}} + {{^isCollectionFormatMulti}} + localVarFormParams.set('{{baseName}}', {{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"])); + {{/isCollectionFormatMulti}} + } + {{/isListContainer}} + {{^isListContainer}} + if ({{paramName}} !== undefined) { + localVarFormParams.set('{{baseName}}', (({{paramName}}:any):string)); + } + {{/isListContainer}} + + {{/formParams}} + {{#bodyParam}} + {{^consumes}} + localVarHeaderParameter['Content-Type'] = 'application/json'; + {{/consumes}} + {{#consumes.0}} + localVarHeaderParameter['Content-Type'] = '{{{mediaType}}}'; + {{/consumes.0}} + + {{/bodyParam}} + localVarUrlObj.query = Object.assign({}, localVarUrlObj.query, localVarQueryParameter, options.query); + // fix override query string Detail: https://stackoverflow.com/a/7517673/1077943 + delete localVarUrlObj.search; + localVarRequestOptions.headers = Object.assign({}, localVarHeaderParameter, options.headers); + {{#hasFormParams}} + localVarRequestOptions.body = localVarFormParams; + {{/hasFormParams}} + {{#bodyParam}} + const needsSerialization = (typeof {{paramName}} !== "string") || localVarRequestOptions.headers['Content-Type'] === 'application/json'; + localVarRequestOptions.body = needsSerialization ? JSON.stringify({{paramName}} || {}) : ((({{paramName}}:any):string) || ""); + {{/bodyParam}} + + return { + url: url.format(localVarUrlObj), + options: localVarRequestOptions, + }; + }, + {{/operation}} + } +}; + +export type {{classname}}Type = { {{#operation}} + {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: RequestOptions): Promise<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Response{{/returnType}}>, + {{/operation}} +} + +/** + * {{classname}} - factory function to inject configuration {{#description}} + * {{{description}}}{{/description}} + * @export + */ +export const {{classname}} = function(configuration?: Configuration, fetch: FetchAPI = portableFetch): {{classname}}Type { + const basePath: string = (configuration && configuration.basePath) || BASE_PATH; + return { + {{#operation}} + /** + * {{¬es}} + {{#summary}} + * @summary {{&summary}} + {{/summary}} + * @throws {RequiredError} + */ + {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: RequestOptions = {}): Promise<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Response{{/returnType}}> { + const localVarFetchArgs = {{classname}}FetchParamCreator(configuration).{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}options); + return fetch(basePath + localVarFetchArgs.url, localVarFetchArgs.options).then((response) => { + if (response.status >= 200 && response.status < 300) { + return response{{#returnType}}.json(){{/returnType}}; + } else { + throw response; + } + }); + }, + {{/operation}} + } +}; +{{/operations}}{{/apis}}{{/apiInfo}} +export type ApiTypes = { {{#apiInfo}}{{#apis}}{{#operations}} + {{classname}}: {{classname}}Type, +{{/operations}}{{/apis}}{{/apiInfo}} } diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/babelrc b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/babelrc new file mode 100644 index 0000000000000000000000000000000000000000..75148dc5edb1e1a946c56c8708fd147715d71c5b --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/babelrc @@ -0,0 +1,4 @@ +{ + "presets": ["react-app"], + "plugins": ["transform-flow-strip-types"] +} diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/configuration.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/configuration.mustache new file mode 100644 index 0000000000000000000000000000000000000000..4c6144d5d47229bfbc99c1652f2a8aff917dd90e --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/configuration.mustache @@ -0,0 +1,65 @@ +// @flow +{{>licenseInfo}} + +export type ConfigurationParameters = { + apiKey?: string | (name: string) => string; + username?: string; + password?: string; + accessToken?: string | (name: string, scopes?: string[]) => string; + basePath?: string; +} + +export class Configuration { + /** + * parameter for apiKey security + * @param name security name + * @memberof Configuration + */ + apiKey: string | (name: string) => string; + /** + * parameter for basic security + * + * @type {string} + * @memberof Configuration + */ + username: string; + /** + * parameter for basic security + * + * @type {string} + * @memberof Configuration + */ + password: string; + /** + * parameter for oauth2 security + * @param name security name + * @param scopes oauth2 scope + * @memberof Configuration + */ + accessToken: string | ((name: string, scopes?: string[]) => string); + /** + * override base path + * + * @type {string} + * @memberof Configuration + */ + basePath: string; + + constructor(param: ConfigurationParameters = {}) { + if (param.apiKey) { + this.apiKey = param.apiKey; + } + if (param.username) { + this.username = param.username; + } + if (param.password) { + this.password = param.password; + } + if (param.accessToken) { + this.accessToken = param.accessToken; + } + if (param.basePath) { + this.basePath = param.basePath; + } + } +} diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/flowconfig.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/flowconfig.mustache new file mode 100644 index 0000000000000000000000000000000000000000..1fed445333e85fb9996542978fa56866de90a2fb --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/flowconfig.mustache @@ -0,0 +1,11 @@ +[ignore] + +[include] + +[libs] + +[lints] + +[options] + +[strict] diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/gitignore b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/gitignore new file mode 100644 index 0000000000000000000000000000000000000000..3c3629e647f5ddf82548912e337bea9826b434af --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/gitignore @@ -0,0 +1 @@ +node_modules diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/index.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/index.mustache new file mode 100644 index 0000000000000000000000000000000000000000..44d58c71f1bdc20bec86c62bc9e5ec47a511b455 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/index.mustache @@ -0,0 +1,5 @@ +// @flow +{{>licenseInfo}} + +export * from "./api"; +export * from "./configuration"; diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/licenseInfo.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/licenseInfo.mustache new file mode 100644 index 0000000000000000000000000000000000000000..bbd8742e52a525c0f33248bac069c555f49b17fd --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/licenseInfo.mustache @@ -0,0 +1,11 @@ +/** + * {{{appName}}} + * {{{appDescription}}} + * + * {{#version}}OpenAPI spec version: {{{version}}}{{/version}} + * {{#infoEmail}}Contact: {{{infoEmail}}}{{/infoEmail}} + * + * NOTE: This class is auto generated by the swagger code generator program. + * https://github.com/swagger-api/swagger-codegen.git + * Do not edit the class manually. + */ diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelEnum.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelEnum.mustache new file mode 100644 index 0000000000000000000000000000000000000000..8b427630ff04c8085a4f74102c020e930bf5d525 --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelEnum.mustache @@ -0,0 +1,6 @@ +/** + * {{{description}}} + * @export + * @enum {string} + */ +export type {{classname}} = {{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}} | {{/-last}}{{/enumVars}}{{/allowableValues}}; diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelGeneric.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelGeneric.mustache new file mode 100644 index 0000000000000000000000000000000000000000..a1ada999736377f1c7f1dce9a0c855880504e38e --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelGeneric.mustache @@ -0,0 +1,27 @@ +{{#hasEnums}} + {{#vars}} + {{#isEnum}} + + export type {{classname}}{{enumName}} = {{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}} | {{/-last}}{{/enumVars}}{{/allowableValues}}; + {{/isEnum}} + {{/vars}} +{{/hasEnums}} +/** + * {{{description}}} + * @export + */ +export type {{classname}} = { +{{#additionalPropertiesType}} + [key: string]: {{{additionalPropertiesType}}}{{#hasVars}} | any{{/hasVars}}; + +{{/additionalPropertiesType}} +{{#vars}} + /** + * {{{description}}} + * @type {{=<% %>=}}{<%&datatype%>}<%={{ }}=%> + * @memberof {{classname}} + */ + {{name}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{/isEnum}}; +{{/vars}} +} + diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/package.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/package.mustache new file mode 100644 index 0000000000000000000000000000000000000000..29eaca85ffcd18813ccae502ff79abea684618fc --- /dev/null +++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/package.mustache @@ -0,0 +1,37 @@ +{ + "name": "{{npmName}}", + "version": "{{npmVersion}}", + "description": "swagger client for {{npmName}}", + "author": "Swagger Codegen Contributors", + "keywords": [ + "fetch", + "flow", + "swagger-client", + "{{npmName}}" + ], + "license": "Unlicense", + "main": "./lib/index.js", + "scripts": { + "prepublishOnly": "npm run build", + "build": "npm run build:clean && npm run build:lib && npm run build:flow", + "build:clean": "rimraf lib", + "build:lib": "node_modules/.bin/babel -d lib src --ignore '**/__tests__/**'", + "build:flow": "flow-copy-source -v -i '**/__tests__/**' src lib" + }, + "dependencies": { + "portable-fetch": "^3.0.0" + }, + "devDependencies": { + "babel-cli": "^6.26.0", + "babel-core": "^6.26.3", + "babel-plugin-transform-flow-strip-types": "^6.22.0", + "babel-preset-react-app": "^3.1.1", + "flow-copy-source": "^1.3.0", + "rimraf": "^2.6.2" + }{{#npmRepository}},{{/npmRepository}} +{{#npmRepository}} + "publishConfig":{ + "registry":"{{npmRepository}}" + } +{{/npmRepository}} +}