@capgo/cli 4.0.11 → 4.0.13

package/src/api/versions.ts

@@ -1,86 +1,87 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { program } from 'commander';
-import { Table } from 'console-table-printer';
-import * as p from '@clack/prompts';
-import { Database } from '../types/supabase.types';
+import type { SupabaseClient } from '@supabase/supabase-js'
+import { program } from 'commander'
+import { Table } from 'console-table-printer'
+import * as p from '@clack/prompts'
+import type { Database } from '../types/supabase.types'
+
 // import { definitions } from '../types/types_supabase';
-import { getHumanDate } from '../utils';
-import { checkVersionNotUsedInChannel } from './channels';
-import { checkVersionNotUsedInDeviceOverride } from './devices_override';
+import { getHumanDate } from '../utils'
+import { checkVersionNotUsedInChannel } from './channels'
+import { checkVersionNotUsedInDeviceOverride } from './devices_override'
 
-export const deleteAppVersion = async (supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) => {
+export async function deleteAppVersion(supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) {
   const { error: delAppSpecVersionError } = await supabase
     .from('app_versions')
     .update({
-      deleted: true
+      deleted: true,
     })
     .eq('app_id', appid)
     .eq('deleted', false)
     .eq('user_id', userId)
-    .eq('name', bundle);
+    .eq('name', bundle)
   if (delAppSpecVersionError) {
-    p.log.error(`App Version ${appid}@${bundle} not found in database`);
-    program.error('');
+    p.log.error(`App Version ${appid}@${bundle} not found in database`)
+    program.error('')
   }
 }
 
-export const deleteSpecificVersion = async (supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) => {
-  const versionData = await getVersionData(supabase, appid, userId, bundle);
-  await checkVersionNotUsedInChannel(supabase, appid, userId, versionData);
-  await checkVersionNotUsedInDeviceOverride(supabase, appid, versionData);
+export async function deleteSpecificVersion(supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) {
+  const versionData = await getVersionData(supabase, appid, userId, bundle)
+  await checkVersionNotUsedInChannel(supabase, appid, userId, versionData)
+  await checkVersionNotUsedInDeviceOverride(supabase, appid, versionData)
   // Delete only a specific version in storage
-  await deleteAppVersion(supabase, appid, userId, bundle);
+  await deleteAppVersion(supabase, appid, userId, bundle)
 }
 
-export const displayBundles = (data: (Database['public']['Tables']['app_versions']['Row'] & { keep?: string })[]) => {
+export function displayBundles(data: (Database['public']['Tables']['app_versions']['Row'] & { keep?: string })[]) {
   const t = new Table({
-    title: "Bundles",
-    charLength: { "❌": 2, "✅": 2 },
-  });
+    title: 'Bundles',
+    charLength: { '❌': 2, '✅': 2 },
+  })
 
   // add rows with color
-  data.reverse().forEach(row => {
+  data.reverse().forEach((row) => {
     t.addRow({
       Version: row.name,
       Created: getHumanDate(row.created_at),
-      ...(row.keep != null ? { Keep: row.keep } : {})
-    });
-  });
+      ...(row.keep != null ? { Keep: row.keep } : {}),
+    })
+  })
 
-  p.log.success(t.render());
+  p.log.success(t.render())
 }
 
-export const getActiveAppVersions = async (supabase: SupabaseClient<Database>, appid: string, userId: string) => {
+export async function getActiveAppVersions(supabase: SupabaseClient<Database>, appid: string, userId: string) {
   const { data, error: vError } = await supabase
     .from('app_versions')
     .select()
     .eq('app_id', appid)
     .eq('user_id', userId)
     .eq('deleted', false)
-    .order('created_at', { ascending: false });
+    .order('created_at', { ascending: false })
 
   if (vError) {
-    p.log.error(`App ${appid} not found in database`);
-    program.error('');
+    p.log.error(`App ${appid} not found in database`)
+    program.error('')
   }
-  return data;
+  return data
 }
 
-export const getChannelsVersion = async (supabase: SupabaseClient<Database>, appid: string) => {
+export async function getChannelsVersion(supabase: SupabaseClient<Database>, appid: string) {
 // get all channels versionID
   const { data: channels, error: channelsError } = await supabase
     .from('channels')
     .select('version')
     .eq('app_id', appid)
-  
+
   if (channelsError) {
-    p.log.error(`App ${appid} not found in database`);
-    program.error('');
+    p.log.error(`App ${appid} not found in database`)
+    program.error('')
   }
-  return channels.map(c => c.version);
+  return channels.map(c => c.version)
 }
 
-export const getVersionData = async (supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) => {
+export async function getVersionData(supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) {
   const { data: versionData, error: versionIdError } = await supabase
     .from('app_versions')
     .select()
@@ -88,10 +89,10 @@ export const getVersionData = async (supabase: SupabaseClient<Database>, appid:
     .eq('user_id', userId)
     .eq('name', bundle)
     .eq('deleted', false)
-    .single();
+    .single()
   if (!versionData || versionIdError) {
-    p.log.error(`App Version ${appid}@${bundle} doesn't exist`);
-    program.error('');
+    p.log.error(`App Version ${appid}@${bundle} doesn't exist`)
+    program.error('')
   }
-  return versionData;
+  return versionData
 }

package/src/app/add.ts

@@ -1,72 +1,80 @@
-import { randomUUID } from 'node:crypto';
-import mime from 'mime';
-import { program } from 'commander';
-import * as p from '@clack/prompts';
-import { existsSync, readFileSync } from 'node:fs';
-import { checkLatest } from '../api/update';
-import { newIconPath, Options, checkAppExists } from '../api/app';
+import { randomUUID } from 'node:crypto'
+import { existsSync, readFileSync } from 'node:fs'
+import process from 'node:process'
+import mime from 'mime'
+import { program } from 'commander'
+import * as p from '@clack/prompts'
+import { checkLatest } from '../api/update'
+import type { Options } from '../api/app'
+import { checkAppExists, newIconPath } from '../api/app'
 import {
-  getConfig, createSupabaseClient,
-  findSavedKey, useLogSnag, verifyUser, formatError
-} from '../utils';
+  createSupabaseClient,
+  findSavedKey,
+  formatError,
+  getConfig,
+  useLogSnag,
+  verifyUser,
+} from '../utils'
 
-export const addApp = async (appId: string, options: Options, throwErr = true) => {
-  if (throwErr) {
-    p.intro(`Adding`);
-  }
-  await checkLatest();
+export async function addApp(appId: string, options: Options, throwErr = true) {
+  if (throwErr)
+    p.intro(`Adding`)
+
+  await checkLatest()
   options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig();
+  const config = await getConfig()
   appId = appId || config?.app?.appId
   const snag = useLogSnag()
 
   if (!options.apikey) {
-    p.log.error(`Missing API key, you need to provide a API key to upload your bundle`);
-    program.error('');
+    p.log.error(`Missing API key, you need to provide a API key to upload your bundle`)
+    program.error('')
   }
   if (!appId) {
-    p.log.error("Missing argument, you need to provide a appId, or be in a capacitor project");
-    program.error('');
+    p.log.error('Missing argument, you need to provide a appId, or be in a capacitor project')
+    program.error('')
   }
   const supabase = await createSupabaseClient(options.apikey)
 
-  const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
+  const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
   // Check we have app access to this appId
-  const appExist = await checkAppExists(supabase, appId);
+  const appExist = await checkAppExists(supabase, appId)
   if (throwErr && appExist) {
-    p.log.error(`App ${appId} already exist`);
-    program.error('');
-  } else if (appExist) {
+    p.log.error(`App ${appId} already exist`)
+    program.error('')
+  }
+  else if (appExist) {
     return true
   }
 
-  let { name, icon } = options;
+  let { name, icon } = options
   appId = appId || config?.app?.appId
   name = name || config?.app?.appName || 'Unknown'
-  icon = icon || "resources/icon.png" // default path for capacitor app
+  icon = icon || 'resources/icon.png' // default path for capacitor app
   if (!icon || !name) {
-    p.log.error("Missing argument, you need to provide a appId and a name, or be in a capacitor project");
-    program.error('');
+    p.log.error('Missing argument, you need to provide a appId and a name, or be in a capacitor project')
+    program.error('')
   }
-  if (throwErr) {
-    p.log.info(`Adding ${appId} to Capgo`);
-  }
-  let iconBuff;
-  let iconType;
+  if (throwErr)
+    p.log.info(`Adding ${appId} to Capgo`)
+
+  let iconBuff
+  let iconType
 
   if (icon && existsSync(icon)) {
-    iconBuff = readFileSync(icon);
-    const contentType = mime.getType(icon);
-    iconType = contentType || 'image/png';
-    p.log.warn(`Found app icon ${icon}`);
+    iconBuff = readFileSync(icon)
+    const contentType = mime.getType(icon)
+    iconType = contentType || 'image/png'
+    p.log.warn(`Found app icon ${icon}`)
   }
   else if (existsSync(newIconPath)) {
-    iconBuff = readFileSync(newIconPath);
-    const contentType = mime.getType(newIconPath);
-    iconType = contentType || 'image/png';
-    p.log.warn(`Found app icon ${newIconPath}`);
-  } else {
-    p.log.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`);
+    iconBuff = readFileSync(newIconPath)
+    const contentType = mime.getType(newIconPath)
+    iconType = contentType || 'image/png'
+    p.log.warn(`Found app icon ${newIconPath}`)
+  }
+  else {
+    p.log.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`)
   }
 
   const fileName = `icon_${randomUUID()}`
@@ -80,8 +88,8 @@ export const addApp = async (appId: string, options: Options, throwErr = true) =
         contentType: iconType,
       })
     if (error) {
-      p.log.error(`Could not add app ${formatError(error)}`);
-      program.error('');
+      p.log.error(`Could not add app ${formatError(error)}`)
+      program.error('')
     }
     const { data: signedURLData } = await supabase
       .storage
@@ -99,8 +107,8 @@ export const addApp = async (appId: string, options: Options, throwErr = true) =
       app_id: appId,
     })
   if (dbError) {
-    p.log.error(`Could not add app ${formatError(dbError)}`);
-    program.error('');
+    p.log.error(`Could not add app ${formatError(dbError)}`)
+    program.error('')
   }
   const { error: dbVersionError } = await supabase
     .from('app_versions')
@@ -116,8 +124,8 @@ export const addApp = async (appId: string, options: Options, throwErr = true) =
       app_id: appId,
     }])
   if (dbVersionError) {
-    p.log.error(`Could not add app ${formatError(dbVersionError)}`);
-    program.error('');
+    p.log.error(`Could not add app ${formatError(dbVersionError)}`)
+    program.error('')
   }
   await snag.track({
     channel: 'app',
@@ -129,14 +137,14 @@ export const addApp = async (appId: string, options: Options, throwErr = true) =
     },
     notify: false,
   }).catch()
-  p.log.success(`App ${appId} added to Capgo. ${throwErr ? 'You can upload a bundle now' : ''}`);
+  p.log.success(`App ${appId} added to Capgo. ${throwErr ? 'You can upload a bundle now' : ''}`)
   if (throwErr) {
-    p.outro(`Done ✅`);
+    p.outro(`Done ✅`)
     process.exit()
   }
   return true
 }
 
-export const addCommand = async (apikey: string, options: Options) => {
+export async function addCommand(apikey: string, options: Options) {
   addApp(apikey, options, true)
 }