hatena-fotolife-api/lib/fotolife.js

Hatena::Fotolife API wrapper for Node.js (unofficial)

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Fotolife = void 0;

var _fs = _interopRequireDefault(require("fs"));

var _mime = _interopRequireDefault(require("mime"));

var _request = _interopRequireDefault(require("request"));

var _wsse = _interopRequireDefault(require("wsse"));

var _xml2js = _interopRequireDefault(require("xml2js"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const rejectE = s => Promise.reject(new Error(s));

const requestPromise = params => {
  return new Promise((resolve, reject) => {
    return (0, _request.default)(params, (error, response) => {
      if (error !== null) return reject(error);else return resolve(response);
    });
  });
};

const xmlStringToObject = xmlString => {
  return new Promise((resolve, reject) => {
    const parser = new _xml2js.default.Parser({
      explicitArray: false,
      explicitCharkey: true
    });
    return parser.parseString(xmlString, (error, result) => {
      if (error !== null) return reject(error);else return resolve(result);
    });
  });
};

const xmlObjectToXmlString = xmlObject => {
  try {
    const builder = new _xml2js.default.Builder();
    const xmlString = builder.buildObject(xmlObject);
    return Promise.resolve(xmlString);
  } catch (error) {
    return Promise.reject(error);
  }
};

class Fotolife {
  constructor(options) {
    this._type = typeof options.type !== "undefined" ? options.type : "wsse";

    if (options.type === "oauth") {
      this._username = null;
      this._apikey = null;
      this._consumerKey = options.consumerKey;
      this._consumerSecret = options.consumerSecret;
      this._accessToken = options.accessToken;
      this._accessTokenSecret = options.accessTokenSecret;
    } else {
      this._username = options.username;
      this._apikey = options.apikey;
      this._consumerKey = null;
      this._consumerSecret = null;
      this._accessToken = null;
      this._accessTokenSecret = null;
    }
  }

  create({
    file,
    folder: folderOrUndefined,
    generator: generatorOrUndefined,
    title: titleOrUndefined,
    type: typeOrUndefined
  }) {
    if (!_fs.default.existsSync(file)) return rejectE("options.file does not exist");
    return this._request({
      body: {
        entry: Object.assign(Object.assign({
          $: {
            xmlns: "http://purl.org/atom/ns#"
          },
          content: {
            $: {
              mode: "base64",
              type: typeof typeOrUndefined !== "undefined" ? typeOrUndefined : _mime.default.getType(file)
            },
            _: _fs.default.readFileSync(file).toString("base64")
          },
          title: {
            _: typeof titleOrUndefined !== "undefined" ? titleOrUndefined : ""
          }
        }, typeof folderOrUndefined !== "undefined" ? {
          "dc:subject": {
            _: folderOrUndefined
          }
        } : {}), typeof generatorOrUndefined !== "undefined" ? {
          generator: {
            _: generatorOrUndefined
          }
        } : {})
      },
      method: "post",
      path: "/atom/post",
      statusCode: 201
    });
  }

  update({
    id,
    title
  }) {
    return this._request({
      body: {
        entry: {
          $: {
            xmlns: "http://purl.org/atom/ns#"
          },
          title: {
            _: title
          }
        }
      },
      method: "put",
      path: "/atom/edit/" + id,
      statusCode: 200
    });
  }

  destroy({
    id
  }) {
    return this._request({
      method: "delete",
      path: "/atom/edit/" + id,
      statusCode: 200
    });
  }

  show({
    id
  }) {
    return this._request({
      method: "get",
      path: "/atom/edit/" + id,
      statusCode: 200
    });
  }

  index() {
    return this._request({
      method: "get",
      path: "/atom/feed",
      statusCode: 200
    });
  }

  _request({
    body,
    method,
    path,
    statusCode
  }) {
    const bodyOrNullPromise = typeof body !== "undefined" ? xmlObjectToXmlString(body) : Promise.resolve(null);
    return bodyOrNullPromise.then(bodyOrNull => {
      return requestPromise(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, bodyOrNull !== null ? {
        body: bodyOrNull
      } : {}), this._type !== "oauth" ? {
        headers: {
          Authorization: 'WSSE profile="UsernameToken"',
          "X-WSSE": (0, _wsse.default)({
            password: this._apikey,
            username: this._username
          }).getWSSEHeader({
            nonceBase64: true
          })
        }
      } : {}), {
        method
      }), this._type === "oauth" ? {
        oauth: {
          consumer_key: this._consumerKey,
          consumer_secret: this._consumerSecret,
          token: this._accessToken,
          token_secret: this._accessTokenSecret
        }
      } : {}), {
        url: Fotolife.BASE_URL + path
      }));
    }).then(res => {
      if (res.statusCode !== statusCode) throw new Error("HTTP status code is " + res.statusCode);
      return xmlStringToObject(res.body);
    });
  }

}

exports.Fotolife = Fotolife;
Fotolife.BASE_URL = "https://f.hatena.ne.jp";