create-snapify-app 0.0.0-stage → 1.1.0

package/template/server/community/routes.ts

@@ -0,0 +1,410 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import crypto from 'crypto';
+import { and, asc, count, desc, eq, ilike, inArray, isNull } from 'drizzle-orm';
+import { asyncRouter, HttpError, paging } from '../http';
+import { db } from '../db/client';
+import {
+  forumCategories,
+  forumLikes,
+  forumNotifications,
+  forumPosts,
+  forumReports,
+  forumSubscriptions,
+  forumTopics,
+  platformUsers,
+} from '../db/schema';
+import { platformAuthOptional, requirePlatformUser, requireRole, toPublicUser } from '../platform/auth';
+import { slugify } from '../platform/passwords';
+
+async function usersByIds(ids: string[]) {
+  if (!ids.length) return {};
+  const rows = await db.select().from(platformUsers).where(inArray(platformUsers.id, [...new Set(ids)]));
+  return Object.fromEntries(rows.map((u) => [u.id, toPublicUser(u)]));
+}
+
+async function notify(userId: string, type: string, payload: Record<string, unknown>) {
+  if (!userId) return;
+  await db.insert(forumNotifications).values({
+    id: crypto.randomUUID(),
+    userId,
+    type,
+    payload,
+  });
+}
+
+export function createCommunityRouter() {
+  const r = asyncRouter();
+
+  r.get('/stats', async (_req, res) => {
+    const [topics] = await db.select({ n: count() }).from(forumTopics);
+    const [posts] = await db.select({ n: count() }).from(forumPosts);
+    const [members] = await db.select({ n: count() }).from(platformUsers);
+    res.json({ topics: topics?.n || 0, posts: posts?.n || 0, members: members?.n || 0 });
+  });
+
+  r.get('/categories', async (_req, res) => {
+    const cats = await db.select().from(forumCategories).orderBy(asc(forumCategories.position));
+    const topicCounts = await db
+      .select({ categoryId: forumTopics.categoryId, n: count() })
+      .from(forumTopics)
+      .groupBy(forumTopics.categoryId);
+    const byCat = Object.fromEntries(topicCounts.map((t) => [t.categoryId, t.n]));
+    res.json({
+      items: cats.map((c) => ({ ...c, topicCount: byCat[c.id] || 0 })),
+    });
+  });
+
+  r.get('/topics', platformAuthOptional, async (req, res) => {
+    const { page, pageSize } = paging(req.query as Record<string, unknown>, 20);
+    const category = String(req.query.category || '');
+    const q = String(req.query.q || '').trim();
+    const sort = String(req.query.sort || 'recent');
+
+    const conditions = [];
+    if (category) {
+      const [cat] = await db.select().from(forumCategories).where(eq(forumCategories.slug, category)).limit(1);
+      if (cat) conditions.push(eq(forumTopics.categoryId, cat.id));
+    }
+    if (q) conditions.push(ilike(forumTopics.title, `%${q}%`));
+
+    const where = conditions.length ? and(...conditions) : undefined;
+    const [totalRow] = await db.select({ n: count() }).from(forumTopics).where(where);
+    const order =
+      sort === 'popular'
+        ? [desc(forumTopics.views), desc(forumTopics.lastPostAt)]
+        : [desc(forumTopics.pinned), desc(forumTopics.lastPostAt)];
+
+    const rows = await db
+      .select()
+      .from(forumTopics)
+      .where(where)
+      .orderBy(...order)
+      .limit(pageSize)
+      .offset((page - 1) * pageSize);
+
+    const authors = await usersByIds(rows.map((t) => t.authorId));
+    const cats = await db.select().from(forumCategories);
+    const catMap = Object.fromEntries(cats.map((c) => [c.id, c]));
+    const postCounts = rows.length
+      ? await db
+          .select({ topicId: forumPosts.topicId, n: count() })
+          .from(forumPosts)
+          .where(inArray(forumPosts.topicId, rows.map((t) => t.id)))
+          .groupBy(forumPosts.topicId)
+      : [];
+    const pc = Object.fromEntries(postCounts.map((x) => [x.topicId, x.n]));
+
+    res.json({
+      items: rows.map((t) => ({
+        ...t,
+        author: authors[t.authorId] || null,
+        category: catMap[t.categoryId] || null,
+        replyCount: Math.max(0, (pc[t.id] || 1) - 1),
+      })),
+      page,
+      pageSize,
+      total: totalRow?.n || 0,
+    });
+  });
+
+  r.get('/topics/:slug', platformAuthOptional, async (req, res) => {
+    const [topic] = await db.select().from(forumTopics).where(eq(forumTopics.slug, req.params.slug)).limit(1);
+    if (!topic) throw new HttpError(404, 'Sujet introuvable');
+
+    await db.update(forumTopics).set({ views: topic.views + 1 }).where(eq(forumTopics.id, topic.id));
+
+    const { page, pageSize } = paging(req.query as Record<string, unknown>, 20);
+    const [totalRow] = await db.select({ n: count() }).from(forumPosts).where(eq(forumPosts.topicId, topic.id));
+    const posts = await db
+      .select()
+      .from(forumPosts)
+      .where(eq(forumPosts.topicId, topic.id))
+      .orderBy(asc(forumPosts.createdAt))
+      .limit(pageSize)
+      .offset((page - 1) * pageSize);
+
+    const authors = await usersByIds([topic.authorId, ...posts.map((p) => p.authorId)]);
+    const likes = posts.length
+      ? await db.select().from(forumLikes).where(inArray(forumLikes.postId, posts.map((p) => p.id)))
+      : [];
+    const likeCount = likes.reduce<Record<string, number>>((acc, l) => {
+      acc[l.postId] = (acc[l.postId] || 0) + 1;
+      return acc;
+    }, {});
+    const likedByMe = new Set(likes.filter((l) => l.userId === req.platformUser?.id).map((l) => l.postId));
+    const [cat] = await db.select().from(forumCategories).where(eq(forumCategories.id, topic.categoryId)).limit(1);
+    let subscribed = false;
+    if (req.platformUser) {
+      const [sub] = await db
+        .select()
+        .from(forumSubscriptions)
+        .where(and(eq(forumSubscriptions.topicId, topic.id), eq(forumSubscriptions.userId, req.platformUser.id)))
+        .limit(1);
+      subscribed = !!sub;
+    }
+
+    res.json({
+      topic: {
+        ...topic,
+        views: topic.views + 1,
+        author: authors[topic.authorId] || null,
+        category: cat || null,
+        subscribed,
+      },
+      posts: posts.map((p) => ({
+        ...p,
+        author: authors[p.authorId] || null,
+        likeCount: likeCount[p.id] || 0,
+        liked: likedByMe.has(p.id),
+      })),
+      page,
+      pageSize,
+      total: totalRow?.n || 0,
+    });
+  });
+
+  r.post('/topics', requirePlatformUser, async (req, res) => {
+    const title = String(req.body?.title || '').trim().slice(0, 200);
+    const body = String(req.body?.body || '').trim();
+    const categorySlug = String(req.body?.category || '');
+    if (title.length < 3) throw new HttpError(422, 'Titre trop court');
+    if (body.length < 3) throw new HttpError(422, 'Message trop court');
+    const [cat] = await db.select().from(forumCategories).where(eq(forumCategories.slug, categorySlug)).limit(1);
+    if (!cat) throw new HttpError(422, 'Catégorie invalide');
+
+    let slug = slugify(title);
+    const clash = await db.select({ id: forumTopics.id }).from(forumTopics).where(eq(forumTopics.slug, slug)).limit(1);
+    if (clash.length) slug = `${slug}-${crypto.randomBytes(2).toString('hex')}`;
+
+    const topicId = crypto.randomUUID();
+    const postId = crypto.randomUUID();
+    const now = new Date();
+    await db.insert(forumTopics).values({
+      id: topicId,
+      categoryId: cat.id,
+      authorId: req.platformUser!.id,
+      title,
+      slug,
+      lastPostAt: now,
+    });
+    await db.insert(forumPosts).values({
+      id: postId,
+      topicId,
+      authorId: req.platformUser!.id,
+      body,
+    });
+    await db.insert(forumSubscriptions).values({ topicId, userId: req.platformUser!.id });
+    res.status(201).json({ slug, id: topicId });
+  });
+
+  r.post('/topics/:slug/posts', requirePlatformUser, async (req, res) => {
+    const [topic] = await db.select().from(forumTopics).where(eq(forumTopics.slug, req.params.slug)).limit(1);
+    if (!topic) throw new HttpError(404, 'Sujet introuvable');
+    if (topic.locked && req.platformUser!.role !== 'mod' && req.platformUser!.role !== 'admin') {
+      throw new HttpError(403, 'Sujet verrouillé');
+    }
+    const body = String(req.body?.body || '').trim();
+    if (body.length < 1) throw new HttpError(422, 'Message vide');
+
+    const id = crypto.randomUUID();
+    await db.insert(forumPosts).values({ id, topicId: topic.id, authorId: req.platformUser!.id, body });
+    await db.update(forumTopics).set({ lastPostAt: new Date(), updatedAt: new Date() }).where(eq(forumTopics.id, topic.id));
+
+    const subs = await db.select().from(forumSubscriptions).where(eq(forumSubscriptions.topicId, topic.id));
+    for (const s of subs) {
+      if (s.userId === req.platformUser!.id) continue;
+      await notify(s.userId, 'reply', { topicId: topic.id, slug: topic.slug, title: topic.title, postId: id });
+    }
+
+    res.status(201).json({ id });
+  });
+
+  r.patch('/posts/:id', requirePlatformUser, async (req, res) => {
+    const [post] = await db.select().from(forumPosts).where(eq(forumPosts.id, req.params.id)).limit(1);
+    if (!post) throw new HttpError(404, 'Message introuvable');
+    const isMod = req.platformUser!.role === 'mod' || req.platformUser!.role === 'admin';
+    if (post.authorId !== req.platformUser!.id && !isMod) throw new HttpError(403, 'Accès refusé');
+    const body = String(req.body?.body || '').trim();
+    if (body.length < 1) throw new HttpError(422, 'Message vide');
+    const [updated] = await db
+      .update(forumPosts)
+      .set({ body, editedAt: new Date() })
+      .where(eq(forumPosts.id, post.id))
+      .returning();
+    res.json({ post: updated });
+  });
+
+  r.delete('/posts/:id', requirePlatformUser, async (req, res) => {
+    const [post] = await db.select().from(forumPosts).where(eq(forumPosts.id, req.params.id)).limit(1);
+    if (!post) throw new HttpError(404, 'Message introuvable');
+    const isMod = req.platformUser!.role === 'mod' || req.platformUser!.role === 'admin';
+    if (post.authorId !== req.platformUser!.id && !isMod) throw new HttpError(403, 'Accès refusé');
+    await db.delete(forumLikes).where(eq(forumLikes.postId, post.id));
+    await db.delete(forumPosts).where(eq(forumPosts.id, post.id));
+    res.json({ ok: true });
+  });
+
+  r.post('/posts/:id/like', requirePlatformUser, async (req, res) => {
+    const [post] = await db.select().from(forumPosts).where(eq(forumPosts.id, req.params.id)).limit(1);
+    if (!post) throw new HttpError(404, 'Message introuvable');
+    const [existing] = await db
+      .select()
+      .from(forumLikes)
+      .where(and(eq(forumLikes.postId, post.id), eq(forumLikes.userId, req.platformUser!.id)))
+      .limit(1);
+    if (existing) {
+      await db.delete(forumLikes).where(and(eq(forumLikes.postId, post.id), eq(forumLikes.userId, req.platformUser!.id)));
+      return res.json({ liked: false });
+    }
+    await db.insert(forumLikes).values({ postId: post.id, userId: req.platformUser!.id });
+    if (post.authorId !== req.platformUser!.id) {
+      await notify(post.authorId, 'like', { postId: post.id });
+    }
+    res.json({ liked: true });
+  });
+
+  r.post('/topics/:slug/subscribe', requirePlatformUser, async (req, res) => {
+    const [topic] = await db.select().from(forumTopics).where(eq(forumTopics.slug, req.params.slug)).limit(1);
+    if (!topic) throw new HttpError(404, 'Sujet introuvable');
+    const [existing] = await db
+      .select()
+      .from(forumSubscriptions)
+      .where(and(eq(forumSubscriptions.topicId, topic.id), eq(forumSubscriptions.userId, req.platformUser!.id)))
+      .limit(1);
+    if (existing) {
+      await db
+        .delete(forumSubscriptions)
+        .where(and(eq(forumSubscriptions.topicId, topic.id), eq(forumSubscriptions.userId, req.platformUser!.id)));
+      return res.json({ subscribed: false });
+    }
+    await db.insert(forumSubscriptions).values({ topicId: topic.id, userId: req.platformUser!.id });
+    res.json({ subscribed: true });
+  });
+
+  r.post('/topics/:slug/moderate', requirePlatformUser, requireRole('mod', 'admin'), async (req, res) => {
+    const [topic] = await db.select().from(forumTopics).where(eq(forumTopics.slug, req.params.slug)).limit(1);
+    if (!topic) throw new HttpError(404, 'Sujet introuvable');
+    const action = req.body?.action;
+    if (action === 'pin') {
+      await db.update(forumTopics).set({ pinned: !topic.pinned }).where(eq(forumTopics.id, topic.id));
+    } else if (action === 'lock') {
+      await db.update(forumTopics).set({ locked: !topic.locked }).where(eq(forumTopics.id, topic.id));
+    } else if (action === 'delete') {
+      const posts = await db.select({ id: forumPosts.id }).from(forumPosts).where(eq(forumPosts.topicId, topic.id));
+      if (posts.length) await db.delete(forumLikes).where(inArray(forumLikes.postId, posts.map((p) => p.id)));
+      await db.delete(forumPosts).where(eq(forumPosts.topicId, topic.id));
+      await db.delete(forumSubscriptions).where(eq(forumSubscriptions.topicId, topic.id));
+      await db.delete(forumTopics).where(eq(forumTopics.id, topic.id));
+      return res.json({ deleted: true });
+    } else {
+      throw new HttpError(422, 'action = pin | lock | delete');
+    }
+    const [updated] = await db.select().from(forumTopics).where(eq(forumTopics.id, topic.id)).limit(1);
+    res.json({ topic: updated });
+  });
+
+  r.post('/report', requirePlatformUser, async (req, res) => {
+    const targetType = req.body?.targetType === 'topic' ? 'topic' : 'post';
+    const targetId = String(req.body?.targetId || '');
+    const reason = String(req.body?.reason || '').trim().slice(0, 500);
+    if (!targetId || reason.length < 3) throw new HttpError(422, 'Signalement invalide');
+    await db.insert(forumReports).values({
+      id: crypto.randomUUID(),
+      reporterId: req.platformUser!.id,
+      targetType,
+      targetId,
+      reason,
+    });
+    res.status(201).json({ ok: true });
+  });
+
+  r.get('/reports', requirePlatformUser, requireRole('mod', 'admin'), async (_req, res) => {
+    const rows = await db
+      .select()
+      .from(forumReports)
+      .where(eq(forumReports.status, 'open'))
+      .orderBy(desc(forumReports.createdAt))
+      .limit(100);
+    res.json({ items: rows });
+  });
+
+  r.post('/reports/:id', requirePlatformUser, requireRole('mod', 'admin'), async (req, res) => {
+    const status = req.body?.status === 'dismissed' ? 'dismissed' : 'resolved';
+    const [row] = await db
+      .update(forumReports)
+      .set({ status, resolvedAt: new Date() })
+      .where(eq(forumReports.id, req.params.id))
+      .returning();
+    res.json({ report: row });
+  });
+
+  r.get('/notifications', requirePlatformUser, async (req, res) => {
+    const rows = await db
+      .select()
+      .from(forumNotifications)
+      .where(eq(forumNotifications.userId, req.platformUser!.id))
+      .orderBy(desc(forumNotifications.createdAt))
+      .limit(50);
+    const unread = rows.filter((n) => !n.readAt).length;
+    res.json({ items: rows, unread });
+  });
+
+  r.post('/notifications/read', requirePlatformUser, async (req, res) => {
+    const ids = Array.isArray(req.body?.ids) ? req.body.ids.filter((x: unknown) => typeof x === 'string') : null;
+    if (ids?.length) {
+      await db
+        .update(forumNotifications)
+        .set({ readAt: new Date() })
+        .where(and(eq(forumNotifications.userId, req.platformUser!.id), inArray(forumNotifications.id, ids), isNull(forumNotifications.readAt)));
+    } else {
+      await db
+        .update(forumNotifications)
+        .set({ readAt: new Date() })
+        .where(and(eq(forumNotifications.userId, req.platformUser!.id), isNull(forumNotifications.readAt)));
+    }
+    res.json({ ok: true });
+  });
+
+  r.get('/users/:id', async (req, res) => {
+    const [user] = await db.select().from(platformUsers).where(eq(platformUsers.id, req.params.id)).limit(1);
+    if (!user) throw new HttpError(404, 'Utilisateur introuvable');
+    const posts = await db
+      .select()
+      .from(forumPosts)
+      .where(eq(forumPosts.authorId, user.id))
+      .orderBy(desc(forumPosts.createdAt))
+      .limit(20);
+    const topics = await db
+      .select()
+      .from(forumTopics)
+      .where(eq(forumTopics.authorId, user.id))
+      .orderBy(desc(forumTopics.createdAt))
+      .limit(20);
+    res.json({ user: toPublicUser(user), recentPosts: posts, recentTopics: topics });
+  });
+
+  r.get('/search', async (req, res) => {
+    const q = String(req.query.q || '').trim();
+    if (q.length < 2) return res.json({ topics: [], posts: [] });
+    const topics = await db
+      .select()
+      .from(forumTopics)
+      .where(ilike(forumTopics.title, `%${q}%`))
+      .orderBy(desc(forumTopics.lastPostAt))
+      .limit(20);
+    const posts = await db
+      .select()
+      .from(forumPosts)
+      .where(ilike(forumPosts.body, `%${q}%`))
+      .orderBy(desc(forumPosts.createdAt))
+      .limit(20);
+    res.json({ topics, posts });
+  });
+
+  return r;
+}

package/template/server/db/client.ts

@@ -0,0 +1,43 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import path from 'path';
+import { fileURLToPath } from 'url';
+import pg from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import * as schema from './schema';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+if (!process.env.DATABASE_URL) {
+  throw new Error('DATABASE_URL manquant : configurez PostgreSQL dans .env');
+}
+
+export const pool = new pg.Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: 10,
+  idleTimeoutMillis: 30_000,
+  connectionTimeoutMillis: 5_000,
+});
+
+pool.on('error', (err) => console.error('[db] erreur du pool PostgreSQL', err));
+
+export const db = drizzle(pool, { schema });
+export type Db = typeof db;
+export type Tx = Parameters<Parameters<Db['transaction']>[0]>[0];
+
+let migrated: Promise<void> | null = null;
+
+/** Applique les migrations SQL versionnées (dossier drizzle/) une seule fois par processus. */
+export function runMigrations(): Promise<void> {
+  migrated ??= migrate(db, { migrationsFolder: path.resolve(__dirname, '../../drizzle') });
+  return migrated;
+}
+
+export async function closeDb(): Promise<void> {
+  await pool.end();
+}