9drive 1.0.0

package/backend/dist/modules/cdn/cdn.routes.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdnRouter = void 0;
+const express_1 = require("express");
+const prisma_js_1 = require("../../config/prisma.js");
+const stream_file_js_1 = require("../files/stream-file.js");
+exports.cdnRouter = (0, express_1.Router)();
+async function findCdnFile(id) {
+    const file = await prisma_js_1.prisma.file.findFirst({
+        where: {
+            id,
+            status: 'active',
+            deletedAt: null,
+        },
+        include: {
+            connectedAccount: true,
+        },
+    });
+    if (!file || file.connectedAccount.status !== 'connected') {
+        return null;
+    }
+    return file;
+}
+function setCdnHeaders(res, file) {
+    const etag = `"${file.id}-${file.updatedAt ? file.updatedAt.getTime() : file.createdAt.getTime()}"`;
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS');
+    res.setHeader('Access-Control-Expose-Headers', 'Content-Length, Content-Range, Content-Type, ETag, Cache-Control');
+    res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+    res.setHeader('ETag', etag);
+    res.setHeader('Last-Modified', (file.updatedAt || file.createdAt).toUTCString());
+    return etag;
+}
+// View/Preview route (inline disposition for <img> and web embedding)
+exports.cdnRouter.all('/view/:id', async (req, res, next) => {
+    try {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            return res.status(405).json({ code: 'METHOD_NOT_ALLOWED', message: 'Only GET and HEAD methods are supported.' });
+        }
+        const file = await findCdnFile(String(req.params.id));
+        if (!file) {
+            return res.status(404).json({ code: 'FILE_NOT_FOUND', message: 'File not found or inactive.' });
+        }
+        const etag = setCdnHeaders(res, file);
+        const ifNoneMatch = req.header('if-none-match');
+        if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === `W/${etag}` || ifNoneMatch === '*')) {
+            return res.status(304).end();
+        }
+        if (req.method === 'HEAD') {
+            res.setHeader('Content-Type', file.mimeType);
+            res.setHeader('Content-Length', file.sizeBytes.toString());
+            res.setHeader('Accept-Ranges', 'bytes');
+            res.setHeader('Content-Disposition', `inline; filename="${file.name.replaceAll('"', '')}"`);
+            return res.status(200).end();
+        }
+        return (0, stream_file_js_1.streamProviderFile)(file, req.headers.range, res, {
+            disposition: 'inline',
+            headers: {
+                'Cache-Control': 'public, max-age=31536000, immutable',
+                'Access-Control-Allow-Origin': '*',
+            },
+        });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+// Raw/Download route (attachment disposition for file download)
+exports.cdnRouter.all('/raw/:id', async (req, res, next) => {
+    try {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            return res.status(405).json({ code: 'METHOD_NOT_ALLOWED', message: 'Only GET and HEAD methods are supported.' });
+        }
+        const file = await findCdnFile(String(req.params.id));
+        if (!file) {
+            return res.status(404).json({ code: 'FILE_NOT_FOUND', message: 'File not found or inactive.' });
+        }
+        const etag = setCdnHeaders(res, file);
+        const ifNoneMatch = req.header('if-none-match');
+        if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === `W/${etag}` || ifNoneMatch === '*')) {
+            return res.status(304).end();
+        }
+        if (req.method === 'HEAD') {
+            res.setHeader('Content-Type', file.mimeType);
+            res.setHeader('Content-Length', file.sizeBytes.toString());
+            res.setHeader('Accept-Ranges', 'bytes');
+            res.setHeader('Content-Disposition', `attachment; filename="${file.name.replaceAll('"', '')}"`);
+            return res.status(200).end();
+        }
+        return (0, stream_file_js_1.streamProviderFile)(file, req.headers.range, res, {
+            disposition: 'attachment',
+            headers: {
+                'Cache-Control': 'public, max-age=31536000, immutable',
+                'Access-Control-Allow-Origin': '*',
+            },
+        });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+// Redirect /cdn/:id to /cdn/view/:id
+exports.cdnRouter.get('/:id', (req, res) => {
+    res.redirect(301, `/cdn/view/${req.params.id}`);
+});

package/backend/dist/modules/connected-accounts/connected-account.routes.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectedAccountRouter = void 0;
+const express_1 = require("express");
+const googleapis_1 = require("googleapis");
+const zod_1 = require("zod");
+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 crypto_js_1 = require("../../utils/crypto.js");
+const password_js_1 = require("../../utils/password.js");
+const google_service_js_1 = require("../google/google.service.js");
+const s3_service_js_1 = require("../s3/s3.service.js");
+exports.connectedAccountRouter = (0, express_1.Router)();
+const s3ConnectSchema = zod_1.z.object({
+    name: zod_1.z.string().trim().min(1).max(191),
+    bucket: zod_1.z.string().trim().min(1).max(191),
+    region: zod_1.z.string().trim().min(1).max(191),
+    endpoint: zod_1.z.string().url().optional().or(zod_1.z.literal('')),
+    accessKeyId: zod_1.z.string().min(1),
+    secretAccessKey: zod_1.z.string().min(1),
+    forcePathStyle: zod_1.z.boolean().optional(),
+    quotaBytes: zod_1.z.string().regex(/^\d+$/).optional().nullable(),
+});
+async function syncQuotaForAccount(account) {
+    if (account.provider === 's3')
+        return (0, s3_service_js_1.syncS3Quota)(account.id);
+    return (0, google_service_js_1.syncGoogleQuota)(account.id);
+}
+exports.connectedAccountRouter.get('/', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const accounts = await prisma_js_1.prisma.connectedAccount.findMany({
+            where: { userId: req.user.id, status: 'connected' },
+            include: { storageAccount: true },
+            orderBy: { createdAt: 'desc' },
+        });
+        const missingQuota = accounts.filter((account) => !account.storageAccount?.lastSyncedAt);
+        for (const account of missingQuota)
+            await syncQuotaForAccount(account).catch(() => undefined);
+        const syncedAccounts = missingQuota.length > 0
+            ? await prisma_js_1.prisma.connectedAccount.findMany({
+                where: { userId: req.user.id, status: 'connected' },
+                include: { storageAccount: true },
+                orderBy: { createdAt: 'desc' },
+            })
+            : accounts;
+        return res.json({
+            accounts: syncedAccounts.map(({ accessTokenEncrypted: _a, refreshTokenEncrypted: _r, storageAccount, ...account }) => ({
+                ...account,
+                storageAccount: storageAccount ? {
+                    ...storageAccount,
+                    totalBytes: storageAccount.totalBytes?.toString() ?? null,
+                    usedBytes: storageAccount.usedBytes.toString(),
+                    availableBytes: storageAccount.availableBytes?.toString() ?? null,
+                    trashBytes: storageAccount.trashBytes?.toString() ?? null,
+                } : null,
+            })),
+        });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+async function createGoogleConnectUrl(req) {
+    const query = zod_1.z.object({ providerConfigId: zod_1.z.string().min(1).optional() }).parse(req.query);
+    const config = query.providerConfigId
+        ? await prisma_js_1.prisma.providerConfig.findFirstOrThrow({ where: { id: query.providerConfigId, OR: [{ userId: req.user.id }, { userId: null }], provider: 'google_drive', status: 'active' } })
+        : await prisma_js_1.prisma.providerConfig.findFirstOrThrow({ where: { userId: null, provider: 'google_drive', status: 'active' }, orderBy: { createdAt: 'desc' } });
+    const state = (0, crypto_js_1.randomToken)();
+    await prisma_js_1.prisma.oauthState.create({ data: { userId: req.user.id, providerConfigId: config.id, flow: 'connect', stateHash: (0, crypto_js_1.hashToken)(state), expiresAt: new Date(Date.now() + 10 * 60_000) } });
+    const client = (0, google_service_js_1.createOAuthClient)(config);
+    return client.generateAuthUrl({
+        access_type: 'offline',
+        prompt: 'consent',
+        include_granted_scopes: true,
+        scope: config.scopes,
+        state,
+    });
+}
+exports.connectedAccountRouter.post('/s3', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const body = s3ConnectSchema.parse(req.body);
+        const providerConfig = await prisma_js_1.prisma.providerConfig.findFirstOrThrow({ where: { provider: 'google_drive', status: 'active' }, orderBy: { createdAt: 'desc' } });
+        const providerAccountId = `${body.bucket}:${body.endpoint || body.region}`;
+        const existingAccount = await prisma_js_1.prisma.connectedAccount.findUnique({ where: { userId_provider_providerAccountId: { userId: req.user.id, provider: 's3', providerAccountId } } });
+        const account = existingAccount
+            ? await prisma_js_1.prisma.connectedAccount.update({
+                where: { id: existingAccount.id },
+                data: {
+                    providerConfigId: providerConfig.id,
+                    email: `${body.bucket} (S3)`,
+                    displayName: body.name,
+                    accessTokenEncrypted: (0, crypto_js_1.encryptText)('s3'),
+                    refreshTokenEncrypted: (0, crypto_js_1.encryptText)((0, crypto_js_1.randomToken)()),
+                    tokenExpiresAt: new Date(Date.now() + 100 * 365 * 24 * 60 * 60 * 1000),
+                    scopes: [],
+                    status: 'connected',
+                },
+            })
+            : await prisma_js_1.prisma.connectedAccount.create({ data: {
+                    userId: req.user.id,
+                    providerConfigId: providerConfig.id,
+                    provider: 's3',
+                    providerAccountId,
+                    email: `${body.bucket} (S3)`,
+                    displayName: body.name,
+                    accessTokenEncrypted: (0, crypto_js_1.encryptText)('s3'),
+                    refreshTokenEncrypted: (0, crypto_js_1.encryptText)((0, crypto_js_1.randomToken)()),
+                    tokenExpiresAt: new Date(Date.now() + 100 * 365 * 24 * 60 * 60 * 1000),
+                    scopes: [],
+                    status: 'connected',
+                } });
+        const config = await prisma_js_1.prisma.s3StorageConfig.upsert({
+            where: { connectedAccountId: account.id },
+            create: {
+                userId: req.user.id,
+                connectedAccountId: account.id,
+                name: body.name,
+                bucket: body.bucket,
+                region: body.region,
+                endpoint: body.endpoint || null,
+                accessKeyIdEncrypted: (0, crypto_js_1.encryptText)(body.accessKeyId),
+                secretAccessKeyEncrypted: (0, crypto_js_1.encryptText)(body.secretAccessKey),
+                forcePathStyle: body.forcePathStyle ?? Boolean(body.endpoint),
+                quotaBytes: body.quotaBytes ? BigInt(body.quotaBytes) : null,
+            },
+            update: {
+                name: body.name,
+                bucket: body.bucket,
+                region: body.region,
+                endpoint: body.endpoint || null,
+                accessKeyIdEncrypted: (0, crypto_js_1.encryptText)(body.accessKeyId),
+                secretAccessKeyEncrypted: (0, crypto_js_1.encryptText)(body.secretAccessKey),
+                forcePathStyle: body.forcePathStyle ?? Boolean(body.endpoint),
+                quotaBytes: body.quotaBytes ? BigInt(body.quotaBytes) : null,
+                status: 'active',
+            },
+        });
+        try {
+            await (0, s3_service_js_1.testS3Connection)(config);
+            const quota = await (0, s3_service_js_1.syncS3Quota)(account.id);
+            return res.status(201).json({
+                account: {
+                    ...account,
+                    storageAccount: { ...quota, totalBytes: quota.totalBytes?.toString() ?? null, usedBytes: quota.usedBytes.toString(), availableBytes: quota.availableBytes?.toString() ?? null, trashBytes: quota.trashBytes?.toString() ?? null },
+                },
+            });
+        }
+        catch (error) {
+            if (!existingAccount)
+                await prisma_js_1.prisma.connectedAccount.delete({ where: { id: account.id } }).catch(() => undefined);
+            throw error;
+        }
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.connectedAccountRouter.get('/google/connect-url', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const url = await createGoogleConnectUrl(req);
+        return res.json({ url });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.connectedAccountRouter.get('/google/connect', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const url = await createGoogleConnectUrl(req);
+        return res.redirect(url);
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.connectedAccountRouter.get('/google/callback', async (req, res, next) => {
+    try {
+        const query = zod_1.z.object({ code: zod_1.z.string(), state: zod_1.z.string() }).parse(req.query);
+        const oauthState = await prisma_js_1.prisma.oauthState.findUniqueOrThrow({ where: { stateHash: (0, crypto_js_1.hashToken)(query.state) }, include: { providerConfig: true } });
+        if (oauthState.usedAt || oauthState.expiresAt < new Date())
+            return res.status(400).json({ code: 'GOOGLE_OAUTH_STATE_INVALID', message: 'OAuth state expired.' });
+        const client = (0, google_service_js_1.createOAuthClient)(oauthState.providerConfig);
+        const tokenResult = await client.getToken(query.code);
+        const tokens = tokenResult.tokens;
+        if (!tokens.access_token)
+            return res.status(400).json({ code: 'GOOGLE_OAUTH_FAILED', message: 'Google did not return required tokens.' });
+        client.setCredentials(tokens);
+        const oauth2 = googleapis_1.google.oauth2({ version: 'v2', auth: client });
+        const profile = await oauth2.userinfo.get();
+        const providerAccountId = profile.data.id;
+        const email = profile.data.email;
+        if (!providerAccountId || !email)
+            return res.status(400).json({ code: 'GOOGLE_PROFILE_FAILED', message: 'Google profile missing id or email.' });
+        if (oauthState.flow === 'login') {
+            const name = profile.data.name || email.split('@')[0] || 'Google User';
+            const user = await prisma_js_1.prisma.user.upsert({
+                where: { email },
+                create: { email, name, passwordHash: await (0, password_js_1.hashPassword)((0, crypto_js_1.randomToken)(32)) },
+                update: { name },
+            });
+            const existingAccount = await prisma_js_1.prisma.connectedAccount.findUnique({ where: { userId_provider_providerAccountId: { userId: user.id, provider: 'google_drive', providerAccountId } } });
+            const refreshTokenEncrypted = tokens.refresh_token ? (0, crypto_js_1.encryptText)(tokens.refresh_token) : existingAccount?.refreshTokenEncrypted;
+            if (!refreshTokenEncrypted) {
+                console.error('Google login failed: no refresh token received and no existing account. Has refresh_token:', !!tokens.refresh_token);
+                return res.redirect(`${env_js_1.env.FRONTEND_URL}/google-auth?status=error`);
+            }
+            const account = await prisma_js_1.prisma.connectedAccount.upsert({
+                where: { userId_provider_providerAccountId: { userId: user.id, provider: 'google_drive', providerAccountId } },
+                create: {
+                    userId: user.id,
+                    providerConfigId: oauthState.providerConfigId,
+                    provider: 'google_drive',
+                    providerAccountId,
+                    email,
+                    displayName: profile.data.name,
+                    avatarUrl: profile.data.picture,
+                    accessTokenEncrypted: (0, crypto_js_1.encryptText)(tokens.access_token),
+                    refreshTokenEncrypted,
+                    tokenExpiresAt: new Date(tokens.expiry_date ?? Date.now() + 3600_000),
+                    scopes: oauthState.providerConfig.scopes,
+                    status: 'connected',
+                },
+                update: {
+                    providerConfigId: oauthState.providerConfigId,
+                    email,
+                    displayName: profile.data.name,
+                    avatarUrl: profile.data.picture,
+                    accessTokenEncrypted: (0, crypto_js_1.encryptText)(tokens.access_token),
+                    refreshTokenEncrypted,
+                    tokenExpiresAt: new Date(tokens.expiry_date ?? Date.now() + 3600_000),
+                    scopes: oauthState.providerConfig.scopes,
+                    status: 'connected',
+                },
+            });
+            await prisma_js_1.prisma.oauthState.update({ where: { id: oauthState.id }, data: { usedAt: new Date(), userId: user.id } });
+            await (0, google_service_js_1.syncGoogleQuota)(account.id).catch(() => undefined);
+            const handoffToken = (0, crypto_js_1.randomToken)();
+            await prisma_js_1.prisma.authHandoff.create({ data: { userId: user.id, tokenHash: (0, crypto_js_1.hashToken)(handoffToken), expiresAt: new Date(Date.now() + 5 * 60_000) } });
+            return res.redirect(`${env_js_1.env.FRONTEND_URL}/google-auth?token=${handoffToken}`);
+        }
+        if (oauthState.flow !== 'connect' || !oauthState.userId)
+            return res.status(400).json({ code: 'GOOGLE_OAUTH_STATE_INVALID', message: 'OAuth state expired.' });
+        const existingAccount = await prisma_js_1.prisma.connectedAccount.findUnique({ where: { userId_provider_providerAccountId: { userId: oauthState.userId, provider: 'google_drive', providerAccountId } } });
+        const refreshTokenEncrypted = tokens.refresh_token ? (0, crypto_js_1.encryptText)(tokens.refresh_token) : existingAccount?.refreshTokenEncrypted;
+        if (!refreshTokenEncrypted)
+            return res.status(400).json({ code: 'GOOGLE_OAUTH_FAILED', message: 'Google did not return required tokens.' });
+        const account = await prisma_js_1.prisma.connectedAccount.upsert({
+            where: { userId_provider_providerAccountId: { userId: oauthState.userId, provider: 'google_drive', providerAccountId } },
+            create: {
+                userId: oauthState.userId,
+                providerConfigId: oauthState.providerConfigId,
+                provider: 'google_drive',
+                providerAccountId,
+                email,
+                displayName: profile.data.name,
+                avatarUrl: profile.data.picture,
+                accessTokenEncrypted: (0, crypto_js_1.encryptText)(tokens.access_token),
+                refreshTokenEncrypted,
+                tokenExpiresAt: new Date(tokens.expiry_date ?? Date.now() + 3600_000),
+                scopes: oauthState.providerConfig.scopes,
+                status: 'connected',
+            },
+            update: {
+                providerConfigId: oauthState.providerConfigId,
+                email,
+                displayName: profile.data.name,
+                avatarUrl: profile.data.picture,
+                accessTokenEncrypted: (0, crypto_js_1.encryptText)(tokens.access_token),
+                refreshTokenEncrypted,
+                tokenExpiresAt: new Date(tokens.expiry_date ?? Date.now() + 3600_000),
+                scopes: oauthState.providerConfig.scopes,
+                status: 'connected',
+            },
+        });
+        await prisma_js_1.prisma.oauthState.update({ where: { id: oauthState.id }, data: { usedAt: new Date() } });
+        await (0, google_service_js_1.syncGoogleQuota)(account.id);
+        return res.redirect(`${env_js_1.env.FRONTEND_URL}/google-connected?status=success`);
+    }
+    catch (error) {
+        console.error('Google OAuth callback failed:', error);
+        return res.redirect(`${env_js_1.env.FRONTEND_URL}/google-connected?status=error`);
+    }
+});
+exports.connectedAccountRouter.post('/:id/sync-quota', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const accountId = String(req.params.id);
+        const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({ where: { id: accountId, userId: req.user.id } });
+        const quota = await syncQuotaForAccount(account);
+        return res.json({
+            quota: {
+                ...quota,
+                totalBytes: quota.totalBytes?.toString() ?? null,
+                usedBytes: quota.usedBytes.toString(),
+                availableBytes: quota.availableBytes?.toString() ?? null,
+                trashBytes: quota.trashBytes?.toString() ?? null,
+            },
+        });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.connectedAccountRouter.delete('/:id', auth_middleware_js_1.requireAuth, async (req, res, next) => {
+    try {
+        const accountId = String(req.params.id);
+        await prisma_js_1.prisma.connectedAccount.updateMany({ where: { id: accountId, userId: req.user.id }, data: { status: 'disconnected' } });
+        return res.json({ status: 'ok' });
+    }
+    catch (error) {
+        return next(error);
+    }
+});