@arela/uploader 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"
@@ -32,10 +32,11 @@
     "commander": "^13.1.0",
     "dotenv": "^16.5.0",
     "globby": "^14.1.0",
-    "mime-types": "^3.0.1"
+    "mime-types": "^3.0.1",
+    "ora": "^8.2.0"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
     "prettier": "^3.5.3"
   }
-}
+}

package/src/index.js

@@ -5,6 +5,7 @@ import { config } from 'dotenv';
 import fs from 'fs';
 import { globby } from 'globby';
 import mime from 'mime-types';
+import ora from 'ora';
 import path from 'path';
 
 config();
@@ -14,14 +15,31 @@ const program = new Command();
 const supabaseUrl = process.env.SUPABASE_URL;
 const supabaseKey = process.env.SUPABASE_KEY;
 const bucket = process.env.SUPABASE_BUCKET;
+const basePath = process.env.UPLOAD_BASE_PATH;
+const sources = process.env.UPLOAD_SOURCES?.split('|').map((s) => s.trim()).filter(Boolean);
 
 const supabase = createClient(supabaseUrl, supabaseKey);
 
+const sendLogToSupabase = async ({ file, uploadPath, status, message }) => {
+  const { error } = await supabase.from('upload_logs').insert([
+    {
+      filename: path.basename(file),
+      path: uploadPath,
+      status,
+      message,
+    },
+  ]);
+
+  if (error) {
+    console.error(`⚠️ Error saving the log to Supabase: ${error.message}`);
+  }
+};
+
 const checkCredentials = async () => {
   if (!supabaseUrl || !supabaseKey || !bucket) {
-    console.error(
-      '⚠️ Missing Supabase credentials. Please set SUPABASE_URL, SUPABASE_KEY, and SUPABASE_BUCKET in your environment variables.',
-    );
+    console.error('⚠️ Missing Supabase credentials. Please set SUPABASE_URL, SUPABASE_KEY, and SUPABASE_BUCKET in your environment variables.');
+    writeLog('⚠️ Missing Supabase credentials.');
+    await sendLogToSupabase({ file: 'Error', uploadPath: 'Error', status: 'error', message: 'Missing Supabase credentials.' });
     process.exit(1);
   }
 
@@ -29,80 +47,126 @@ const checkCredentials = async () => {
     const { error } = await supabase.storage.from(bucket).list('');
     if (error) {
       console.error('⚠️ Error connecting to Supabase:', error.message);
+      writeLog(`⚠️ Error connecting to Supabase: ${error.message}`);
+      await sendLogToSupabase({ file: 'Error', uploadPath: 'Error', status: 'error', message: error.message });
       process.exit(1);
     }
   } catch (err) {
     console.error('⚠️ Error:', err.message);
+    writeLog(`⚠️ Error: ${err.message}`);
+    await sendLogToSupabase({ file: 'Error', uploadPath: 'Error', status: 'error', message: err.message });
     process.exit(1);
   }
 };
 
 await checkCredentials();
 
-function getCommonPathPrefix(paths) {
-  if (paths.length === 0) return '';
-
-  const splitPaths = paths.map((p) => path.resolve(p).split(path.sep));
-
-  const commonParts = [];
-  for (let i = 0; i < splitPaths[0].length; i++) {
-    const segment = splitPaths[0][i];
-    if (splitPaths.every((parts) => parts[i] === segment)) {
-      commonParts.push(segment);
-    } else {
-      break;
-    }
+const fileExistsInBucket = async (pathInBucket) => {
+  const dir = path.dirname(pathInBucket);
+  const filename = path.basename(pathInBucket);
+  const { data, error } = await supabase.storage.from(bucket).list(dir === '.' ? '' : dir, { limit: 1000 });
+  if (error) {
+    console.error(`⚠️ Could not verify duplicate: ${error.message}`);
+    writeLog(`⚠️ Could not verify duplicate: ${error.message}`);
+    await sendLogToSupabase({ file: 'Error', uploadPath: 'Error', status: 'error', message: error.message });
+    return false;
   }
+  return data.some((file) => file.name === filename);
+};
 
-  return commonParts.length > 0 ? commonParts.join(path.sep) : '';
-}
+const logFilePath = path.resolve(process.cwd(), 'upload.log');
+const writeLog = (message) => {
+  const timestamp = new Date().toISOString();
+  fs.appendFileSync(logFilePath, `[${timestamp}] ${message}\n`);
+};
 
-// const sleep = () => new Promise((resolve) => setTimeout(resolve, 5000));
+// const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 program
   .name('supabase-uploader')
-  .description('CLI to upload files using glob patterns to Supabase Storage')
-  .argument('<source>', 'Glob pattern of files to upload')
+  .description('CLI to upload folders from a base path to Supabase Storage')
   .option('-p, --prefix <prefix>', 'Prefix path in bucket', '')
-  .action(async (source, options) => {
-    try {
-      // await sleep();
-      const files = await globby([`${source}/**/*`], { onlyFiles: true });
-
-      if (files.length === 0) {
-        console.error('⚠️ No matching files found for pattern:', source);
-        process.exit(1);
-      }
+  .action(async (options) => {
+    if (!basePath || !sources || sources.length === 0) {
+      console.error('⚠️ UPLOAD_BASE_PATH or UPLOAD_SOURCES not defined in environment variables.');
+      process.exit(1);
+    }
 
-      const baseDir = getCommonPathPrefix(
-        files.map((file) => path.dirname(file)),
-      );
-
-      for (const file of files) {
-        const content = fs.readFileSync(file);
-        const relativePath = path.relative(baseDir, file);
-        const uploadPath = options.prefix
-          ? path.posix.join(options.prefix, relativePath).replace(/\\/g, '/')
-          : relativePath.replace(/\\/g, '/');
-
-        const contentType = mime.lookup(file) || 'application/octet-stream';
-
-        const { error } = await supabase.storage
-          .from(bucket)
-          .upload(uploadPath, content, {
-            upsert: true,
-            contentType,
-          });
-
-        if (error) {
-          console.error(`❌ Failed to upload ${file}:`, error.message);
-        } else {
-          console.log(`✅ Uploaded ${file} -> ${uploadPath}`);
+    let globalSuccess = 0;
+    let globalFailure = 0;
+
+    for (const folder of sources) {
+      const sourcePath = path.join(basePath, folder);
+      console.log(`📂 Processing folder: ${sourcePath}`);
+
+      try {
+        const stats = fs.statSync(sourcePath);
+        const files = stats.isDirectory() ? await globby([`${sourcePath}/**/*`], { onlyFiles: true }) : [sourcePath];
+
+        let successCount = 0;
+        let failureCount = 0;
+
+        for (const file of files) {
+          const content = fs.readFileSync(file);
+          const relativePath = path.relative(basePath, file).replace(/^[\\/]+/, '').replace(/\\/g, '/');
+          const uploadPath = options.prefix ? path.posix.join(options.prefix, relativePath) : relativePath;
+          const contentType = mime.lookup(file) || 'application/octet-stream';
+
+          const spinner = ora(`Checking ${file}...`).start();
+          const exists = await fileExistsInBucket(uploadPath);
+
+          if (exists) {
+            spinner.info(`⏭️  Skipped (already exists): ${file}`);
+            writeLog(`SKIPPED: ${file} -> ${uploadPath}`);
+            await sendLogToSupabase({ file, uploadPath, status: 'skipped', message: 'Already exists in bucket' });
+            continue;
+          }
+
+          try {
+            // await delay(5000); // TODO: Remove this delay before production
+
+            const { error } = await supabase.storage.from(bucket).upload(uploadPath, content, {
+                upsert: true,
+                contentType,
+              });
+
+            if (error) {
+              failureCount++;
+              globalFailure++;
+              spinner.fail(`❌ Failed to upload ${file}: ${JSON.stringify(error, null, 2)}`);
+              writeLog(`ERROR: ${file} -> ${uploadPath} | ${error.message}`);
+              await sendLogToSupabase({ file, uploadPath, status: 'error', message: error.message });
+            } else {
+              successCount++;
+              globalSuccess++;
+              spinner.succeed(`✅ Uploaded ${file} -> ${uploadPath}`);
+              writeLog(`SUCCESS: ${file} -> ${uploadPath}`);
+              await sendLogToSupabase({ file, uploadPath, status: 'success', message: 'Uploaded successfully' });
+            }
+          } catch (err) {
+            spinner.fail(`❌ Error uploading ${file}: ${err.message}`);
+            writeLog(`❌ Error uploading ${file}: ${err.message}`);
+          }
         }
+
+        console.log(`\n📦 Upload Summary:`);
+        console.log(`   ✅ Successfully uploaded files: ${successCount}`);
+        console.log(`   ❌ Files with errors: ${failureCount}`);
+        console.log(`   ⏭️  Files skipped (already exist): ${files.length - successCount - failureCount}`);
+        console.log(`   📜 Log file: ${logFilePath} \n`);
+
+        writeLog(`📦 Upload Summary for folder ${folder}: Success: ${successCount}, Errors: ${failureCount}, Skipped: ${files.length - successCount - failureCount}`);
+      } catch (err) {
+        console.error(`⚠️ Error processing folder ${folder}:`, err.message);
+        writeLog(`⚠️ Error processing folder ${folder}: ${err.message}`);
+        await sendLogToSupabase({ file: folder, uploadPath: folder, status: 'error', message: err.message });
       }
-    } catch (err) {
-      console.error('⚠️ Error:', err.message);
     }
+
+    console.log(`🎯 Upload completed.`);
+    console.log(`   ✅ Total uploaded: ${globalSuccess}`);
+    console.log(`   ❌ Total with errors: ${globalFailure}`);
+    console.log(`   📜 Log file: ${logFilePath}`);
   });
 
 program.parse();