create-zhx-monorepo 0.2.2 → 2.0.0

package/templates/monorepo-starter/server/src/modules/notification/push.service.ts

@@ -0,0 +1,92 @@
+import * as admin from "firebase-admin";
+import { Injectable } from "@nestjs/common";
+
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { EnvService } from "@/modules/env/env.service";
+import { LoggerService } from "@/modules/logger/logger.service";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+
+@Injectable()
+export class PushService {
+  @InjectLogger()
+  private readonly logger!: LoggerService;
+
+  constructor(
+    private readonly env: EnvService,
+    private readonly prisma: PrismaService,
+  ) {}
+
+  async sendPush(user: SafeUser, title: string, body: string) {
+    const sessions = await this.prisma.session.findMany({
+      where: { userId: user.id, status: "active", pushToken: { not: null } },
+      select: { pushToken: true, pushProvider: true },
+    });
+
+    for (const s of sessions) {
+      if (!s.pushToken || !s.pushProvider) continue;
+
+      switch (s.pushProvider) {
+        case "fcm":
+          await this.sendWithFCM(s.pushToken, title, body, user.id);
+          break;
+
+        case "expo":
+          await this.sendWithExpo(s.pushToken, title, body);
+          break;
+
+        default:
+          this.logger.warn("Unknown push provider", {
+            provider: s.pushProvider,
+          });
+      }
+    }
+  }
+
+  private async sendWithFCM(
+    token: string,
+    title: string,
+    body: string,
+    userId: string,
+  ) {
+    try {
+      this.ensureFirebase();
+      const message: admin.messaging.Message = {
+        token,
+        notification: { title, body },
+      };
+
+      await admin.messaging().send(message);
+    } catch (err: any) {
+      this.logger.error("FCM push failed", { token, error: err.message });
+      if (
+        err.code === "messaging/registration-token-not-registered" ||
+        err.code === "messaging/invalid-registration-token"
+      ) {
+        await this.prisma.session.updateMany({
+          where: { userId, pushToken: token },
+          data: { pushToken: null },
+        });
+        this.logger.warn("Removed invalid FCM token", { token });
+      }
+    }
+  }
+
+  private async sendWithExpo(token: string, title: string, body: string) {
+    // TODO: implement Expo push logic here
+    this.logger.log("Expo push placeholder", { token, title, body });
+  }
+
+  private ensureFirebase() {
+    if (admin.apps.length) return;
+
+    admin.initializeApp({
+      credential: admin.credential.cert({
+        projectId: this.env.get("FIREBASE_PROJECT_ID"),
+        clientEmail: this.env.get("FIREBASE_CLIENT_EMAIL"),
+        privateKey: this.env.get("FIREBASE_PRIVATE_KEY"),
+      }),
+    });
+
+    this.logger.log("✅ Firebase Admin initialized");
+  }
+}

package/templates/monorepo-starter/server/src/modules/prisma/prisma.extension.ts

@@ -1,72 +1,100 @@
 import { Prisma } from "@generated/prisma";
+import { SoftDeleteModels } from "./soft-delete.models";
 
-const hasDeletedAt = (model: string) => {
-  const dmmf = Prisma.dmmf.datamodel.models;
-  const m = dmmf.find((m) => m.name === model);
-  return !!m?.fields.find((f) => f.name === "deletedAt");
+export type SoftDeleteExtraArgs = {
+  force?: boolean | string;
 };
 
-export const softDeleteExtension = Prisma.defineExtension({
-  name: "softDelete",
+export const softDeleteExtension = Prisma.defineExtension((client) =>
+  client.$extends({
+    name: "softDelete",
+    query: {
+      $allModels: {
+        // Single delete
+        async delete<T, A extends Prisma.Args<T, "delete">>({
+          model,
+          args,
+          query,
+        }: {
+          model: string;
+          args: Prisma.Exact<A & SoftDeleteExtraArgs, A & SoftDeleteExtraArgs>;
+          query: (args: A) => Promise<Prisma.Result<T, A, "delete">>;
+        }) {
+          const hasDel = SoftDeleteModels.has(model);
+          const { force, ...rest } = args as A & SoftDeleteExtraArgs;
+          const isForce = force === true || force === "true";
 
-  query: {
-    $allModels: {
-      async delete({ model, args, query }) {
-        const hasDel = hasDeletedAt(model);
-        const force = (args as any).force;
+          if (hasDel && !isForce) {
+            return (client as any)[model].update({
+              where: rest.where,
+              data: { deletedAt: new Date() },
+            });
+          }
 
-        if (hasDel && !force) {
-          const prisma = Prisma.getExtensionContext(this);
-          console.log("prisma", prisma);
-          return (prisma as any)[model].update({
-            where: args.where,
-            data: { deletedAt: new Date() },
-          });
-        }
+          return query(rest as A);
+        },
 
-        return query(args);
-      },
+        // Delete many
+        async deleteMany<T, A extends Prisma.Args<T, "deleteMany">>({
+          model,
+          args,
+          query,
+        }: {
+          model: string;
+          args: Prisma.Exact<A & SoftDeleteExtraArgs, A & SoftDeleteExtraArgs>;
+          query: (args: A) => Promise<Prisma.Result<T, A, "deleteMany">>;
+        }) {
+          const hasDel = SoftDeleteModels.has(model);
+          const { force, ...rest } = args as A & SoftDeleteExtraArgs;
+          const isForce = force === true || force === "true";
 
-      async deleteMany({ model, args, query }) {
-        const hasDel = hasDeletedAt(model);
-        const force = (args as any).force;
+          if (hasDel && !isForce) {
+            return (client as any)[model].updateMany({
+              where: rest.where,
+              data: { deletedAt: new Date() },
+            });
+          }
 
-        if (hasDel && !force) {
-          const prisma = Prisma.getExtensionContext(this);
-          console.log("prisma", prisma);
-          return (prisma as any)[model].updateMany({
-            where: args.where,
-            data: { deletedAt: new Date() },
-          });
-        }
+          return query(rest as A);
+        },
 
-        return query(args);
-      },
+        // Intercept all operations
+        async $allOperations<T, A>({
+          model,
+          operation,
+          args,
+          query,
+        }: {
+          model: string;
+          operation: string;
+          args: A & SoftDeleteExtraArgs;
+          query: (args: A) => Promise<Prisma.Result<T, A, any>>;
+        }) {
+          const hasDel = SoftDeleteModels.has(model);
+          const readOps = [
+            "findUnique",
+            "findFirst",
+            "findMany",
+            "count",
+            "aggregate",
+          ] as const;
 
-      async $allOperations({ model, operation, args, query }) {
-        const hasDel = hasDeletedAt(model);
-        const _args = args as Record<string, any>;
-        const targetOps = [
-          "findUnique",
-          "findFirst",
-          "findMany",
-          "count",
-          "aggregate",
-        ];
+          if (!hasDel || !readOps.includes(operation as any)) {
+            return query(args as A);
+          }
 
-        if (!targetOps.includes(operation) || !hasDel) return query(args);
-        if (_args.includeDeleted) {
-          delete _args.includeDeleted;
-          return query(_args);
-        }
+          const next: any = { ...args };
 
-        _args.where = _args.where ?? {};
-        if (!("deletedAt" in _args.where)) {
-          _args.where = { ..._args.where, deletedAt: null };
-        }
+          next.where ??= {};
+          if (next.where.deletedAt === undefined) {
+            next.where.deletedAt = null;
+          }
 
-        return query(_args);
+          return query(next as A);
+        },
       },
     },
-  },
-});
+  }),
+);
+
+export type ExtendedPrismaClient = ReturnType<typeof softDeleteExtension>;

package/templates/monorepo-starter/server/src/modules/prisma/prisma.service.ts

@@ -3,9 +3,10 @@ import { Injectable } from "@nestjs/common";
 import { PrismaClient } from "@generated/prisma";
 import { PrismaPg } from "@prisma/adapter-pg";
 
-import { LoggerService } from "@modules/logger/logger.service";
-import { InjectLogger } from "@decorators/logger.decorator";
 import { softDeleteExtension } from "./prisma.extension";
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { EnvService } from "@/modules/env/env.service";
+import { LoggerService } from "@/modules/logger/logger.service";
 
 @Injectable()
 export class PrismaService
@@ -15,15 +16,15 @@ export class PrismaService
   @InjectLogger()
   private readonly logger!: LoggerService;
 
-constructor() {
-  const adapter = new PrismaPg({
-    connectionString: process.env.DB_URI!,
-  });
+  constructor(env: EnvService) {
+    const adapter = new PrismaPg({
+      connectionString: env.get("DB_URI"),
+    });
 
-  super({ adapter });
+    super({ adapter });
 
-  Object.assign(this, this.$extends(softDeleteExtension));
-}
+    Object.assign(this, this.$extends(softDeleteExtension));
+  }
 
   async onModuleInit() {
     this.logger.log("Connecting to the database...");

package/templates/monorepo-starter/server/src/modules/prisma/soft-delete.models.ts

@@ -0,0 +1,7 @@
+// AUTO-GENERATED FILE — DO NOT EDIT
+// Generated from schema.prisma
+
+export const SoftDeleteModels = new Set<string>([
+  "User",
+  "Media"
+]);

package/templates/monorepo-starter/server/src/modules/public/public.controller.ts

@@ -1,7 +1,8 @@
+import type { Request } from "express";
 import { Controller, Get, Req } from "@nestjs/common";
+
 import { PublicService } from "./public.service";
-import type { Request } from "express";
-import { Public } from "@decorators/public.decorator";
+import { Public } from "@/decorators/public.decorator";
 
 @Controller()
 export class PublicController {

package/templates/monorepo-starter/server/src/modules/public/public.module.ts

@@ -1,9 +1,10 @@
-import { Module } from '@nestjs/common';
-import { PublicService } from './public.service';
-import { PublicController } from './public.controller';
+import { Module } from "@nestjs/common";
+
+import { PublicService } from "./public.service";
+import { PublicController } from "./public.controller";
 
 @Module({
   providers: [PublicService],
-  controllers: [PublicController]
+  controllers: [PublicController],
 })
 export class PublicModule {}

package/templates/monorepo-starter/server/src/modules/public/public.service.ts

@@ -1,7 +1,8 @@
-import { Injectable } from "@nestjs/common";
-import { LoggerService } from "@modules/logger/logger.service";
 import type { Request } from "express";
-import { InjectLogger } from "@decorators/logger.decorator";
+import { Injectable } from "@nestjs/common";
+
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { LoggerService } from "@/modules/logger/logger.service";
 
 @Injectable()
 export class PublicService {
@@ -9,8 +10,10 @@ export class PublicService {
   private readonly logger!: LoggerService;
 
   welcome(req: Request) {
+    const origin = `${req.protocol}://${req.get("host")}`;
+
     this.logger.log(
-      `Welcome endpoint hit from IP: ${req.ip}, path: ${req.url}`
+      `Welcome endpoint hit from IP: ${req.ip}, path: ${origin}${req.url}`,
     );
     return { message: "Server is running 🚀" };
   }

package/templates/monorepo-starter/server/src/modules/scheduler/cleanup.service.ts

@@ -1,8 +1,9 @@
 import { Injectable } from "@nestjs/common";
 import { Cron, CronExpression } from "@nestjs/schedule";
-import { PrismaService } from "@modules/prisma/prisma.service";
-import { LoggerService } from "@modules/logger/logger.service";
-import { InjectLogger } from "@decorators/logger.decorator";
+
+import { InjectLogger } from "@/decorators/logger.decorator";
+import { PrismaService } from "@/modules/prisma/prisma.service";
+import { LoggerService } from "@/modules/logger/logger.service";
 
 @Injectable()
 export class CleanupService {
@@ -22,12 +23,19 @@ export class CleanupService {
 
   @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
   async handleRefreshTokenCleanup() {
-    this.logger.log("🧹 Running Refresh Token cleanup job...");
-    const result = await this.prisma.refreshToken.deleteMany({
+    this.logger.log("🧹 Running Session Revokes job...");
+    const updated = await this.prisma.session.updateMany({
+      where: { expiresAt: { lt: new Date() } },
+      data: { status: "expired" },
+    });
+    this.logger.log(`✅ Updated ${updated.count} expired sessions`);
+
+    const deleted = await this.prisma.session.deleteMany({
       where: {
-        expiresAt: { lt: new Date() },
+        pushToken: null,
+        OR: [{ expiresAt: { lt: new Date() } }, { status: "revoked" }],
       },
     });
-    this.logger.log(`✅ Deleted ${result.count} expired refresh tokens`);
+    this.logger.log(`✅ Deleted ${deleted.count} expired sessions`);
   }
 }

package/templates/monorepo-starter/server/src/modules/scheduler/scheduler.module.ts

@@ -1,7 +1,9 @@
 import { Module } from "@nestjs/common";
+import { ScheduleModule } from "@nestjs/schedule";
 import { CleanupService } from "./cleanup.service";
 
 @Module({
+  imports: [ScheduleModule.forRoot()],
   providers: [CleanupService],
 })
 export class SchedulerModule {}

package/templates/monorepo-starter/server/src/modules/token/token.module.ts

@@ -1,11 +1,10 @@
 import { Module } from "@nestjs/common";
 import { TokenService } from "./token.service";
-import { JwtModule } from "@nestjs/jwt";
-import { CookieService } from "@utils/cookie.util";
+import { CookieService } from "@/utils/cookie.util";
+import { ClientService } from "@/utils/client.utils";
 
 @Module({
-  imports: [JwtModule.register({})],
-  providers: [TokenService, CookieService],
+  providers: [TokenService, CookieService, ClientService],
   exports: [TokenService],
 })
 export class TokenModule {}