@mono-labs/cli 0.0.5

package/lib/commands/dev/dev-editor.js

@@ -0,0 +1,265 @@
+import blessed from 'blessed'
+import { spawn } from 'child_process'
+import 'dotenv/config'
+import inquirer from 'inquirer'
+import { env } from 'process'
+import readline from 'readline'
+import treeKill from 'tree-kill'
+
+import { generateEnvValues } from '../../app.js'
+import { STAGING_URL } from '../../config.js'
+import { getNgrokUrl, updateNgrokUrl } from './ngrok.js'
+
+// EXPO_FORCE_PROD = true;
+// EXPO_UNSTABLE_ATLAS = false;
+
+// Import the runDevCommand function
+const colors = {
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  white: '\x1b[37m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m',
+}
+
+function getContinuedServices() {
+  const continuedServices = Object.keys(devServices).filter((key) => devServices[key].continue)
+  return continuedServices
+}
+
+function getPrepServices() {
+  const continuedServices = Object.keys(devServices).filter((key) => !devServices[key].continue)
+  return continuedServices
+}
+
+const devServicesRoot = {
+  docker: {
+    command: 'docker compose up -d',
+    key: '?',
+    icon: '🐳',
+    stdio: 'ignore',
+  },
+  backend: {
+    command: 'yarn backend server',
+    key: 'b',
+    color: colors.yellow,
+    continue: true,
+    icon: '🦾',
+  },
+  // app: {
+  // 	command: 'yarn workspace app expo start -c --tunnel --dev-client',
+  // 	key: 'a',
+  // 	color: colors.white,
+  // 	continue: true,
+  // 	icon: '📱',
+  // 	stdio: ['inherit', 'inherit', 'inherit'],
+  // },
+  dynamo: {
+    command: 'yarn backend dynamodb-admin -p 8082 --dynamo-endpoint=http://localhost:8000',
+    key: 'd',
+    continue: true,
+    icon: '📦',
+  },
+}
+
+const devServices = {}
+Object.keys(devServicesRoot).forEach((key) => {
+  const service = devServicesRoot[key]
+  devServices[key] = {
+    ...service,
+    name: key,
+  }
+})
+const childProcesses = {}
+let allowRestart = true
+
+const totalRetries = 5
+
+function startService(key, forceProd, ngrokUrl, stage, envObj) {
+  const { command, stdio } = devServices[key]
+  const isContinued = devServices[key].continue
+
+  const child = spawn(command, {
+    stdio: stdio ? stdio : ['ignore', 'pipe', 'pipe'],
+    shell: true,
+    env: {
+      ...envObj,
+    },
+  })
+
+  childProcesses[key] = child
+  childManager(child, devServices[key], false, () => {
+    if (isContinued && allowRestart && key !== 'backend') {
+      setTimeout(() => startService(key, forceProd, ngrokUrl, stage, envObj), 2000)
+    }
+  })
+}
+
+const write = (color, message) => {
+  process.stdout.write(`${color}${message}${colors.reset}\n`)
+}
+
+const serviceSigInt = {}
+
+function childManager(child, service, nowrite = false, restartCallback = undefined) {
+  const color = service.color || undefined
+  const writeToBox = (data) => {
+    if (color) write(color, data.toString())
+  }
+
+  if (!nowrite) {
+    child.stdout?.on('data', writeToBox)
+    child.stderr?.on('data', writeToBox)
+  }
+
+  child.on('sigint', (code) => {
+    console.log('sigint')
+    console.log(`\n${service.icon || '🔚'} ${service.name || 'Service'} exited with code ${code}`)
+    if (restartCallback) restartCallback()
+  })
+
+  child.on('exit', (code) => {
+    if (!serviceSigInt[service.name] && restartCallback) {
+      console.log(
+        `\n${service.icon || '🔚'} ${service.name || 'Service'} exited with code ${code}\n`
+      )
+      restartCallback()
+    }
+  })
+}
+
+export async function dev(_forceProd, useAtlas, argServices, stage) {
+  const forceProd = stage === true ? true : _forceProd
+  let acceptedServices = argServices || undefined
+  if (acceptedServices === undefined && !stage) {
+    const { acceptedServices: services } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'acceptedServices',
+        message: 'Select services to run:',
+        choices: Object.keys(devServices).map((key) => ({
+          name: key,
+          value: key,
+        })),
+        default: Object.keys(devServices).map((key) => key),
+      },
+    ])
+
+    acceptedServices = services
+  }
+
+  let ngrokUrl = ''
+  if (!forceProd && !stage) {
+    let envObj = generateEnvValues(forceProd)
+    getPrepServices().forEach((key) => {
+      const { command, stdio } = devServices[key]
+      if (acceptedServices.includes(key)) {
+        console.log(`Running command for service ${key}: ${command}`)
+        const child = spawn(command, {
+          stdio: ['pipe', 'inherit', 'pipe'], // Read from terminal, but capture output
+          shell: true,
+          env: {
+            ...envObj,
+          },
+        })
+        if (key === 'app') {
+          child.on('sigint', () => {
+            console.log('SIGINT received for app service')
+          })
+          child.on('exit', () => {
+            console.log('exit received for app service')
+          })
+        }
+
+        childProcesses[key] = child
+        childManager(child, devServices[key], true)
+      }
+    })
+
+    while (!ngrokUrl) {
+      try {
+        ngrokUrl = (await getNgrokUrl()) + '/'
+      } catch (e) {
+        console.log('Ngrok failed to start. Retrying in 2 seconds...')
+        console.log(e)
+        await new Promise((res) => setTimeout(res, 2000)) // Delay before retry
+      }
+    }
+  }
+
+  let envObj = generateEnvValues(forceProd, ngrokUrl, useAtlas)
+  if (stage) {
+    envObj.EXPO_PUBLIC_API_URL = `${STAGING_URL}`
+    envObj.ApiUrl = `${STAGING_URL}`
+    envObj.EXPO_FORCE_PROD = 'true'
+  } else {
+    const publicUrl = process.env.EXPO_PUBLIC_API_URL || `${STAGING_URL}`
+    envObj.EXPO_PUBLIC_API_URL = publicUrl
+    envObj.ApiUrl = `${STAGING_URL}`
+  }
+
+  setTimeout(
+    () => {
+      console.log('ngrokUrl', ngrokUrl)
+      console.log('envObj', envObj)
+      getContinuedServices().forEach((key) => {
+        if (stage && key === 'app') {
+          startService(key, forceProd, ngrokUrl, stage, envObj)
+        } else {
+          if (!stage && acceptedServices.includes(key)) {
+            startService(key, forceProd, ngrokUrl, stage, envObj)
+          }
+        }
+      })
+    },
+    !forceProd ? 5000 : 100
+  )
+
+  async function shutdown() {
+    console.log('\n🛑 Shutting down all services...')
+    for (const [key, child] of Object.entries(childProcesses)) {
+      if (
+        child &&
+        child.pid &&
+        !child.killed &&
+        devServices[key].continue &&
+        !['docker'].includes(key)
+      ) {
+        console.log(`→ Killing service: ${key}`)
+        await new Promise((resolve) => {
+          treeKill(child.pid, 'SIGTERM', (err) => {
+            if (!err) {
+              console.log(`✅ ${key} has been tree-killed.`)
+            }
+            resolve()
+          })
+        })
+      }
+      if (key === ' docker') {
+        spawn(command, {
+          stdio: 'docker-compose down', // Read from terminal, but capture output
+          shell: true,
+          env: {
+            ...envObj,
+          },
+        })
+      }
+    }
+  }
+
+  process.on('SIGINT', () => {
+    shutdown().then(() => process.exit(0))
+  })
+
+  process.on('SIGTERM', () => {
+    shutdown().then(() => process.exit(0))
+  })
+
+  // Exit signal
+  process.on('exit', () => {
+    console.log('👋 Process exiting...')
+  })
+}

package/lib/commands/dev/index.js

@@ -0,0 +1,22 @@
+import { program } from '../../app.js'
+import { dev } from './dev-editor.js'
+
+program
+  .command('dev2')
+  .description('Run local dev environment')
+  .option('-d, --dev', 'Deploy to dev environment')
+  .option('-a, --atlas', 'Region to deploy to')
+  .option('--app', 'Runs just the native app')
+  .option('--host', 'Runs just the backend host app')
+  .option('--stage', 'Connect to staging environment')
+  .action(async (str, options) => {
+    let services = undefined
+    console.log('str', str)
+    if (str.app || str.host) {
+      if (str.app) services = ['app']
+      if (str.host) services = ['backend']
+    }
+    const stage = str.stage || false
+    console.log(str.dev || false)
+    dev(str.dev || false, str.atlas || false, services, stage)
+  })

package/lib/commands/dev/ngrok.js

@@ -0,0 +1,88 @@
+import fs from 'fs'
+import http from 'http'
+import https from 'https'
+
+// Define the path to your .env file
+const envFilePath = '../.env'
+
+// Fetch the ngrok public URL from localhost:4040 (ngrok web interface)
+export function getNgrokUrl() {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'localhost',
+      port: 4040,
+      path: '/api/tunnels',
+      method: 'GET',
+    }
+
+    const req = (options.port === 443 ? https : http).request(options, (res) => {
+      let data = ''
+      res.on('data', (chunk) => {
+        data += chunk
+      })
+
+      res.on('end', () => {
+        try {
+          const jsonResponse = JSON.parse(data)
+          const publicUrl = jsonResponse.tunnels && jsonResponse.tunnels[0]?.public_url
+          if (publicUrl) {
+            resolve(publicUrl)
+          } else {
+            reject('Could not find public URL in the response')
+          }
+        } catch (err) {
+          reject('Error parsing JSON response')
+        }
+      })
+    })
+
+    req.on('error', (error) => {
+      reject(error)
+    })
+
+    req.end()
+  })
+}
+
+// Update the .env file with the new NGROK_URL value
+function updateEnvFile(ngrokUrl) {
+  console.log('Updating .env file with ngrok URL:', ngrokUrl)
+  console.log('Env file path:', envFilePath)
+  fs.readFile(envFilePath, 'utf8', (err, data) => {
+    if (err) {
+      console.error('Error reading .env file:', err)
+      return
+    }
+
+    console.log('data', data)
+
+    let newData
+    if (data.includes('EXPO_PRIVATE_API_URL=')) {
+      // If NGROK_URL exists, replace it
+      newData = data.replace(/EXPO_PRIVATE_API_URL=.*/, `EXPO_PRIVATE_API_URL=${ngrokUrl}/`)
+    } else {
+      // If NGROK_URL doesn't exist, add it to the file
+      newData = `${data}\nEXPO_PRIVATE_API_URL=${ngrokUrl}/`
+    }
+
+    console.log('newData', newData)
+
+    // Write the updated data back to the .env file
+    fs.writeFile(envFilePath, newData, 'utf8', (writeErr) => {
+      if (writeErr) {
+        console.error('Error writing to .env file:', writeErr)
+      } else {
+        console.log(`NGROK_URL has been updated to: ${ngrokUrl}`)
+      }
+    })
+  })
+}
+// Main function to get the ngrok URL and update the .env file
+export async function updateNgrokUrl() {
+  try {
+    const ngrokUrl = await getNgrokUrl()
+    updateEnvFile(ngrokUrl)
+  } catch (error) {
+    console.error('Error:', error)
+  }
+}

package/lib/commands/generate/generateSeed.js

@@ -0,0 +1,224 @@
+import fs from 'fs'
+// Initialize the DynamoDB client
+
+import { readFileSync } from 'fs'
+import path from 'path'
+
+import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb'
+import { marshall, unmarshall } from '@aws-sdk/util-dynamodb'
+
+import { join } from 'node:path';
+const packageJSON = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'));
+
+console.log('Deploy command loaded')
+
+const awsObject = packageJSON['aws'] || {}
+const projectName = packageJSON['name'] || 'project'
+
+const awsProfile = awsObject['profile'] || 'default'
+
+// TODO: Fix Copy Issues
+const dirPath = './docker/seed' // Folder path to delete files from
+
+// Function to delete all files in the specified directory (ignores directories)
+function deleteFilesInDir(dir) {
+	// Read all files and directories inside the directory
+	const files = fs.readdirSync(dir)
+
+	// Loop through each file and directory
+	files.forEach((file) => {
+		const filePath = path.join(dir, file) // Get full path of the file or directory
+
+		// Check if it's a file (not a directory)
+		const stats = fs.statSync(filePath)
+
+		if (stats.isFile()) {
+			// If it's a file, delete it
+			fs.unlinkSync(filePath)
+			console.log(`Deleted file: ${filePath}`)
+		}
+	})
+}
+
+// Function to scan the DynamoDB table and generate the desired JSON format
+async function generateTableExport(tablename, client, profilesOnly = false) {
+	let params = {
+		TableName: tablename,
+	}
+
+	// This will hold all the data retrieved from DynamoDB
+	let allItems = []
+	let lastEvaluatedKey = null
+
+	// If there are more items (pagination in case of large tables)
+	do {
+		if (lastEvaluatedKey) {
+			params.ExclusiveStartKey = lastEvaluatedKey
+		}
+
+		try {
+			// Perform the scan operation
+			console.log('params', params)
+			const data = await client.send(new ScanCommand(params))
+			allItems = allItems.concat(data.Items)
+			lastEvaluatedKey = data.LastEvaluatedKey // Set the last evaluated key for pagination
+		} catch (error) {
+			console.error('Error scanning DynamoDB table:', error)
+			return
+		}
+	} while (lastEvaluatedKey) // Continue scanning if there are more pages of results
+
+	// Format the data into the desired JSON structure
+	//console.log(JSON.stringify)
+	const formattedData = {
+		[tablename]: allItems
+			.filter(
+				(item) =>
+					!profilesOnly ||
+					!tablename.includes('Database') ||
+					unmarshall(item)['SK'].includes('PROFILE'),
+			)
+			.map((item) => {
+				const formattedItem = unmarshall(item) // Unmarshall DynamoDB format to JS object
+				// Ensure the correct format: PutRequest -> Item
+				//if (tablename.includes('Database') && !formattedItem['SK'].includes('USER')) return undefined;
+				return {
+					PutRequest: {
+						Item: marshall(formattedItem), // Marshall JS object back to DynamoDB format
+					},
+				}
+			}),
+	}
+	return formattedData
+}
+async function exportDynamoTable(
+	tables,
+	client,
+	dbRewrites,
+	profilesOnly = false,
+	strOut = './docker/seed',
+) {
+	deleteFilesInDir(dirPath)
+	let output = await Promise.all(
+		tables.map(async (tableName) => await generateTableExport(tableName, client, profilesOnly)),
+	)
+	const fileName = `${strOut}/dynamodb-seed`
+
+	const outputRes = {}
+	output.map((item) => {
+		const keys = Object.keys(item)
+		console.log(keys)
+
+		return keys.map((key) => {
+			const value = item[key].filter((item) => item !== undefined)
+			outputRes[key] = value
+			return { value }
+		})
+	})
+
+	output = outputRes
+
+	const fileObject = {}
+	const dbObject = {}
+	Object.keys(output).forEach((key) => {
+		console.log('key', key)
+		const value = output[key]
+		console.log('value', value.length)
+		if (value.length > 0) {
+			console.log('dbRewrites', dbRewrites)
+			console.log('key', key)
+			const dbKey = dbRewrites[key] || key
+			console.log('dbKey', dbKey)
+			dbObject[dbKey] = value
+		}
+	})
+	console.log('dbObject', dbObject)
+
+	let countTotal = 0
+
+	Object.keys(dbObject).forEach((key) => {
+		console.log(key)
+		let currentPosition = 0
+		const numOfItems = 20
+		const putItems = dbObject[key]
+		while (currentPosition < putItems.length) {
+			if (dbObject[key].length > numOfItems) {
+				const result = putItems.slice(currentPosition, currentPosition + numOfItems)
+				fileObject[`${fileName}-${countTotal}`] = { [key]: result }
+				currentPosition += numOfItems
+				countTotal += 1
+			} else {
+				const result = putItems.slice(currentPosition, putItems.length)
+				fileObject[`${fileName}-${countTotal}`] = { [key]: result }
+				currentPosition += numOfItems
+				countTotal += 1
+			}
+		}
+	})
+
+	Object.keys(fileObject).forEach((key) => {
+		console.log('Writing to file: ', key)
+		fs.writeFileSync(`${key}.json`, JSON.stringify(fileObject[key], null, 2))
+	})
+
+	console.log(`Export complete. Data written to ${fileName}`)
+}
+export function createDirIfNotExists(dirname) {
+	if (!fs.existsSync(dirname)) {
+		fs.mkdirSync(dirname)
+	}
+}
+
+// Run the function
+
+export function exportTable(
+	newTables,
+	owner,
+	altOwner = 'dev',
+	rewriteDb,
+	live = false,
+	region = 'us-east-2',
+	profilesOnly = false,
+) {
+	createDirIfNotExists(dirPath)
+	const tables = live ? ['MainDatabase'] : ['MainDB']
+	const dbRewrites = {}
+	const dbOg = {}
+	tables.map((table, index) => (dbOg[table] = newTables[index] || ''))
+	tables.map((table, index) => {
+		const rewriteDbIndex = rewriteDb[index]
+		if (rewriteDbIndex === 'MainDB') {
+			dbRewrites[`${projectName}-infra-${table}-${owner}`] = `${rewriteDbIndex || table}`
+		} else {
+			const newTable = tables[index].replace(tables[index], newTables[index] || tables[index])
+			dbRewrites[`${projectName}-infra-${table}-${owner}`] =
+				`${projectName}-infra-${newTable || table}-${altOwner || owner}`
+		}
+	})
+
+	let dbTables = ['MainDB']
+
+	if (live) {
+		dbTables = tables.map((table) => {
+			return `${projectName}-infra-${table}-${owner}`
+		})
+	}
+
+	let client = undefined
+	if (live) {
+		client = new DynamoDBClient({
+			region: region, // Replace with your AWS region
+		})
+	} else {
+		console.log('LOCAL')
+		client = new DynamoDBClient({
+			region: region, // Replace with your AWS region
+			endpoint: 'http://localhost:8000', // The default local DynamoDB endpoint
+			credentials: {
+				accessKeyId: 'fakeAccessKeyId', // Use fake credentials for local DynamoDB
+				secretAccessKey: 'fakeSecretAccessKey',
+			},
+		})
+	}
+	exportDynamoTable(dbTables, client, dbRewrites, profilesOnly)
+}

package/lib/commands/generate/index.js

@@ -0,0 +1,30 @@
+import { program } from '../../app.js'
+import { exportTable } from './generateSeed.js'
+
+program
+	.command('generate')
+	.description('Generate seed data in ./docker/seed')
+	.argument('[<string>]', 'Tables to generateFrom')
+	.option('-o, --owner <owner>', 'Owner of the tables')
+	.option('-n, --newowner <newowner>', 'New owner of the tables')
+	.option('-p, --live', 'Pull from live')
+	.option('-r, --region <region>', 'Region to deploy to')
+	.option('-d, --db <db>', 'Databases to rewrite to')
+	.option('--profiles', 'Profiles only seed generation')
+	.action(async (str, options) => {
+		const owner = options.owner || 'dev'
+		const profilesOnly = options.profiles || false
+		const tables = (str || '').split(',')
+		let nameRedirect = []
+		if (options.db) nameRedirect = options.db.split(',')
+
+		exportTable(
+			tables,
+			owner,
+			options.newowner,
+			nameRedirect,
+			options.live,
+			options.region,
+			profilesOnly,
+		)
+	})

package/lib/commands/init/index.js

@@ -0,0 +1,37 @@
+import assert from 'assert'
+import { spawn } from 'child_process'
+import { readFileSync } from 'fs'
+
+import { program } from '../../app.js'
+
+import { join } from 'node:path';
+const packageJSON = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'));
+
+console.log('Deploy command loaded')
+
+const awsObject = packageJSON['aws'] || {}
+
+const accountId = process.env.CDK_DEPLOY_ACCOUNT
+const awsProfile = process.env.CDK_DEPLOY_PROFILE || 'default'
+
+program
+  .command('init')
+  .description('Execute cdk deploy command')
+  .action((str, options) => {
+    const owner = str || 'dev'
+    const region = options.region || 'us-east-2'
+    console.log(`Deploying to ${owner} environment`)
+    const command = `workspace infra cdk bootstrap`
+    const child = spawn('yarn', [`${command}`], {
+      stdio: 'inherit',
+      shell: true, // required if using shell-style commands or cross-platform support
+      env: {
+        AWS_PROFILE: awsProfile,
+      },
+    })
+
+    child.on('exit', (code) => {
+      console.log(`Process exited with code ${code}`)
+      process.exit(code ?? 0)
+    })
+  })

package/lib/commands/loadFromRoot.js

@@ -0,0 +1,38 @@
+import fs from 'fs'
+import path from 'path'
+
+export function getRootDirectory() {
+  return path.join(process.cwd(), 'myfile.json')
+}
+
+export function getRootJson() {
+  const jsonPath = path.join(process.cwd(), 'package.json') // cwd + file
+  const raw = fs.readFileSync(jsonPath, 'utf-8')
+  const data = JSON.parse(raw)
+
+  return data
+}
+
+export function getHasteFiles() {
+  const dir = path.join(process.cwd(), '.haste')
+
+  if (!fs.existsSync(dir)) {
+    return []
+  }
+
+  const files = fs.readdirSync(dir) // names only
+  return files.map((f) => path.join(dir, f))
+}
+
+export function getHasteConfig() {
+  const objHaste = getHasteFiles()
+  const hasteConfig = {}
+  for (const file of objHaste) {
+    const fileName = path.basename(file).replace('.json', '')
+    const raw = fs.readFileSync(file, 'utf-8')
+    console.log('file content', file, raw)
+    const data = JSON.parse(raw)
+    hasteConfig[fileName] = data
+  }
+  return hasteConfig
+}