moyan-api 1.0.1

package/src/lib/base.ts

@@ -0,0 +1,180 @@
+
+export type MoMethod = 'POST' | 'GET' | 'DELETE' | 'PUT'
+export interface ObjectAny {
+  [key: string]: any //一般用于字段字段
+}
+
+export interface Option {
+  /**
+   * 下载文件的文件名
+   */
+  fileName?: string
+  /**
+   * 是否使用 api的prefix;
+   * @default true
+   */
+  prefix?: boolean
+
+  /**
+   * 提示成功信息
+   * @default true
+   */
+  hintSuccess?: boolean
+
+  /**
+   * 提示错误信息
+   * @default true
+   */
+  hintFail?: boolean
+
+  /**
+   * 是否显示加载蒙版
+   * @default false
+   */
+  showLoading?: boolean
+
+  /**
+   * 成功提示消息，successMsg可以为string和Function，Function返回提示语， 如果没有定义了改属性，则默认使用api接口返回的message
+   * @default null
+   */
+  successMsg?: ((res: any) => string) | string | null
+
+  /**
+   * 失败提示消息，failMsg可以为string和Function，Function返回提示语，如果没有定义了改属性，则默认使用api接口返回的message
+   * @default null
+   */
+  failMsg?: ((err: any) => string) | string | null
+
+  /**
+   * 加载状态
+   */
+  loading?: boolean
+}
+
+
+export interface ApiCallProps<T> {
+  params?: T
+  option?: Option | {}
+}
+
+export abstract class RequestClass {
+  abstract request(apiEntity:ApiEntity):Promise<any>
+}
+
+export interface SubApiEntity extends RequestClass{}
+
+
+export abstract class ApiCall<ReqType, ResType> extends Promise<ResType & ObjectAny> {
+  static MoCall:SubApiEntity
+
+  static use (moCall: SubApiEntity ){
+    ApiCall.MoCall = moCall
+  }
+
+  static hasPrompted = false
+
+  params!: ReqType | { [key: string]: any }
+  result!: ResType & ObjectAny
+
+  option!: Option
+
+  static hintSuccessHandler = (result: any) => {}
+
+  static hintFailHandler = (err: any) => {}
+
+  /**
+   * 请求路径
+   */
+  abstract path: string
+
+  abstract method: MoMethod
+
+  error: any
+
+  response: any
+
+  resolve!: (result: ApiCall<ReqType, ResType>['result']) => void
+  reject!: (err: any) => void
+
+  get successMsg() {
+    if (typeof this.option.successMsg === 'string') {
+      return this.option.successMsg
+    } else if (typeof this.option.successMsg === 'function') {
+      return this.option.successMsg(this.result)
+    } else if (this.result.message) {
+      return this.result.message
+    }
+    return '请求成功'
+  }
+
+  get failMsg() {
+    if (this.error) {
+      if (typeof this.option.failMsg === 'string') {
+        return this.option.failMsg
+      } else if (typeof this.option.failMsg === 'function') {
+        return this.option.failMsg(this.error)
+      }
+      return this.error.message || this.error.data ? this.error.data.mssage : '请求错误'
+    }
+    return false
+  }
+
+  constructor(props?: ApiCallProps<ReqType>) {
+    if (typeof props === 'function') {
+      super(props)
+    } else {
+      const slef: any = {}
+      super((resolve, reject) => {
+        slef.resolve = resolve
+        slef.reject = reject
+      })
+      Object.assign(this, slef)
+      setTimeout(() => {
+        this.init(props)
+        this.exec()
+      })
+    }
+  }
+
+  init(props?: ApiCallProps<ReqType>) {
+    const defaultOption: Option = {
+      prefix: true,
+      hintSuccess: false,
+      hintFail: true,
+      showLoading: true,
+      loading: false,
+      successMsg: (res) => {
+        return res.message || '请求成功'
+      },
+      failMsg: (err) => {
+        return err.message
+      }
+    }
+
+    this.option = this.option || {}
+    if (props && typeof props.option === 'object') {
+      const option = Object.assign(defaultOption, this.option, props.option)
+      Object.assign(props.option, option)
+      this.option = props.option
+    } else {
+      this.option = Object.assign(defaultOption, this.option)
+    }
+    this.params = props && props.params ? props.params : {}
+  }
+
+  exec() {
+    ApiCall.MoCall.request(this)
+      .then((response) => {
+        this.result = response.data
+        this.option.hintSuccess && !ApiCall.hasPrompted && ApiCall.hintSuccessHandler(this)
+        this.resolve(response.data)
+      })
+      .catch((err) => {
+        this.error = err
+        this.option.hintSuccess && !ApiCall.hasPrompted && ApiCall.hintFailHandler(this)
+        this.reject(err)
+      })
+  }
+}
+
+export interface ApiEntity extends ApiCall<any, any> {}

package/src/main.ts

@@ -0,0 +1,90 @@
+
+import * as path from "path"
+import MFManage, { mFconfig, smfType, SchemaManager } from "moyan-file-model"
+import axios from 'axios'
+
+
+import { ApiTemplate } from "./template/api"
+import { SchemasTemplate } from "./template/schemas"
+
+export class ApisdkCreator {
+  mFManage: MFManage
+  error: Array<any> = []
+
+  get runPath() {
+    const g = process.env.INIT_CWD
+    return g
+  }
+
+  get packageData(){
+    return require(path.resolve('package.json'))
+  }
+
+  get outputPath(){
+    return path.resolve(this.packageData['moyan-api'] && this.packageData['moyan-api']['output']? this.packageData['moyan-api']['output']:"./src")
+  }
+
+  get openAPIObject(){
+    const file = this.packageData['moyan-api'] && this.packageData['moyan-api']['apijson']?this.packageData['moyan-api']['apijson']:'moyan.api.json'
+    console.info('获取本地数据：'+file)
+    const data = require(path.resolve(file))
+    return data
+  }
+
+  constructor() {
+    mFconfig.modulesPath = this.outputPath
+    mFconfig.modulesTemplatePath =  path.resolve(__dirname, './')
+    mFconfig.modulesTemplateViewsName = path.resolve(__dirname,"../view")
+  }
+
+  schemaManagerData = {}
+
+  schemaManager: SchemaManager
+
+
+  async getRemoteData(){
+    const result = await axios.get(this.packageData['moyan-api']['jsonurl'])
+    return result.data
+  }
+
+  async init() {
+    let openAPIObject :any= {}
+    if(this.packageData['moyan-api'] && this.packageData['moyan-api']['jsonurl']){
+      console.log('获取远程数据：'+this.packageData['moyan-api']['jsonurl'])
+      openAPIObject = await this.getRemoteData()
+    }else{
+      openAPIObject = this.openAPIObject
+    }
+
+    if(!openAPIObject.openapi){
+      throw new Error('api 数据错误')
+    }
+
+    this.schemaManagerData = {
+      type: smfType.dir,
+      name: "api",
+      children: [
+        {
+          type: smfType.ts,
+          name: "index",
+          template: new ApiTemplate(openAPIObject)
+        },
+        {
+          type: smfType.ts,
+          name: "schemas",
+          template: new SchemasTemplate(openAPIObject)
+        }
+      ]
+    }
+  }
+
+  async create() {
+    await this.init()
+    this.mFManage = new MFManage()
+    this.schemaManager = new SchemaManager(this.schemaManagerData)
+    this.mFManage.run(this.schemaManager)
+    return this.error
+  }
+}
+
+

package/src/template/api.ts

@@ -0,0 +1,102 @@
+import { OpenAPIObject } from '@nestjs/swagger'
+import { Temp, Template, smfType } from 'moyan-file-model'
+
+export class ApiTemplate extends Temp implements Template {
+  openAPIObject: OpenAPIObject
+
+  list: Array<any> = []
+
+  schemaKeys = []
+
+  constructor(openAPIObject:OpenAPIObject) {
+    super(smfType.ts)
+    this.openAPIObject = openAPIObject
+    this.init()
+  }
+
+  init() {
+    const paths = new Map()
+    for (const key in this.openAPIObject.paths) {
+      for (const key1 in this.openAPIObject.paths[key]) {
+        const item = this.openAPIObject.paths[key][key1]
+        item.path = key
+        item.method = key1.toUpperCase()
+        paths.set(`${item.operationId}`, {
+          ...item,
+          reqType: this._getReqType(item),
+          resType: this._getResType(item),
+          reqDescription: this._getReqDescription(item),
+          resDescription: this._getResDescription(item),
+          tag: JSON.stringify(item.tag)
+        })
+      }
+    }
+    this.list = [...paths.values()]
+    this.schemaKeys = Object.keys(this.openAPIObject.components.schemas)
+  }
+
+  private _getReqType(item: any) {
+    try {
+      return this.getSchemaEntity(item.requestBody.content['application/json'].schema.$ref)
+    } catch {
+      return this.parseSchema(item)
+    }
+  }
+
+  parseSchema(schema: any) {
+    const parameters = new Map()
+
+    schema.parameters.forEach((item: any) => {
+      parameters.set(item.name, item)
+    })
+    const arr = [...parameters.values()]
+
+    try {
+      let str = '{'
+      arr.forEach((item1: any) => {
+        str += `  ${item1.name}${item1.required ? '' : '?'}:${item1.schema.type},${item1.description ? ' //' + item1.description : ''}\n`
+      })
+      str += '}'
+      return str
+    } catch (e) {
+      return `any`
+    }
+  }
+
+  getSchemaEntity(str: string): string {
+    const arr = str.split('/')
+    return arr[3] || `any`
+  }
+
+  _getResType(item: any) {
+    try {
+      return this.getSchemaEntity(item.responses[200].content['application/json'].schema.$ref)
+    } catch {
+      return `any`
+    }
+  }
+
+  _getReqDescription(item: any) {
+    try {
+      return item.requestBody.description || ''
+    } catch {
+      return ''
+    }
+  }
+
+  _getResDescription(item: any) {
+    try {
+      return item.responses[200].description || ''
+    } catch {
+      return ''
+    }
+  }
+
+  public async run() {
+    try {
+      return await this.render('api')
+    } catch (err) {
+      console.info('===========ApiTemplate=err==========', err)
+    }
+  }
+}

package/src/template/schemas.ts

@@ -0,0 +1,89 @@
+import { OpenAPIObject } from '@nestjs/swagger'
+import { Temp, Template, smfType } from 'moyan-file-model'
+
+export class SchemasTemplate extends Temp implements Template {
+  openAPIObject: OpenAPIObject
+
+  list: Array<any> = []
+
+  constructor(openAPIObject:OpenAPIObject) {
+    super(smfType.ts)
+    this.openAPIObject = openAPIObject
+    this.init()
+  }
+
+  init() {
+    const schemas = new Map()
+    for (const key in this.openAPIObject.components.schemas) {
+      const arr = this.parseSchema(this.openAPIObject.components.schemas[key])
+      schemas.set(key, {
+        key,
+        arr
+      })
+    }
+    this.list = [...schemas.values()]
+  }
+
+  parseSchema(schema: any) {
+    const parameters = new Map()
+    for (const key in schema.properties) {
+      const item = schema.properties[key]
+
+      if (item.type && item.type === 'array') {
+        if (item.items && item.items.$ref) {
+          parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:Array<${this.getSchemaEntity(item.items.$ref)}>${this.getDescription(item)}`)
+          continue
+        } else if (item.items && item.items.oneOf && Array.isArray(item.items.oneOf)) {
+          const schemaEntityArr = item.items.oneOf.map((item1: any) => {
+            return this.getSchemaEntity(item1.$ref)
+          })
+          parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:Array<${schemaEntityArr.join('|')}>${this.getDescription(item)}`)
+          continue
+        } else {
+          parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:Array<any>${this.getDescription(item)}`)
+          continue
+        }
+      } else if (Array.isArray(item.allOf)) {
+        const schemaEntityArr = item.allOf.map((item1: any) => {
+          return this.getSchemaEntity(item1.$ref)
+        })
+        parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:${schemaEntityArr.join('|')}${this.getDescription(item)}`)
+        continue
+      } else if (Array.isArray(item.oneOf)) {
+        const schemaEntityArr = item.oneOf.map((item1: any) => {
+          return this.getSchemaEntity(item1.$ref)
+        })
+        parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:${schemaEntityArr.join('|')}${this.getDescription(item)}`)
+        continue
+      } else if (item.type) {
+        parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:${item.type}${this.getDescription(item)}`)
+        continue
+      } else {
+        parameters.set(key, `${key}${this.isRequired(schema, key) ? '?' : ''}:any${this.getDescription(item)}`)
+        continue
+      }
+    }
+    return [...parameters.values()].map((item) => item + '\n')
+  }
+
+  isRequired(schema: any, key: string) {
+    return !(schema.required && schema.required.includes(key))
+  }
+
+  getSchemaEntity(str: string): string {
+    const arr = str.split('/')
+    return arr[3] || `any`
+  }
+
+  getDescription(item: any) {
+    return item.description ? ' // ' + item.description : ''
+  }
+
+  public async run() {
+    try {
+      return await this.render('schemas')
+    } catch (err) {
+      console.info('===========SchemasTemplate=err==========', err)
+    }
+  }
+}