initial commit

Author: asomoza

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+store/
+dist/

environment.d.ts

@@ -0,0 +1,11 @@
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      PORT: string;
+      SALT_ROUNDS: string;
+      SESSION_SECRET: string;
+    }
+  }
+}
+
+export {}

package.json

@@ -0,0 +1,32 @@
+{
+  "name": "z-home-media-server-api",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "start": "nodemon server/server.ts"
+  },
+  "dependencies": {
+    "bcrypt": "^5.0.1",
+    "connect-redis": "^6.1.3",
+    "cookie-parser": "^1.4.6",
+    "cors": "^2.8.5",
+    "dotenv": "^16.0.1",
+    "express": "^4.18.1",
+    "express-session": "^1.17.3",
+    "mongodb": "4.7",
+    "redis": "^4.1.1"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.0",
+    "@types/connect-redis": "^0.0.18",
+    "@types/cookie-parser": "^1.4.3",
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "@types/express-session": "^1.17.4",
+    "@types/mongodb": "^4.0.7",
+    "@types/node": "^18.0.1",
+    "nodemon": "^2.0.16",
+    "ts-node": "^10.8.1",
+    "typescript": "^4.7.4"
+  }
+}

server/db/mongo.ts

@@ -0,0 +1,24 @@
+const { MongoClient } = require("mongodb");
+
+const uri = "mongodb://localhost:27017/?readPreference=primary&ssl=false";
+
+const client = new MongoClient(uri);
+
+let dbConnection: any;
+
+export function connectToServer (callback: any) {
+  client.connect(function (err: undefined, db: { db: (arg0: string) => any; }) {
+    if (err || !db) {
+      return callback(err);
+    }
+
+    dbConnection = db.db("zHomeMedia");
+    console.log("Successfully connected to MongoDB.");
+
+    return callback();
+  });
+}
+
+export function getDb () {
+  return dbConnection;
+}

server/endpoints/auth.ts

@@ -0,0 +1,75 @@
+import express from 'express';
+import { getDb } from '../db/mongo';
+import dotenv from 'dotenv';
+import bcrypt from 'bcrypt';
+
+dotenv.config();
+
+const auth = express.Router();
+// const saltRounds = Number(process.env.SALT_ROUNDS);
+
+declare module 'express-session' {
+  interface SessionData {
+    userId: string;
+    user: string;
+  }
+}
+
+auth.post('/', function (req, res) {
+  const { user, password, remember } = req.body;
+
+  if (
+    user !== undefined &&
+    user.length > 0 &&
+    password !== undefined &&
+    password.length > 0
+  ) {
+    const db = getDb();
+
+    db.collection('users')
+      .findOne({ username: user })
+      .then((dbResult: any) => {
+        if (dbResult !== null) {
+          bcrypt.compare(
+            password,
+            dbResult.password,
+            function (_err, authResult) {
+              if (authResult) {
+                req.session.userId = dbResult._id;
+                req.session.user = dbResult.username;
+                res.json({ user: dbResult.username });
+                return;
+              }
+
+              res.status(400).send('Invalid credentials');
+            }
+          );
+
+          return;
+        }
+
+        res.status(400).send('Invalid credentials');
+      });
+
+    return;
+  }
+
+  res.status(400).send('Invalid credentials');
+});
+
+auth.get('/logout', function (req, res) {
+  req.session.destroy(() => {
+    res.sendStatus(200);
+  });
+});
+
+auth.get('/info', function (req, res) {
+  if (req.session.userId === undefined) {
+    res.status(400).send('Invalid credentials');
+    return;
+  }
+
+  res.json({user: req.session.user});
+});
+
+export default auth;

server/endpoints/image.ts

@@ -0,0 +1,15 @@
+import express from 'express';
+import fs from 'fs';
+
+const image = express.Router();
+
+image.get('/image/:imageId', function (req, res) {
+  const imageId = parseInt(req.params.imageId);
+  let filename = imageId + '.jpg';
+
+  var img = fs.readFileSync('store/images/files/' + filename);
+  res.writeHead(200, { 'Content-Type': 'image/jpg' });
+  res.end(img, 'binary');
+});
+
+export default image;

server/endpoints/video.ts

@@ -0,0 +1,47 @@
+import express from 'express';
+import fs from 'fs';
+import {getDb} from '../db/mongo';
+
+const video = express.Router();
+
+video.get('/:videoId/info', function (req, res) {
+  const db = getDb();
+
+  const uuid = req.params.videoId;
+
+  db.collection('videos')
+    .findOne({ uuid: uuid })
+    .then((result: any) => {
+      res.json(result);
+    });
+});
+
+video.get('/:videoId', function (req, res) {
+  let range = req.headers.range;
+
+  if (range === undefined) {
+    res.status(400).send('Requires Range header');
+    return;
+  }
+
+  const videoId = req.params.videoId;
+  let filename = videoId;
+
+  const videoPath = 'store/videos/files/' + filename;
+  const videoSize = fs.statSync('store/videos/files/' + filename).size;
+  const CHUNK_SIZE = 10 ** 6;
+  const start = Number(range.replace(/\D/g, ''));
+  const end = Math.min(start + CHUNK_SIZE, videoSize - 1);
+  const contentLength = end - start + 1;
+  const headers = {
+    'Content-Range': `bytes ${start}-${end}/${videoSize}`,
+    'Accept-Ranges': 'bytes',
+    'Content-Length': contentLength,
+    'Content-Type': 'video/mp4',
+  };
+  res.writeHead(206, headers);
+  const videoStream = fs.createReadStream(videoPath, { start, end });
+  videoStream.pipe(res);
+});
+
+export default video;

server/endpoints/videos.ts

@@ -0,0 +1,30 @@
+import express from 'express';
+import fs from 'fs';
+import { getDb } from '../db/mongo';
+
+const videos = express.Router();
+
+videos.get('/', function (_req, res) {
+  const db = getDb();
+
+  db.collection('videos')
+    .find({})
+    .toArray(function (err: any, result: any) {
+      if (err) {
+        res.status(400).send('Error fetching listings!');
+      } else {
+        res.json({items: result});
+      }
+    });
+});
+
+videos.get('/thumb/:videoId', function (req, res) {
+  const videoId = req.params.videoId;
+  let filename = videoId;
+
+  var img = fs.readFileSync('store/videos/thumbs/' + filename);
+  res.writeHead(200, { 'Content-Type': 'image/png' });
+  res.end(img, 'binary');
+});
+
+export default videos;

server/middleware/requireAuth.ts

@@ -0,0 +1,18 @@
+import { Request, Response, NextFunction } from 'express';
+
+function requireAuth (req: Request, res: Response, next: NextFunction) {
+  // console.log(req.path);
+  // console.log(req.session);
+
+  if (req.path !== '/api/auth') {
+    if (req.session.userId === undefined) {
+      console.log('Bloqued request!');
+      res.status(400).send('Invalid user');
+      return;
+    }
+  }
+
+  next()
+}
+
+export default requireAuth;

server/server.ts

@@ -0,0 +1,66 @@
+import express from 'express';
+import dotenv from 'dotenv';
+import cors from 'cors';
+import { connectToServer } from './db/mongo';
+import cookieParser from 'cookie-parser';
+import auth from './endpoints/auth';
+import video from './endpoints/video';
+import videos from './endpoints/videos';
+import image from './endpoints/image';
+import requireAuth from './middleware/requireAuth';
+import connectRedis from 'connect-redis';
+import { createClient } from 'redis';
+import session from 'express-session';
+
+const RedisStore = connectRedis(session);
+const redisClient = createClient({ legacyMode: true });
+redisClient
+  .connect()
+  .then(() => {
+    console.log('redis connected');
+  })
+  .catch(console.error);
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT;
+const allowedOrigins = ['http://localhost', 'http://localhost:8080'];
+
+const options: cors.CorsOptions = {
+  origin: allowedOrigins,
+  credentials: true,
+};
+
+app.use(
+  session({
+    store: new RedisStore({ client: redisClient }),
+    secret: process.env.SESSION_SECRET as string,
+    resave: false,
+    saveUninitialized: false,
+    cookie: {
+      secure: false,  // Change in production
+      httpOnly: true,
+    },
+  })
+);
+app.use(cors(options));
+app.use(cookieParser());
+app.use(requireAuth);
+app.use(express.json());
+
+app.use('/api/auth', auth);
+app.use('/api/video', video);
+app.use('/api/videos', videos);
+app.use('/api/image', image);
+
+connectToServer(function (error: any) {
+  if (error) {
+    console.log(error);
+    process.exit();
+  }
+
+  app.listen(port, function () {
+    console.log(`[server]: Server is running on port ${port}`);
+  });
+});

tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "exclude": ["node_modules", "**/node_modules/*"],
+}