9drive 1.0.0

package/backend/dist/modules/google/google.service.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOAuthClient = createOAuthClient;
+exports.getAuthedGoogleClient = getAuthedGoogleClient;
+exports.syncGoogleQuota = syncGoogleQuota;
+exports.ensureGoogleAppFolder = ensureGoogleAppFolder;
+exports.syncGoogleAppFolderFiles = syncGoogleAppFolderFiles;
+exports.getGoogleStarredFiles = getGoogleStarredFiles;
+exports.getGoogleRecentFiles = getGoogleRecentFiles;
+exports.getGoogleSharedFiles = getGoogleSharedFiles;
+exports.setGoogleFileStarred = setGoogleFileStarred;
+exports.findInheritedPermissionOrigin = findInheritedPermissionOrigin;
+const googleapis_1 = require("googleapis");
+const prisma_js_1 = require("../../config/prisma.js");
+const crypto_js_1 = require("../../utils/crypto.js");
+const googleDriveFolderMimeType = 'application/vnd.google-apps.folder';
+const appFolderName = '9drive';
+function createOAuthClient(config) {
+    return new googleapis_1.google.auth.OAuth2((0, crypto_js_1.decryptText)(config.clientIdEncrypted), (0, crypto_js_1.decryptText)(config.clientSecretEncrypted), config.redirectUri);
+}
+async function getAuthedGoogleClient(account) {
+    if (!account.accessTokenEncrypted || !account.refreshTokenEncrypted || !account.tokenExpiresAt)
+        throw new Error('Google account tokens are missing.');
+    if (!account.providerConfigId)
+        throw new Error('Google provider config is missing.');
+    const config = await prisma_js_1.prisma.providerConfig.findUniqueOrThrow({ where: { id: account.providerConfigId } });
+    const client = createOAuthClient(config);
+    client.setCredentials({
+        access_token: (0, crypto_js_1.decryptText)(account.accessTokenEncrypted),
+        refresh_token: (0, crypto_js_1.decryptText)(account.refreshTokenEncrypted),
+        expiry_date: account.tokenExpiresAt.getTime(),
+    });
+    if (account.tokenExpiresAt.getTime() < Date.now() + 60_000) {
+        const result = await client.refreshAccessToken();
+        const credentials = result.credentials;
+        if (credentials.access_token) {
+            await prisma_js_1.prisma.connectedAccount.update({
+                where: { id: account.id },
+                data: {
+                    accessTokenEncrypted: (0, crypto_js_1.encryptText)(credentials.access_token),
+                    tokenExpiresAt: new Date(credentials.expiry_date ?? Date.now() + 3600_000),
+                },
+            });
+            client.setCredentials(credentials);
+        }
+    }
+    return client;
+}
+async function syncGoogleQuota(accountId) {
+    const account = await prisma_js_1.prisma.connectedAccount.findUniqueOrThrow({ where: { id: accountId } });
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    const about = await drive.about.get({ fields: 'storageQuota,user' });
+    const quota = about.data.storageQuota;
+    const total = quota?.limit ? BigInt(quota.limit) : null;
+    const used = quota?.usage ? BigInt(quota.usage) : 0n;
+    return prisma_js_1.prisma.storageAccount.upsert({
+        where: { connectedAccountId: accountId },
+        create: {
+            connectedAccountId: accountId,
+            totalBytes: total,
+            usedBytes: used,
+            availableBytes: total === null ? null : total - used,
+            trashBytes: quota?.usageInDriveTrash ? BigInt(quota.usageInDriveTrash) : null,
+            lastSyncedAt: new Date(),
+        },
+        update: {
+            totalBytes: total,
+            usedBytes: used,
+            availableBytes: total === null ? null : total - used,
+            trashBytes: quota?.usageInDriveTrash ? BigInt(quota.usageInDriveTrash) : null,
+            lastSyncedAt: new Date(),
+        },
+    });
+}
+function escapeDriveQueryValue(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+async function ensureGoogleAppFolder(account) {
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    const queryName = escapeDriveQueryValue(appFolderName);
+    const existing = await drive.files.list({
+        q: `name = '${queryName}' and mimeType = '${googleDriveFolderMimeType}' and 'root' in parents and trashed = false`,
+        spaces: 'drive',
+        fields: 'files(id,name)',
+        pageSize: 1,
+    });
+    const folderId = existing.data.files?.[0]?.id ?? (await drive.files.create({
+        requestBody: { name: appFolderName, mimeType: googleDriveFolderMimeType, parents: ['root'] },
+        fields: 'id',
+    })).data.id;
+    if (!folderId)
+        throw new Error('Failed to create Google Drive app folder.');
+    return folderId;
+}
+async function syncGoogleAppFolderFiles(accountId, userId) {
+    const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({ where: { id: accountId, userId, provider: 'google_drive', status: 'connected' } });
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    const driveFolders = [];
+    let folderPageToken;
+    do {
+        const response = await drive.files.list({
+            q: `mimeType = '${googleDriveFolderMimeType}' and trashed = false`,
+            spaces: 'drive',
+            fields: 'nextPageToken,files(id,name,parents)',
+            pageSize: 1000,
+            pageToken: folderPageToken,
+        });
+        for (const folder of response.data.files ?? []) {
+            if (!folder.id || !folder.name)
+                continue;
+            driveFolders.push({
+                id: folder.id,
+                name: folder.name,
+                parentId: folder.parents?.[0] ?? null,
+            });
+        }
+        folderPageToken = response.data.nextPageToken ?? undefined;
+    } while (folderPageToken);
+    const existingFolders = await prisma_js_1.prisma.folder.findMany({
+        where: { userId, connectedAccountId: account.id },
+    });
+    const existingFolderByProviderId = new Map(existingFolders.filter((f) => f.providerFolderId).map((f) => [f.providerFolderId, f]));
+    const gdriveFolderIdToDbFolder = new Map();
+    for (const driveFolder of driveFolders) {
+        let dbFolder = existingFolderByProviderId.get(driveFolder.id);
+        if (!dbFolder) {
+            dbFolder = await prisma_js_1.prisma.folder.create({
+                data: {
+                    userId,
+                    connectedAccountId: account.id,
+                    provider: 'google_drive',
+                    providerFolderId: driveFolder.id,
+                    name: driveFolder.name,
+                    color: 'text-blue-500',
+                },
+            });
+            existingFolderByProviderId.set(driveFolder.id, dbFolder);
+        }
+        else {
+            if (dbFolder.name !== driveFolder.name || dbFolder.deletedAt !== null) {
+                dbFolder = await prisma_js_1.prisma.folder.update({
+                    where: { id: dbFolder.id },
+                    data: { name: driveFolder.name, deletedAt: null },
+                });
+            }
+        }
+        gdriveFolderIdToDbFolder.set(driveFolder.id, dbFolder);
+    }
+    // Set parentId relationships among synced folders
+    for (const driveFolder of driveFolders) {
+        const dbFolder = gdriveFolderIdToDbFolder.get(driveFolder.id);
+        if (!dbFolder)
+            continue;
+        const parentDbFolder = driveFolder.parentId ? gdriveFolderIdToDbFolder.get(driveFolder.parentId) : null;
+        const targetParentId = parentDbFolder ? parentDbFolder.id : null;
+        if (dbFolder.parentId !== targetParentId) {
+            await prisma_js_1.prisma.folder.update({
+                where: { id: dbFolder.id },
+                data: { parentId: targetParentId },
+            });
+            dbFolder.parentId = targetParentId;
+        }
+    }
+    // Mark folders missing on Google Drive as deleted
+    const driveFolderIds = new Set(driveFolders.map((f) => f.id));
+    const missingFolderIds = existingFolders
+        .filter((f) => f.deletedAt === null && f.providerFolderId && !driveFolderIds.has(f.providerFolderId))
+        .map((f) => f.id);
+    if (missingFolderIds.length > 0) {
+        await prisma_js_1.prisma.folder.updateMany({
+            where: { id: { in: missingFolderIds } },
+            data: { deletedAt: new Date() },
+        });
+    }
+    const driveFiles = [];
+    let pageToken;
+    do {
+        const response = await drive.files.list({
+            q: `mimeType != '${googleDriveFolderMimeType}' and trashed = false`,
+            spaces: 'drive',
+            fields: 'nextPageToken,files(id,name,mimeType,size,parents,createdTime,modifiedTime)',
+            pageSize: 1000,
+            pageToken,
+        });
+        for (const file of response.data.files ?? []) {
+            if (!file.id || !file.name || !file.mimeType)
+                continue;
+            const parentId = file.parents?.[0] ?? null;
+            driveFiles.push({
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType,
+                sizeBytes: BigInt(file.size ?? 0),
+                parentId,
+                createdTime: file.createdTime,
+                modifiedTime: file.modifiedTime,
+            });
+        }
+        pageToken = response.data.nextPageToken ?? undefined;
+    } while (pageToken);
+    const existingFiles = await prisma_js_1.prisma.file.findMany({ where: { userId, connectedAccountId: account.id, provider: 'google_drive' } });
+    const existingByProviderId = new Map(existingFiles.map((file) => [file.providerFileId, file]));
+    const driveFileIds = new Set(driveFiles.map((file) => file.id));
+    let created = 0;
+    let updated = 0;
+    let deleted = 0;
+    for (const driveFile of driveFiles) {
+        const dbFolder = driveFile.parentId ? gdriveFolderIdToDbFolder.get(driveFile.parentId) : null;
+        const dbFolderId = dbFolder ? dbFolder.id : null;
+        const existing = existingByProviderId.get(driveFile.id);
+        if (!existing) {
+            await prisma_js_1.prisma.file.create({
+                data: {
+                    userId,
+                    connectedAccountId: account.id,
+                    provider: 'google_drive',
+                    providerFileId: driveFile.id,
+                    name: driveFile.name,
+                    mimeType: driveFile.mimeType,
+                    sizeBytes: driveFile.sizeBytes,
+                    status: 'active',
+                    folderId: dbFolderId,
+                    createdAt: driveFile.createdTime ? new Date(driveFile.createdTime) : new Date(),
+                    updatedAt: driveFile.modifiedTime ? new Date(driveFile.modifiedTime) : new Date(),
+                },
+            });
+            created += 1;
+            continue;
+        }
+        const needsUpdate = existing.name !== driveFile.name ||
+            existing.mimeType !== driveFile.mimeType ||
+            existing.sizeBytes !== driveFile.sizeBytes ||
+            existing.status !== 'active' ||
+            existing.deletedAt !== null ||
+            existing.folderId !== dbFolderId;
+        if (needsUpdate) {
+            await prisma_js_1.prisma.file.update({
+                where: { id: existing.id },
+                data: {
+                    name: driveFile.name,
+                    mimeType: driveFile.mimeType,
+                    sizeBytes: driveFile.sizeBytes,
+                    status: 'active',
+                    deletedAt: null,
+                    folderId: dbFolderId,
+                    ...(driveFile.modifiedTime ? { updatedAt: new Date(driveFile.modifiedTime) } : {}),
+                },
+            });
+            updated += 1;
+        }
+    }
+    const missingActiveIds = existingFiles.filter((file) => file.status === 'active' && !driveFileIds.has(file.providerFileId)).map((file) => file.id);
+    if (missingActiveIds.length > 0) {
+        const result = await prisma_js_1.prisma.file.updateMany({ where: { id: { in: missingActiveIds }, userId }, data: { status: 'deleted', deletedAt: new Date() } });
+        deleted = result.count;
+    }
+    await syncGoogleQuota(account.id).catch(() => undefined);
+    return { accountId: account.id, created, updated, deleted };
+}
+async function getGoogleStarredFiles(accountId, userId) {
+    const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({ where: { id: accountId, userId, provider: 'google_drive', status: 'connected' } });
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    const response = await drive.files.list({
+        q: 'starred = true and trashed = false',
+        spaces: 'drive',
+        fields: 'files(id,name,mimeType,size,parents,createdTime,modifiedTime,webViewLink)',
+        pageSize: 100,
+    });
+    // Look up folder names from DB if available
+    const existingFiles = await prisma_js_1.prisma.file.findMany({
+        where: { userId, connectedAccountId: account.id, providerFileId: { in: (response.data.files ?? []).map((f) => f.id).filter(Boolean) } },
+        include: { folder: { select: { id: true, name: true } } },
+    });
+    const fileByProviderId = new Map(existingFiles.map((f) => [f.providerFileId, f]));
+    return (response.data.files ?? []).map((f) => {
+        const dbFile = f.id ? fileByProviderId.get(f.id) : null;
+        return {
+            id: dbFile?.id ?? f.id ?? '',
+            providerFileId: f.id ?? '',
+            name: f.name ?? 'Untitled',
+            mimeType: f.mimeType ?? 'application/octet-stream',
+            sizeBytes: String(f.size ?? '0'),
+            createdAt: f.createdTime ?? new Date().toISOString(),
+            updatedAt: f.modifiedTime ?? f.createdTime ?? new Date().toISOString(),
+            folderId: dbFile?.folderId ?? null,
+            folder: dbFile?.folder ?? null,
+            connectedAccount: { id: account.id, email: account.email, provider: 'google_drive' },
+            driveUrl: f.webViewLink ?? (f.id ? `https://drive.google.com/file/d/${f.id}/view?usp=sharing` : null),
+        };
+    });
+}
+async function getGoogleRecentFiles(accountId, userId) {
+    const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({ where: { id: accountId, userId, provider: 'google_drive', status: 'connected' } });
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    const response = await drive.files.list({
+        q: `mimeType != '${googleDriveFolderMimeType}' and trashed = false`,
+        orderBy: 'viewedByMeTime desc, modifiedTime desc',
+        spaces: 'drive',
+        fields: 'files(id,name,mimeType,size,parents,createdTime,modifiedTime,viewedByMeTime,webViewLink)',
+        pageSize: 50,
+    });
+    const existingFiles = await prisma_js_1.prisma.file.findMany({
+        where: { userId, connectedAccountId: account.id, providerFileId: { in: (response.data.files ?? []).map((f) => f.id).filter(Boolean) } },
+        include: { folder: { select: { id: true, name: true } } },
+    });
+    const fileByProviderId = new Map(existingFiles.map((f) => [f.providerFileId, f]));
+    return (response.data.files ?? []).map((f) => {
+        const dbFile = f.id ? fileByProviderId.get(f.id) : null;
+        return {
+            id: dbFile?.id ?? f.id ?? '',
+            providerFileId: f.id ?? '',
+            name: f.name ?? 'Untitled',
+            mimeType: f.mimeType ?? 'application/octet-stream',
+            sizeBytes: String(f.size ?? '0'),
+            createdAt: f.createdTime ?? new Date().toISOString(),
+            updatedAt: f.modifiedTime ?? f.createdTime ?? new Date().toISOString(),
+            viewedAt: f.viewedByMeTime ?? f.modifiedTime ?? f.createdTime,
+            folderId: dbFile?.folderId ?? null,
+            folder: dbFile?.folder ?? null,
+            connectedAccount: { id: account.id, email: account.email, provider: 'google_drive' },
+            driveUrl: f.webViewLink ?? (f.id ? `https://drive.google.com/file/d/${f.id}/view?usp=sharing` : null),
+        };
+    });
+}
+async function getGoogleSharedFiles(accountId, userId) {
+    const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({
+        where: { id: accountId, userId, provider: 'google_drive', status: 'connected' },
+    });
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    const response = await drive.files.list({
+        q: 'sharedWithMe = true and trashed = false',
+        orderBy: 'sharedWithMeTime desc',
+        spaces: 'drive',
+        fields: 'files(id,name,mimeType,size,parents,createdTime,modifiedTime,sharedWithMeTime,sharingUser(displayName,emailAddress,photoLink),owners(displayName,emailAddress,photoLink),webViewLink,iconLink)',
+        pageSize: 100,
+        supportsAllDrives: true,
+        includeItemsFromAllDrives: true,
+    });
+    const rawItems = response.data.files ?? [];
+    const rawFolders = rawItems.filter((f) => f.mimeType === googleDriveFolderMimeType);
+    const rawFiles = rawItems.filter((f) => f.mimeType !== googleDriveFolderMimeType);
+    // Find or create DB records for shared folders
+    const folderByProviderId = new Map();
+    for (const rf of rawFolders) {
+        if (!rf.id || !rf.name)
+            continue;
+        let dbFolder = await prisma_js_1.prisma.folder.findFirst({
+            where: { userId, connectedAccountId: account.id, providerFolderId: rf.id },
+        });
+        if (!dbFolder) {
+            dbFolder = await prisma_js_1.prisma.folder.create({
+                data: {
+                    userId,
+                    connectedAccountId: account.id,
+                    provider: 'google_drive',
+                    providerFolderId: rf.id,
+                    name: rf.name,
+                    color: 'text-blue-500',
+                },
+            });
+        }
+        folderByProviderId.set(rf.id, dbFolder);
+    }
+    // Find or create DB records for shared files (needed for preview & download streaming)
+    const fileByProviderId = new Map();
+    for (const rf of rawFiles) {
+        if (!rf.id || !rf.name)
+            continue;
+        let dbFile = await prisma_js_1.prisma.file.findFirst({
+            where: { userId, connectedAccountId: account.id, providerFileId: rf.id },
+            include: { folder: { select: { id: true, name: true } } },
+        });
+        if (!dbFile) {
+            dbFile = await prisma_js_1.prisma.file.create({
+                data: {
+                    userId,
+                    connectedAccountId: account.id,
+                    provider: 'google_drive',
+                    providerFileId: rf.id,
+                    name: rf.name,
+                    mimeType: rf.mimeType ?? 'application/octet-stream',
+                    sizeBytes: BigInt(rf.size ?? 0),
+                    status: 'active',
+                },
+                include: { folder: { select: { id: true, name: true } } },
+            });
+        }
+        fileByProviderId.set(rf.id, dbFile);
+    }
+    const folders = rawFolders.map((f) => {
+        const dbFolder = f.id ? folderByProviderId.get(f.id) : null;
+        const ownerName = f.sharingUser?.displayName ||
+            f.sharingUser?.emailAddress ||
+            f.owners?.[0]?.displayName ||
+            f.owners?.[0]?.emailAddress ||
+            'Shared';
+        return {
+            id: dbFolder?.id ?? f.id ?? '',
+            name: f.name ?? 'Untitled Folder',
+            updated: f.sharedWithMeTime ?? f.modifiedTime ?? f.createdTime ?? new Date().toISOString(),
+            color: 'text-blue-500',
+            iconUrl: f.iconLink ?? null,
+            providerFolderId: f.id ?? null,
+            driveUrl: f.webViewLink ?? (f.id ? `https://drive.google.com/drive/folders/${f.id}` : undefined),
+            owner: ownerName,
+            connectedAccount: { id: account.id, email: account.email, provider: 'google_drive' },
+        };
+    });
+    const files = rawFiles.map((f) => {
+        const dbFile = f.id ? fileByProviderId.get(f.id) : null;
+        const ownerName = f.sharingUser?.displayName ||
+            f.sharingUser?.emailAddress ||
+            f.owners?.[0]?.displayName ||
+            f.owners?.[0]?.emailAddress ||
+            'Shared';
+        return {
+            id: dbFile?.id ?? f.id ?? '',
+            providerFileId: f.id ?? '',
+            name: f.name ?? 'Untitled',
+            mimeType: f.mimeType ?? 'application/octet-stream',
+            sizeBytes: String(f.size ?? '0'),
+            createdAt: f.createdTime ?? new Date().toISOString(),
+            updatedAt: f.modifiedTime ?? f.createdTime ?? new Date().toISOString(),
+            sharedWithMeTime: f.sharedWithMeTime ?? f.modifiedTime ?? f.createdTime ?? new Date().toISOString(),
+            owner: ownerName,
+            folderId: dbFile?.folderId ?? null,
+            folder: dbFile?.folder ?? null,
+            connectedAccount: { id: account.id, email: account.email, provider: 'google_drive' },
+            driveUrl: f.webViewLink ?? (f.id ? `https://drive.google.com/file/d/${f.id}/view?usp=sharing` : null),
+        };
+    });
+    return { files, folders };
+}
+async function setGoogleFileStarred(accountId, userId, providerFileId, starred) {
+    const account = await prisma_js_1.prisma.connectedAccount.findFirstOrThrow({ where: { id: accountId, userId, provider: 'google_drive', status: 'connected' } });
+    const auth = await getAuthedGoogleClient(account);
+    const drive = googleapis_1.google.drive({ version: 'v3', auth });
+    await drive.files.update({
+        fileId: providerFileId,
+        requestBody: { starred },
+    });
+}
+async function findInheritedPermissionOrigin(drive, startingFileOrFolderId) {
+    let currentId = startingFileOrFolderId;
+    const visited = new Set();
+    while (currentId && !visited.has(currentId)) {
+        visited.add(currentId);
+        try {
+            const fileRes = await drive.files.get({
+                fileId: currentId,
+                fields: 'id, name, parents, permissions(id, type, role, permissionDetails)',
+                supportsAllDrives: true,
+            });
+            const permissions = fileRes.data?.permissions || [];
+            const anyonePerm = permissions.find((p) => p.type === 'anyone' || p.id === 'anyoneWithLink');
+            if (anyonePerm) {
+                const isInherited = anyonePerm.permissionDetails?.some((d) => d.inherited === true);
+                if (!isInherited) {
+                    return {
+                        id: fileRes.data.id,
+                        name: fileRes.data.name || 'Folder Induk',
+                        permissionId: anyonePerm.id || 'anyoneWithLink',
+                    };
+                }
+            }
+            const parents = fileRes.data?.parents;
+            if (parents && parents.length > 0) {
+                currentId = parents[0];
+            }
+            else {
+                break;
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    return null;
+}

package/backend/dist/modules/invites/invite.routes.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inviteRouter = void 0;
+const express_1 = require("express");
+const zod_1 = require("zod");
+const prisma_js_1 = require("../../config/prisma.js");
+const auth_middleware_js_1 = require("../../middleware/auth.middleware.js");
+exports.inviteRouter = (0, express_1.Router)();
+exports.inviteRouter.use(auth_middleware_js_1.requireAuth);
+const inviteSchema = zod_1.z.object({ email: zod_1.z.string().email(), role: zod_1.z.enum(['viewer', 'editor']).default('viewer'), targetType: zod_1.z.enum(['file', 'folder']), targetId: zod_1.z.string().min(1) });
+async function assertTargetOwner(userId, targetType, targetId) {
+    if (targetType === 'file') {
+        const file = await prisma_js_1.prisma.file.findFirst({
+            where: {
+                OR: [
+                    { id: targetId, userId },
+                    { providerFileId: targetId, userId },
+                    { id: targetId },
+                    { providerFileId: targetId },
+                ],
+                status: 'active',
+            },
+        });
+        if (!file)
+            throw new Error('File not found');
+        return file;
+    }
+    const folder = await prisma_js_1.prisma.folder.findFirst({
+        where: {
+            OR: [
+                { id: targetId, userId },
+                { providerFolderId: targetId, userId },
+                { id: targetId },
+                { providerFolderId: targetId },
+            ],
+            deletedAt: null,
+        },
+    });
+    if (!folder)
+        throw new Error('Folder not found');
+    return folder;
+}
+async function resolveTargets(invites) {
+    const fileIds = invites.filter((invite) => invite.targetType === 'file').map((invite) => invite.targetId);
+    const folderIds = invites.filter((invite) => invite.targetType === 'folder').map((invite) => invite.targetId);
+    const [files, folders] = await Promise.all([
+        prisma_js_1.prisma.file.findMany({ where: { id: { in: fileIds }, status: 'active' }, select: { id: true, name: true, mimeType: true, sizeBytes: true, folderId: true } }),
+        prisma_js_1.prisma.folder.findMany({ where: { id: { in: folderIds }, deletedAt: null }, select: { id: true, name: true } }),
+    ]);
+    const targets = new Map();
+    for (const file of files)
+        targets.set(`file:${file.id}`, { id: file.id, name: file.name, type: 'file', mimeType: file.mimeType, sizeBytes: file.sizeBytes.toString(), folderId: file.folderId });
+    for (const folder of folders)
+        targets.set(`folder:${folder.id}`, { id: folder.id, name: folder.name, type: 'folder' });
+    return targets;
+}
+function serializeInvite(invite, target, user) {
+    return {
+        id: invite.id,
+        email: invite.inviteeEmail,
+        role: invite.role,
+        status: invite.status,
+        targetType: invite.targetType,
+        targetId: invite.targetId,
+        target,
+        revokedAt: invite.revokedAt?.toISOString() ?? null,
+        acceptedAt: invite.acceptedAt?.toISOString() ?? null,
+        createdAt: invite.createdAt.toISOString(),
+        updatedAt: invite.updatedAt.toISOString(),
+        user: user ?? null,
+    };
+}
+exports.inviteRouter.get('/', async (req, res, next) => {
+    try {
+        const me = await prisma_js_1.prisma.user.findUniqueOrThrow({ where: { id: req.user.id }, select: { email: true } });
+        const [sent, received] = await Promise.all([
+            prisma_js_1.prisma.workspaceInvite.findMany({ where: { inviterId: req.user.id, revokedAt: null, targetId: { not: '' } }, orderBy: { createdAt: 'desc' } }),
+            prisma_js_1.prisma.workspaceInvite.findMany({ where: { inviteeEmail: me.email, revokedAt: null, targetId: { not: '' } }, orderBy: { createdAt: 'desc' } }),
+        ]);
+        const allInvites = [...sent, ...received];
+        const emails = [...new Set(sent.map((invite) => invite.inviteeEmail))];
+        const users = await prisma_js_1.prisma.user.findMany({ where: { email: { in: emails } }, select: { id: true, name: true, email: true } });
+        const userByEmail = new Map(users.map((user) => [user.email, user]));
+        const acceptedInvites = sent.filter((invite) => invite.status === 'pending' && userByEmail.has(invite.inviteeEmail));
+        if (acceptedInvites.length > 0)
+            await prisma_js_1.prisma.workspaceInvite.updateMany({ where: { id: { in: acceptedInvites.map((invite) => invite.id) } }, data: { status: 'accepted', acceptedAt: new Date() } });
+        const targetByKey = await resolveTargets(allInvites);
+        const sentInvites = sent.map((invite) => serializeInvite({ ...invite, status: userByEmail.has(invite.inviteeEmail) ? 'accepted' : invite.status, acceptedAt: userByEmail.has(invite.inviteeEmail) ? invite.acceptedAt ?? new Date() : invite.acceptedAt }, targetByKey.get(`${invite.targetType}:${invite.targetId}`) ?? null, userByEmail.get(invite.inviteeEmail)));
+        const receivedInvites = received.map((invite) => serializeInvite(invite, targetByKey.get(`${invite.targetType}:${invite.targetId}`) ?? null));
+        return res.json({ sent: sentInvites, received: receivedInvites, invites: sentInvites });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.inviteRouter.post('/', async (req, res, next) => {
+    try {
+        const body = inviteSchema.parse(req.body);
+        const email = body.email.trim().toLowerCase();
+        const inviter = await prisma_js_1.prisma.user.findUniqueOrThrow({ where: { id: req.user.id }, select: { email: true } });
+        if (email === inviter.email)
+            return res.status(400).json({ code: 'INVITE_SELF_NOT_ALLOWED', message: 'You cannot invite yourself.' });
+        await assertTargetOwner(req.user.id, body.targetType, body.targetId);
+        const existingUser = await prisma_js_1.prisma.user.findUnique({ where: { email }, select: { id: true, name: true, email: true } });
+        const invite = await prisma_js_1.prisma.workspaceInvite.upsert({
+            where: { inviterId_inviteeEmail_targetType_targetId: { inviterId: req.user.id, inviteeEmail: email, targetType: body.targetType, targetId: body.targetId } },
+            create: { inviterId: req.user.id, inviteeEmail: email, role: body.role, targetType: body.targetType, targetId: body.targetId, status: existingUser ? 'accepted' : 'pending', acceptedAt: existingUser ? new Date() : null },
+            update: { role: body.role, status: existingUser ? 'accepted' : 'pending', acceptedAt: existingUser ? new Date() : null, revokedAt: null },
+        });
+        const targetByKey = await resolveTargets([invite]);
+        return res.status(201).json({ invite: serializeInvite(invite, targetByKey.get(`${invite.targetType}:${invite.targetId}`) ?? null, existingUser) });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.inviteRouter.delete('/:id', async (req, res, next) => {
+    try {
+        const result = await prisma_js_1.prisma.workspaceInvite.updateMany({ where: { id: String(req.params.id), inviterId: req.user.id, revokedAt: null }, data: { status: 'revoked', revokedAt: new Date() } });
+        if (result.count === 0)
+            return res.status(404).json({ code: 'INVITE_NOT_FOUND', message: 'Invite not found.' });
+        return res.json({ status: 'ok' });
+    }
+    catch (error) {
+        return next(error);
+    }
+});

package/backend/dist/modules/provider-configs/provider-config.routes.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerConfigRouter = void 0;
+const express_1 = require("express");
+const zod_1 = require("zod");
+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");
+exports.providerConfigRouter = (0, express_1.Router)();
+exports.providerConfigRouter.use(auth_middleware_js_1.requireAuth);
+const schema = zod_1.z.object({
+    clientId: zod_1.z.string().min(1),
+    clientSecret: zod_1.z.string().min(1),
+    redirectUri: zod_1.z.string().url(),
+    scopes: zod_1.z.array(zod_1.z.string()).min(1),
+});
+exports.providerConfigRouter.post('/google', async (req, res, next) => {
+    try {
+        const body = schema.parse(req.body);
+        const config = await prisma_js_1.prisma.providerConfig.create({
+            data: {
+                userId: req.user.id,
+                provider: 'google_drive',
+                clientIdEncrypted: (0, crypto_js_1.encryptText)(body.clientId),
+                clientSecretEncrypted: (0, crypto_js_1.encryptText)(body.clientSecret),
+                redirectUri: body.redirectUri,
+                scopes: body.scopes,
+            },
+        });
+        return res.status(201).json({ id: config.id, provider: config.provider, redirectUri: config.redirectUri, scopes: config.scopes, status: config.status });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.providerConfigRouter.get('/', async (req, res, next) => {
+    try {
+        const configs = await prisma_js_1.prisma.providerConfig.findMany({ where: { userId: req.user.id }, select: { id: true, provider: true, redirectUri: true, scopes: true, status: true, createdAt: true } });
+        return res.json({ configs });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.providerConfigRouter.delete('/:id', async (req, res, next) => {
+    try {
+        await prisma_js_1.prisma.providerConfig.deleteMany({ where: { id: String(req.params.id), userId: req.user.id } });
+        return res.json({ status: 'ok' });
+    }
+    catch (error) {
+        return next(error);
+    }
+});