my-crud-lib 1.0.0 → 1.0.2

package/README.md

@@ -196,6 +196,12 @@ The package exports the main public types:
 
 ---
 
+## Optional
+
+if you want to use the prisma adeapter use:
+
+npm i @prisma/client prisma
+npx prisma generate
 
 ## Contributing
 

package/dist/adapters/prisma.d.ts

@@ -0,0 +1,3 @@
+import type { PrismaClient } from '@prisma/client';
+import type { UserRepo } from '../core/ports/user.repo.js';
+export declare function makePrismaUserRepo(prisma: PrismaClient): UserRepo;

package/dist/adapters/prisma.js

@@ -0,0 +1,132 @@
+export function makePrismaUserRepo(prisma) {
+    return {
+        async count({ role, search }) {
+            const where = {};
+            if (role)
+                where.role = role;
+            if (search?.trim()) {
+                const s = search.trim();
+                where.OR = [
+                    { email: { contains: s, mode: 'insensitive' } },
+                    { name: { contains: s, mode: 'insensitive' } },
+                ];
+            }
+            return prisma.user.count({ where });
+        },
+        async findMany({ page, pageSize, role, search, sortField, sortDir }) {
+            const where = {};
+            if (role)
+                where.role = role;
+            if (search?.trim()) {
+                const s = search.trim();
+                where.OR = [
+                    { email: { contains: s, mode: 'insensitive' } },
+                    { name: { contains: s, mode: 'insensitive' } },
+                ];
+            }
+            const orderBy = { [sortField]: sortDir };
+            const users = await prisma.user.findMany({
+                where,
+                orderBy,
+                skip: (page - 1) * pageSize,
+                take: pageSize,
+                select: {
+                    id: true,
+                    email: true,
+                    name: true,
+                    role: true,
+                    createdAt: true,
+                    updatedAt: true,
+                    profile: { select: { bio: true, avatarUrl: true } },
+                },
+            });
+            return users;
+        },
+        async findById(id) {
+            return prisma.user.findUnique({
+                where: { id: id },
+                select: {
+                    id: true,
+                    email: true,
+                    name: true,
+                    role: true,
+                    createdAt: true,
+                    updatedAt: true,
+                    profile: { select: { bio: true, avatarUrl: true } },
+                },
+            });
+        },
+        async findByEmail(email) {
+            return prisma.user.findUnique({
+                where: { email },
+                select: {
+                    id: true,
+                    email: true,
+                    name: true,
+                    role: true,
+                    passwordHash: true,
+                    createdAt: true,
+                    updatedAt: true,
+                    profile: { select: { bio: true, avatarUrl: true } },
+                },
+            });
+        },
+        async create(input) {
+            return prisma.user.create({
+                data: {
+                    email: input.email,
+                    passwordHash: input.passwordHash,
+                    name: input.name ?? null,
+                    role: input.role ?? 'USER',
+                    profile: { create: { bio: input.bio ?? null, avatarUrl: input.avatarUrl ?? null } },
+                },
+                select: {
+                    id: true, email: true, name: true, role: true,
+                    createdAt: true, updatedAt: true,
+                    profile: { select: { bio: true, avatarUrl: true } },
+                },
+            });
+        },
+        async update(id, input) {
+            return prisma.user.update({
+                where: { id: id },
+                data: {
+                    name: input.name ?? undefined,
+                    role: input.role ?? undefined,
+                    profile: {
+                        upsert: {
+                            create: { bio: input.bio ?? null, avatarUrl: input.avatarUrl ?? null },
+                            update: { bio: input.bio ?? null, avatarUrl: input.avatarUrl ?? null },
+                        },
+                    },
+                },
+                select: {
+                    id: true, email: true, name: true, role: true,
+                    profile: { select: { bio: true, avatarUrl: true } },
+                    createdAt: true, updatedAt: true,
+                },
+            });
+        },
+        async delete(id) {
+            await prisma.user.delete({ where: { id: id } });
+        },
+        async updateMe(userId, data) {
+            return prisma.user.update({
+                where: { id: userId },
+                data: {
+                    name: data.name ?? undefined,
+                    profile: {
+                        upsert: {
+                            create: { bio: data.bio ?? null, avatarUrl: data.avatarUrl ?? null },
+                            update: { bio: data.bio ?? null, avatarUrl: data.avatarUrl ?? null },
+                        },
+                    },
+                },
+                select: {
+                    id: true, email: true, name: true, role: true,
+                    profile: { select: { bio: true, avatarUrl: true } },
+                },
+            });
+        },
+    };
+}

package/dist/core/ports/user.repo.d.ts

@@ -0,0 +1,34 @@
+import type { AdminUpdateUserInput, UserListItem } from "../../modules/user/user.types.js";
+export interface UserRepo {
+    count(where: {
+        role?: string;
+        search?: string;
+    }): Promise<number>;
+    findMany(params: {
+        page: number;
+        pageSize: number;
+        role?: string;
+        search?: string;
+        sortField: 'createdAt' | 'updatedAt' | 'email' | 'name';
+        sortDir: 'asc' | 'desc';
+    }): Promise<UserListItem[]>;
+    findById(id: number | string): Promise<UserListItem | null>;
+    findByEmail(email: string): Promise<UserListItem & {
+        passwordHash?: string;
+    } | null>;
+    create(input: {
+        email: string;
+        passwordHash: string;
+        name?: string | null;
+        role?: string;
+        bio?: string | null;
+        avatarUrl?: string | null;
+    }): Promise<UserListItem>;
+    update(id: number | string, input: AdminUpdateUserInput): Promise<UserListItem>;
+    delete(id: number | string): Promise<void>;
+    updateMe(userId: number | string, input: {
+        name?: string | null;
+        bio?: string | null;
+        avatarUrl?: string | null;
+    }): Promise<UserListItem>;
+}

package/dist/core/ports/user.repo.js

@@ -0,0 +1 @@
+export {};

package/dist/dev.js

@@ -2,9 +2,13 @@ import { createServer } from './index.js';
 import { createAuthRouter } from './modules/auth/auth.controller.js';
 import 'dotenv/config';
 import { createUserRouter } from './modules/user/user.controller.js';
+import { makePrismaUserRepo } from './adapters/prisma.js';
+import { PrismaClient } from '@prisma/client';
 const app = createServer();
+const prisma = new PrismaClient();
+const userRepo = makePrismaUserRepo(prisma);
 app.use('/auth', createAuthRouter());
-app.use('/users', createUserRouter());
+app.use('/users', createUserRouter({ userRepo }));
 const PORT = Number(process.env.PORT) || 3000;
 app.listen(PORT, () => {
     console.log(`API dev up on http://localhost:${PORT}`);

package/dist/modules/user/user.controller.d.ts

@@ -1 +1,4 @@
-export declare function createUserRouter(): import("express-serve-static-core").Router;
+import type { UserRepo } from '../../core/ports/user.repo.js';
+export declare function createUserRouter(deps: {
+    userRepo: UserRepo;
+}): import("express-serve-static-core").Router;

package/dist/modules/user/user.controller.js

@@ -2,13 +2,14 @@ import { Router } from 'express';
 import { isAuth } from '../../middleware/isAuth.js';
 import { hasRole, isSelfOrAdmin } from '../../middleware/hasRole.js';
 import { listUsersQuerySchema, updateMeSchema, adminCreateUserSchema, adminUpdateUserSchema, } from './user.schemas.js';
-import { listUsers, getUserById, updateMe, adminCreateUser, adminUpdateUser, adminDeleteUser, } from './user.service.js';
-export function createUserRouter() {
+import { makeUserService } from './user.service.js';
+export function createUserRouter(deps) {
     const router = Router();
+    const service = makeUserService({ userRepo: deps.userRepo });
     router.get('/', isAuth, hasRole('ADMIN'), async (req, res) => {
         try {
             const q = listUsersQuerySchema.parse(req.query);
-            const data = await listUsers(q);
+            const data = await service.listUsers(q);
             res.json(data);
         }
         catch (e) {
@@ -17,15 +18,8 @@ export function createUserRouter() {
             res.status(500).json({ error: 'InternalError' });
         }
     });
-    router.get('/:id', isAuth, isSelfOrAdmin(), async (req, res) => {
-        const id = Number(req.params.id);
-        const data = await getUserById(id);
-        if (!data)
-            return res.status(404).json({ error: 'User not found' });
-        res.json(data);
-    });
-    router.get('/me/self', isAuth, async (req, res) => {
-        const data = await getUserById(req.user.id);
+    router.get('/me', isAuth, async (req, res) => {
+        const data = await service.getUserById(req.user.id);
         if (!data)
             return res.status(404).json({ error: 'User not found' });
         res.json(data);
@@ -33,7 +27,7 @@ export function createUserRouter() {
     router.put('/me', isAuth, async (req, res) => {
         try {
             const body = updateMeSchema.parse(req.body);
-            const data = await updateMe(req.user.id, body);
+            const data = await service.updateMe(req.user.id, body);
             res.json(data);
         }
         catch (e) {
@@ -45,7 +39,7 @@ export function createUserRouter() {
     router.post('/', isAuth, hasRole('ADMIN'), async (req, res) => {
         try {
             const body = adminCreateUserSchema.parse(req.body);
-            const data = await adminCreateUser(body);
+            const data = await service.adminCreateUser(body);
             res.status(201).json(data);
         }
         catch (e) {
@@ -56,14 +50,26 @@ export function createUserRouter() {
             res.status(500).json({ error: 'InternalError' });
         }
     });
+    router.get('/:id', isAuth, isSelfOrAdmin(), async (req, res) => {
+        const id = Number(req.params.id);
+        if (Number.isNaN(id))
+            return res.status(400).json({ error: 'Invalid id' });
+        const data = await service.getUserById(id);
+        if (!data)
+            return res.status(404).json({ error: 'User not found' });
+        res.json(data);
+    });
     router.put('/:id', isAuth, isSelfOrAdmin(), async (req, res) => {
         try {
             const id = Number(req.params.id);
+            if (Number.isNaN(id))
+                return res.status(400).json({ error: 'Invalid id' });
             const body = adminUpdateUserSchema.parse(req.body);
             if (req.user.role !== 'ADMIN' && body.role) {
                 return res.status(403).json({ error: 'Forbidden: cannot change role' });
             }
-            const data = await adminUpdateUser(id, body);
+            const sanitizedBody = { ...body, role: body.role === null ? undefined : body.role };
+            const data = await service.adminUpdateUser(id, sanitizedBody);
             res.json(data);
         }
         catch (e) {
@@ -75,8 +81,10 @@ export function createUserRouter() {
     router.delete('/:id', isAuth, hasRole('ADMIN'), async (req, res) => {
         try {
             const id = Number(req.params.id);
-            const data = await adminDeleteUser(id);
-            res.json(data);
+            if (Number.isNaN(id))
+                return res.status(400).json({ error: 'Invalid id' });
+            await service.adminDeleteUser(id);
+            res.status(204).end();
         }
         catch {
             res.status(500).json({ error: 'InternalError' });

package/dist/modules/user/user.schemas.d.ts

@@ -1,18 +1,19 @@
 import { z } from 'zod';
+export declare const SortEnum: z.ZodEnum<["createdAt:desc", "createdAt:asc", "updatedAt:asc", "updatedAt:desc", "email:asc", "email:desc", "name:asc", "name:desc"]>;
 export declare const listUsersQuerySchema: z.ZodObject<{
     page: z.ZodDefault<z.ZodNumber>;
     pageSize: z.ZodDefault<z.ZodNumber>;
-    search: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodEffects<z.ZodString, string | undefined, string>>;
     role: z.ZodOptional<z.ZodEnum<["USER", "ADMIN"]>>;
-    sort: z.ZodDefault<z.ZodString>;
+    sort: z.ZodDefault<z.ZodEnum<["createdAt:desc", "createdAt:asc", "updatedAt:asc", "updatedAt:desc", "email:asc", "email:desc", "name:asc", "name:desc"]>>;
 }, "strip", z.ZodTypeAny, {
-    sort: string;
+    sort: "createdAt:desc" | "createdAt:asc" | "updatedAt:asc" | "updatedAt:desc" | "email:asc" | "email:desc" | "name:asc" | "name:desc";
     page: number;
     pageSize: number;
     search?: string | undefined;
     role?: "USER" | "ADMIN" | undefined;
 }, {
-    sort?: string | undefined;
+    sort?: "createdAt:desc" | "createdAt:asc" | "updatedAt:asc" | "updatedAt:desc" | "email:asc" | "email:desc" | "name:asc" | "name:desc" | undefined;
     search?: string | undefined;
     role?: "USER" | "ADMIN" | undefined;
     page?: number | undefined;

package/dist/modules/user/user.schemas.js

@@ -1,13 +1,24 @@
 import { z } from 'zod';
+export const SortEnum = z.enum([
+    'createdAt:desc',
+    'createdAt:asc',
+    'updatedAt:asc',
+    'updatedAt:desc',
+    'email:asc',
+    'email:desc',
+    'name:asc',
+    'name:desc',
+]);
 export const listUsersQuerySchema = z.object({
     page: z.coerce.number().int().min(1).default(1),
     pageSize: z.coerce.number().int().min(1).max(100).default(10),
-    search: z.string().trim().min(1).optional(),
-    role: z.enum(['USER', 'ADMIN']).optional(),
-    sort: z
+    search: z
         .string()
-        .regex(/^(createdAt|updatedAt|email|name):(asc|desc)$/i)
-        .default('createdAt:desc'),
+        .trim()
+        .transform((v) => (v === '' ? undefined : v))
+        .optional(),
+    role: z.enum(['USER', 'ADMIN']).optional(),
+    sort: SortEnum.default('createdAt:desc'),
 });
 export const updateMeSchema = z.object({
     name: z.string().min(1).max(100).nullish(),

package/dist/modules/user/user.service.d.ts

@@ -1,68 +1,14 @@
-import type { AdminCreateUserInput, AdminUpdateUserInput, ListUsersQuery, UpdateMeInput } from './user.schemas.js';
-export declare function listUsers(q: ListUsersQuery): Promise<{
-    page: number;
-    pageSize: number;
-    total: number;
-    items: {
-        email: string;
-        name: string | null;
-        id: number;
-        role: import("@prisma/client").$Enums.Role;
-        createdAt: Date;
-        updatedAt: Date;
-        profile: {
-            bio: string | null;
-            avatarUrl: string | null;
-        } | null;
-    }[];
-    totalPages: number;
-}>;
-export declare function getUserById(id: number): Promise<{
-    email: string;
-    name: string | null;
-    id: number;
-    role: import("@prisma/client").$Enums.Role;
-    createdAt: Date;
-    updatedAt: Date;
-    profile: {
-        bio: string | null;
-        avatarUrl: string | null;
-    } | null;
-} | null>;
-export declare function updateMe(userId: number, data: UpdateMeInput): Promise<{
-    email: string;
-    name: string | null;
-    id: number;
-    role: import("@prisma/client").$Enums.Role;
-    profile: {
-        bio: string | null;
-        avatarUrl: string | null;
-    } | null;
-}>;
-export declare function adminCreateUser(input: AdminCreateUserInput): Promise<{
-    email: string;
-    name: string | null;
-    id: number;
-    role: import("@prisma/client").$Enums.Role;
-    createdAt: Date;
-    updatedAt: Date;
-    profile: {
-        bio: string | null;
-        avatarUrl: string | null;
-    } | null;
-}>;
-export declare function adminUpdateUser(id: number, input: AdminUpdateUserInput): Promise<{
-    email: string;
-    name: string | null;
-    id: number;
-    role: import("@prisma/client").$Enums.Role;
-    createdAt: Date;
-    updatedAt: Date;
-    profile: {
-        bio: string | null;
-        avatarUrl: string | null;
-    } | null;
-}>;
-export declare function adminDeleteUser(id: number): Promise<{
-    ok: boolean;
-}>;
+import type { AdminCreateUserInput, AdminUpdateUserInput, ListUsersQuery, Paginated, UpdateMeInput, UserListItem } from './user.types.js';
+import type { UserRepo } from '../../core/ports/user.repo.js';
+export declare function makeUserService(deps: {
+    userRepo: UserRepo;
+}): {
+    listUsers(q: ListUsersQuery): Promise<Paginated<UserListItem>>;
+    getUserById(id: number | string): Promise<UserListItem | null>;
+    updateMe(userId: number | string, data: UpdateMeInput): Promise<UserListItem>;
+    adminCreateUser(input: AdminCreateUserInput): Promise<UserListItem>;
+    adminUpdateUser(id: number | string, input: AdminUpdateUserInput): Promise<UserListItem>;
+    adminDeleteUser(id: number | string): Promise<{
+        ok: true;
+    }>;
+};

package/dist/modules/user/user.service.js

@@ -1,136 +1,52 @@
-import { prisma } from '../../utils/prisma.js';
 import bcrypt from 'bcryptjs';
-export async function listUsers(q) {
-    const { page, pageSize, role, search } = q;
-    const [rawField, rawDir] = (q.sort ?? 'createdAt:desc').split(':');
-    const allowedFields = ['createdAt', 'updatedAt', 'email', 'name'];
+const allowedFields = ['createdAt', 'updatedAt', 'email', 'name'];
+function parseSort(sort) {
+    const [rawField, rawDir] = (sort ?? 'createdAt:desc').split(':');
     const sortField = allowedFields.includes(rawField || '')
         ? rawField
         : 'createdAt';
     const sortDir = rawDir === 'asc' || rawDir === 'desc' ? rawDir : 'desc';
-    const where = {};
-    if (role)
-        where.role = role;
-    if (search && search.trim() !== '') {
-        const s = search.trim();
-        where.OR = [
-            { email: { contains: s, mode: 'insensitive' } },
-            { name: { contains: s, mode: 'insensitive' } },
-        ];
-    }
-    const orderBy = { [sortField]: sortDir };
-    const [total, items] = await Promise.all([
-        prisma.user.count({ where }),
-        prisma.user.findMany({
-            where,
-            orderBy,
-            skip: (page - 1) * pageSize,
-            take: pageSize,
-            select: {
-                id: true,
-                email: true,
-                name: true,
-                role: true,
-                createdAt: true,
-                updatedAt: true,
-                profile: { select: { bio: true, avatarUrl: true } },
-            },
-        }),
-    ]);
-    return {
-        page,
-        pageSize,
-        total,
-        items,
-        totalPages: Math.ceil(total / pageSize),
-    };
+    return { sortField, sortDir };
 }
-export async function getUserById(id) {
-    return prisma.user.findUnique({
-        where: { id },
-        select: {
-            id: true,
-            email: true,
-            name: true,
-            role: true,
-            createdAt: true,
-            updatedAt: true,
-            profile: { select: { bio: true, avatarUrl: true } },
+export function makeUserService(deps) {
+    const { userRepo } = deps;
+    return {
+        async listUsers(q) {
+            const { page, pageSize, role, search } = q;
+            const { sortField, sortDir } = parseSort(q.sort);
+            const [total, items] = await Promise.all([
+                userRepo.count({ role, search }),
+                userRepo.findMany({ page, pageSize, role, search, sortField, sortDir }),
+            ]);
+            return { page, pageSize, total, totalPages: Math.ceil(total / pageSize), items };
         },
-    });
-}
-export async function updateMe(userId, data) {
-    return prisma.user.update({
-        where: { id: userId },
-        data: {
-            name: data.name ?? undefined,
-            profile: {
-                upsert: {
-                    create: { bio: data.bio ?? null, avatarUrl: data.avatarUrl ?? null },
-                    update: { bio: data.bio ?? null, avatarUrl: data.avatarUrl ?? null },
-                },
-            },
+        getUserById(id) {
+            return userRepo.findById(id);
         },
-        select: {
-            id: true,
-            email: true,
-            name: true,
-            role: true,
-            profile: { select: { bio: true, avatarUrl: true } },
+        updateMe(userId, data) {
+            return userRepo.updateMe(userId, data);
         },
-    });
-}
-export async function adminCreateUser(input) {
-    const exists = await prisma.user.findUnique({ where: { email: input.email } });
-    if (exists)
-        throw new Error('EMAIL_TAKEN');
-    const passwordHash = await bcrypt.hash(input.password, Number(process.env.BCRYPT_SALT) || 10);
-    return prisma.user.create({
-        data: {
-            email: input.email,
-            passwordHash,
-            name: input.name ?? null,
-            role: input.role ?? 'USER',
-            profile: {
-                create: {
-                    bio: input.bio ?? null,
-                    avatarUrl: input.avatarUrl ?? null,
-                },
-            },
+        async adminCreateUser(input) {
+            const exists = await userRepo.findByEmail(input.email);
+            if (exists)
+                throw new Error('EMAIL_TAKEN');
+            const rounds = Number(process.env.BCRYPT_SALT) || 10;
+            const passwordHash = await bcrypt.hash(input.password, rounds);
+            return userRepo.create({
+                email: input.email,
+                passwordHash,
+                name: input.name ?? null,
+                role: input.role ?? 'USER',
+                bio: input.bio ?? null,
+                avatarUrl: input.avatarUrl ?? null,
+            });
         },
-        select: {
-            id: true,
-            email: true,
-            name: true,
-            role: true,
-            profile: { select: { bio: true, avatarUrl: true } },
-            createdAt: true,
-            updatedAt: true,
+        adminUpdateUser(id, input) {
+            return userRepo.update(id, input);
         },
-    });
-}
-export async function adminUpdateUser(id, input) {
-    return prisma.user.update({
-        where: { id },
-        data: {
-            name: input.name ?? undefined,
-            role: input.role ?? undefined,
-            profile: {
-                upsert: {
-                    create: { bio: input.bio ?? null, avatarUrl: input.avatarUrl ?? null },
-                    update: { bio: input.bio ?? null, avatarUrl: input.avatarUrl ?? null },
-                },
-            },
-        },
-        select: {
-            id: true, email: true, name: true, role: true,
-            profile: { select: { bio: true, avatarUrl: true } },
-            createdAt: true, updatedAt: true,
+        async adminDeleteUser(id) {
+            await userRepo.delete(id);
+            return { ok: true };
         },
-    });
-}
-export async function adminDeleteUser(id) {
-    const user = await prisma.user.findUnique({ where: { id } });
-    await prisma.user.delete({ where: { id } });
-    return { ok: true };
+    };
 }

package/dist/modules/user/user.types.d.ts

@@ -1 +1,46 @@
-export {};
+export type Role = 'USER' | 'ADMIN';
+export type UserListItem = {
+    id: number | string;
+    email: string;
+    name: string | null;
+    role: Role;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+    profile?: {
+        bio: string | null;
+        avatarUrl: string | null;
+    } | null;
+};
+export type ListUsersQuery = {
+    page: number;
+    pageSize: number;
+    role?: Role;
+    search?: string;
+    sort?: `${'createdAt' | 'updatedAt' | 'email' | 'name'}:${'asc' | 'desc'}`;
+};
+export type Paginated<T> = {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+    items: T[];
+};
+export type UpdateMeInput = {
+    name?: string | null;
+    bio?: string | null;
+    avatarUrl?: string | null;
+};
+export type AdminCreateUserInput = {
+    email: string;
+    password: string;
+    name?: string | null;
+    role?: Role;
+    bio?: string | null;
+    avatarUrl?: string | null;
+};
+export type AdminUpdateUserInput = {
+    name?: string | null;
+    role?: Role;
+    bio?: string | null;
+    avatarUrl?: string | null;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "my-crud-lib",
-  "version": "1.0.0",
-  "description": "Libreria CRUD modulare (Auth/User/Profile) con Prisma + TS",
+  "version": "1.0.2",
+  "description": "Libreria CRUD modulare (Auth/User/Profile) con TS; Prisma opzionale via adapter",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -10,10 +10,16 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./adapter-prisma": {
+      "import": "./dist/adapters/prisma.js",
+      "types": "./dist/adapters/prisma.d.ts"
     }
   },
   "files": [
     "dist",
+    "README.md",
+    "LICENSE",
     "prisma/schema.prisma"
   ],
   "engines": {
@@ -31,7 +37,6 @@
     "prisma:generate": "prisma generate",
     "prisma:migrate": "prisma migrate dev",
     "prisma:studio": "prisma studio",
-    "postinstall": "prisma generate",
     "prepublishOnly": "npm run build",
     "db:schema": "docker exec -i mycrud_postgres psql -U app -d mycrud -v ON_ERROR_STOP=1 -f /dev/stdin < prisma/schema.sql",
     "db:seed": "docker exec -i mycrud_postgres psql -U app -d mycrud -v ON_ERROR_STOP=1 -f /dev/stdin < prisma/seed.sql",
@@ -45,20 +50,30 @@
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.3.0",
     "prisma": "^6.14.0",
+    "@prisma/client": "^6.14.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@prisma/client": "^6.14.0",
     "bcryptjs": "^2.4.3",
     "dotenv": "^16.3.1",
     "jsonwebtoken": "^9.0.2",
     "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "body-parser": "^1.20.2",
+    "express": "^4.18.2",
     "cors": "^2.8.5",
-    "express": "^4.18.2"
+    "body-parser": "^1.20.2",
+    "@prisma/client": "^6.14.0",
+    "prisma": "^6.14.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": true
+    },
+    "prisma": {
+      "optional": true
+    }
   },
   "publishConfig": {
     "access": "public"