streamby-core 0.9.19 → 0.9.21

package/dist/adapters/s3.js

@@ -23,7 +23,17 @@ function createS3Adapter(config) {
             const publicUrl = `https://${config.bucket}.s3.${config.region}.amazonaws.com/${encodeURIComponent(key)}`;
             return { url, publicUrl };
         },
-        async getPresignedUrl(filename, contentType, projectId) {
+        async deleteProjectImage(projectId) {
+            const key = `${projectId}/project-image`;
+            const command = new client_s3_1.DeleteObjectsCommand({
+                Bucket: config.bucket,
+                Delete: {
+                    Objects: [{ Key: key }],
+                },
+            });
+            await s3.send(command);
+        },
+        async getPresignedUrl(contentType, projectId) {
             const key = `${projectId}/${contentType}/file-${Date.now()}`;
             const command = new client_s3_1.PutObjectCommand({
                 Bucket: config.bucket,

package/dist/middleware/createRouter.d.ts

@@ -1,5 +1,2 @@
-import { Router } from 'express';
-import { StreamByConfig, StorageAdapter } from '../types';
-export declare function createStreamByRouter(config: StreamByConfig & {
-    adapter?: StorageAdapter;
-}): Router;
+import type { StreamByConfig } from '../types';
+export declare function createStreamByRouter(config: StreamByConfig): import("express-serve-static-core").Router;

package/dist/middleware/createRouter.js

@@ -5,147 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStreamByRouter = createStreamByRouter;
 const express_1 = __importDefault(require("express"));
-const s3_1 = require("../adapters/s3");
-const file_1 = require("../services/file");
 const project_1 = require("../services/project");
-const presign_1 = require("../services/presign");
 function createStreamByRouter(config) {
-    const router = express_1.default.Router();
-    const adapter = config.adapter || (() => {
-        switch (config.storageProvider.type) {
-            case 's3':
-                return (0, s3_1.createS3Adapter)(config.storageProvider.config);
-            default:
-                throw new Error('Unsupported storage type');
-        }
-    })();
-    router.get('/auth', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            res.status(200).json({ logged: true, ...auth });
-        }
-        catch (err) {
-            res.status(401).json({ logged: false });
-        }
-    });
-    router.get('/upload-project-image-url/:id', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            if (!projectId) {
-                return res.status(400).json({ error: 'Missing filename, contentType, or projectId' });
-            }
-            const url = await (0, presign_1.getPresignedProjectImageUrl)(adapter, projectId);
-            res.json(url);
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to generate presigned URL', details: err.message });
-        }
-    });
-    router.post('/upload-url', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
-            }
-            const { filename, contentType, projectId } = req.body;
-            if (!filename || !contentType || !projectId) {
-                return res.status(400).json({ error: 'Missing filename, contentType, or projectId' });
-            }
-            const url = await (0, presign_1.getPresignedUrl)(adapter, filename, contentType, projectId);
-            res.json(url);
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to generate presigned URL', details: err.message });
-        }
-    });
-    router.get('/files', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            const projectId = (req.query.projectId || req.headers['x-project-id']);
-            if (!projectId || !auth.projects.includes(projectId)) {
-                return res.status(403).json({ error: 'Unauthorized or missing projectId' });
-            }
-            const files = await (0, file_1.listFilesService)(adapter, req, projectId);
-            res.json(files);
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to list files', details: err });
-        }
-    });
-    router.patch('/projects/:id', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
-            }
-            const projectId = req.params.id;
-            const updates = req.body;
-            if (!updates || typeof updates !== 'object') {
-                return res.status(400).json({ error: 'Missing updates payload' });
-            }
-            const updated = await config.projectProvider.update(projectId, updates);
-            res.status(200).json({ success: true, project: updated });
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to update project', details: err.message });
-        }
-    });
-    router.get('/projects/:id', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            const projectId = req.params.id;
-            const project = await config.projectProvider.getById(projectId);
-            const isMember = project.members?.some((m) => m.userId?.toString() === auth.userId?.toString());
-            if (!isMember) {
-                return res.status(403).json({ error: 'Unauthorized project access' });
-            }
-            res.json({ project });
-        }
-        catch (err) {
-            res.status(404).json({ error: 'Project not found', details: err.message });
-        }
-    });
-    router.post('/projects/create', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
-            }
-            const created = await (0, project_1.createProjectService)(req, config.authProvider, config.projectProvider);
-            res.status(201).json(created);
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to create project', details: err.message });
-        }
-    });
-    router.delete('/projects/:id', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            const projectId = req.params.id;
-            if (auth.role !== 'admin' && auth.role !== 'editor') {
-                return res.status(403).json({ error: 'Permission denied' });
-            }
-            await config.projectProvider.delete(projectId);
-            await adapter.deleteProjectDirectory(projectId);
-            res.status(200).json({ success: true });
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to delete project', details: err.message });
-        }
-    });
-    router.get('/projects', async (req, res) => {
-        try {
-            const auth = await config.authProvider(req);
-            const projects = await config.projectProvider.list(auth.userId);
-            res.json({ projects });
-        }
-        catch (err) {
-            res.status(500).json({ error: 'Failed to list projects', details: err });
-        }
-    });
-    return router;
+    const app = express_1.default.Router();
+    app.post('/project', (req, res) => {
+        (0, project_1.createProjectService)(req, config.authProvider, config.projectProvider)
+            .then((result) => res.json(result))
+            .catch((err) => res.status(400).json({ error: err.message }));
+    });
+    app.put('/project/:projectId', (req, res) => {
+        (0, project_1.updateProjectService)(req, config.authProvider, config.projectProvider)
+            .then((result) => res.json(result))
+            .catch((err) => res.status(400).json({ error: err.message }));
+    });
+    app.delete('/project/:projectId/image', (req, res) => {
+        (0, project_1.deleteProjectImageService)(req, config.authProvider, config.projectProvider, config.storageAdapter)
+            .then((result) => res.json(result))
+            .catch((err) => res.status(400).json({ error: err.message }));
+    });
+    return app;
 }

package/dist/services/file.d.ts

@@ -1,3 +1,4 @@
 import { StorageAdapter } from '../types';
 import { Request } from 'express';
 export declare function listFilesService(adapter: StorageAdapter, req: Request, projectId: string): Promise<any[]>;
+export declare function deleteProjectImage(adapter: StorageAdapter, projectId: string): Promise<any>;

package/dist/services/file.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listFilesService = listFilesService;
+exports.deleteProjectImage = deleteProjectImage;
 async function listFilesService(adapter, req, projectId) {
     return adapter.listFiles(projectId);
 }
+async function deleteProjectImage(adapter, projectId) {
+    if (!('deleteProjectImage' in adapter)) {
+        throw new Error('StorageAdapter does not support deleting project images');
+    }
+    return adapter.deleteProjectImage(projectId);
+}

package/dist/services/presign.d.ts

@@ -1,3 +1,3 @@
 import { StorageAdapter } from '../types';
-export declare function getPresignedUrl(adapter: StorageAdapter, filename: string, contentType: string, projectId: string): Promise<any>;
+export declare function getPresignedUrl(adapter: StorageAdapter, contentType: string, projectId: string): Promise<any>;
 export declare function getPresignedProjectImageUrl(adapter: StorageAdapter, projectId: string): Promise<any>;

package/dist/services/presign.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPresignedUrl = getPresignedUrl;
 exports.getPresignedProjectImageUrl = getPresignedProjectImageUrl;
-async function getPresignedUrl(adapter, filename, contentType, projectId) {
+async function getPresignedUrl(adapter, contentType, projectId) {
     if (!('getPresignedUrl' in adapter)) {
         throw new Error('StorageAdapter does not support presigned URLs');
     }
-    return adapter.getPresignedUrl(filename, contentType, projectId);
+    return adapter.getPresignedUrl(contentType, projectId);
 }
 async function getPresignedProjectImageUrl(adapter, projectId) {
     if (!('getPresignedProjectImageUrl' in adapter)) {

package/dist/services/project.d.ts

@@ -1,6 +1,13 @@
 import { Request } from 'express';
-import { AuthProvider, ProjectProvider } from '../types';
+import { AuthProvider, ProjectProvider, StorageAdapter } from '../types';
 export declare function createProjectService(req: Request, authProvider: AuthProvider, projectProvider: ProjectProvider): Promise<{
     success: boolean;
     project: import("../types").ProjectInfo;
 }>;
+export declare function updateProjectService(req: Request, authProvider: AuthProvider, projectProvider: ProjectProvider): Promise<{
+    success: boolean;
+    project: import("../types").ProjectInfo;
+}>;
+export declare function deleteProjectImageService(req: Request, authProvider: AuthProvider, projectProvider: ProjectProvider, storageAdapter: StorageAdapter): Promise<{
+    success: boolean;
+}>;

package/dist/services/project.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProjectService = createProjectService;
+exports.updateProjectService = updateProjectService;
+exports.deleteProjectImageService = deleteProjectImageService;
+const file_1 = require("./file");
 async function createProjectService(req, authProvider, projectProvider) {
     const { name, description } = req.body;
     const auth = await authProvider(req);
@@ -17,3 +20,33 @@ async function createProjectService(req, authProvider, projectProvider) {
         project: newProject,
     };
 }
+async function updateProjectService(req, authProvider, projectProvider) {
+    const { projectId } = req.params;
+    const updates = req.body;
+    const auth = await authProvider(req);
+    const project = await projectProvider.getById(projectId);
+    if (!project) {
+        throw new Error('Project not found');
+    }
+    if (!project.members?.find((e) => e.userId === auth.userId)) {
+        throw new Error('Unauthorized');
+    }
+    const updatedProject = await projectProvider.update(projectId, updates);
+    return {
+        success: true,
+        project: updatedProject,
+    };
+}
+async function deleteProjectImageService(req, authProvider, projectProvider, storageAdapter) {
+    const { projectId } = req.params;
+    const auth = await authProvider(req);
+    const project = await projectProvider.getById(projectId);
+    if (!project) {
+        throw new Error('Project not found');
+    }
+    if (!project.members?.find((e) => e.userId === auth.userId)) {
+        throw new Error('Unauthorized');
+    }
+    await (0, file_1.deleteProjectImage)(storageAdapter, projectId);
+    return { success: true };
+}

package/dist/types/index.d.ts

@@ -9,8 +9,9 @@ export interface S3Config {
 export type StorageProviderType = 's3';
 export interface StorageAdapter {
     listFiles(projectId: string): Promise<any[]>;
+    deleteProjectImage: (projectId: string) => Promise<any>;
     deleteProjectDirectory: (projectId: string) => Promise<any>;
-    getPresignedUrl?: (filename: string, contentType: string, projectId: string) => Promise<any>;
+    getPresignedUrl?: (contentType: string, projectId: string) => Promise<any>;
     getPresignedProjectImageUrl?: (projectId: string) => Promise<any>;
 }
 export interface ProjectInfo {
@@ -39,6 +40,7 @@ export interface StreamByConfig {
         config: S3Config;
     };
     authProvider: AuthProvider;
+    storageAdapter: StorageAdapter;
     projectProvider: ProjectProvider;
     dbConnection?: Connection;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",