Add possabilit to follow users

.github/workflows/check.yml

@@ -0,0 +1,34 @@
+name: checks
+
+on:
+  pull_request:
+    branches:
+      - master
+      - dev
+  push:
+    branches:
+      - master
+
+jobs:
+  linting:
+    name: linting
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+
+      # run eslint and prettier on the frontend and api
+      - run: bun install && bun lint && bun format:check
+        working-directory: ./frontend
+      - run: bun install && bun format:check
+        working-directory: ./api
+  testing:
+    name: testing
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+
+      # run tests on the api
+      - run: bun install && bun test
+        working-directory: ./api

README.md

@@ -37,7 +37,9 @@ Currently optimised mobile devices are:
 
 #### Running the api
 - go into the directory `cd api`
+- copy the `.env.example` file to `.env` and fill in the values
 - run `bun install` to install the dependencies
+- run `bun drizzle:push` to push the database schema to the database
 - run `bun dev` to start the api
 
 #### Running the frontend

api/eslint.config.js

@@ -1,12 +1,32 @@
-import globals from "globals";
-import pluginJs from "@eslint/js";
-import tseslint from "typescript-eslint";
-
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+import tseslint from 'typescript-eslint'
 
 /** @type {import('eslint').Linter.Config[]} */
 export default [
-  {files: ["**/*.{js,mjs,cjs,ts}"]},
-  {languageOptions: { globals: globals.browser }},
+  { files: ['**/*.{js,mjs,cjs,ts}'] },
+  { languageOptions: { globals: globals.browser } },
   pluginJs.configs.recommended,
   ...tseslint.configs.recommended,
-];
+  {
+    name: 'app/files-to-ignore',
+    ignores: ['**/dist/**', '**/dist-ssr/**', '**/coverage/**', 'pm2.config.js']
+  },
+  {
+    rules: {
+      'no-unused-vars': ['off'],
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          args: 'all',
+          argsIgnorePattern: '^_',
+          caughtErrors: 'all',
+          caughtErrorsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          ignoreRestSiblings: true
+        }
+      ]
+    }
+  }
+]

api/package.json

@@ -8,7 +8,11 @@
     "test": "bun test",
     "drizzle:push": "drizzle-kit push",
     "drizzle:migrate": "drizzle-kit migrate",
-    "drizzle:generate": "drizzle-kit generate"
+    "drizzle:generate": "drizzle-kit generate",
+    "lint": "bunx eslint .",
+    "lint:fix": "bunx eslint --fix .",
+    "format": "bunx prettier . --write",
+    "format:check": "prettier --check ."
   },
   "type": "module",
   "devDependencies": {

api/src/db/schema.ts

@@ -1,40 +1,61 @@
-import { relations, eq, sql } from 'drizzle-orm'
+import { relations, sql } from 'drizzle-orm'
 import { boolean, text, serial, pgTable as table, timestamp, integer, pgView } from 'drizzle-orm/pg-core'
 
 export const users = table('users', {
   id: serial().primaryKey(),
   name: text().notNull(),
+  displayName: text('display_name').notNull().unique(),
   webId: text('web_id').notNull().unique(),
   email: text('email').notNull().unique(),
-  providerEndpoint: text('provider_endpoint').notNull(),
+  providerName: text('provider_name').notNull() // This is done so there is no import here. It crashes the drizzle:push command
 })
 
-export const usersRelations = relations(users, ({one}) => ({
-  posts: one(posts),
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+  followers: many(users)
 }))
 
+export const followers = table('followers', {
+  followerId: integer('follower_id')
+    .notNull()
+    .references(() => users.id),
+  followedId: integer('followed_id')
+    .notNull()
+    .references(() => users.id)
+})
+
 export const posts = table('posts', {
   id: serial().primaryKey(),
   content: text().notNull(),
   createdAt: timestamp('created_at', { withTimezone: true }).defaultNow(),
   isPublic: boolean('is_public').notNull(),
-  authorId: integer('author_id').notNull().references(() => users.id),
+  authorId: integer('author_id').notNull()
 })
 
+export const postsRelations = relations(posts, ({ one }) => ({
+  author: one(users, {
+    fields: [posts.authorId],
+    references: [users.id]
+  })
+}))
+
+// Views
 export const postsView = pgView('posts_view', {
   id: serial().primaryKey(),
   content: text().notNull(),
   createdAt: timestamp('created_at', { withTimezone: true }).defaultNow(),
   isPublic: boolean('is_public').notNull(),
-  authorId: integer('author_id').notNull().references(() => users.id),
-  authorName: text("author_name").notNull(),
+  authorId: integer('author_id')
+    .notNull()
+    .references(() => users.id),
+  authorName: text('author_name').notNull(),
   authorWebId: text('author_web_id').notNull().unique(),
-  authorProviderEndpoint: text('author_provider_endpoint').notNull(),
+  authorProviderEndpoint: text('author_provider_endpoint').notNull()
 }).as(sql`SELECT
     posts.*,
     users.name as author_name,
     users.web_id as author_web_id,
-    users.provider_endpoint as author_provider_endpoint
+    users.provider_name as author_provider_name
   FROM posts
   INNER JOIN users on posts.author_id = users.id
   WHERE posts.is_public = true`)

api/src/decorater/User.ts

@@ -1,52 +1,52 @@
-import type { SelectUsers } from "../types"
+import { encodeWebId } from '@/util/user'
+import { podProviderEndpoint, ViablePodProvider, type SelectUsers } from '../types'
 
 export default class User {
-  userId: number
-  userName: string
-  token: string
-  endpoint: string
+  userId: number = 0
+  username: string = ''
+  token: string = ''
+  provider: string = ''
+  endpoint: string = ''
+  webId: string = ''
+  providerWebId: string = ''
 
   constructor(dbUser?: SelectUsers, token?: string) {
-    this.userId = 0
-    this.userName = ''
-    this.token = ''
-    this.endpoint = ''
-
     if (dbUser) {
       this.userId = dbUser.id
-      this.userName = dbUser.name
-      this.endpoint = dbUser.providerEndpoint
+      this.username = dbUser.name
+      this.provider = dbUser.providerName
+      this.computeValues()
     }
     if (token) {
       this.token = token
     }
   }
 
-  loadUser(oldUser: User) {
-    this.userId = oldUser.userId
-    this.userName = oldUser.userName
-    this.token = oldUser.token
-    this.endpoint = oldUser.endpoint
+  loadUser(oldUser: string) {
+    const newUser = JSON.parse(oldUser)
+    this.userId = newUser.userId
+    this.username = newUser.username
+    this.token = newUser.token
+    this.provider = newUser.provider
+    this.computeValues()
   }
 
-  getWebId() {
-    return `${this.endpoint}/${this.userName}`
+  private computeValues() {
+    this.endpoint = podProviderEndpoint[this.provider as ViablePodProvider]
+    this.webId = encodeWebId(this)
+    this.providerWebId = this.endpoint + '/' + this.username
   }
 
-  setUser(userId: number, userName: string, token: string, endpoint: string) {
-    this.userId = userId
-    this.userName = userName
-    this.token = token
-    this.endpoint = endpoint
-  }
-
-  setUsername(userName: string) {
-    const userIdSplit = userName.split('/')
-    this.userName = userName
-    this.endpoint = userIdSplit[userIdSplit.length - 2]
+  getWebId() {
+    return encodeWebId(this)
   }
 
-  setToken(token: string) {
-    this.token = token
+  toString() {
+    return JSON.stringify({
+      userId: this.userId,
+      username: this.username,
+      token: this.token,
+      provider: this.provider
+    })
   }
 }

api/src/index.ts

@@ -1,30 +1,14 @@
 import { Elysia } from 'elysia'
 import { drizzle } from 'drizzle-orm/node-postgres'
-import { _createPost, _selectUsers } from './types'
-import { postsPlugin, authPlugin, setupPlugin } from './routes'
+import { postsPlugin, authPlugin, setupPlugin, usersPlugin } from './routes'
 
 export const db = drizzle({ connection: process.env.DB_URL || '', casing: 'snake_case' })
 
 export const app = new Elysia()
   .use(setupPlugin)
-  .macro({
-    isSignedIn: enabled => {
-      if (!enabled) return
-
-      return {
-        async beforeHandle({ headers: { auth }, jwt, error, user }) {
-          const authValue = await jwt.verify(auth)
-          if (!authValue) {
-            return error(401, 'You must be signed in to do that')
-          } else {
-            user.loadUser(JSON.parse(authValue.user as string))
-          }
-        }
-      }
-    }
-  })
   .use(authPlugin)
   .use(postsPlugin)
+  .use(usersPlugin)
   .listen(process.env.API_PORT || 8796)
 
 console.info(`Listening on port ${process.env.API_PORT}`)