@arela/uploader 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"

package/src/index.js

@@ -5,9 +5,13 @@ import { config } from 'dotenv';
 import fs from 'fs';
 import { globby } from 'globby';
 import mime from 'mime-types';
+import { createRequire } from 'module';
 import ora from 'ora';
 import path from 'path';
 
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
 config();
 
 const program = new Command();
@@ -16,10 +20,19 @@ 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 sources = process.env.UPLOAD_SOURCES?.split('|')
+  .map((s) => s.trim())
+  .filter(Boolean);
 
 const supabase = createClient(supabaseUrl, supabaseKey);
 
+const sanitizePath = (path) =>
+  path
+    .replace(/[\\?%*:|"<>[\]~]/g, '-')
+    .replace(/ +/g, ' ')
+    .replace(/^\.+/, '')
+    .replace(/\/+/g, '/');
+
 const sendLogToSupabase = async ({ file, uploadPath, status, message }) => {
   const { error } = await supabase.from('upload_logs').insert([
     {
@@ -37,9 +50,16 @@ const sendLogToSupabase = async ({ file, uploadPath, status, 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.' });
+    await sendLogToSupabase({
+      file: 'Error',
+      uploadPath: 'Error',
+      status: 'error',
+      message: 'Missing Supabase credentials.',
+    });
     process.exit(1);
   }
 
@@ -48,13 +68,23 @@ const checkCredentials = async () => {
     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 });
+      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 });
+    await sendLogToSupabase({
+      file: 'Error',
+      uploadPath: 'Error',
+      status: 'error',
+      message: err.message,
+    });
     process.exit(1);
   }
 };
@@ -64,11 +94,18 @@ await checkCredentials();
 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 });
+  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 });
+    await sendLogToSupabase({
+      file: 'Error',
+      uploadPath: 'Error',
+      status: 'error',
+      message: error.message,
+    });
     return false;
   }
   return data.some((file) => file.name === filename);
@@ -76,8 +113,27 @@ const fileExistsInBucket = async (pathInBucket) => {
 
 const logFilePath = path.resolve(process.cwd(), 'upload.log');
 const writeLog = (message) => {
-  const timestamp = new Date().toISOString();
-  fs.appendFileSync(logFilePath, `[${timestamp}] ${message}\n`);
+  try {
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(logFilePath, `[${timestamp}] ${message}\n`);
+  } catch (error) {
+    console.error(`❌ Error writing to log file: ${err.message}`);
+  }
+};
+
+const getProcessedPaths = () => {
+  const lines = fs.existsSync(logFilePath)
+    ? fs.readFileSync(logFilePath, 'utf-8').split('\n')
+    : [];
+  const processed = new Set();
+  for (const line of lines) {
+    const match = line.match(/(SUCCESS|SKIPPED): .*? -> (.+)/);
+    if (match) {
+      const [, , path] = match;
+      processed.add(path.trim());
+    }
+  }
+  return processed;
 };
 
 // const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -85,13 +141,17 @@ const writeLog = (message) => {
 program
   .name('supabase-uploader')
   .description('CLI to upload folders from a base path to Supabase Storage')
+  .version(version)
   .option('-p, --prefix <prefix>', 'Prefix path in bucket', '')
   .action(async (options) => {
     if (!basePath || !sources || sources.length === 0) {
-      console.error('⚠️ UPLOAD_BASE_PATH or UPLOAD_SOURCES not defined in environment variables.');
+      console.error(
+        '⚠️ UPLOAD_BASE_PATH or UPLOAD_SOURCES not defined in environment variables.',
+      );
       process.exit(1);
     }
 
+    const processedPaths = getProcessedPaths();
     let globalSuccess = 0;
     let globalFailure = 0;
 
@@ -101,15 +161,39 @@ program
 
       try {
         const stats = fs.statSync(sourcePath);
-        const files = stats.isDirectory() ? await globby([`${sourcePath}/**/*`], { onlyFiles: true }) : [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 relativePathRaw = path
+            .relative(basePath, file)
+            .replace(/^[\\/]+/, '')
+            .replace(/\\/g, '/');
+          const uploadPathRaw = options.prefix
+            ? path.posix.join(options.prefix, relativePathRaw)
+            : relativePathRaw;
+          const uploadPath = sanitizePath(uploadPathRaw);
+
+          if (uploadPath !== uploadPathRaw) {
+            writeLog(`SANITIZED: ${uploadPathRaw} → ${uploadPath}`);
+            await sendLogToSupabase({
+              file,
+              uploadPath: uploadPathRaw,
+              status: 'sanitized',
+              message: `Sanitized to ${uploadPath}`,
+            });
+          }
+
+          if (processedPaths.has(uploadPath)) {
+            ora().info(`⏭️  Already processed (log): ${file}`);
+            continue;
+          }
+
           const contentType = mime.lookup(file) || 'application/octet-stream';
 
           const spinner = ora(`Checking ${file}...`).start();
@@ -118,30 +202,52 @@ program
           if (exists) {
             spinner.info(`⏭️  Skipped (already exists): ${file}`);
             writeLog(`SKIPPED: ${file} -> ${uploadPath}`);
-            await sendLogToSupabase({ file, uploadPath, status: 'skipped', message: 'Already exists in bucket' });
+            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, {
+            const { error } = await supabase.storage
+              .from(bucket)
+              .upload(uploadPath, content, {
                 upsert: true,
                 contentType,
+                metadata: {
+                  originalName: path.basename(file),
+                },
               });
 
             if (error) {
               failureCount++;
               globalFailure++;
-              spinner.fail(`❌ Failed to upload ${file}: ${JSON.stringify(error, null, 2)}`);
+              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 });
+              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' });
+              await sendLogToSupabase({
+                file,
+                uploadPath,
+                status: 'success',
+                message: 'Uploaded successfully',
+              });
             }
           } catch (err) {
             spinner.fail(`❌ Error uploading ${file}: ${err.message}`);
@@ -152,14 +258,23 @@ program
         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(
+          `   ⏭️  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}`);
+        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 });
+        await sendLogToSupabase({
+          file: folder,
+          uploadPath: folder,
+          status: 'error',
+          message: err.message,
+        });
       }
     }