9drive 1.0.0

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicRouter = void 0;
+const express_1 = require("express");
+const prisma_js_1 = require("../../config/prisma.js");
+const crypto_js_1 = require("../../utils/crypto.js");
+const stream_file_js_1 = require("../files/stream-file.js");
+exports.publicRouter = (0, express_1.Router)();
+async function findSharedFile(token) {
+    const share = await prisma_js_1.prisma.fileShare.findFirst({
+        where: { enabled: true, AND: [{ OR: [{ token }, { tokenHash: (0, crypto_js_1.hashToken)(token) }] }, { OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }] }] },
+        include: { file: { include: { connectedAccount: true } } },
+    });
+    if (!share || share.file.status !== 'active')
+        throw new Error('Shared file not found');
+    return share.file;
+}
+exports.publicRouter.get('/files/:token', async (req, res, next) => {
+    try {
+        const file = await findSharedFile(String(req.params.token));
+        return res.json({ file: { id: file.id, name: file.name, mimeType: file.mimeType, sizeBytes: file.sizeBytes.toString(), createdAt: file.createdAt } });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.publicRouter.get('/files/:token/download', async (req, res, next) => {
+    try {
+        const file = await findSharedFile(String(req.params.token));
+        return (0, stream_file_js_1.streamProviderFile)(file, req.headers.range, res, { disposition: 'attachment' });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.publicRouter.get('/files/:token/preview', async (req, res, next) => {
+    try {
+        const file = await findSharedFile(String(req.params.token));
+        return (0, stream_file_js_1.streamProviderFile)(file, req.headers.range, res, { disposition: 'inline' });
+    }
+    catch (error) {
+        return next(error);
+    }
+});

package/backend/dist/modules/public-api/public-api.routes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicApiRouter = void 0;
+const express_1 = require("express");
+const api_key_middleware_js_1 = require("../../middleware/api-key.middleware.js");
+const upload_routes_js_1 = require("../uploads/upload.routes.js");
+exports.publicApiRouter = (0, express_1.Router)();
+exports.publicApiRouter.post('/v1/uploads', (0, api_key_middleware_js_1.requireApiKey)('files:upload'), upload_routes_js_1.handleUpload);

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createS3Client = createS3Client;
+exports.getS3ConfigForAccount = getS3ConfigForAccount;
+exports.testS3Connection = testS3Connection;
+exports.buildS3ObjectKey = buildS3ObjectKey;
+exports.uploadS3Object = uploadS3Object;
+exports.deleteS3Object = deleteS3Object;
+exports.syncS3Quota = syncS3Quota;
+exports.streamS3File = streamS3File;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const lib_storage_1 = require("@aws-sdk/lib-storage");
+const prisma_js_1 = require("../../config/prisma.js");
+const crypto_js_1 = require("../../utils/crypto.js");
+function contentDisposition(type, fileName) {
+    return `${type}; filename="${fileName.replaceAll('"', '')}"`;
+}
+function createS3Client(config) {
+    return new client_s3_1.S3Client({
+        region: config.region,
+        endpoint: config.endpoint ?? undefined,
+        forcePathStyle: config.forcePathStyle || Boolean(config.endpoint),
+        credentials: {
+            accessKeyId: (0, crypto_js_1.decryptText)(config.accessKeyIdEncrypted),
+            secretAccessKey: (0, crypto_js_1.decryptText)(config.secretAccessKeyEncrypted),
+        },
+    });
+}
+async function getS3ConfigForAccount(accountId, userId) {
+    return prisma_js_1.prisma.s3StorageConfig.findFirstOrThrow({ where: { connectedAccountId: accountId, status: 'active', ...(userId ? { userId } : {}) } });
+}
+async function testS3Connection(config) {
+    const client = createS3Client(config);
+    await client.send(new client_s3_1.HeadBucketCommand({ Bucket: config.bucket }));
+}
+function safeFileName(name) {
+    return name.replace(/[\\/]+/g, '-').replace(/[\u0000-\u001f\u007f]+/g, '').slice(0, 180) || 'file';
+}
+function buildS3ObjectKey(config, userId, fileId, fileName) {
+    return `${config.prefix.replace(/^\/+|\/+$/g, '')}/${userId}/${fileId}/${safeFileName(fileName)}`;
+}
+async function uploadS3Object(config, key, body, mimeType) {
+    const client = createS3Client(config);
+    await new lib_storage_1.Upload({
+        client,
+        params: { Bucket: config.bucket, Key: key, Body: body, ContentType: mimeType },
+    }).done();
+}
+async function deleteS3Object(file) {
+    const config = await getS3ConfigForAccount(file.connectedAccountId);
+    const client = createS3Client(config);
+    await client.send(new client_s3_1.DeleteObjectCommand({ Bucket: config.bucket, Key: file.providerFileId }));
+}
+async function syncS3Quota(accountId) {
+    const config = await getS3ConfigForAccount(accountId);
+    const client = createS3Client(config);
+    let usedBytes = 0n;
+    let continuationToken;
+    do {
+        const response = await client.send(new client_s3_1.ListObjectsV2Command({ Bucket: config.bucket, ContinuationToken: continuationToken }));
+        for (const object of response.Contents ?? [])
+            usedBytes += BigInt(object.Size ?? 0);
+        continuationToken = response.NextContinuationToken;
+    } while (continuationToken);
+    return prisma_js_1.prisma.storageAccount.upsert({
+        where: { connectedAccountId: accountId },
+        create: {
+            connectedAccountId: accountId,
+            totalBytes: config.quotaBytes,
+            usedBytes,
+            availableBytes: config.quotaBytes === null ? null : config.quotaBytes - usedBytes,
+            lastSyncedAt: new Date(),
+        },
+        update: {
+            totalBytes: config.quotaBytes,
+            usedBytes,
+            availableBytes: config.quotaBytes === null ? null : config.quotaBytes - usedBytes,
+            lastSyncedAt: new Date(),
+        },
+    });
+}
+async function streamS3File(file, range, res, options = {}) {
+    const config = await getS3ConfigForAccount(file.connectedAccountId);
+    const client = createS3Client(config);
+    const response = await client.send(new client_s3_1.GetObjectCommand({ Bucket: config.bucket, Key: file.providerFileId, Range: range }));
+    res.status(response.ContentRange ? 206 : 200);
+    res.setHeader('Content-Type', response.ContentType ?? file.mimeType);
+    res.setHeader('Accept-Ranges', 'bytes');
+    if (options.disposition)
+        res.setHeader('Content-Disposition', contentDisposition(options.disposition, file.name));
+    if (options.headers) {
+        for (const [key, value] of Object.entries(options.headers)) {
+            res.setHeader(key, value);
+        }
+    }
+    if (response.ContentLength !== undefined)
+        res.setHeader('Content-Length', response.ContentLength.toString());
+    if (response.ContentRange)
+        res.setHeader('Content-Range', response.ContentRange);
+    const body = response.Body;
+    if (!body)
+        return res.end();
+    return body.pipe(res);
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageRouter = 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.storageRouter = (0, express_1.Router)();
+exports.storageRouter.use(auth_middleware_js_1.requireAuth);
+function bytesToString(value) {
+    if (value === null || value === undefined)
+        return '0';
+    return value.toString();
+}
+const routingModes = ['most_available', 'round_robin', 'priority'];
+const routingPolicySchema = zod_1.z.object({ mode: zod_1.z.enum(routingModes), priorityAccountIds: zod_1.z.array(zod_1.z.string().min(1)).max(100).optional() });
+function normalizePriorityAccountIds(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+async function getOrCreateRoutingPolicy(userId) {
+    return prisma_js_1.prisma.uploadRoutingPolicy.upsert({
+        where: { userId },
+        create: { userId, mode: 'most_available', priorityAccountIds: [] },
+        update: {},
+    });
+}
+exports.storageRouter.get('/summary', async (req, res, next) => {
+    try {
+        const accounts = await prisma_js_1.prisma.connectedAccount.findMany({ where: { userId: req.user.id, status: 'connected' }, include: { storageAccount: true } });
+        const summary = accounts.reduce((acc, account) => {
+            const storage = account.storageAccount;
+            acc.totalBytes += storage?.totalBytes ?? 0n;
+            acc.usedBytes += storage?.usedBytes ?? 0n;
+            acc.availableBytes += storage?.availableBytes ?? 0n;
+            return acc;
+        }, { totalBytes: 0n, usedBytes: 0n, availableBytes: 0n });
+        return res.json({
+            totalBytes: summary.totalBytes.toString(),
+            usedBytes: summary.usedBytes.toString(),
+            availableBytes: summary.availableBytes.toString(),
+            accounts: accounts.map((account) => ({
+                id: account.id,
+                provider: account.provider,
+                email: account.email,
+                status: account.status,
+                totalBytes: account.storageAccount?.totalBytes?.toString() ?? null,
+                usedBytes: account.storageAccount?.usedBytes.toString() ?? '0',
+                availableBytes: account.storageAccount?.availableBytes?.toString() ?? null,
+                lastSyncedAt: account.storageAccount?.lastSyncedAt ?? null,
+            })),
+        });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.storageRouter.get('/routing-policy', async (req, res, next) => {
+    try {
+        const policy = await getOrCreateRoutingPolicy(req.user.id);
+        return res.json({ policy: { id: policy.id, mode: policy.mode, priorityAccountIds: normalizePriorityAccountIds(policy.priorityAccountIds), roundRobinCursor: policy.roundRobinCursor } });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.storageRouter.patch('/routing-policy', async (req, res, next) => {
+    try {
+        const body = routingPolicySchema.parse(req.body);
+        const accountIds = [...new Set(body.priorityAccountIds ?? [])];
+        const validAccounts = accountIds.length === 0 ? [] : await prisma_js_1.prisma.connectedAccount.findMany({ where: { id: { in: accountIds }, userId: req.user.id, status: 'connected' }, select: { id: true } });
+        const validIds = new Set(validAccounts.map((account) => account.id));
+        const priorityAccountIds = accountIds.filter((id) => validIds.has(id));
+        const policy = await prisma_js_1.prisma.uploadRoutingPolicy.upsert({
+            where: { userId: req.user.id },
+            create: { userId: req.user.id, mode: body.mode, priorityAccountIds, roundRobinCursor: 0 },
+            update: { mode: body.mode, priorityAccountIds, ...(body.mode !== 'round_robin' ? { roundRobinCursor: 0 } : {}) },
+        });
+        return res.json({ policy: { id: policy.id, mode: policy.mode, priorityAccountIds: normalizePriorityAccountIds(policy.priorityAccountIds), roundRobinCursor: policy.roundRobinCursor } });
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+exports.storageRouter.get('/breakdown', async (req, res, next) => {
+    try {
+        const rows = await prisma_js_1.prisma.$queryRaw `
+      SELECT
+        CASE
+          WHEN mime_type LIKE 'image/%' THEN 'photo'
+          WHEN mime_type LIKE 'video/%' THEN 'video'
+          ELSE 'document'
+        END AS kind,
+        COALESCE(SUM(size_bytes), 0) AS bytes
+      FROM files
+      WHERE user_id = ${req.user.id} AND status = 'active'
+      GROUP BY kind
+    `;
+        const breakdown = { photo: '0', video: '0', document: '0' };
+        for (const row of rows) {
+            if (row.kind === 'photo' || row.kind === 'video' || row.kind === 'document')
+                breakdown[row.kind] = bytesToString(row.bytes);
+        }
+        return res.json(breakdown);
+    }
+    catch (error) {
+        return next(error);
+    }
+});