TypeScript Strands.line方法代码示例

  private createThisResources(withParams: KeyedNestedResources, noParams: KeyedNestedResources, client: string, isChild = true) {
    for (const key of Object.keys(noParams)) {
      const child = noParams[key];
      let constructor;
      let path: string;
      if (isChild) {
        path = `\`\${this.path}${child.relativeUri}\``;
      } else {
        path = `'${child.relativeUri}'`;
      }
      if (this.currentPath.length === 0) {
        constructor = `new ${uppercamelcase(child.methodName)}(${client}, ${path})`;
      } else {
        constructor = `new ${this.currentPath.join('.')}.` +
          `${uppercamelcase(child.methodName)}(${client}, ${path})`;
      }

      if (withParams[key] == null) {
        this.buffer.line(`    this.${child.methodName} = ${constructor};`);
      } else {
        this.buffer.line();
        this.buffer.append(`    this.${child.methodName} = Object.setPrototypeOf(` +
          `${this.toParamsFunction(withParams[key], client, isChild, ` ${constructor});`)}`);
      }
    }
  }

    this.supportedSecuritySchemes.forEach((scheme: any, index: number, schemes: any[]) => {
      const name = camelCase(scheme.name);
      const trailing = index < schemes.length - 1 ? ',' : '';

      if (scheme.type === 'OAuth 2.0') {
        this.buffer.return();
        this.buffer.line('// eslint-disable-next-line');
        this.buffer.line(`  ${name}: function ${name}(options) {`);
        this.buffer.multiline(`    const schemeSettings = ${this.formatJSON(scheme.settings, 2, 4)};`);
        this.buffer.line(`    return new ClientOAuth2(Object.assign(schemeSettings, options));`);
        this.buffer.line(`  }${trailing}`);
      }
    });

  // Create nested resource instances.
  private createResource(resource: NestedResource) {
    this.currentPath.push(uppercamelcase(resource.methodName));
    const { withParams, noParams } = separateChildren(resource);
    const className = this.currentPath.join('.');

    this.buffer.return();
    // Check if this class is already there
    if (this.classes.filter(x => x === className).length > 0) {
      this.createProtoMethods(resource.methods, 'this.client', 'this.path', className);
    } else {
      this.classes.push(className);
      if (className.indexOf('.') > 0) {
        this.buffer.line(`${className} = class {`);
      } else {
        this.buffer.line(`class ${className} {`);
      }
      this.buffer.line(`  constructor(client, path) {`);
      this.buffer.line(`    this.client = client;`);
      this.buffer.line(`    this.path = path;`);

      this.createThisResources(withParams, noParams, 'this.client');
      this.buffer.line(`  }`);
      this.createProtoResources(withParams, noParams);
      this.createProtoMethods(resource.methods, 'this.client', 'this.path');
      if (className.indexOf('.') > 0) {
        this.buffer.line(`};`);
      } else {
        this.buffer.line(`}`);
      }
      this.createChildren(resource.children);
    }
    this.currentPath.pop();

  }

  private generateStaticMethodsAndExport() {
    this.buffer.line(`Client.version = ${javascriptStringify(this.api.version)};`);
    this.buffer.line('Client.Security = {');

    this.supportedSecuritySchemes.forEach((scheme: any, index: number, schemes: any[]) => {
      const name = camelCase(scheme.name);
      const trailing = index < schemes.length - 1 ? ',' : '';

      if (scheme.type === 'OAuth 2.0') {
        this.buffer.return();
        this.buffer.line('// eslint-disable-next-line');
        this.buffer.line(`  ${name}: function ${name}(options) {`);
        this.buffer.multiline(`    const schemeSettings = ${this.formatJSON(scheme.settings, 2, 4)};`);
        this.buffer.line(`    return new ClientOAuth2(Object.assign(schemeSettings, options));`);
        this.buffer.line(`  }${trailing}`);
      }
    });
    this.buffer.line('};');
    this.buffer.line(`module.exports = Client;`);
  }

  private generateRequiresAndGlobalFunctions() {
    this.buffer.line(`/* eslint no-use-before-define: 0 */`);

    if (hasSecurity(this.api, 'OAuth 2.0')) {
      this.buffer.line(`const ClientOAuth2 = require('client-oauth2');`);
    }

    this.buffer.multiline(`const rp = require('request-promise');
const queryString = require('query-string');
const debuglog = require('util').debuglog('${this.api.title}');

const TEMPLATE_REGEXP = /\{\\+?([^\{\}]+)\}/g;

const template = (string, interpolate) => string.replace(TEMPLATE_REGEXP, (match, key) => {
  if (interpolate[key] != null) {
    return encodeURIComponent(interpolate[key]);
  }

  return '';
});

const request = (client, method, path, opts) => {
  const headers = opts.headers ? Object.assign(
    {}, client.options.headers, opts.headers
  ) : client.options.headers;
  const options = Object.assign({}, client.options, opts);
  const baseUri = template(options.baseUri, options.baseUriParameters);

  if (typeof options.query === 'string') {
    options.query = queryString.parse(options.query);
  }

  let reqOpts = {
    url: baseUri.replace(/\\/$/, '') + template(path, options.uriParameters),
    json: !Buffer.isBuffer(options.body),
    method,
    headers,
    formData: options.formData,
    body: options.body,
    qs: options.query,
    options: options.options,
    resolveWithFullResponse: true
  };

  if (options.options !== undefined) {
    reqOpts = Object.assign(reqOpts, options.options);
  }

  if (options.user && typeof options.user.sign === 'function') {
    reqOpts = options.user.sign(reqOpts);
  }

  debuglog(\`[REQUEST]: \${JSON.stringify(reqOpts, null, 2)}\`);

  return rp(reqOpts)
    .then((response) => {
      const responseLog = {
        headers: response.headers,
        body: response.body,
        statusCode: response.statusCode
      };
      debuglog(\`[RESPONSE]: \${JSON.stringify(responseLog, null, 2)}\`);

      // adding backward compatibility
      response.status = response.statusCode;
      return response;
    })
    .catch((error) => {
      debuglog(\`[RESPONSE]: \${JSON.stringify(error, null, 2)}\`);

      // rethrow the error so that the returned promise is rejected
      throw error;
    });
};`);
  }

  private createClientClass() {
    this.buffer.multiline(`
class Client {
  constructor(options) {
    this.path = '';
    this.options = Object.assign({
      baseUri: ${javascriptStringify(this.api.baseUri)},
      baseUriParameters: ${this.formatJSON(getDefaultParameters(this.api.baseUriParameters), 2, 6).split('\n').join('\n') },
      headers: {}
    }, options);
    this.customRequest = (method, path, opts) => request(
      this, method, path, opts
    );\n
    this.form = (payload) => {
      const data = {
        formData: payload,
        append(key, value) {
          if (typeof value !== 'string') {
            this.formData.file = value;
          } else {
            data.formData[key] = value;
          }
        }
      };
      return data;
    };\n`);

    this.createThisResources(this.withParams, this.noParams, 'this', false);

    this.buffer.line(`  }\n`);
    // Adding the extensibility point

    this.buffer.multiline(`  setHeaders(headers) {
    this.options.headers = headers;`);
    this.buffer.line(`  }`);

    this.buffer.multiline(`
  use(name, module) {
    const moduleType = typeof module;
    if (Object.prototype.hasOwnProperty.call(this, name)) {
      throw Error(\`The property \${name} already exists\`);
    }
    switch (moduleType) {
      case 'string':
        // eslint-disable-next-line
        this[name] = require(module);
        break;
      case 'function':
        this[name] = new module(); // eslint-disable-line new-cap
        break;
      case 'object':
        this[name] = module;
        break;
      case 'undefined':
        if (typeof name === 'string') {
          // eslint-disable-next-line
          this[name] = require(name);
          break;
        }
        throw Error('Cannot create the extension point with the values provided');
      default:
        throw Error('Cannot create the extension point with the values provided');
    }
  }`);
    for (const resource of this.flatTree) {
      const { relativeUri, uriParameters } = resource;

      for (const method of resource.methods) {
        if (method.annotations && method.annotations['client.methodName']) {
          const methodName = method.annotations['client.methodName'].structuredValue;
          const type = isQueryMethod(method) ? 'query' : 'body';
          const headers = getDefaultParameters(method.headers);

          const headersText = Object.keys(headers).length === 0 ? '' : `, headers: ${javascriptStringify(headers)}`;

          if (Object.keys(uriParameters).length) {
            this.buffer.return();
            this.buffer.line(`  ${methodName}(uriParams, ${type}, opts) {`);
            this.buffer.line(`    const uriParameters = Object.assign(` +
              `${javascriptStringify(getDefaultParameters(uriParameters))}, uriParams);`);
            this.buffer.line(`  const options = Object.assign({ ${type}, ` +
              `uriParameters: uriParameters${headersText} }, opts);`);
            this.buffer.line(`  return request(this, ${javascriptStringify(method.method)}, ` +
              `${javascriptStringify(relativeUri)}, options);`);
            this.buffer.line(`  }`);
          } else {
            this.buffer.return();
            this.buffer.line(`  ${methodName}(${type}, opts) {`);
            this.buffer.line(`    const options = Object.assign({ ${type}${headersText} }, opts);`);
            this.buffer.line(`    return request(this, ${javascriptStringify(method.method)}, ` +
              `${javascriptStringify(relativeUri)}, options);`);
            this.buffer.line(`  }`);
          }
        }
      }
    }
    this.createProtoMethods(this.nestedTree.methods, 'this', `''`);
    this.createProtoResources(this.withParams, this.noParams);
    this.buffer.line(`}`);
  }

  // Create prototype methods.
  private createProtoMethods(methods: NestedMethod[], client: string, path: string, prefix?: string) {
    for (const method of methods) {
      const headers = getDefaultParameters(method.headers);
      const type = isQueryMethod(method) ? 'query' : 'body';
      const headersText = Object.keys(headers).length === 0 ? '' : `,\n    {\n      headers: ${this.formatJSON(headers, 2, 6)}\n    }`;

      if (prefix) {
        this.buffer.line(`${prefix}.prototype.${camelCase(method.method)} = function ${camelCase(method.method)}Func(${type}, opts) {`);
        this.buffer.line(`  const options = Object.assign(${type} && ${type}.formData ? ${type} : {`);
        this.buffer.line(`    ${type}`);
        this.buffer.line(`  }${headersText}, opts);`);
        this.buffer.line(`  return request(${client}, ${javascriptStringify(method.method)}, ${path}, options);`);
        this.buffer.line(`};`);
      } else {
        this.buffer.line();
        this.buffer.line(`  ${camelCase(method.method)}(${type}, opts) {`);
        this.buffer.line(`    const options = Object.assign(${type} && ${type}.formData ? ${type} : {`);
        this.buffer.line(`      ${type}`);
        this.buffer.line(`    }${headersText}, opts);`);
        this.buffer.line(`    return request(${client}, ${javascriptStringify(method.method)}, ${path}, options);`);
        this.buffer.line(`  }`);
      }
    }
  }

export default function (api: Api): string {
  const s = new Strands()
  const flatTree = allResources(api) // For short-hand annotations.
  const nestedTree = nestedResources(api)
  const { withParams, noParams } = separateChildren(nestedTree)
  const supportedSecuritySchemes = getSecuritySchemes(api).filter(x => x.type === 'OAuth 2.0')

  if (hasSecurity(api, 'OAuth 2.0')) {
    s.line(`var ClientOAuth2 = require('client-oauth2')`)
  }

  s.multiline(`var popsicle = require('popsicle')
var extend = require('xtend')
var setprototypeof = require('setprototypeof')

var TEMPLATE_REGEXP = /\\{([^\\{\\}]+)\\}/g

module.exports = Client

function template (string, interpolate) {
  return string.replace(TEMPLATE_REGEXP, function (match, key) {
    if (interpolate[key] != null) {
      return encodeURIComponent(interpolate[key])
    }

    return ''
  })
}

function request (client, method, path, opts) {
  var options = extend({}, client._options, opts)
  var baseUri = template(options.baseUri, options.baseUriParameters)

  var reqOpts = {
    url: baseUri.replace(/\\/$/, '') + template(path, options.uriParameters),
    method: method,
    headers: options.headers,
    body: options.body,
    query: options.query,
    options: options.options
  }

  if (options.user && typeof options.user.sign === 'function') {
    reqOpts = options.user.sign(reqOpts)
  }

  return popsicle.request(reqOpts)
}

function Client (options) {
  this._path = ''
  this._options = extend({
    baseUri: ${stringify(api.baseUri)},
    baseUriParameters: ${stringify(getDefaultParameters(api.baseUriParameters)) }
  }, options)

  function client (method, path, options) {
    return request(client, method, path, options)
  }
`)

  createThisResources(withParams, noParams, 'client', '')

  s.line(`  setprototypeof(client, this)`)
  s.line(`  return client`)
  s.line(`}`)
  s.line()
  s.line(`Client.form = popsicle.form`)
  s.line(`Client.version = ${stringify(api.version)}`)

  s.line('Client.Security = {')

  supportedSecuritySchemes.forEach((scheme: any, index: number, schemes: any[]) => {
    const name = camelCase(scheme.name)
    const trailing = index < schemes.length ? ',' : ''

    if (scheme.type === 'OAuth 2.0') {
      s.line(`  ${name}: function (options) { return new ClientOAuth2(extend(${stringify(scheme.settings)}, options)) }${trailing}`)
    }
  })

  s.line('}')

  for (const resource of flatTree) {
    const { relativeUri, uriParameters } = resource

    for (const method of resource.methods) {
      if (method.annotations && method.annotations['client.methodName']) {
        const methodName = method.annotations['client.methodName'].structuredValue
        const type = isQueryMethod(method) ? 'query' : 'body'
        const headers = getDefaultParameters(method.headers)

        if (Object.keys(uriParameters).length) {
          s.line(`Client.prototype.${methodName} = function (uriParams, ${type}, opts) {`)
          s.line(`  var uriParameters = extend(${stringify(getDefaultParameters(uriParameters))}, uriParams)`)
          s.line(`  var options = extend({ ${type}: ${type}, uriParameters: uriParameters, headers: ${stringify(headers)} }, opts)`)
          s.line(`  return request(this, ${stringify(method.method)}, ${stringify(relativeUri)}, options)`)
          s.line(`}`)
        } else {
          s.line(`Client.prototype.${methodName} = function (${type}, opts) {`)
//.........这里部分代码省略.........

export default function (api: Api) {
  const s = new Strands()
  const projectName = paramCase(api.title)
  const className = pascalCase(api.title)

  s.multiline(`# ${api.title}

> Browser and node module for making API requests against [${api.title}](${api.baseUri}).

## Installation

\`\`\`sh
npm install ${projectName} --save
\`\`\`

## Usage

\`\`\`js
var ${className} = require('${projectName}')

var client = new ${className}()
\`\`\`
`)

  if (hasSecurity(api, 'OAuth 2.0')) {
    s.multiline(`### Authentication

#### OAuth 2.0

This API supports authentication with [OAuth 2.0](https://github.com/mulesoft/js-client-oauth2). Initialize the \`OAuth2\` instance with the application client id, client secret and a redirect uri to authenticate with users.

\`\`\`js
var auth = new ${className}.security.<method>({
  clientId:     '123',
  clientSecret: 'abc',
  redirectUri:  'http://example.com/auth/callback'
});

// Available methods for OAuth 2.0:`)

    for (const scheme of getSecuritySchemes(api)) {
      if (scheme.type === 'OAuth 2.0') {
        s.line(` - ${camelCase(scheme.name)}`)
      }
    }

    s.line('```')
  }

  s.multiline(`### Options

You can set options when you initialize a client or at any time with the \`options\` property. You may also override options per request by passing an object as the last argument of request methods. For example:

\`\`\`javascript
var client = new ${className}({ ... })

client('GET', '/', {
  baseUri: 'http://example.com',
  headers: {
    'Content-Type': 'application/json'
  }
})
\`\`\`

#### Base URI

You can override the base URI by setting the \`baseUri\` property, or initializing a client with a base URI. For example:

\`\`\`javascript
new ${className}({
  baseUri: 'https://example.com'
});
\`\`\`

### Helpers

Exports \`${className}.form\`, which exposes a cross-platform \`FormData\` interface that can be used with request bodies.

### Methods

All methods return a HTTP request instance of [Popsicle](https://github.com/blakeembrey/popsicle), which allows the use of promises (and streaming in node).
`)

  for (const resource of allResources(api)) {
    for (const method of resource.methods) {
      s.line(`#### ${getDisplayName(method, resource)}`)
      s.line()

      if (Object.keys(resource.uriParameters).length) {
        s.line(getUriParametersSnippet(resource))
        s.line()
      }

      if (method.description) {
        s.multiline(method.description.trim())
        s.line()
      }

      s.multiline(`\`\`\`js
client.${getRequestSnippet(method, resource)}.then(...)
//.........这里部分代码省略.........