streamby-core 0.9.21 → 0.10.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { initProjectModel } from './db/initProjectModel';
-export { createStreamByRouter } from './middleware/createRouter';
-export { createMongoProjectProvider } from './providers/mongoProjectProvider';
+import { StreamByConfig, StorageAdapter } from './types';
+export declare function createStreamByApp(config: StreamByConfig & {
+    adapter?: StorageAdapter;
+}): import("express-serve-static-core").Express;

package/dist/index.js

@@ -1,9 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMongoProjectProvider = exports.createStreamByRouter = exports.initProjectModel = void 0;
-var initProjectModel_1 = require("./db/initProjectModel");
-Object.defineProperty(exports, "initProjectModel", { enumerable: true, get: function () { return initProjectModel_1.initProjectModel; } });
-var createRouter_1 = require("./middleware/createRouter");
-Object.defineProperty(exports, "createStreamByRouter", { enumerable: true, get: function () { return createRouter_1.createStreamByRouter; } });
-var mongoProjectProvider_1 = require("./providers/mongoProjectProvider");
-Object.defineProperty(exports, "createMongoProjectProvider", { enumerable: true, get: function () { return mongoProjectProvider_1.createMongoProjectProvider; } });
+exports.createStreamByApp = createStreamByApp;
+const express_1 = __importDefault(require("express"));
+const createRouter_1 = require("./middleware/createRouter");
+function createStreamByApp(config) {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    app.use((0, createRouter_1.createStreamByRouter)(config));
+    return app;
+}

package/dist/middleware/createRouter.d.ts

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

package/dist/middleware/createRouter.js

@@ -5,23 +5,174 @@ 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 isProjectMember(project, userId) {
+    return project.members?.some((m) => m.userId?.toString() === userId?.toString());
+}
 function createStreamByRouter(config) {
-    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;
+    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 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.delete('/delete-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 projectId' });
+            }
+            await (0, file_1.deleteProjectImage)(adapter, projectId);
+            const updated = await (0, project_1.deleteProjectImageService)(req, config.authProvider, config.projectProvider);
+            res.status(201).json(updated);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to delete image', 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, contentType, projectId);
+            res.json(url);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to generate upload 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);
+            if (!project) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            if (!isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            res.json({ project });
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to fetch project', 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;
+            const project = await config.projectProvider.getById(projectId);
+            if (!project) {
+                return res.status(404).json({ error: 'Project not found' });
+            }
+            if (!isProjectMember(project, auth.userId)) {
+                return res.status(403).json({ error: 'Unauthorized project access' });
+            }
+            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;
 }

package/dist/services/auth.d.ts

@@ -2,3 +2,4 @@ import { Request } from 'express';
 import { StreamByConfig, AuthContext } from '../types';
 export declare function resolveAuth(config: StreamByConfig, req: Request): Promise<AuthContext>;
 export declare function checkRole(auth: AuthContext, required: 'viewer' | 'editor' | 'admin'): void;
+export declare function dummyAuthProvider(req: Request): Promise<AuthContext>;

package/dist/services/auth.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAuth = resolveAuth;
 exports.checkRole = checkRole;
+exports.dummyAuthProvider = dummyAuthProvider;
 async function resolveAuth(config, req) {
     const auth = await config.authProvider(req);
     if (!auth ||
@@ -21,3 +22,11 @@ function checkRole(auth, required) {
         throw new Error(`Insufficient role: requires ${required}, found ${auth.role}`);
     }
 }
+async function dummyAuthProvider(req) {
+    return {
+        userId: '67ad0832cae5e7e270ee086a',
+        username: 'dev-user',
+        projects: [],
+        role: 'admin'
+    };
+}

package/dist/services/project.d.ts

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

package/dist/services/project.js

@@ -3,7 +3,6 @@ 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);
@@ -37,7 +36,7 @@ async function updateProjectService(req, authProvider, projectProvider) {
         project: updatedProject,
     };
 }
-async function deleteProjectImageService(req, authProvider, projectProvider, storageAdapter) {
+async function deleteProjectImageService(req, authProvider, projectProvider) {
     const { projectId } = req.params;
     const auth = await authProvider(req);
     const project = await projectProvider.getById(projectId);
@@ -47,6 +46,8 @@ async function deleteProjectImageService(req, authProvider, projectProvider, sto
     if (!project.members?.find((e) => e.userId === auth.userId)) {
         throw new Error('Unauthorized');
     }
-    await (0, file_1.deleteProjectImage)(storageAdapter, projectId);
-    return { success: true };
+    await projectProvider.update(projectId, { image: '' });
+    return {
+        success: true,
+    };
 }

package/dist/types/index.d.ts

@@ -40,7 +40,6 @@ 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.21",
+  "version": "0.10.00",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
   "scripts": {
     "build": "tsc",
     "test": "vitest",
-    "dev": "tsc --watch",
+    "dev": "ts-node-dev --respawn --clear dev.ts",
     "prepublishOnly": "npm run build"
   },
   "repository": {
@@ -32,14 +32,17 @@
     "@aws-sdk/client-s3": "^3.528.0",
     "@aws-sdk/s3-request-presigner": "^3.787.0",
     "bcrypt": "^5.1.1",
+    "dotenv": "^16.5.0",
     "express": "^4.0.0",
     "mongoose": "^8.13.2"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",
     "@types/express": "^4.17.17",
+    "@types/node": "^22.15.21",
     "@types/supertest": "^6.0.3",
     "supertest": "^7.1.0",
+    "ts-node-dev": "^2.0.0",
     "typescript": "^5.8.3",
     "vitest": "^3.1.1"
   },