chore: wip

Author: chrisbbreuer

.stacks/core/buddy/src/commands/cloud.ts

@@ -3,6 +3,7 @@ import { addJumpBox, deleteCdkRemnants, deleteJumpBox, deleteLogGroups, deleteSt
 import { path as p } from '@stacksjs/path'
 import type { CLI, CloudCliOptions } from '@stacksjs/types'
 import { ExitCode } from '@stacksjs/types'
+import { loop } from '@stacksjs/utils'
 import process from 'node:process'
 
 export function cloud(buddy: CLI) {
@@ -152,8 +153,26 @@ export function cloud(buddy: CLI) {
         stdin: 'inherit',
       })
 
-      await outro('Your cloud has been removed', { startTime, useSeconds: true })
-      process.exit(ExitCode.Success)
+      // TODO: this should not be necessary but for some reason some buckets with versions aren't properly getting deleted
+      // and because of that, we simply run the command several times, because eventually the versions will be deleted
+      // and consequently the buckets will be deleted
+      // the reason we are using 7 as the number of times to run the command is because it's the most amount of times I have had to run it to get it to delete everything
+      try {
+        await loop(7, async () => {
+          await runCommand('buddy cloud:clean-up', {
+            ...options,
+            cwd: p.projectPath(),
+            stdout: 'ignore',
+          })
+        })
+
+        await outro('Your cloud has been removed', { startTime, useSeconds: true })
+        process.exit(ExitCode.Success)
+      }
+      catch (error) {
+        await outro('While cleaning up the cloud, there was an issue', { startTime, useSeconds: true }, error as Error)
+        process.exit(ExitCode.FatalError)
+      }
     })
 
   buddy

.stacks/core/cli/src/exec.ts

@@ -1,7 +1,7 @@
-import process from 'node:process'
-import { ExitCode } from '@stacksjs/types'
+import { err, handleError, ok, type Result } from '@stacksjs/error-handling'
 import type { CliOptions, StacksError, Subprocess, SyncSubprocess } from '@stacksjs/types'
-import { type Result, err, handleError, ok } from '@stacksjs/error-handling'
+import { ExitCode } from '@stacksjs/types'
+import process from 'node:process'
 
 /**
  * Execute a command.
@@ -42,7 +42,7 @@ export async function exec(command: string | string[], options?: CliOptions): Pr
     cwd: options?.cwd || import.meta.dir,
     // env: { ...e, ...options?.env },
     onExit(subprocess, exitCode, signalCode, error) {
-      if (exitCode !== ExitCode.Success && exitCode)
+      if (exitCode && exitCode !== ExitCode.Success)
         process.exit(exitCode)
     },
   })

.stacks/core/cloud/src/helpers.ts

@@ -197,39 +197,41 @@ export async function deleteStacksBuckets() {
       return err('No stacks buckets found')
 
     const promises = stacksBuckets.map(async (bucket) => {
-      try {
-        const bucketName = bucket.Name || ''
-
-        // Delete the bucket
-        log.info(`Deleting bucket ${bucketName}...`)
-
-        // List all objects in the bucket
-        const objects = await s3.listObjectsV2({ Bucket: bucketName })
-
-        // Delete all objects
-        if (objects.Contents) {
-          log.info('Deleting bucket objects...')
-          await Promise.all(objects.Contents.map(object =>
-            s3.deleteObject({ Bucket: bucketName, Key: object.Key || '' }).catch(error => handleError(error)),
-          ))
-          log.info(`Finished deleting objects from bucket ${bucketName}`)
-        }
+      const bucketName = bucket.Name || ''
+
+      // Delete the bucket
+      log.info(`Deleting bucket ${bucketName}...`)
+
+      // List all objects in the bucket
+      const objects = await s3.listObjectsV2({ Bucket: bucketName })
+      log.info(`Finished listing bucket ${bucketName} objects`, objects)
+      // Delete all objects
+      if (objects.Contents) {
+        log.info('Deleting bucket objects...')
+        await Promise.all(objects.Contents.map(object =>
+          s3.deleteObject({ Bucket: bucketName, Key: object.Key || '' }).catch(error => handleError(error)),
+        ))
+        log.info(`Finished deleting objects from bucket ${bucketName}`)
+      }
 
-        log.info(`Deleting bucket ${bucketName} versions...`)
+      log.info(`aaDeleting bucket ${bucketName} versions...`)
+      try {
         const versions = await s3.listObjectVersions({ Bucket: bucketName })
+
+        log.info(`reaching?? Finished listing bucket ${bucketName} versions`, versions)
         if (versions.Versions) {
           await Promise.all(versions.Versions.map(version =>
-            s3.deleteObject({ Bucket: bucketName, Key: version.Key || '', VersionId: version.VersionId }).catch(error => handleError(error)),
-          ))
+            s3.deleteObject({ Bucket: bucketName, Key: version.Key || '', VersionId: version.VersionId }),
+          )).catch(error => handleError(error))
           log.info(`Finished deleting versions from bucket ${bucketName}`)
         }
 
         // Delete all delete markers
         log.info(`Deleting bucket ${bucketName} delete markers...`)
         if (versions.DeleteMarkers) {
           await Promise.all(versions.DeleteMarkers.map(marker =>
-            s3.deleteObject({ Bucket: bucketName, Key: marker.Key || '', VersionId: marker.VersionId }).catch(error => handleError(error)),
-          ))
+            s3.deleteObject({ Bucket: bucketName, Key: marker.Key || '', VersionId: marker.VersionId }),
+          )).catch(error => handleError(error))
           log.info(`Finished deleting delete markers from bucket ${bucketName}`)
         }
 
@@ -238,20 +240,22 @@ export async function deleteStacksBuckets() {
         if (uploads.Uploads) {
           log.info('Aborting bucket multipart uploads...')
           await Promise.all(uploads.Uploads.map(upload =>
-            s3.abortMultipartUpload({ Bucket: bucketName, Key: upload.Key || '', UploadId: upload.UploadId }).catch(error => handleError(error)),
-          ))
+            s3.abortMultipartUpload({ Bucket: bucketName, Key: upload.Key || '', UploadId: upload.UploadId }),
+          )).catch(error => handleError(error))
           log.info(`Finished aborting multipart uploads from bucket ${bucketName}`)
         }
 
-        await s3.deleteBucket({ Bucket: bucketName })
+        await s3.deleteBucket({ Bucket: bucketName }).catch(error => handleError(error))
         log.info(`Bucket ${bucketName} deleted`)
       }
       catch (error) {
-        return err(handleError('Error deleting stacks buckets', error as Error))
+        log.info(`Error listing bucket ${bucketName} versions`, error)
       }
     })
 
-    await Promise.all(promises)
+    await Promise.all(promises).catch((error: Error) => {
+      return err(handleError('Error deleting stacks buckets', error))
+    })
 
     return ok('Stacks buckets deleted')
   }

.stacks/core/types/src/search-engine.ts

@@ -43,36 +43,31 @@ export interface SearchEngineOptions {
 
 export type SearchEngineConfig = Partial<SearchEngineOptions>
 
-export interface MeiliSearchOptions {
-  apiKey: string
-  host: string
-}
-
 export interface SearchEngineDriver {
   client: MeiliSearch
 
   // Indexes
   createIndex: (name: string, options?: IndexOptions) => MaybePromise<EnqueuedTask>
   getIndex: (name: string) => MaybePromise<Index>
-  updateIndex?: (name: string, options: IndexOptions) => MaybePromise<EnqueuedTask>
-  deleteIndex?: (name: string) => MaybePromise<EnqueuedTask>
+  updateIndex: (name: string, options: IndexOptions) => MaybePromise<EnqueuedTask>
+  deleteIndex: (name: string) => MaybePromise<EnqueuedTask>
   updateIndexSettings: (name: string, settings: SearchEngineSettings) => MaybePromise<EnqueuedTask>
   listAllIndexes: () => MaybePromise<IndexesResults<Index[]>>
   listAllIndices: () => MaybePromise<IndexesResults<Index[]>> // alternatives plural spelling
 
   // Records (MeiliSearch uses the term "documents")
-  getRecord?: (key: string) => MaybePromise<any>
-  getRecords?: (key: string) => MaybePromise<RecordOptions>
-  createRecord?: (record: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
-  createRecords?: (records: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
-  createOrReplaceRecord?: (record: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
-  createOrUpdateRecord?: (record: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
-  deleteRecord?: (recordId: string | number, indexName: string) => MaybePromise<EnqueuedTask>
-  deleteAllRecords?: (indexName: string) => MaybePromise<EnqueuedTask>
-  batchDeleteRecords?: (recordIds: string[] | number[], indexName: string) => MaybePromise<EnqueuedTask>
+  getRecord: (key: string) => MaybePromise<any>
+  getRecords: (key: string) => MaybePromise<RecordOptions>
+  createRecord: (record: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
+  createRecords: (records: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
+  createOrReplaceRecord: (record: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
+  createOrUpdateRecord: (record: any, indexName: string, options: RecordOptions) => MaybePromise<EnqueuedTask>
+  deleteRecord: (recordId: string | number, indexName: string) => MaybePromise<EnqueuedTask>
+  deleteAllRecords: (indexName: string) => MaybePromise<EnqueuedTask>
+  batchDeleteRecords: (recordIds: string[] | number[], indexName: string) => MaybePromise<EnqueuedTask>
 
   // Search
-  search?: (query: string, indexName: string, options: SearchParams) => MaybePromise<Search>
+  search: (query: string, indexName: string, options: SearchParams) => MaybePromise<Search>
 
   calculatePagination: Pages
   currentPage: Page
@@ -95,8 +90,6 @@ export interface SearchEngineDriver {
   totalPages: number
 }
 
-export type SearchEngineDriverFactory<T> = (opts?: T) => SearchEngineDriver
-
 /**
  * This interface is used to unify the persisting of data to localStorage
  */
@@ -128,4 +121,9 @@ export interface SearchEngineStorage {
   currentPage: number
 }
 
+export interface MeiliSearchOptions {
+  apiKey: string
+  host: string
+}
+
 export type { EnqueuedTask, Hits, Index, IndexOptions, IndexesResults, MeiliSearch, RecordOptions, SearchEngineSettings, SearchParams, SearchResponse }