9drive 1.0.0

package/backend/dist/modules/uploads/upload.routes.js

@@ -0,0 +1,569 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadRouter = void 0;
+exports.getBaseUrl = getBaseUrl;
+exports.formatFileResponse = formatFileResponse;
+exports.handleUpload = handleUpload;
+const busboy_1 = __importDefault(require("busboy"));
+const express_1 = require("express");
+const stream_1 = require("stream");
+const zod_1 = require("zod");
+const googleapis_1 = require("googleapis");
+const env_js_1 = require("../../config/env.js");
+const prisma_js_1 = require("../../config/prisma.js");
+const auth_middleware_js_1 = require("../../middleware/auth.middleware.js");
+const google_service_js_1 = require("../google/google.service.js");
+const s3_service_js_1 = require("../s3/s3.service.js");
+const audit_js_1 = require("../../utils/audit.js");
+exports.uploadRouter = (0, express_1.Router)();
+function getBaseUrl(req) {
+    if (process.env.CDN_BASE_URL) {
+        return process.env.CDN_BASE_URL.replace(/\/+$/, '');
+    }
+    const proto = req.headers['x-forwarded-proto'] || req.protocol || 'http';
+    const host = req.headers['x-forwarded-host'] || req.get('host') || `localhost:${env_js_1.env.APP_PORT}`;
+    return `${proto}://${host}`;
+}
+function formatFileResponse(file, baseUrl) {
+    const sizeNum = typeof file.sizeBytes === 'bigint' ? Number(file.sizeBytes) : Number(file.sizeBytes || 0);
+    const sizeStr = file.sizeBytes !== undefined && file.sizeBytes !== null ? file.sizeBytes.toString() : '0';
+    return {
+        id: file.id,
+        name: file.name,
+        mimeType: file.mimeType,
+        size: sizeNum,
+        sizeBytes: sizeStr,
+        provider: file.provider,
+        folderId: file.folderId ?? null,
+        status: file.status ?? 'active',
+        createdAt: file.createdAt,
+        updatedAt: file.updatedAt,
+        url: `${baseUrl}/cdn/view/${file.id}`,
+        downloadUrl: `${baseUrl}/cdn/raw/${file.id}`,
+    };
+}
+function logUpload(message, metadata) {
+    console.info('[upload]', message, metadata ?? '');
+}
+function syncQuotaInBackground(accountId, sessionId) {
+    logUpload('quota sync started', { accountId, sessionId });
+    (0, google_service_js_1.syncGoogleQuota)(accountId)
+        .then(() => logUpload('quota sync completed', { accountId, sessionId }))
+        .catch((error) => logUpload('quota sync failed', { accountId, sessionId, message: error instanceof Error ? error.message : 'Unknown error' }));
+}
+function normalizePriorityAccountIds(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function byPriority(items, priorityAccountIds) {
+    const order = new Map(priorityAccountIds.map((id, index) => [id, index]));
+    return [...items].sort((a, b) => {
+        const aOrder = order.get(a.account.id);
+        const bOrder = order.get(b.account.id);
+        if (aOrder !== undefined && bOrder !== undefined)
+            return aOrder - bOrder;
+        if (aOrder !== undefined)
+            return -1;
+        if (bOrder !== undefined)
+            return 1;
+        return a.account.createdAt.getTime() - b.account.createdAt.getTime();
+    });
+}
+async function selectAccount(userId, sizeBytes, reservedBytesByAccount = new Map(), targetAccountId) {
+    const accounts = await prisma_js_1.prisma.connectedAccount.findMany({
+        where: { userId, provider: { in: ['google_drive', 's3'] }, status: 'connected', ...(targetAccountId ? { id: targetAccountId } : {}) },
+        include: { storageAccount: true },
+    });
+    const stale = accounts.filter((account) => !account.storageAccount?.lastSyncedAt || account.storageAccount.lastSyncedAt.getTime() < Date.now() - 5 * 60_000);
+    await Promise.allSettled(stale.map(async (account) => {
+        try {
+            if (account.provider === 's3') {
+                await (0, s3_service_js_1.syncS3Quota)(account.id);
+            }
+            else {
+                await (0, google_service_js_1.syncGoogleQuota)(account.id);
+            }
+        }
+        catch (err) {
+            console.error(`[upload] failed to sync quota for account ${account.email} (${account.id}):`, err.message || err);
+            await prisma_js_1.prisma.connectedAccount.update({
+                where: { id: account.id },
+                data: { lastError: err.message || 'Quota sync failed' }
+            }).catch(() => undefined);
+        }
+    }));
+    const fresh = await prisma_js_1.prisma.connectedAccount.findMany({
+        where: { userId, provider: { in: ['google_drive', 's3'] }, status: 'connected' },
+        include: { storageAccount: true },
+    });
+    const eligible = fresh
+        .map((account) => ({ account, availableBytes: account.storageAccount?.availableBytes === null || account.storageAccount?.availableBytes === undefined ? null : account.storageAccount.availableBytes - (reservedBytesByAccount.get(account.id) ?? 0n) }))
+        .filter(({ availableBytes }) => availableBytes === null || availableBytes >= sizeBytes);
+    if (eligible.length === 0)
+        return null;
+    if (targetAccountId) {
+        const target = eligible.find(e => e.account.id === targetAccountId);
+        return target?.account ?? null;
+    }
+    const policy = await prisma_js_1.prisma.uploadRoutingPolicy.upsert({ where: { userId }, create: { userId, mode: 'most_available', priorityAccountIds: [] }, update: {} });
+    const mode = (['most_available', 'round_robin', 'priority'].includes(policy.mode) ? policy.mode : 'most_available');
+    const priorityAccountIds = normalizePriorityAccountIds(policy.priorityAccountIds);
+    if (mode === 'priority')
+        return byPriority(eligible, priorityAccountIds)[0]?.account ?? null;
+    if (mode === 'round_robin') {
+        const ordered = byPriority(eligible, priorityAccountIds);
+        const selected = ordered[policy.roundRobinCursor % ordered.length]?.account ?? ordered[0]?.account ?? null;
+        await prisma_js_1.prisma.uploadRoutingPolicy.update({ where: { userId }, data: { roundRobinCursor: policy.roundRobinCursor + 1 } });
+        return selected;
+    }
+    return eligible
+        .sort((a, b) => {
+        if (a.availableBytes === null && b.availableBytes === null)
+            return a.account.provider === 's3' ? -1 : 1;
+        if (a.availableBytes === null)
+            return a.account.provider === 's3' ? -1 : 1;
+        if (b.availableBytes === null)
+            return b.account.provider === 's3' ? 1 : -1;
+        return Number(b.availableBytes - a.availableBytes);
+    })[0]?.account;
+}
+async function handleUpload(req, res, next) {
+    try {
+        logUpload('request started', { userId: req.user.id, contentLength: req.headers['content-length'] });
+        const contentType = req.headers['content-type'];
+        if (!contentType?.includes('multipart/form-data'))
+            return res.status(400).json({ code: 'UPLOAD_INVALID_CONTENT_TYPE', message: 'multipart/form-data required.' });
+        const busboy = (0, busboy_1.default)({ headers: req.headers, limits: { files: 25, fileSize: env_js_1.env.MAX_UPLOAD_BYTES } });
+        const fields = {};
+        let batchMeta = null;
+        let responded = false;
+        let fileSeen = false;
+        const reservedBytesByAccount = new Map();
+        const completed = [];
+        const failed = [];
+        const pendingUploads = [];
+        const baseUrl = getBaseUrl(req);
+        const fail = async (status, code, message) => {
+            if (responded)
+                return;
+            responded = true;
+            req.unpipe(busboy);
+            req.resume();
+            return res.status(status).json({ code, message });
+        };
+        const parseBatchMeta = (value) => JSON.parse(value).map((item) => ({
+            fieldName: item.fieldName,
+            fileName: item.fileName,
+            mimeType: item.mimeType,
+            sizeBytes: BigInt(item.sizeBytes),
+            folderId: item.folderId,
+        }));
+        const metaForFile = (fieldName, info) => {
+            if (batchMeta)
+                return batchMeta.find((item) => item.fieldName === fieldName);
+            const sizeBytes = fields.sizeBytes;
+            return {
+                fieldName,
+                sizeBytes: sizeBytes ?? undefined,
+                fileName: fields.fileName || info.filename,
+                mimeType: fields.mimeType || info.mimeType || 'application/octet-stream',
+                folderId: fields.folderId,
+            };
+        };
+        const uploadOne = async (fieldName, fileStream, info) => {
+            const meta = metaForFile(fieldName, info);
+            const fileName = meta?.fileName || info.filename;
+            try {
+                let limitHit = false;
+                fileStream.on('limit', () => {
+                    limitHit = true;
+                    logUpload('file stream size limit reached', { fileName });
+                });
+                const chunks = [];
+                fileStream.on('data', (chunk) => {
+                    chunks.push(chunk);
+                });
+                await new Promise((resolve, reject) => {
+                    fileStream.on('end', resolve);
+                    fileStream.on('error', reject);
+                });
+                if (limitHit) {
+                    failed.push({ fileName, code: 'UPLOAD_TOO_LARGE', message: 'File exceeds max upload size.' });
+                    return;
+                }
+                const fileBuffer = Buffer.concat(chunks);
+                const streamedBytes = BigInt(fileBuffer.length);
+                if (streamedBytes <= 0n) {
+                    failed.push({ fileName, code: 'UPLOAD_SIZE_REQUIRED', message: 'File cannot be empty.' });
+                    return;
+                }
+                const effectiveSizeBytes = (meta?.sizeBytes && meta.sizeBytes > 0n) ? meta.sizeBytes : streamedBytes;
+                if (effectiveSizeBytes > BigInt(env_js_1.env.MAX_UPLOAD_BYTES) || streamedBytes > BigInt(env_js_1.env.MAX_UPLOAD_BYTES)) {
+                    failed.push({ fileName, code: 'UPLOAD_TOO_LARGE', message: 'File exceeds max upload size.' });
+                    return;
+                }
+                if (meta?.sizeBytes && meta.sizeBytes > 0n && streamedBytes !== meta.sizeBytes) {
+                    failed.push({ fileName, code: 'UPLOAD_SIZE_MISMATCH', message: 'Streamed byte count did not match declared size.' });
+                    return;
+                }
+                const folderId = meta?.folderId || fields.folderId || null;
+                let targetAccountId = undefined;
+                if (folderId) {
+                    const folderRecord = await prisma_js_1.prisma.folder.findFirstOrThrow({ where: { id: folderId, userId: req.user.id, deletedAt: null } });
+                    if (folderRecord.connectedAccountId) {
+                        targetAccountId = folderRecord.connectedAccountId;
+                    }
+                }
+                const account = await selectAccount(req.user.id, effectiveSizeBytes, reservedBytesByAccount, targetAccountId);
+                if (!account) {
+                    failed.push({ fileName, code: 'NO_ACCOUNT_WITH_ENOUGH_SPACE', message: 'No connected storage account has enough space for this upload.' });
+                    return;
+                }
+                reservedBytesByAccount.set(account.id, (reservedBytesByAccount.get(account.id) ?? 0n) + effectiveSizeBytes);
+                const session = await prisma_js_1.prisma.uploadSession.create({ data: { userId: req.user.id, targetConnectedAccountId: account.id, folderId, fileName, mimeType: meta?.mimeType || info.mimeType || 'application/octet-stream', sizeBytes: effectiveSizeBytes, status: 'uploading' } });
+                logUpload('file upload started', { sessionId: session.id, accountId: account.id, fileName, sizeBytes: effectiveSizeBytes.toString() });
+                let providerFileId = '';
+                let uploadedName = fileName;
+                let uploadedMimeType = meta?.mimeType || info.mimeType || 'application/octet-stream';
+                if (account.provider === 's3') {
+                    const config = await (0, s3_service_js_1.getS3ConfigForAccount)(account.id, req.user.id);
+                    const provisionalFile = await prisma_js_1.prisma.file.create({
+                        data: { userId: req.user.id, connectedAccountId: account.id, folderId, provider: 's3', providerFileId: 'pending', name: fileName, mimeType: uploadedMimeType, sizeBytes: effectiveSizeBytes, status: 'uploading' },
+                    });
+                    providerFileId = (0, s3_service_js_1.buildS3ObjectKey)(config, req.user.id, provisionalFile.id, fileName);
+                    await (0, s3_service_js_1.uploadS3Object)(config, providerFileId, stream_1.Readable.from(fileBuffer), uploadedMimeType);
+                    const updated = await prisma_js_1.prisma.file.update({ where: { id: provisionalFile.id }, data: { providerFileId, status: 'active' } });
+                    completed.push(formatFileResponse(updated, baseUrl));
+                    logUpload('s3 upload completed', { sessionId: session.id, accountId: account.id, fileName });
+                }
+                else {
+                    const auth = await (0, google_service_js_1.getAuthedGoogleClient)(account);
+                    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+                    let targetParentId = undefined;
+                    if (folderId) {
+                        const folderRecord = await prisma_js_1.prisma.folder.findFirst({ where: { id: folderId, userId: req.user.id } });
+                        if (folderRecord?.providerFolderId) {
+                            targetParentId = folderRecord.providerFolderId;
+                        }
+                    }
+                    const uploaded = await drive.files.create({
+                        requestBody: {
+                            name: fileName,
+                            ...(targetParentId ? { parents: [targetParentId] } : {}),
+                        },
+                        media: { mimeType: uploadedMimeType, body: stream_1.Readable.from(fileBuffer) },
+                        fields: 'id,name,mimeType,size',
+                    });
+                    providerFileId = uploaded.data.id ?? '';
+                    uploadedName = uploaded.data.name ?? fileName;
+                    uploadedMimeType = uploaded.data.mimeType ?? uploadedMimeType;
+                    logUpload('google upload completed', { sessionId: session.id, accountId: account.id, fileName });
+                    // Make the file public (anyone with link can edit/download)
+                    try {
+                        await drive.permissions.create({
+                            fileId: providerFileId,
+                            requestBody: {
+                                role: 'writer',
+                                type: 'anyone'
+                            }
+                        });
+                        logUpload('google file permissions set to public writer', { sessionId: session.id, providerFileId });
+                    }
+                    catch (err) {
+                        console.error('Failed to make Google Drive file public:', err.message || err);
+                    }
+                    const file = await prisma_js_1.prisma.file.create({ data: { userId: req.user.id, connectedAccountId: account.id, folderId, provider: 'google_drive', providerFileId, name: uploadedName, mimeType: uploadedMimeType, sizeBytes: effectiveSizeBytes } });
+                    if (file) {
+                        logUpload('database file created', { sessionId: session.id, fileId: file.id, accountId: account.id });
+                        completed.push(formatFileResponse(file, baseUrl));
+                    }
+                }
+                await prisma_js_1.prisma.uploadSession.update({ where: { id: session.id }, data: { status: 'completed', completedAt: new Date() } });
+                if (account.provider === 's3')
+                    (0, s3_service_js_1.syncS3Quota)(account.id).catch(() => undefined);
+                else
+                    syncQuotaInBackground(account.id, session.id);
+            }
+            catch (error) {
+                fileStream.resume();
+                logUpload('file upload failed', { fileName, message: error instanceof Error ? error.message : 'Upload failed' });
+                failed.push({ fileName, code: 'UPLOAD_FAILED', message: error instanceof Error ? error.message : 'Upload failed' });
+            }
+        };
+        busboy.on('field', (name, value) => {
+            if (name === 'sizeBytes')
+                fields.sizeBytes = BigInt(value);
+            if (name === 'fileName')
+                fields.fileName = value;
+            if (name === 'mimeType')
+                fields.mimeType = value;
+            if (name === 'folderId')
+                fields.folderId = value;
+            if (name === 'filesMeta')
+                batchMeta = parseBatchMeta(value);
+        });
+        busboy.on('file', (name, fileStream, info) => {
+            fileSeen = true;
+            pendingUploads.push(uploadOne(name, fileStream, info));
+        });
+        busboy.on('error', (error) => {
+            logUpload('multipart parser failed', { message: error instanceof Error ? error.message : 'Unknown error' });
+            if (!responded) {
+                responded = true;
+                next(error);
+            }
+        });
+        busboy.on('finish', () => {
+            if (!responded && !fileSeen)
+                return fail(400, 'UPLOAD_FILE_REQUIRED', 'file field required.');
+            Promise.all(pendingUploads).then(() => {
+                if (responded)
+                    return;
+                responded = true;
+                logUpload('response sent', { completed: completed.length, failed: failed.length });
+                if (completed.length === 0)
+                    return res.status(400).json({ code: failed[0]?.code ?? 'UPLOAD_FAILED', message: failed[0]?.message ?? 'Upload failed', failed });
+                if (completed.length === 1 && failed.length === 0) {
+                    return res.status(201).json({
+                        success: true,
+                        file: completed[0],
+                        files: completed,
+                        failed: [],
+                    });
+                }
+                return res.status(201).json({ success: failed.length === 0, files: completed, failed });
+            }).catch(next);
+        });
+        req.pipe(busboy);
+    }
+    catch (error) {
+        return next(error);
+    }
+}
+exports.uploadRouter.post('/', auth_middleware_js_1.requireAuth, handleUpload);
+// Resumable upload endpoints
+// 1. Initialize resumable session
+exports.uploadRouter.post('/resumable/init', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const body = zod_1.z.object({
+            fileName: zod_1.z.string().min(1),
+            mimeType: zod_1.z.string().min(1),
+            sizeBytes: zod_1.z.string(),
+            folderId: zod_1.z.string().nullable().optional(),
+            targetAccountId: zod_1.z.string().nullable().optional()
+        }).parse(req.body);
+        const sizeBytes = BigInt(body.sizeBytes);
+        if (sizeBytes <= 0n)
+            return res.status(400).json({ code: 'UPLOAD_SIZE_REQUIRED', message: 'Valid sizeBytes required.' });
+        if (sizeBytes > BigInt(env_js_1.env.MAX_UPLOAD_BYTES))
+            return res.status(400).json({ code: 'UPLOAD_TOO_LARGE', message: 'File exceeds max upload size.' });
+        const folderId = body.folderId || null;
+        let targetAccountId = body.targetAccountId;
+        if (folderId) {
+            const folderRecord = await prisma_js_1.prisma.folder.findFirstOrThrow({ where: { id: folderId, userId: req.user.id, deletedAt: null } });
+            if (folderRecord.connectedAccountId) {
+                targetAccountId = folderRecord.connectedAccountId;
+            }
+        }
+        const account = await selectAccount(req.user.id, sizeBytes, undefined, targetAccountId);
+        if (!account)
+            return res.status(400).json({ code: 'NO_ACCOUNT_WITH_ENOUGH_SPACE', message: 'No connected storage account has enough space.' });
+        if (account.provider !== 'google_drive') {
+            const session = await prisma_js_1.prisma.uploadSession.create({
+                data: {
+                    userId: req.user.id,
+                    targetConnectedAccountId: account.id,
+                    folderId,
+                    fileName: body.fileName,
+                    mimeType: body.mimeType,
+                    sizeBytes,
+                    status: 'uploading'
+                }
+            });
+            return res.status(201).json({ sessionId: session.id, provider: account.provider, offset: 0 });
+        }
+        const auth = await (0, google_service_js_1.getAuthedGoogleClient)(account);
+        let targetParentId = undefined;
+        if (folderId) {
+            const folderRecord = await prisma_js_1.prisma.folder.findFirst({ where: { id: folderId, userId: req.user.id } });
+            if (folderRecord?.providerFolderId) {
+                targetParentId = folderRecord.providerFolderId;
+            }
+        }
+        // Initiate Google Drive Resumable Session
+        const headers = new Headers();
+        const token = await auth.getAccessToken();
+        headers.set('Authorization', `Bearer ${token.token}`);
+        headers.set('Content-Type', 'application/json');
+        headers.set('X-Upload-Content-Type', body.mimeType);
+        headers.set('X-Upload-Content-Length', sizeBytes.toString());
+        const initRes = await fetch('https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                name: body.fileName,
+                ...(targetParentId ? { parents: [targetParentId] } : {}),
+            })
+        });
+        if (!initRes.ok) {
+            const errText = await initRes.text();
+            throw new Error(`Google API Init Error: ${errText}`);
+        }
+        const sessionUri = initRes.headers.get('location');
+        if (!sessionUri)
+            throw new Error('Google API did not return Location header.');
+        const session = await prisma_js_1.prisma.uploadSession.create({
+            data: {
+                userId: req.user.id,
+                targetConnectedAccountId: account.id,
+                folderId,
+                fileName: body.fileName,
+                mimeType: body.mimeType,
+                sizeBytes,
+                status: 'uploading',
+                googleSessionUri: sessionUri
+            }
+        });
+        return res.status(201).json({ sessionId: session.id, provider: 'google_drive', offset: 0 });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+// 2. Query/Resume resumable status
+exports.uploadRouter.get('/resumable/status/:id', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const session = await prisma_js_1.prisma.uploadSession.findFirstOrThrow({
+            where: { id: String(req.params.id), userId: req.user.id }
+        });
+        if (session.status === 'completed') {
+            return res.json({ status: 'completed', offset: session.sizeBytes.toString() });
+        }
+        if (!session.googleSessionUri || !session.targetConnectedAccountId) {
+            return res.json({ status: 'uploading', offset: '0' });
+        }
+        const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({
+            where: { id: session.targetConnectedAccountId, userId: req.user.id }
+        });
+        const auth = await (0, google_service_js_1.getAuthedGoogleClient)(account);
+        const token = await auth.getAccessToken();
+        // Query Google Drive for uploaded offset
+        const queryHeaders = new Headers();
+        queryHeaders.set('Authorization', `Bearer ${token.token}`);
+        queryHeaders.set('Content-Range', `bytes */${session.sizeBytes}`);
+        const queryRes = await fetch(session.googleSessionUri, {
+            method: 'PUT',
+            headers: queryHeaders
+        });
+        if (queryRes.status === 308) {
+            const range = queryRes.headers.get('range');
+            if (range) {
+                // e.g. bytes=0-1048575
+                const parts = range.split('-');
+                const lastByte = BigInt(parts[1]);
+                return res.json({ status: 'uploading', offset: (lastByte + 1n).toString() });
+            }
+        }
+        else if (queryRes.ok) {
+            return res.json({ status: 'completed', offset: session.sizeBytes.toString() });
+        }
+        return res.json({ status: 'uploading', offset: '0' });
+    }
+    catch (error) {
+        return res.json({ status: 'failed', offset: '0' });
+    }
+});
+// 3. Upload chunk
+exports.uploadRouter.put('/resumable/chunk/:id', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const session = await prisma_js_1.prisma.uploadSession.findFirstOrThrow({
+            where: { id: String(req.params.id), userId: req.user.id }
+        });
+        const rangeHeader = req.headers['content-range'];
+        if (!rangeHeader || typeof rangeHeader !== 'string') {
+            return res.status(400).json({ code: 'MISSING_CONTENT_RANGE', message: 'Content-Range header is required.' });
+        }
+        // Parse Content-Range, e.g. bytes 0-5242879/10485760
+        const match = rangeHeader.match(/bytes\s+(\d+)-(\d+)\/(\d+)/);
+        if (!match)
+            return res.status(400).json({ code: 'INVALID_CONTENT_RANGE', message: 'Invalid Content-Range format.' });
+        const startByte = BigInt(match[1]);
+        const endByte = BigInt(match[2]);
+        const totalBytes = BigInt(match[3]);
+        if (!session.googleSessionUri || !session.targetConnectedAccountId) {
+            return res.status(400).json({ code: 'UNSUPPORTED_PROVIDER', message: 'Only Google Drive resumable uploads supported.' });
+        }
+        const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({
+            where: { id: session.targetConnectedAccountId, userId: req.user.id }
+        });
+        const auth = await (0, google_service_js_1.getAuthedGoogleClient)(account);
+        const drive = googleapis_1.google.drive({ version: 'v3', auth });
+        const token = await auth.getAccessToken();
+        // Stream chunk body from client to Google Drive resumable URI
+        const putHeaders = new Headers();
+        putHeaders.set('Authorization', `Bearer ${token.token}`);
+        putHeaders.set('Content-Range', rangeHeader);
+        putHeaders.set('Content-Length', (endByte - startByte + 1n).toString());
+        const putRes = await fetch(session.googleSessionUri, {
+            method: 'PUT',
+            headers: putHeaders,
+            body: req,
+            duplex: 'half'
+        });
+        if (putRes.status === 308) {
+            return res.json({ status: 'uploading', offset: (endByte + 1n).toString() });
+        }
+        if (putRes.ok) {
+            // Completed! Parse metadata
+            const fileMeta = await putRes.json();
+            // Make the file public (anyone with link can edit/download)
+            try {
+                await drive.permissions.create({
+                    fileId: fileMeta.id,
+                    requestBody: {
+                        role: 'writer',
+                        type: 'anyone'
+                    }
+                });
+            }
+            catch (err) {
+                console.error('Failed to make Google Drive resumable file public:', err.message || err);
+            }
+            let existingFile = await prisma_js_1.prisma.file.findFirst({
+                where: { providerFileId: fileMeta.id, userId: req.user.id }
+            });
+            if (!existingFile) {
+                existingFile = await prisma_js_1.prisma.file.create({
+                    data: {
+                        userId: req.user.id,
+                        connectedAccountId: account.id,
+                        folderId: session.folderId,
+                        provider: 'google_drive',
+                        providerFileId: fileMeta.id,
+                        name: fileMeta.name || session.fileName,
+                        mimeType: fileMeta.mimeType || session.mimeType,
+                        sizeBytes: totalBytes
+                    }
+                });
+            }
+            await prisma_js_1.prisma.uploadSession.update({
+                where: { id: session.id },
+                data: { status: 'completed', completedAt: new Date() }
+            });
+            await (0, audit_js_1.createAuditLog)(req.user.id, 'UPLOAD_FILE', 'file', existingFile.id, { name: existingFile.name, size: existingFile.sizeBytes.toString() });
+            syncQuotaInBackground(account.id, session.id);
+            return res.status(201).json({ status: 'completed', file: formatFileResponse(existingFile, getBaseUrl(req)) });
+        }
+        const errorMsg = await putRes.text();
+        await prisma_js_1.prisma.uploadSession.update({
+            where: { id: session.id },
+            data: { status: 'failed', errorMessage: errorMsg }
+        });
+        return res.status(putRes.status).json({ code: 'UPLOAD_FAILED', message: errorMsg });
+    }
+    catch (error) {
+        return next(error);
+    }
+});

package/backend/dist/scripts/debug-query.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prisma_js_1 = require("../config/prisma.js");
+async function main() {
+    const users = await prisma_js_1.prisma.user.findMany({ select: { id: true, email: true, name: true } });
+    console.log('USERS:', users);
+    const files = await prisma_js_1.prisma.file.findMany({
+        select: { id: true, name: true, userId: true, status: true, provider: true, providerFileId: true },
+    });
+    console.log('FILES COUNT:', files.length);
+    console.log('FILES:', files);
+    const folders = await prisma_js_1.prisma.folder.findMany({
+        select: { id: true, name: true, userId: true, providerFolderId: true },
+    });
+    console.log('FOLDERS:', folders);
+    const shares = await prisma_js_1.prisma.fileShare.findMany();
+    console.log('SHARES:', shares);
+}
+main().catch(console.error).finally(() => process.exit(0));

package/backend/dist/scripts/seed-google-config-if-present.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prisma_js_1 = require("../config/prisma.js");
+const crypto_js_1 = require("../utils/crypto.js");
+const scopes = [
+    'https://www.googleapis.com/auth/drive',
+    'https://www.googleapis.com/auth/userinfo.email',
+    'https://www.googleapis.com/auth/userinfo.profile',
+];
+function isConfigured(value, placeholders) {
+    if (!value?.trim())
+        return false;
+    return !placeholders.includes(value.trim());
+}
+async function main() {
+    const clientId = process.env.GOOGLE_CLIENT_ID?.trim();
+    const clientSecret = process.env.GOOGLE_CLIENT_SECRET?.trim();
+    const redirectUri = process.env.GOOGLE_REDIRECT_URI?.trim() || 'http://localhost:4000/connected-accounts/google/callback';
+    const hasClientId = isConfigured(clientId, ['your-google-client-id', 'your-client-id']);
+    const hasClientSecret = isConfigured(clientSecret, ['your-google-client-secret', 'your-client-secret']);
+    if (!hasClientId || !hasClientSecret) {
+        console.warn('Skipping Google Drive config seed: GOOGLE_CLIENT_ID/GOOGLE_CLIENT_SECRET not configured. Set them in .env and run docker compose up -d --build.');
+        return;
+    }
+    await prisma_js_1.prisma.providerConfig.updateMany({
+        where: { userId: null, provider: 'google_drive', status: 'active' },
+        data: { status: 'disabled' },
+    });
+    const config = await prisma_js_1.prisma.providerConfig.create({
+        data: {
+            userId: null,
+            provider: 'google_drive',
+            clientIdEncrypted: (0, crypto_js_1.encryptText)(clientId),
+            clientSecretEncrypted: (0, crypto_js_1.encryptText)(clientSecret),
+            redirectUri,
+            scopes,
+            status: 'active',
+        },
+    });
+    console.log(`Seeded global Google Drive config: ${config.id}`);
+}
+main()
+    .catch((error) => {
+    console.error(error);
+    process.exit(1);
+})
+    .finally(async () => {
+    await prisma_js_1.prisma.$disconnect();
+});