codekingpro/portable-devtools

1const liborg = require('libnpmorg')
2const { otplease } = require('../utils/auth.js')
3const BaseCommand = require('../base-cmd.js')
4const { output } = require('proc-log')
5
6class Org extends BaseCommand {
7  static description = 'Manage orgs'
8  static name = 'org'
9  static usage = [
10    'set orgname username [developer | admin | owner]',
11    'rm orgname username',
12    'ls orgname [<username>]',
13  ]
14
15  static params = ['registry', 'otp', 'json', 'parseable']
16
17  static async completion (opts) {
18    const argv = opts.conf.argv.remain
19    if (argv.length === 2) {
20      return ['set', 'rm', 'ls']
21    }
22
23    switch (argv[2]) {
24      case 'ls':
25      case 'add':
26      case 'rm':
27      case 'set':
28        return []
29      default:
30        throw new Error(argv[2] + ' not recognized')
31    }
32  }
33
34  async exec ([cmd, orgname, username, role]) {
35    return otplease(this.npm, {
36      ...this.npm.flatOptions,
37    }, opts => {
38      switch (cmd) {
39        case 'add':
40        case 'set':
41          return this.set(orgname, username, role, opts)
42        case 'rm':
43          return this.rm(orgname, username, opts)
44        case 'ls':
45          return this.ls(orgname, username, opts)
46        default:
47          throw this.usageError()
48      }
49    })
50  }
51
52  async set (org, user, role, opts) {
53    role = role || 'developer'
54    if (!org) {
55      throw new Error('First argument `orgname` is required.')
56    }
57
58    if (!user) {
59      throw new Error('Second argument `username` is required.')
60    }
61
62    if (!['owner', 'admin', 'developer'].find(x => x === role)) {
63      throw new Error(
64        'Third argument `role` must be one of `owner`, `admin`, or `developer`, with `developer` being the default value if omitted.'
65      )
66    }
67
68    const memDeets = await liborg.set(org, user, role, opts)
69    if (opts.json) {
70      output.standard(JSON.stringify(memDeets, null, 2))
71    } else if (opts.parseable) {
72      output.standard(['org', 'orgsize', 'user', 'role'].join('\t'))
73      output.standard(
74        [memDeets.org.name, memDeets.org.size, memDeets.user, memDeets.role].join('\t')
75      )
76    } else if (!this.npm.silent) {
77      output.standard(
78        `Added ${memDeets.user} as ${memDeets.role} to ${memDeets.org.name}. You now have ${
79            memDeets.org.size
80          } member${memDeets.org.size === 1 ? '' : 's'} in this org.`
81      )
82    }
83
84    return memDeets
85  }
86
87  async rm (org, user, opts) {
88    if (!org) {
89      throw new Error('First argument `orgname` is required.')
90    }
91
92    if (!user) {
93      throw new Error('Second argument `username` is required.')
94    }
95
96    await liborg.rm(org, user, opts)
97    const roster = await liborg.ls(org, opts)
98    user = user.replace(/^[~@]?/, '')
99    org = org.replace(/^[~@]?/, '')
100    const userCount = Object.keys(roster).length
101    if (opts.json) {
102      output.buffer({
103        user,
104        org,
105        userCount,
106        deleted: true,
107      })
108    } else if (opts.parseable) {
109      output.standard(['user', 'org', 'userCount', 'deleted'].join('\t'))
110      output.standard([user, org, userCount, true].join('\t'))
111    } else if (!this.npm.silent) {
112      output.standard(
113        `Successfully removed ${user} from ${org}. You now have ${userCount} member${userCount === 1 ? '' : 's'} in this org.`
114      )
115    }
116  }
117
118  async ls (org, user, opts) {
119    if (!org) {
120      throw new Error('First argument `orgname` is required.')
121    }
122
123    let roster = await liborg.ls(org, opts)
124    if (user) {
125      const newRoster = {}
126      if (roster[user]) {
127        newRoster[user] = roster[user]
128      }
129
130      roster = newRoster
131    }
132    if (opts.json) {
133      output.buffer(roster)
134    } else if (opts.parseable) {
135      output.standard(['user', 'role'].join('\t'))
136      Object.keys(roster).forEach(u => {
137        output.standard([u, roster[u]].join('\t'))
138      })
139    } else if (!this.npm.silent) {
140      const chalk = this.npm.chalk
141      for (const u of Object.keys(roster).sort()) {
142        output.standard(`${u} - ${chalk.cyan(roster[u])}`)
143      }
144    }
145  }
146}
147
148module.exports = Org
149