@ycmd/creds/cjs/chunk-3KVVDUHC.js

LSK.js CLI Creds is the easiest way to manage GitHub / Gitlab secrets and credentials

'use strict';

var chunkU2DZE3DI_js = require('./chunk-U2DZE3DI.js');
var err = require('@lsk4/err');
var log = require('@lsk4/log');
var axios = require('axios');
var fishbird = require('fishbird');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var axios__default = /*#__PURE__*/_interopDefault(axios);

var Service = class {
  static {
    chunkU2DZE3DI_js.__name(this, "Service");
  }
  client;
  log = log.createLogger(this.constructor.name);
  constructor(options) {
    this.assign(options);
    this.checkConfig();
    this.client = this.createClient(options.clientOptions);
  }
  createClient(clientOptions = {}) {
    return axios__default.default.create(clientOptions);
  }
  assign(options) {
    Object.assign(this, options);
  }
  checkConfig() {
    throw new err.Err("NOT_IMPLEMENTED", "checkConfig method not implemented");
  }
  getServiceHostname() {
    throw new err.Err("NOT_IMPLEMENTED", "getServiceHostname method not implemented");
  }
  getProjectUrl() {
    throw new err.Err("NOT_IMPLEMENTED", "getProjectUrl method not implemented");
  }
  getProjectCICDSettingURL() {
    throw new err.Err("NOT_IMPLEMENTED", "getProjectCICDSettingURL method not implemented");
  }
  getProjectPath() {
    const value = this.projectPath;
    if (!value)
      throw new err.Err("!projectPath");
    return value;
  }
  getProjectId() {
    const value = this.projectId;
    return value;
  }
  getProjectCredsUrl() {
    const value = this.projectCredsUrl;
    if (!value)
      throw new err.Err("!projectCredsUrl");
    return value;
  }
  getProjectCredsOwner() {
    const value = this.projectCredsOwner;
    if (!value)
      throw new err.Err("!projectCredsOwner");
    return value;
  }
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  async uploadSecret(key, content) {
    throw new err.Err("NOT_IMPLEMENTED", "uploadSecret method not implemented");
  }
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  async uploadVariable(key, content) {
    throw new err.Err("NOT_IMPLEMENTED", "uploadVariable method not implemented");
  }
  async removeOldHooks() {
  }
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  async uploadHook(dataHook) {
  }
  async uploadHooks(env) {
    if (!env)
      throw new err.Err("!env");
    const { hooks = [] } = env;
    try {
      await this.removeOldHooks();
    } catch (err$1) {
      this.log.error(`[ERR] Old hooks removing failed:`, err.Err.getMessage(err$1));
    }
    await fishbird.map(hooks, async (dataHook, index) => {
      try {
        await this.uploadHook(dataHook);
        this.log.info(`[OK] Hook ${index} uploaded`);
      } catch (err$1) {
        this.log.error(`[ERR] Hook ${index} not uploaded:`, err.Err.getMessage(err$1));
      }
    });
  }
  async uploadAll(env) {
    if (!env)
      throw new err.Err("!env");
    const { secrets = {}, variables = {}, files = [] } = env;
    await this.uploadHooks(env);
    await fishbird.map(Object.entries(secrets), async ([key, value]) => {
      try {
        await this.uploadSecret(key, value);
        this.log.info(`[OK] Secret ${key} uploaded`);
      } catch (err$1) {
        this.log.error(`[ERR] Secret ${key} not uploaded as secret, because`, err.Err.getMessage(err$1));
        this.log.trace(err$1);
      }
    });
    await fishbird.map(Object.entries(variables), async ([key, value]) => {
      try {
        await this.uploadVariable(key, value);
        this.log.info(`[OK] Variable ${key} uploaded`);
      } catch (err$1) {
        this.log.error(`[ERR] Variable ${key} not uploaded as variable, because`, err.Err.getMessage(err$1));
        this.log.trace(err$1);
      }
    });
    await fishbird.map(Object.values(files), async ({ name, credType, content }) => {
      const key = name;
      const value = content;
      try {
        if (credType === "variable") {
          await this.uploadVariable(key, value);
        } else if (credType === "secret") {
          await this.uploadSecret(key, value);
        } else if (credType === "skip") {
          this.log.debug(`[SKIP] File ${key} uploaded as ${credType}`);
          return;
        } else {
          throw new err.Err("unknown credType", {
            credType
          });
        }
        this.log.info(`[OK] File ${key} uploaded as ${credType}`);
      } catch (err$1) {
        this.log.error(`[ERR] File ${key} not uploaded as ${credType}, because`, err.Err.getMessage(err$1));
        this.log.trace(err$1);
      }
    });
  }
};

exports.Service = Service;
//# sourceMappingURL=out.js.map
//# sourceMappingURL=chunk-3KVVDUHC.js.map