progress init

src/db/schemas.js

@@ -17,13 +17,13 @@ export const sessions = pgTable("sessions", {
   expires_at: timestamp("expires_at")
 })
 
-export const site = pgTable("sites", {
+export const sites = pgTable("sites", {
   id: uuid("id").defaultRandom().primaryKey(),
   user_id: uuid("user_id").references(() => users.id),
   name: text("name")
 })
 
-export const article = pgTable("articles", {
+export const articles = pgTable("articles", {
   id: uuid("id").defaultRandom().primaryKey(),
   site_id: uuid("site_id").references(() => site.id),
   content: text("content"),

src/index.js

@@ -1,5 +1,5 @@
 import { initDb } from "./db/index.js";
-import { channelRoutes, authRoutes, videoRoutes, meRoutes } from "./routes/index.js";
+import { channelRoutes, authRoutes, videoRoutes, meRoutes, blogRoutes } from "./routes/index.js";
 import { env, Logger, Redis } from "./utils/index.js";
 import fastify from "fastify";
 import { middleware } from "./modules/middleware.js";
@@ -67,6 +67,10 @@ export const main = async () => {
     prefix: `/me`
   });
 
+  server.register(blogRoutes, {
+    prefix: `/blog`
+  });
+
   server.get("/hello", (req, res) => {
     res.send({message: "world", cookies: req.cookies});
   })

src/modules/middleware.js

@@ -5,7 +5,7 @@ import { db } from "../db/index.js";
 import { sessions } from "../db/schemas.js";
 import { eq } from "drizzle-orm";
 
-const middleware = fp(
+export const middleware = fp(
   /**
    * @param {FastifyInstance} fastify 
    * @param {unknown} _options 
@@ -17,31 +17,33 @@ const middleware = fp(
     });
   });
 
-const authMiddleware = fp(
+export const authMiddlewareFn = async (request, response) => {
-  async (fastify, _options) => {
+  try {
-    fastify.addHook("preValidation", async (request, response) => {
+    // if (!request.headers.authorization || !request.headers.authorization.startsWith("Bearer")) {
-      try {
+    if (!request.cookies.token) {
-        // if (!request.headers.authorization || !request.headers.authorization.startsWith("Bearer")) {
+      response.status(401).send({ success: false, message: "Missing authentication token" });
-        if(!request.cookies.token) {
+      return false;
-          response.status(401).send({ success: false, message: "Missing authentication token" });
+    }
-          return;
+    // const token = request.headers.authorization.split(" ")[1];
-        }
+    const token = request.cookies.token;
-        // const token = request.headers.authorization.split(" ")[1];
-        const token = request.cookies.token;
 
-        const session = await db.select().from(sessions).where(eq(sessions.id, token));
+    const session = await db.select().from(sessions).where(eq(sessions.id, token));
-        if(session.length == 0) {
+    if (session.length == 0) {
-          response.status(401).send({ success: false, message: "Invalid authentication token" });
+      response.status(401).send({ success: false, message: "Invalid authentication token" });
-          return;
+      return false;
-        }
+    }
-        // console.log(token);
+    // console.log(token);
-        // console.log(session);
+    // console.log(session);
-        request.session = session[0];
+    request.session = session[0];
-      } catch (e) {
+    return true;
-        console.log(e);
+  } catch (e) {
-      }
+    console.log(e);
-    });
+  }
+}
+
+export const authMiddleware = fp(
+  async (fastify, _options) => {
+    fastify.addHook("preValidation", authMiddlewareFn);
   }
 )
 
-export { middleware, authMiddleware };

src/routes/auth.js

@@ -1,10 +1,7 @@
-import sget from 'simple-get';
 import { createSession as createSession } from '../utils/token.js';
-import { google } from 'googleapis';
 import { getChannelInfo, getUserInfo } from '../utils/youtube.js';
 import { db } from '../db/index.js';
 import { users as usersTable } from '../db/schemas.js';
-import { userInfo } from 'os';
 import { eq } from 'drizzle-orm';
 import { env } from '../utils/env.js';
 
@@ -55,11 +52,11 @@ export const authRoutes = (fastify, _, done) => {
             });
             
             response.setCookie("token", session_id, {
-                httpOnly: true,
+                httpOnly: false,
                 path: "/",
-                // sameSite: false,
+                sameSite: false,
                 maxAge: 1000 * 60 * 60 * 24 * 7,
-                domain: "api.omersabic.com"
+                domain: ".omersabic.com"
             }).redirect(env.FRONTEND_URL);
             // response.send({
             //     token: session_id

src/routes/blog.js

@@ -1,5 +1,8 @@
-import { authMiddleware } from "../modules/middleware.js";
+import { eq } from "drizzle-orm";
+import { db } from "../db/index.js";
+import { authMiddleware, authMiddlewareFn } from "../modules/middleware.js";
 import { getAccessToken, getChannelInfo } from "../utils/youtube.js";
+import { articles as articlesTable, sites } from "../db/schemas.js";
 
 /**
  * 
@@ -7,27 +10,63 @@ import { getAccessToken, getChannelInfo } from "../utils/youtube.js";
  * @param {unknown} _ 
  * @param {() => void} done 
  */
-export const channelRoutes = (fastify, _, done) => {
+export const blogRoutes = (fastify, _, done) => {
-    fastify.register(authMiddleware);
 
     fastify.get("/", async (request, response) => {
         try {
-            const mine = request.query.mine || true;
+            const mine = request.query.mine != 'false' || true;
-            const blog_id = request.query
+            const blog_id = request.query.blog_id;
-            if(mine && request)
+            if(!mine && !blog_id) {
+                response.send({
+                    success: false,
+                    message: "Request can either have \"mine\" set to true or provide a blog_id"
+                })
+            }
+            let clause;
 
-            const access_token = await getAccessToken(fastify, request);
+            if(mine) {
+                if(!(await authMiddlewareFn(request, response))) return;
+                clause = eq(sites.user_id, request.session.user_id);
+            }
 
-            const channel = await getChannelInfo(access_token);
+            if(mine == false) {
+                clause = eq(sites.user_id, request.query.blog_id);
+            }
+            // const access_token = await getAccessToken(fastify, request);
+
+            // const channel = await getChannelInfo(access_token);
+
+            const articles = await db.select().from(articlesTable).leftJoin(sites, articlesTable.site_id == sites.id).where(clause);
 
             response.send({
                 success: true,
-                channel
+                articles
             });
         } catch (e) {
             console.log(e);
         }
     });
 
+    fastify.post("/create", {
+        schema: {
+            body: {
+                youtube_url: {
+                    type: "string"
+                },
+                length: {
+                    type: ["string", null],
+                    enum: ["short", "medium", "long"]
+                },
+                format: {
+                    type: ["string", null]
+                }
+            }
+        }
+    }, async (req, reply) => {
+        reply.send()
+    })
+
+    fastify.register(authMiddleware);
+
     done();
 };

src/routes/index.js

@@ -2,3 +2,4 @@ export * from "./channels.js";
 export * from "./auth.js";
 export * from "./videos.js";
 export * from "./me.js";
+export * from "./blog.js"