@multiplayer-app/cli 1.3.35

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Multiplayer Software, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# Overview
+
+This module is for creating release and deployment. It can be used from the command line or programatically from a node script.
+
+## Command Line
+
+### Install
+
+In order to create release or deployment from the command line, install the library globally.
+
+```
+npm install -g @multiplayer-app/cli
+```
+
+### Usage
+
+Options can be provided on the command line or as environment variables.
+
+##### Create release:
+
+```
+multiplayer-app-cli releases create --apiKey=[apiKey] --service=[name] --release=[release] --releaseNotes=[releaseNotes]
+
+Options:
+  --apiKey         Multiplayer personal user API key (MULTIPLAYER_API_KEY)
+  --service        Service name (SERVICE_NAME)
+  --release        Service release (RELEASE)
+  --commitHash     [Optional] Repository URL (REPOSITORY_URL)
+  --releaseNotes   [Optional] Release notes (RELEASE_NOTES)
+```
+
+##### To create deployment:
+
+```
+multiplayer-app-cli deployments create --apiKey=[apiKey] --service=[name] --release=[release] --environment=[environment]
+
+Options:
+  --apiKey         Multiplayer personal user API key (MULTIPLAYER_API_KEY)
+  --service        Service name (SERVICE_NAME)
+  --release        Service release (RELEASE)
+  --environment    [Optional] Environment name (ENVIRONMENT)
+```
+
+### Upload sourcemap
+
+```
+multiplayer-app-cli sourcemap upload /path/to/directory --apiKey=[apiKey] --service=[name] --release=[release] --environment=[environment]
+
+Options:
+  --apiKey         Multiplayer personal user API key (MULTIPLAYER_API_KEY)
+  --service        Service name (SERVICE_NAME)
+  --release        Service release (RELEASE)
+  --environment    [Optional] Environment name (ENVIRONMENT)
+```

package/bin/multiplayer-app-cli

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import yargs from 'yargs'
+import { hideBin } from 'yargs/helpers'
+import { create as createRelease } from '../src/commands/releases/create.js'
+import { create as createDeployment } from '../src/commands/deployments/create.js'
+import { upload as uploadSourcemap } from '../src/commands/sourcemaps/upload.js'
+
+function handleResult(err, response) {
+  if (err) {
+    if (err.status) console.error('Status Code:', err.status)
+    if (err.response) console.error(err.response.text)
+    else console.error(err.message)
+    process.exit(1)
+  } else {
+    console.log(JSON.stringify(response, null, 2))
+  }
+}
+
+yargs(hideBin(process.argv))
+  .command('releases', 'Manage releases', (yargs) => {
+    yargs.command(
+      'create',
+      'Create a release',
+      (yargs) => yargs
+        .option('apiKey', { describe: 'Multiplayer personal user API key (MULTIPLAYER_API_KEY)', type: 'string' })
+        .option('service', { describe: 'Service name (SERVICE_NAME)', type: 'string' })
+        .option('releaseVersion', { describe: 'Release version (RELEASE)', type: 'string' })
+        .option('commitHash', { describe: 'Commit hash (COMMIT_HASH)', type: 'string' })
+        .option('releaseNotes', { describe: '[Optional] Release notes (RELEASE_NOTES)', type: 'string' })
+        .option('baseUrl', { describe: '[Optional] Base URL (BASE_URL)', type: 'string' }),
+      (argv) => {
+
+        const options = {
+          apiKey: argv.apiKey || process.env.MULTIPLAYER_API_KEY,
+          service: argv.service || process.env.SERVICE_NAME,
+          release: argv.release || process.env.RELEASE,
+          commitHash: argv.commitHash || process.env.COMMIT_HASH,
+          releaseNotes: argv.releaseNotes || process.env.RELEASE_NOTES,
+          baseUrl: argv.baseUrl || process.env.BASE_URL,
+        }
+        if (!options.apiKey) return exitWithError('A Multiplayer personal user API key is required.', yargs)
+        if (!options.service) return exitWithError('A service name is required.', yargs)
+        if (!options.release) return exitWithError('A release is required.', yargs)
+        createRelease(options, handleResult)
+      },
+    )
+      .demandCommand()
+      .help()
+  })
+  .command('deployments', 'Manage deployments', (yargs) => {
+    yargs.command(
+      'create',
+      'Create a deployment',
+      (yargs) => yargs
+        .option('apiKey', { describe: 'Multiplayer personal user API key (MULTIPLAYER_API_KEY)', type: 'string' })
+        .option('service', { describe: 'Service name (SERVICE_NAME)', type: 'string' })
+        .option('release', { describe: 'Service release (RELEASE)', type: 'string' })
+        .option('environment', { describe: 'Environment name (ENVIRONMENT)', type: 'string' })
+        .option('baseUrl', { describe: '[Optional] Base URL (BASE_URL)', type: 'string' }),
+      (argv) => {
+        const options = {
+          apiKey: argv.apiKey || process.env.MULTIPLAYER_API_KEY,
+          service: argv.service || process.env.SERVICE_NAME,
+          release: argv.release || process.env.VERSION,
+          environment: argv.environment || process.env.ENVIRONMENT,
+          baseUrl: argv.baseUrl || process.env.BASE_URL,
+        }
+        if (!options.apiKey) return exitWithError('A Multiplayer personal user API key is required.', yargs)
+        if (!options.service) return exitWithError('A service name is required.', yargs)
+        if (!options.release) return exitWithError('A version is required.', yargs)
+        if (!options.environment) return exitWithError('A environment is required.', yargs)
+        createDeployment(options, handleResult)
+      },
+    )
+      .demandCommand()
+      .help()
+  })
+  .command('sourcemaps', 'Manage sourcemaps', (yargs) => {
+    yargs.command(
+      'upload <directories...>',
+      'Upload sourcemaps from a directory',
+      (yargs) => yargs
+        .positional('directories', { describe: 'Path to directory containing sourcemap files' })
+        .option('apiKey', { describe: 'Multiplayer personal user API key (MULTIPLAYER_API_KEY)', type: 'string' })
+        .option('service', { describe: 'Service name (SERVICE_NAME)', type: 'string' })
+        .option('release', { describe: 'Service release (RELEASE)', type: 'string' })
+        .option('baseUrl', { describe: '[Optional] Base URL (BASE_URL)', type: 'string' }),
+      (argv) => {
+        const options = {
+          apiKey: argv.apiKey || process.env.MULTIPLAYER_API_KEY,
+          service: argv.service || process.env.SERVICE_NAME,
+          release: argv.release || process.env.RELEASE,
+          baseUrl: argv.baseUrl || process.env.BASE_URL,
+        }
+        if (!options.apiKey) return exitWithError('A Multiplayer personal user API key is required.', yargs)
+        if (!options.service) return exitWithError('A service name is required.', yargs)
+        if (!options.release) return exitWithError('A release is required.', yargs)
+
+        uploadSourcemap(argv.directories, options, handleResult)
+      },
+    )
+      .demandCommand()
+      .help()
+  })
+  .demandCommand()
+  .help()
+  .parse()
+
+function exitWithError(message, yargsInstance) {
+  yargsInstance.showHelp()
+  console.error(message)
+  process.exit(1)
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@multiplayer-app/cli",
+  "version": "1.3.35",
+  "description": "Multiplayer CLI",
+  "author": {
+    "name": "Multiplayer Software, Inc.",
+    "url": "https://www.multiplayer.app"
+  },
+  "private": false,
+  "bugs": {
+    "url": "https://github.com/multiplayer-app/multiplayer-session-recorder-javascript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/multiplayer-app/multiplayer-session-recorder-javascript.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=18",
+    "npm": ">=8"
+  },
+  "keywords": [
+    "multiplayer",
+    "api",
+    "release",
+    "sourcemap",
+    "deployment"
+  ],
+  "main": "src/index.js",
+  "bin": {
+    "multiplayer-app-cli": "./bin/multiplayer-app-cli"
+  },
+  "scripts": {
+    "lint": "eslint src/**/*.js",
+    "preversion": "npm run lint",
+    "prepublishOnly": "npm run lint"
+  },
+  "dependencies": {
+    "jsonwebtoken": "9.0.3",
+    "superagent": "10.1.0",
+    "yargs": "16.0.3"
+  },
+  "devDependencies": {
+    "eslint": "9.30.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,97 @@
+import superagent from 'superagent'
+
+const MULTIPLAYER_BASE_API_URL = 'https://api.multiplayer.app/v0'
+
+export const getDefaultBranchId = async (
+  apiKey,
+  workspaceId,
+  projectId,
+  baseUrl = MULTIPLAYER_BASE_API_URL,
+) => {
+  const response = await superagent.get(`${baseUrl}/version/workspaces/${workspaceId}/projects/${projectId}/branches/default`)
+    .set('x-api-key', apiKey)
+
+  return response.body?._id
+}
+
+export const getEntityId = async (
+  apiKey,
+  workspaceId,
+  projectId,
+  branchId,
+  entityName,
+  entityType,
+  baseUrl = MULTIPLAYER_BASE_API_URL,
+) => {
+  const response = await superagent.get(`${baseUrl}/version/workspaces/${workspaceId}/projects/${projectId}/branches/${branchId}/entities?key=${entityName}&type=${entityType}&limit=1&skip=0`)
+    .set('x-api-key', apiKey)
+
+  const entityId = response.body?.data?.[0]?.entityId
+  if (!entityId) {
+    throw new Error(`Entity ${entityName} not found`)
+  }
+  return entityId
+}
+
+export const createRelease = async (
+  apiKey,
+  workspaceId,
+  projectId,
+  payload,
+  baseUrl = MULTIPLAYER_BASE_API_URL,
+) => {
+  const response = await superagent.post(`${baseUrl}/version/workspaces/${workspaceId}/projects/${projectId}/releases`)
+    .set('x-api-key', apiKey)
+    .send(payload)
+
+  return response.body
+}
+
+export const getReleaseId = async (
+  apiKey,
+  workspaceId,
+  projectId,
+  entityId,
+  version,
+  baseUrl = MULTIPLAYER_BASE_API_URL,
+) => {
+  const response = await superagent.get(`${baseUrl}/version/workspaces/${workspaceId}/projects/${projectId}/releases?version=${version}&entity=${entityId}`)
+    .set('x-api-key', apiKey)
+
+  const versionId = response.body?.data?.[0]?._id
+  if (!versionId) {
+    throw new Error(`Version ${version} not found`)
+  }
+  return versionId
+}
+
+export const createDeployment = async (
+  apiKey,
+  workspaceId,
+  projectId,
+  payload,
+  baseUrl = MULTIPLAYER_BASE_API_URL,
+) => {
+  const response = await superagent.post(`${baseUrl}/version/workspaces/${workspaceId}/projects/${projectId}/deployments`)
+    .set('x-api-key', apiKey)
+    .send(payload)
+
+  return response.body
+}
+
+export const uploadSourcemap = async (
+  apiKey,
+  workspaceId,
+  projectId,
+  releaseId,
+  filePath,
+  stream,
+  baseUrl = MULTIPLAYER_BASE_API_URL,
+) => {
+  const response = await superagent.post(`${baseUrl}/version/workspaces/${workspaceId}/projects/${projectId}/releases/${releaseId}/sourcemaps`)
+    .set('x-api-key', apiKey)
+    .set('Content-disposition', `attachment; filename=${filePath}`)
+    .attach('file', stream, filePath)
+
+  return response.body
+}

package/src/commands/deployments/create.js

@@ -0,0 +1,70 @@
+import * as API from '../../api.js'
+import { decodeJwtToken } from '../../helper.js'
+
+export const create = async (options, callback) => {
+  try {
+    const {
+      apiKey,
+      service,
+      release,
+      environment,
+      baseUrl,
+    } = options
+
+    const jwtToken = decodeJwtToken(apiKey) || {}
+
+    const branchId = await API.getDefaultBranchId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      baseUrl,
+    )
+
+    const serviceId = await API.getEntityId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      branchId,
+      service,
+      'platform_component',
+      baseUrl,
+    )
+
+    const releaseId = await API.getReleaseId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      serviceId,
+      release,
+      baseUrl,
+    )
+
+    const environmentId = await API.getEntityId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      branchId,
+      environment,
+      'environment',
+      baseUrl,
+    )
+
+    await API.createDeployment(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      {
+        entity: serviceId,
+        release: releaseId,
+        environment: environmentId,
+      },
+      baseUrl,
+    )
+
+    callback(null, {
+      message: 'Deployment created successfully',
+    })
+  } catch (err) {
+    callback(err, null)
+  }
+}

package/src/commands/releases/create.js

@@ -0,0 +1,55 @@
+import * as API from '../../api.js'
+import { decodeJwtToken } from '../../helper.js'
+
+export const create = async (options, callback) => {
+  try {
+    const {
+      apiKey,
+      service,
+      release,
+      commitHash,
+      repositoryUrl,
+      releaseNotes,
+      baseUrl,
+    } = options
+
+    const jwtToken = decodeJwtToken(apiKey) || {}
+
+    const branchId = await API.getDefaultBranchId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      baseUrl,
+    )
+
+    const serviceId = await API.getEntityId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      branchId,
+      service,
+      'platform_component',
+      baseUrl,
+    )
+
+    await API.createRelease(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      {
+        entity: serviceId,
+        version: release,
+        releaseNotes: releaseNotes || '',
+        commitHash,
+        repositoryUrl,
+      },
+      baseUrl,
+    )
+
+    callback(null, {
+      message: 'Release created successfully',
+    })
+  } catch (err) {
+    callback(err, null)
+  }
+}

package/src/commands/sourcemaps/upload.js

@@ -0,0 +1,76 @@
+import fs from 'fs'
+import path from 'path'
+import * as API from '../../api.js'
+import { decodeJwtToken } from '../../helper.js'
+
+const collectSourcemaps = (dir) => {
+  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  const files = []
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...collectSourcemaps(fullPath))
+    } else if (entry.isFile() && entry.name.endsWith('.map')) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}
+
+export const upload = async (directories, options, callback) => {
+  try {
+    const { apiKey, service, release, baseUrl } = options
+
+    const jwtToken = decodeJwtToken(apiKey) || {}
+
+    const branchId = await API.getDefaultBranchId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      baseUrl,
+    )
+
+    const serviceId = await API.getEntityId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      branchId,
+      service,
+      'platform_component',
+      baseUrl,
+    )
+
+    const releaseId = await API.getReleaseId(
+      apiKey,
+      jwtToken.workspace,
+      jwtToken.project,
+      serviceId,
+      release,
+      baseUrl,
+    )
+
+    const files = directories.flatMap(collectSourcemaps)
+
+    if (files.length === 0) {
+      return callback(new Error(`No sourcemap files found in directories: ${directories.join(', ')}`), null)
+    }
+
+    for (const filePath of files) {
+      const stream = fs.createReadStream(filePath)
+      await API.uploadSourcemap(
+        apiKey,
+        jwtToken.workspace,
+        jwtToken.project,
+        releaseId,
+        filePath,
+        stream,
+        baseUrl,
+      )
+    }
+
+    callback(null, { message: `Uploaded ${files.length} sourcemap(s) successfully` })
+  } catch (err) {
+    callback(err, null)
+  }
+}

package/src/helper.js

@@ -0,0 +1,5 @@
+import jwt from 'jsonwebtoken'
+
+export const decodeJwtToken = (jwtToken) => {
+  return jwt.decode(jwtToken)
+}

package/src/index.js

@@ -0,0 +1,3 @@
+export { create as createRelease } from './commands/releases/create.js'
+export { create as createDeployment } from './commands/deployments/create.js'
+export { upload as uploadSourcemap } from './commands/sourcemaps/upload.js'