diff --git a/src/db/relations/collection-like.relation.ts b/src/db/relations/collection-like.relation.ts
index 73292d5f525f847e39e4b20d6f5c9647ca35614f..6c919854d3fd59f20ad58071587d2b59c4791b91 100644
--- a/src/db/relations/collection-like.relation.ts
+++ b/src/db/relations/collection-like.relation.ts
@@ -1,4 +1,4 @@
-import { integer, pgTable } from "drizzle-orm/pg-core";
+import { integer, pgTable, serial } from "drizzle-orm/pg-core";
 import userTable from "../schema/user.schema";
 import collectionTable from "../schema/collection.schema";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
@@ -6,8 +6,15 @@ import type { z } from "zod";
 import { relations } from "drizzle-orm";
 
 const collectionLikesTable = pgTable("collection_likes", {
-    user_id: integer("user_id").notNull().references(() => userTable.id, {onDelete: 'cascade'}),
-    collection_id: integer("collection").notNull().references(() => collectionTable.id, {onDelete: 'cascade'})
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  user_id: integer("user_id")
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  collection_id: integer("collection")
+    .notNull()
+    .references(() => collectionTable.id, {onDelete: 'cascade'})
 })
 
 export const collectionLikesRelations = relations(collectionLikesTable, ({one}) => ({
diff --git a/src/db/relations/collection-resource.relation.ts b/src/db/relations/collection-resource.relation.ts
index 45fa58049c8534a9977c4722b8c46329d93381fb..ca1a9347f05e51ebc806c64694e7c67f5a2e23a3 100644
--- a/src/db/relations/collection-resource.relation.ts
+++ b/src/db/relations/collection-resource.relation.ts
@@ -1,12 +1,19 @@
-import { integer, pgTable } from "drizzle-orm/pg-core"
+import { integer, pgTable, serial } from "drizzle-orm/pg-core"
 import { collectionTable, resourceTable } from "../schema"
 import { relations } from "drizzle-orm"
 import { createInsertSchema, createSelectSchema } from "drizzle-zod"
 import type { z } from "zod"
 
 const collectionResourcesTable = pgTable("collection_resources", {
-  collection_id: integer("collection_id").notNull().references(() => collectionTable.id, { onDelete: 'cascade' }),
-  resource_id: integer("resource_id").notNull().references(() => resourceTable.id, { onDelete: 'cascade'})
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  collection_id: integer("collection_id")
+    .notNull()
+    .references(() => collectionTable.id, { onDelete: 'cascade' }),
+  resource_id: integer("resource_id")
+    .notNull()
+    .references(() => resourceTable.id, { onDelete: 'cascade'})
 })
 
 export const collectionResourcesRelations = relations(collectionResourcesTable, ({one}) => ({
diff --git a/src/db/relations/followers.relation.ts b/src/db/relations/followers.relation.ts
index cbcc43227b6527cc1e2c43cb5a31568bd2cf83de..53888a4b64e5e17c610b0a31028defa530e3807e 100644
--- a/src/db/relations/followers.relation.ts
+++ b/src/db/relations/followers.relation.ts
@@ -9,11 +9,11 @@ const followRelationTable = pgTable('followers', {
     .unique()
     .notNull(),
   user_id: integer('user_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
   follower_id: integer('follower_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
 })
 
 export const followRelationTableRelations = relations(
diff --git a/src/db/relations/notification.relation.ts b/src/db/relations/notification.relation.ts
index ed932ee0f34bea64e0006685ca6718742e88b926..0a50a4f8813abd81d746fb3f8abb03ff41be2054 100644
--- a/src/db/relations/notification.relation.ts
+++ b/src/db/relations/notification.relation.ts
@@ -12,18 +12,15 @@ const notificationRelationTable = pgTable('notifications', {
     .references(() => actionTable.id, {onDelete: 'cascade'})
     .notNull(),
   actor_user_id: integer('actor_user_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
   target_user_id: integer('target_user_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
   target_resource_id: integer('target_resource_id')
-  .references(() => resourceTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => resourceTable.id, {onDelete: 'cascade'}),
   target_collection_id: integer('target_collection_id')
-  .references(() => collectionTable.id, {onDelete: 'cascade'})
-  .notNull(),
-  
+    .references(() => collectionTable.id, {onDelete: 'cascade'}),
   createdAt: timestamp('created_at', { mode: 'string' })
     .notNull()
     .defaultNow(),
diff --git a/src/db/relations/resource-educational-stage.relation.ts b/src/db/relations/resource-educational-stage.relation.ts
index 7821673f58c2842d97acba265e6e361cc489a2b8..ffeb3a629e0e3388ba018c7bfaa3ddd865e59f34 100644
--- a/src/db/relations/resource-educational-stage.relation.ts
+++ b/src/db/relations/resource-educational-stage.relation.ts
@@ -1,4 +1,4 @@
-import { integer, pgTable } from "drizzle-orm/pg-core";
+import { integer, pgTable, serial } from "drizzle-orm/pg-core";
 import resourceTable from "../schema/resource.schema";
 import educationalStageTable from "../schema/educational-stage.schema";
 import { relations } from "drizzle-orm";
@@ -7,8 +7,15 @@ import type { z } from "zod";
 
 
 const resourceEducationalStagesTable = pgTable('resource_educational_stages', {
-    resource_id: integer('resource_id').notNull().references(() => resourceTable.id, { onDelete: 'cascade' }),
-    educational_stage_id: integer('educational_stage_id').notNull().references(() => educationalStageTable.id, { onDelete: 'cascade' })
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  resource_id: integer('resource_id')
+    .notNull()
+    .references(() => resourceTable.id, { onDelete: 'cascade' }),
+  educational_stage_id: integer('educational_stage_id')
+    .notNull()
+    .references(() => educationalStageTable.id, { onDelete: 'cascade' })
 })
 
 export const resourceEducationalStagesRelations = relations(resourceEducationalStagesTable, ({ one }) => ({
diff --git a/src/db/relations/resource-language.relation.ts b/src/db/relations/resource-language.relation.ts
index b22d4486f4d5edef1e638a8b47b41e42f78fa2e0..81873bdea16f2de7449f075500f12f83f1525542 100644
--- a/src/db/relations/resource-language.relation.ts
+++ b/src/db/relations/resource-language.relation.ts
@@ -1,4 +1,4 @@
-import { integer, pgTable } from "drizzle-orm/pg-core";
+import { integer, pgTable, serial } from "drizzle-orm/pg-core";
 import resourceTable from "../schema/resource.schema";
 import languageTable from "../schema/language.schema";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
@@ -7,8 +7,15 @@ import { relations } from "drizzle-orm";
 
 
 const resourceLanguagesTable = pgTable('resource_languages', {
-    resource_id: integer('resource_id').notNull().references(() => resourceTable.id, {onDelete:'cascade'}),
-    language_id: integer('language_id').notNull().references(() => languageTable.id, {onDelete:'cascade'})
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  resource_id: integer('resource_id')
+    .notNull()
+    .references(() => resourceTable.id, {onDelete:'cascade'}),
+  language_id: integer('language_id')
+    .notNull()
+    .references(() => languageTable.id, {onDelete:'cascade'})
 })
 
 
diff --git a/src/db/relations/resource-like.relation.ts b/src/db/relations/resource-like.relation.ts
index 0b99ed3f18253aa9c6a7cc65ad1a9f407f7009b2..80b1dd2452e8fb8960aae71f37575195df460a7d 100644
--- a/src/db/relations/resource-like.relation.ts
+++ b/src/db/relations/resource-like.relation.ts
@@ -1,12 +1,19 @@
-import { integer, pgTable } from "drizzle-orm/pg-core";
+import { integer, pgTable, serial } from "drizzle-orm/pg-core";
 import { resourceTable, userTable } from "../schema";
 import { relations } from "drizzle-orm";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import type { z } from "zod";
 
 const resourceLikesTable = pgTable("resource_likes", {
-  user_id: integer("user_id").notNull().references(() => userTable.id, { onDelete: 'cascade' }),
-  resource_id: integer("resource_id").notNull().references(() => resourceTable.id, { onDelete: 'cascade' })
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  user_id: integer("user_id")
+    .notNull()
+    .references(() => userTable.id, { onDelete: 'cascade' }),
+  resource_id: integer("resource_id")
+    .notNull()
+    .references(() => resourceTable.id, { onDelete: 'cascade' })
 })
 
 export const resourceLikesRelations = relations(resourceLikesTable, ({ one }) => ({
diff --git a/src/db/relations/resource-subject.relation.ts b/src/db/relations/resource-subject.relation.ts
index d3add64bb4e8e1c8ddc87b5a222b6f8d97b429e0..8d97f3ce849b07fa06d09d92e33ad19e301575ef 100644
--- a/src/db/relations/resource-subject.relation.ts
+++ b/src/db/relations/resource-subject.relation.ts
@@ -1,4 +1,4 @@
-import { integer, pgTable } from "drizzle-orm/pg-core";
+import { integer, pgTable, serial } from "drizzle-orm/pg-core";
 import resourceTable from "../schema/resource.schema";
 import subjectsTable from "../schema/subject.schema";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
@@ -6,6 +6,9 @@ import type { z } from "zod";
 import { relations } from "drizzle-orm";
 
 const resourceSubjectsTable = pgTable('resource_subjects', {
+    id: serial('id').primaryKey()
+      .unique()
+      .notNull(),
     resource_id: integer('resource_id').notNull().references(() => resourceTable.id, {onDelete:'cascade'}),
     subject_id: integer('subject_id').notNull().references(() => subjectsTable.id, {onDelete:'cascade'})
 })
diff --git a/src/db/relations/user-achievement.relation.ts b/src/db/relations/user-achievement.relation.ts
index fca23ef55a5799620fd5731195b0c8b9e99dd59f..8e555ba2627a7ce9136fd148f4dcff01c9ecb4d0 100644
--- a/src/db/relations/user-achievement.relation.ts
+++ b/src/db/relations/user-achievement.relation.ts
@@ -1,12 +1,19 @@
-import { integer, pgTable } from "drizzle-orm/pg-core";
+import { integer, pgTable, serial } from "drizzle-orm/pg-core";
 import { achievementTable, userTable } from "../schema";
 import { relations } from "drizzle-orm";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import type { z } from "zod";
 
 const userAchievementsTable = pgTable("user_achievements", {
-    user_id: integer("user_id").notNull().references(() => userTable.id, {onDelete: 'cascade'}),
-    achievement_id: integer("achievement_id").notNull().references(() => userTable.id, {onDelete: 'cascade'})
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  user_id: integer("user_id")
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  achievement_id: integer("achievement_id")
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'})
 })
 
 export const userAchievementRelations = relations(userAchievementsTable, ({one}) => ({
diff --git a/src/db/relations/user-institution.relation.ts b/src/db/relations/user-institution.relation.ts
index 6bf889f0834fb7de363aa4e52dbd3d27a75e8e61..55ce59046865e13940451a4122ee00538ac7d3dd 100644
--- a/src/db/relations/user-institution.relation.ts
+++ b/src/db/relations/user-institution.relation.ts
@@ -9,11 +9,11 @@ const userInstitutionRelationTable = pgTable('user_institutions', {
     .unique()
     .notNull(),
   user_id: integer('user_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
   institution_id: integer('institution_id')
-  .references(() => institutionTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => institutionTable.id, {onDelete: 'cascade'})
+    .notNull(),
 })
 
 export const userInstitutionRelationTableRelations = relations(
diff --git a/src/db/relations/user-item.relation.ts b/src/db/relations/user-item.relation.ts
index e33a5efe43451fbffd51c3cb63b91c322ae17777..b5344dc4a00059f78d7f3a228143949372ae388f 100644
--- a/src/db/relations/user-item.relation.ts
+++ b/src/db/relations/user-item.relation.ts
@@ -9,11 +9,11 @@ const userItemRelationTable = pgTable('user_items', {
     .unique()
     .notNull(),
   user_id: integer('user_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
   item_id: integer('item_id')
-  .references(() => itemsTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => itemsTable.id, {onDelete: 'cascade'})
+    .notNull(),
 })
 
 export const userItemRelationTableRelations = relations(
diff --git a/src/db/relations/user-role.relation.ts b/src/db/relations/user-role.relation.ts
index 690c4f6e61f26d5a01b696982b6e66e15c596df7..148bd23dc54dd62bf40fc31d84298c08c3256f6d 100644
--- a/src/db/relations/user-role.relation.ts
+++ b/src/db/relations/user-role.relation.ts
@@ -9,11 +9,11 @@ const userRoleRelationTable = pgTable('user_roles', {
     .unique()
     .notNull(),
   user_id: integer('user_id')
-  .references(() => userTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => userTable.id, {onDelete: 'cascade'})
+    .notNull(),
   role_id: integer('role_id')
-  .references(() => roleTable.id, {onDelete: 'cascade'})
-  .notNull(),
+    .references(() => roleTable.id, {onDelete: 'cascade'})
+    .notNull(),
 })
 
 export const userRoleRelationTableRelations = relations(
diff --git a/src/db/repo/collection-stats.repo.ts b/src/db/repo/collection-stats.repo.ts
index 976219d0aee47fa01001879c7f0009a10fbd9c6e..16f82b383154b8c59c34f4b4e641b375f53edaf9 100644
--- a/src/db/repo/collection-stats.repo.ts
+++ b/src/db/repo/collection-stats.repo.ts
@@ -2,7 +2,6 @@ import { Service } from "typedi";
 import type {
   CollectionStatsInput,
   CollectionStatsModel,
-  CollectionStatsUpdate,
 } from '../schema/collection-stats.schema'
 import db from "..";
 import collectionStatsTable, { collectionStatsSchemas } from "../schema/collection-stats.schema";
@@ -11,7 +10,8 @@ import { eq, sql } from 'drizzle-orm'
 
 @Service()
 export class CollectionStatsRepo {
-  async create(collectionStats: CollectionStatsInput): Promise<CollectionStatsModel> {
+  async create(): Promise<CollectionStatsModel> {
+    const collectionStats: CollectionStatsInput = {}
     const [ret] = await db
       .insert(collectionStatsTable)
       .values(collectionStats)
diff --git a/src/db/repo/object-type.schema.ts b/src/db/repo/object-type.repo.ts
similarity index 100%
rename from src/db/repo/object-type.schema.ts
rename to src/db/repo/object-type.repo.ts
diff --git a/src/db/repo/stats-resources.repo.ts b/src/db/repo/resource-stats.repo.ts
similarity index 77%
rename from src/db/repo/stats-resources.repo.ts
rename to src/db/repo/resource-stats.repo.ts
index ed929412d8d4ce7a6d63a41f757856b11d695030..5a6f75001bb5dd38515c9f52de70af6aa648133f 100644
--- a/src/db/repo/stats-resources.repo.ts
+++ b/src/db/repo/resource-stats.repo.ts
@@ -6,8 +6,8 @@ import { sql } from "drizzle-orm";
 
 @Service()
 export class statsResourceRepo {
-    async create(statsResource: ResourceStatsInput
-    ): Promise<ResourceStatsModel> {
+    async create(): Promise<ResourceStatsModel> {
+        const statsResource: ResourceStatsInput = {}
         const [ret] = await db
             .insert(resourceStatsTable)
             .values(statsResource)
@@ -20,42 +20,42 @@ export class statsResourceRepo {
         const [ret] = await db
             .update(resourceStatsTable)
             .set(statsResource)
-            .where(eq(resourceStatsTable.resource_id, statsResource.resource_id))
+            .where(eq(resourceStatsTable.id, statsResource.id))
             .returning()
 
         return resourceStatsSchema.model.parse(ret)
     }
 
-    async sharesUpdate(resource_id: ResourceStatsModel['resource_id']): Promise<ResourceStatsModel> {
+    async sharesUpdate(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
         const [ret] = await db
         .update(resourceStatsTable)
         .set({
             shares: sql`${resourceStatsTable.shares} + 1` // Incrementa diretamente no SQL
         })
-        .where(eq(resourceStatsTable.resource_id, resource_id))
+        .where(eq(resourceStatsTable.id, id))
         .returning();
         return resourceStatsSchema.model.parse(ret)
     }
 
 
-    async viewUpdate(resource_id: ResourceStatsModel['resource_id']): Promise<ResourceStatsModel> {
+    async viewUpdate(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
         const [ret] = await db
             .update(resourceStatsTable)
             .set({
                 views: sql`${resourceStatsTable.views} + 1` // Incrementa diretamente no SQL
             })
-            .where(eq(resourceStatsTable.resource_id, resource_id))
+            .where(eq(resourceStatsTable.id, id))
             .returning();
         return resourceStatsSchema.model.parse(ret)
     }
 
-    async downloadUpdate(resource_id: ResourceStatsModel['resource_id']): Promise<ResourceStatsModel> {
+    async downloadUpdate(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
         const [ret] = await db
             .update(resourceStatsTable)
             .set({
                 downloads: sql`${resourceStatsTable.downloads} + 1` // Incrementa diretamente no SQL
             })
-            .where(eq(resourceStatsTable.resource_id, resource_id))
+            .where(eq(resourceStatsTable.id, id))
             .returning();
         return resourceStatsSchema.model.parse(ret)
     }
diff --git a/src/db/schema/achievement.schema.ts b/src/db/schema/achievement.schema.ts
index 4bcc9f9ab02d0ca1f122cffe5a81ab94d2180a00..16b18c7e540c2becebe89e7c7df8909f2a4e7595 100644
--- a/src/db/schema/achievement.schema.ts
+++ b/src/db/schema/achievement.schema.ts
@@ -1,22 +1,32 @@
-import { boolean, integer, numeric, pgEnum, pgTable, serial, text, timestamp, varchar } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { boolean, integer, numeric, pgTable, serial, text, timestamp, varchar } from "drizzle-orm/pg-core";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import { z } from "zod";
+import stateEnum from "./stateEnum.schema";
 
-const stateEnum = pgEnum('state', ['active', 'inactive', 'under_review'])
-
-const achievementTable = pgTable('achievements', {
-    id: serial('id').primaryKey().notNull().unique(),
-    name: varchar('name', { length: 255 }).notNull(),
-    description: text('description'),
-    reward_experience: numeric('reward_experience'),
-    reward_points: numeric('reward_points'),
-    // o campo state foi comentado pois a criação do tipo enum terá que ser feita manualmente na migração
-    //state: stateEnum('state').notNull().default('inactive'),
-    state: integer('state').notNull().default(0),
-    repeatable: integer('repeatable').notNull(),
-    is_resettable: boolean('is_resettable').notNull(),
-    created_at: timestamp('created_at', { mode: 'string' }).notNull().defaultNow(),
-    updated_at: timestamp('updated_at', { mode: 'string' }).notNull().defaultNow(),
+export const achievementTable = pgTable('achievements', {
+  id: serial('id').primaryKey()
+    .notNull()
+    .unique(),
+  name: varchar('name', { length: 255 })
+    .notNull(),
+  description: text('description'),
+  reward_experience: numeric('reward_experience'),
+  reward_points: numeric('reward_points'),
+  state: stateEnum('state')
+    .notNull()
+    .default('inactive'),
+  repeatable: integer('repeatable')
+    .notNull(),
+  is_resettable: boolean('is_resettable')
+    .notNull(),
+  created_at: timestamp('created_at', { mode: 'string' })
+    .notNull()
+    .defaultNow(),
+  updated_at: timestamp('updated_at', { mode: 'string' })
+    .notNull()
+    .defaultNow()
+    .$onUpdate(() => sql`current_timestamp`)
 })
 
 const achievementModelSchema = createSelectSchema(achievementTable)
diff --git a/src/db/schema/action.schema.ts b/src/db/schema/action.schema.ts
index 1bf4ecea73225cdd0764ed253f14dfcaad8f92cc..c6883835e65ffa3a62fc3ef8c07e11c490e6a56c 100644
--- a/src/db/schema/action.schema.ts
+++ b/src/db/schema/action.schema.ts
@@ -1,5 +1,5 @@
 import { sql } from "drizzle-orm"
-import { pgTable, serial, text, timestamp, varchar } from "drizzle-orm/pg-core"
+import { pgTable, serial, timestamp, varchar } from "drizzle-orm/pg-core"
 import { createInsertSchema, createSelectSchema } from "drizzle-zod"
 import type { z } from "zod"
 
@@ -8,7 +8,6 @@ const actionTable = pgTable('actions', {
     .unique()
     .notNull(),
   name: varchar('name', {length: 255})
-    .unique()
     .notNull(),
   createdAt: timestamp('created_at', { mode: 'string' })
     .notNull()
diff --git a/src/db/schema/collection-stats.schema.ts b/src/db/schema/collection-stats.schema.ts
index b5022022c24e6d264b48f4a5296193095dbbbcae..f114ee1de95484e71edfcb06dea89b3c874c5c9f 100644
--- a/src/db/schema/collection-stats.schema.ts
+++ b/src/db/schema/collection-stats.schema.ts
@@ -1,21 +1,34 @@
 import {
     pgTable,
     serial, 
-    bigint
+    integer,
+    numeric
   } from 'drizzle-orm/pg-core'
   import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
   import { z } from 'zod'
-import collectionTable from './collection.schema'
 
   const collectionStatsTable = pgTable('collection_stats', {
-    id: serial('id').primaryKey().notNull().unique(),
-    collectionId: bigint('collection_id', {mode: 'number'}).notNull().references(() => collectionTable.id, {onDelete: 'cascade'}),
-    views: bigint('views', {mode: 'number'}).default(0),
-    downloads: bigint('downloads', {mode: 'number'}).default(0),
-    likes: bigint('likes', {mode: 'number'}).default(0),
-    shares: bigint('shares', {mode: 'number'}).default(0),
-    score: bigint('score', {mode: 'number'}).default(0),
-    follows: bigint('follows', {mode: 'number'}).default(0),
+    id: serial('id').primaryKey()
+      .notNull()
+      .unique(),
+    views: integer('views')
+      .notNull()
+      .default(0),
+    downloads: integer('downloads')
+      .notNull()
+      .default(0),
+    likes: integer('likes')
+      .notNull()
+      .default(0),
+    shares: integer('shares')
+      .notNull()
+      .default(0),
+    score: numeric('score')
+      .notNull()
+      .default('0.0'),
+    follows: integer('follows')
+      .notNull()
+      .default(0),
   })
 
   const collectionStatsModelSchema = createSelectSchema(collectionStatsTable)
diff --git a/src/db/schema/collection.schema.ts b/src/db/schema/collection.schema.ts
index dba310adad5be409b32f833b43a3f51992d44a67..4a71b94500f4debcc5f00231fcfe4dc2ec482e75 100644
--- a/src/db/schema/collection.schema.ts
+++ b/src/db/schema/collection.schema.ts
@@ -1,5 +1,6 @@
 import {
   boolean,
+  integer,
   pgTable,
   serial, 
   text, 
@@ -8,22 +9,42 @@ import {
 } from 'drizzle-orm/pg-core'
 import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
 import { z } from 'zod'
+import userTable from './user.schema'
+import collectionStatsTable from './collection-stats.schema'
+import { sql } from 'drizzle-orm'
 
 const collectionTable = pgTable('collections', {
-  id: serial('id').primaryKey().notNull().unique(),
+  id: serial('id').primaryKey()
+    .notNull()
+    .unique(),
   name: varchar('name', { length: 255 }),
   description: text('description'),
-  is_private: boolean('is_private'),
-  is_active: boolean('is_active').default(true),
-  created_at: timestamp('created_at', { mode: 'string' }).notNull().defaultNow(),
-  updated_at: timestamp('updated_at', { mode: 'string' }),
+  is_private: boolean('is_private')
+    .default(false),
+  is_active: boolean('is_active')
+    .default(true),
+  created_at: timestamp('created_at', { mode: 'string' })
+    .notNull()
+    .defaultNow(),
+  updated_at: timestamp('updated_at', { mode: 'string' })
+    .notNull()
+    .defaultNow()
+    .$onUpdate(() => sql`current_timestamp`),
   deleted_at: timestamp('deleted_at', { mode: 'string' }),
   thumbnail: varchar('thumbnail', { length: 255 }),
+  user_id: integer('user_id')
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  collection_stats_id: integer('collection_stats_id')
+    .notNull()
+    .references(() => collectionStatsTable.id, {onDelete: 'cascade'}),
 })
 
 const collectionModelSchema = createSelectSchema(collectionTable)
 const collectionDtoSchema = collectionModelSchema
 const collectionInputSchema = createInsertSchema(collectionTable)
+.partial()
+.required({user_id: true})
 const collectionUpdateSchema = collectionInputSchema.partial().required({ id: true })
 
 export type CollectionModel = z.infer<typeof collectionModelSchema>
diff --git a/src/db/schema/complaint.schema.ts b/src/db/schema/complaint.schema.ts
index 063865220ae06dbbec98f500226388a9d0be6fc1..0d6d2e0c423ab383eff36707df195aaa8c0bd2a3 100644
--- a/src/db/schema/complaint.schema.ts
+++ b/src/db/schema/complaint.schema.ts
@@ -2,17 +2,33 @@ import { boolean, integer, pgTable, serial, text, timestamp } from "drizzle-orm/
 import userTable from "./user.schema";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import type { z } from "zod";
+import resourceTable from "./resource.schema";
+import collectionTable from "./collection.schema";
+import stateEnum from "./stateEnum.schema";
 
 const complaintTable = pgTable('complaints', {
-  id: serial('id').primaryKey().notNull(),
-  state: integer('state').notNull().default(0),
-  description: text('description').notNull(),
-  evaluatedUser_id: integer('evaluatedUser').notNull().references(() => userTable.id, {onDelete: 'cascade'}),
-  resource_id: integer('resource_id'),
-  collection_id: integer('collection_id'),  
-  user_id: integer('user_id'),
+  id: serial('id').primaryKey()
+    .notNull()
+    .unique(),
+  state: stateEnum('state')
+    .notNull()
+    .default('under_review'),
+  description: text('description')
+    .notNull(),
+  denouncer_id: integer('denouncer_id')
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  resource_id: integer('resource_id')
+    .notNull()
+    .references(() => resourceTable.id, {onDelete: 'cascade'}),
+  collection_id: integer('collection_id')
+    .references(() => collectionTable.id, {onDelete: 'cascade'}),
+  user_id: integer('user_id')
+    .references(() => userTable.id, {onDelete: 'cascade'}),
   evaluated_at: timestamp('evaluated_at'),
-  created_at: timestamp('created_at').notNull().defaultNow(),
+  created_at: timestamp('created_at')
+    .notNull()
+    .defaultNow(),
   q1: boolean('q1'),
   q2: boolean('q2'),
   q3: boolean('q3'),
diff --git a/src/db/schema/educational-stage.schema.ts b/src/db/schema/educational-stage.schema.ts
index e68d2a55f053645f3b0a7207ed4a476a5c65654d..a1909d7bf5a903bc5b1a74b6fe0c5de2bdfbd153 100644
--- a/src/db/schema/educational-stage.schema.ts
+++ b/src/db/schema/educational-stage.schema.ts
@@ -5,8 +5,11 @@ import type { z } from 'zod'
 
 
 const educationalStageTable = pgTable('educational_stages', {
-    id: serial('id').primaryKey().unique().notNull(),
-    name: varchar('name').unique().notNull(),
+    id: serial('id').primaryKey()
+      .unique()
+      .notNull(),
+    name: varchar('name', { length: 255 })
+      .notNull(),
 })
 
 export const educationalStagesRelations = relations(educationalStageTable, ({many}) => ({
diff --git a/src/db/schema/index.ts b/src/db/schema/index.ts
index 1b9bd16a07f8278f0b8e231385380bd961bd2f08..2c1a609a6248b705b10bd8d9cbcbad6c99bb1425 100644
--- a/src/db/schema/index.ts
+++ b/src/db/schema/index.ts
@@ -31,6 +31,7 @@ import userAchievementsTable from '../relations/user-achievement.relation'
 import actionTable from './action.schema'
 import notificationRelationTable from '../relations/notification.relation'
 import userItemRelationTable from '../relations/user-item.relation'
+import stateEnum from './stateEnum.schema'
 
 export {
   userTable,
@@ -65,6 +66,7 @@ export {
   actionTable,
   notificationRelationTable,
   userItemRelationTable,
+  stateEnum,
 }
 
 export const tables = [
diff --git a/src/db/schema/item.schema.ts b/src/db/schema/item.schema.ts
index 2314e1fb57af33b2733d5c8816eb40ab197f4c9e..97b277c8f6bdaf3b0373c331bc4cd4f2dbb6b9e1 100644
--- a/src/db/schema/item.schema.ts
+++ b/src/db/schema/item.schema.ts
@@ -1,4 +1,4 @@
-import { boolean, serial, timestamp, varchar } from "drizzle-orm/pg-core";
+import { boolean, serial, text, timestamp, varchar } from "drizzle-orm/pg-core";
 import { integer, numeric, pgTable } from "drizzle-orm/pg-core";
 import achievementTable from "./achievement.schema";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
@@ -8,16 +8,25 @@ import { sql } from "drizzle-orm";
 
 
 const itemsTable = pgTable('items', {
-    id: serial('id').primaryKey().unique().notNull(),
-    name: varchar('name', { length: 256 }).notNull(),
-    price: numeric('price', { precision: 10, scale: 2 }),
-    discount: numeric('discount', { precision: 10, scale: 2 }),
-    description: varchar('description', { length: 256 }),
-    is_active: boolean('is_active').default(false),
-    item_type: varchar('item_type', { length: 256 }),
-    created_at: timestamp('created_at', { mode: 'string' }).notNull().defaultNow(),
-    updated_at: timestamp('updated_at', { mode: 'string' }).$onUpdate(() => sql`current_timestamp`).notNull(),
-    achievement_id: integer('achievement_id').references(() => achievementTable.id)
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  name: varchar('name', { length: 255 })
+    .notNull(),
+  price: numeric('price'),
+  discount: numeric('discount'),
+  description: text('description'),
+  is_active: boolean('is_active')
+    .default(false),
+  created_at: timestamp('created_at', { mode: 'string' })
+    .notNull()
+    .defaultNow(),
+  updated_at: timestamp('updated_at', { mode: 'string' })
+  .notNull()
+  .defaultNow()
+  .$onUpdate(() => sql`current_timestamp`),
+  achievement_id: integer('achievement_id')
+    .references(() => achievementTable.id)
 })
 
 const itemsModelSchema = createSelectSchema(itemsTable)
diff --git a/src/db/schema/language.schema.ts b/src/db/schema/language.schema.ts
index 28d28b2476e235d07604c2829cfd9039b918ef22..dc3d8aa37d5e5e47d69b136f075b96ac752b62e9 100644
--- a/src/db/schema/language.schema.ts
+++ b/src/db/schema/language.schema.ts
@@ -6,9 +6,14 @@ import resourceLanguagesTable from "../relations/resource-language.relation";
 
 
 const languageTable = pgTable('languages', {
-    id: serial('id').primaryKey().unique(),
-    name: varchar('name').notNull().unique(),
-    code: varchar('code').notNull().unique()
+    id: serial('id').primaryKey()
+      .unique()
+      .notNull(),
+    name: varchar('name', { length: 255 })
+      .notNull(),
+    code: varchar('code', { length: 10 })
+      .notNull()
+      .unique()
 })
 
 
diff --git a/src/db/schema/license.schema.ts b/src/db/schema/license.schema.ts
index 750c92c65446e1d78afc2793c31083015472685e..09d512f984f33a9f95c918f1394d2cf845328f9f 100644
--- a/src/db/schema/license.schema.ts
+++ b/src/db/schema/license.schema.ts
@@ -1,4 +1,4 @@
-import { varchar } from "drizzle-orm/pg-core";
+import { text, varchar } from "drizzle-orm/pg-core";
 import { serial } from "drizzle-orm/pg-core";
 import { pgTable } from "drizzle-orm/pg-core";
 import { createInsertSchema, createSelectSchema } from "drizzle-zod";
@@ -7,10 +7,15 @@ import type { z } from 'zod'
 
 
 const licenseTable = pgTable('licenses', {
-    id: serial('id').primaryKey().unique(),
-    name: varchar('name').notNull().unique(),
-    description: varchar('description').notNull(),
-    url: varchar('url').notNull(),
+    id: serial('id').primaryKey()
+      .unique()
+      .notNull(),
+    name: varchar('name', { length: 255 })
+      .notNull(),
+    description: text('description')
+      .notNull(),
+    url: varchar('url', { length: 255 })
+      .notNull(),
 })
 
 const licenseModelSchema = createSelectSchema(licenseTable)
diff --git a/src/db/schema/object-type.schema.ts b/src/db/schema/object-type.schema.ts
index c41210bb8d60aa17b58f443e6d8a24d607e5d675..dd83bef004d41ec900b17232f9aecad3fe15aa94 100644
--- a/src/db/schema/object-type.schema.ts
+++ b/src/db/schema/object-type.schema.ts
@@ -4,8 +4,11 @@ import type { z } from 'zod'
 
 
 const objectTypeTable = pgTable("object_types", {
-    id: serial("id").primaryKey().notNull().unique(),
-    name: varchar("name", { length: 255 }).notNull(),
+    id: serial("id").primaryKey()
+      .notNull()
+      .unique(),
+    name: varchar("name", { length: 255 })
+      .notNull(),
 }
 )
 
diff --git a/src/db/schema/resource-stats.schema.ts b/src/db/schema/resource-stats.schema.ts
index 0e7d1eb2621c9af1e07cd2b23e2e96c05b376ce1..2c63b2d32a3870f939a9c6503f4e03cc0ea65383 100644
--- a/src/db/schema/resource-stats.schema.ts
+++ b/src/db/schema/resource-stats.schema.ts
@@ -1,20 +1,35 @@
 import {
     pgTable,
     serial,
-    bigint
+    integer,
+    numeric
 } from 'drizzle-orm/pg-core'
-import resourceTable from './resource.schema'
 import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
 import type { z } from 'zod'
 
 
 const resourceStatsTable = pgTable('resource_stats', {
-    id: serial('id').notNull().primaryKey().unique(),
-    resource_id: bigint('resource_id', {mode: 'number'}).notNull().references(() => resourceTable.id, {onDelete: 'cascade'}),
-    views: bigint('views', {mode: 'number'}).notNull().default(0),
-    downloads: bigint('downloads', {mode: 'number'}).notNull().default(0),
-    shares: bigint('shares', {mode: 'number'}).notNull().default(0),
-    score: bigint('score', {mode: 'number'}).notNull().default(0)
+    id: serial('id').notNull()
+      .primaryKey()
+      .unique(),
+    views: integer('views')
+      .notNull()
+      .default(0),
+    downloads: integer('downloads')
+      .notNull()
+      .default(0),
+    likes: integer('likes')
+      .notNull()
+      .default(0),
+    shares: integer('shares')
+      .notNull()
+      .default(0),
+    score: numeric('score')
+      .notNull()
+      .default('0.0'),
+    follows: integer('follows')
+      .notNull()
+      .default(0),
 })
 
 const resourceStatsModelSchema = createSelectSchema(resourceStatsTable)
@@ -22,7 +37,7 @@ const resourceStatsDtoSchema = resourceStatsModelSchema.omit({})
 const resourceStatsInputSchema = createInsertSchema(resourceStatsTable)
 const resourceStatsUpdateSchema = resourceStatsInputSchema
     .partial()
-    .required({ resource_id: true })
+    .required({ id: true })
 
 export type ResourceStatsModel = z.infer<typeof resourceStatsModelSchema>
 export type ResourceStatsDto = z.infer<typeof resourceStatsDtoSchema>
diff --git a/src/db/schema/resource.schema.ts b/src/db/schema/resource.schema.ts
index dd88b01ae1051b3afef842a1b063fc0870f48372..008644476d737ba8af441b179a652e07a861cf79 100644
--- a/src/db/schema/resource.schema.ts
+++ b/src/db/schema/resource.schema.ts
@@ -4,6 +4,8 @@ import {
     varchar,
     timestamp,
     boolean,
+    text,
+    integer,
 } from 'drizzle-orm/pg-core'
 import { relations, sql } from 'drizzle-orm'
 import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
@@ -11,24 +13,52 @@ import type { z } from 'zod'
 import resourceLanguagesTable from '../relations/resource-language.relation'
 import resourceSubjectsTable from '../relations/resource-subject.relation'
 import resourceEducationalStagesTable from '../relations/resource-educational-stage.relation'
+import userTable from './user.schema'
+import objectTypeTable from './object-type.schema'
+import licenseTable from './license.schema'
+import resourceStatsTable from './resource-stats.schema'
 
 //por padrao active é false, só é true quando o recurso é aprovado
 const resourceTable = pgTable('resources', {
-    id: serial('id').notNull().primaryKey().unique(),
-    name: varchar('name', { length: 256 }).notNull(),
-    author: varchar('author', { length: 256 }).notNull(),
-    description: varchar('description', { length: 256 }),
-    bucket_key: varchar('bucket_key', { length: 256 }).unique(),
-    link: varchar('link', { length: 256 }),
-    thumbnail: varchar('thumbnail', { length: 256 }).notNull(),
-    active: boolean('active').notNull().default(false),
-    published_at: timestamp('published_at', { mode: 'string' }),
-    submited_at: timestamp('submited_at', { mode: 'string' }),
-    created_at: timestamp('created_at', { mode: 'string' })
-        .notNull()
-        .defaultNow(),
-    updated_at: timestamp('updated_at', { mode: 'string' }).$onUpdate(() => sql`current_timestamp`),
-    deleted_at: timestamp('deleted_at', { mode: 'string' }),
+  id: serial('id').primaryKey()
+    .notNull()
+    .unique(),
+  name: varchar('name', { length: 255 })
+    .notNull(),
+  author: varchar('author', { length: 255 })
+    .notNull(),
+  bucket_key: varchar('bucket_key', { length: 255 })
+    .unique(),
+  link: varchar('link', { length: 255 }),
+  thumbnail: varchar('thumbnail', { length: 255 })
+    .notNull(),
+  description: text('description'),
+  active: boolean('active')
+    .notNull()
+    .default(false),
+  created_at: timestamp('created_at', { mode: 'string' })
+    .notNull()
+    .defaultNow(),
+  updated_at: timestamp('updated_at', { mode: 'string' })
+    .notNull()
+    .defaultNow()
+    .$onUpdate(() => sql`current_timestamp`),
+  published_at: timestamp('published_at', { mode: 'string' }),
+  submitted_at: timestamp('submitted_at', { mode: 'string' }),
+  deleted_at: timestamp('deleted_at', { mode: 'string' }),
+  user_id: integer('user_id')
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  resource_stats_id: integer('resource_stats_id')
+    .notNull()
+    .unique()
+    .references(() => resourceStatsTable.id, {onDelete: 'cascade'}),
+  object_type_id: integer('object_type_id')
+    .notNull()
+    .references(() => objectTypeTable.id, {onDelete: 'cascade'}),
+  license_id: integer('license_id')
+    .notNull()
+    .references(() => licenseTable.id, {onDelete: 'cascade'}),
 })
 
 
diff --git a/src/db/schema/stateEnum.schema.ts b/src/db/schema/stateEnum.schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e62861487b1ed6f3466f3aef3f66540c77616a6c
--- /dev/null
+++ b/src/db/schema/stateEnum.schema.ts
@@ -0,0 +1,8 @@
+import { pgEnum } from "drizzle-orm/pg-core"
+import { z } from "zod"
+
+const stateEnum = pgEnum('state', ['active', 'inactive', 'under_review'])
+const stateEnumSchema = z.enum(stateEnum.enumValues)
+
+export default stateEnum;
+export type StateEnum = z.infer<typeof stateEnumSchema>
\ No newline at end of file
diff --git a/src/db/schema/subject.schema.ts b/src/db/schema/subject.schema.ts
index 593bb37706a0b9c02e92191f037b9929938d33e5..ae5f499dc992aab8946c6e9b97de8c0de657e2a3 100644
--- a/src/db/schema/subject.schema.ts
+++ b/src/db/schema/subject.schema.ts
@@ -10,8 +10,11 @@ import type { z } from 'zod'
 
 
 const subjectsTable = pgTable('subjects', {
-    id: serial('id').primaryKey().unique(),
-    name: varchar('name').notNull().unique(),
+    id: serial('id').primaryKey()
+      .unique()
+      .notNull(),
+    name: varchar('name', { length: 255 })
+      .notNull(),
 })
 
 const subjectModelSchema = createSelectSchema(subjectsTable)
diff --git a/src/db/schema/submission.schema.ts b/src/db/schema/submission.schema.ts
index 03eb63b6ce980db92d44569745952a852808b3c6..f739db23a6e31db53b7d875b44f5bd7fdea39d02 100644
--- a/src/db/schema/submission.schema.ts
+++ b/src/db/schema/submission.schema.ts
@@ -3,21 +3,36 @@ import { createInsertSchema, createSelectSchema } from "drizzle-zod";
 import type { z } from "zod";
 import resourceTable from "./resource.schema";
 import userTable from "./user.schema";
+import { sql } from "drizzle-orm";
 
 const submissionTable = pgTable('submissions', {
-    id: serial('id').primaryKey().notNull(),
-    is_accepted: boolean('is_accepted').default(false).notNull(),
-    justification: text('justification'),
-    resource_id: integer('resource_id').notNull().references(() => resourceTable.id, {onDelete: 'cascade'}),
-    submitter_id: integer('submitter_id').notNull().references(() => userTable.id, {onDelete: 'cascade'}),
-    curator_id: integer('curator_id').notNull().references(() => userTable.id, {onDelete: 'cascade'}),
-    created_at: timestamp('created_at').notNull().defaultNow(),
-    updated_at: timestamp('updated_at'),
-    answered_at: timestamp('answered_at'),
-    q1: boolean('q1'),
-    q2: boolean('q2'),
-    q3: boolean('q3'),
-    q4: boolean('q4'),
+  id: serial('id').primaryKey()
+    .unique()
+    .notNull(),
+  is_accepted: boolean('is_accepted')
+    .default(false)
+    .notNull(),
+  justification: text('justification'),
+  resource_id: integer('resource_id')
+    .notNull()
+    .references(() => resourceTable.id, {onDelete: 'cascade'}),
+  submitter_id: integer('submitter_id')
+    .notNull()
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  curator_id: integer('curator_id')
+    .references(() => userTable.id, {onDelete: 'cascade'}),
+  created_at: timestamp('created_at')
+    .notNull()
+    .defaultNow(),
+  updated_at: timestamp('updated_at')
+    .notNull()
+    .defaultNow()
+    .$onUpdate(() => sql`current_timestamp`),
+  answered_at: timestamp('answered_at'),
+  q1: boolean('q1'),
+  q2: boolean('q2'),
+  q3: boolean('q3'),
+  q4: boolean('q4'),
 })
 
 const submissionModelSchema = createSelectSchema(submissionTable)
@@ -31,10 +46,10 @@ export type SubmissionInput = z.infer<typeof submissionInputSchema>
 export type SubmissionUpdate = z.infer<typeof submissionUpdateSchema>
 
 export const submissionSchemas = {
-    submissionModelSchema,
-    submissionDtoSchema,
-    submissionInputSchema,
-    submissionUpdateSchema,
+  submissionModelSchema,
+  submissionDtoSchema,
+  submissionInputSchema,
+  submissionUpdateSchema,
 }
 
 export default submissionTable
\ No newline at end of file
diff --git a/src/db/schema/user.schema.ts b/src/db/schema/user.schema.ts
index 0f552c4480198b7d9bbf489f3b3e01af8cce403e..d6c6dd349c680eaf7dbe2ee7065b6fc0f9457c8d 100644
--- a/src/db/schema/user.schema.ts
+++ b/src/db/schema/user.schema.ts
@@ -24,7 +24,8 @@ const userTable = pgTable('users', {
     .default("sem instituição"),
   birthday: timestamp('birthday', { mode: 'string' })
     .notNull(),
-  cpf: varchar('cpf', { length: 255 })
+  cpf: varchar('cpf', { length: 11 })
+    .unique()
     .notNull(),
   createdAt: timestamp('created_at', { mode: 'string' })
     .notNull()
diff --git a/src/db/seed.ts b/src/db/seed.ts
index fad4420ae27cb9e15919a38b3e4fd53748aa416d..b70603a544967a72d077ff7da99e9cb646e91a7e 100644
--- a/src/db/seed.ts
+++ b/src/db/seed.ts
@@ -23,16 +23,16 @@ for (const table of schema.tables) {
 
 await seeds.userStatsSeed(db)
 await seeds.userSeed(db)
-await seeds.resourceSeed(db)
+await seeds.objectTypeSeed(db)
+await seeds.licenseSeed(db)
 await seeds.resourceStatsSeed(db)
-await seeds.collectionSeed(db)
+await seeds.resourceSeed(db)
 await seeds.collectionStatsSeed(db)
+await seeds.collectionSeed(db)
 await seeds.subjectsData(db)
 await seeds.submissionSeed(db)
-await seeds.licenseSeed(db)
 await seeds.languageSeed(db)
 await seeds.educationalStageSeed(db)
-await seeds.objectTypeSeed(db)
 await seeds.roleSeed(db)
 await seeds.complaintSeed(db)
 await seeds.resourceLanguagesSeed(db)
diff --git a/src/db/seeds/achievement.seed.ts b/src/db/seeds/achievement.seed.ts
index 7fc5bec01ecc671f1f11b7d4967c6707b3205e3f..bfb0da532b4e42e5b4dc89f9c74e81977dea0e33 100644
--- a/src/db/seeds/achievement.seed.ts
+++ b/src/db/seeds/achievement.seed.ts
@@ -10,27 +10,27 @@ const achievementData: AchievementInput[] = [
     {
         name: 'Achievement 1',
         description: 'Achievement 1 description',
-        reward_experience: 100,
-        reward_points: 10,
-        state: 2,
+        reward_experience: '100',
+        reward_points: '10',
+        state: 'active',
         repeatable: 5,
         is_resettable: true,
     },
     {
         name: 'Achievement 2',
         description: 'Achievement 2 description',
-        reward_experience: 200,
-        reward_points: 20,
-        state: 1,
+        reward_experience: '200',
+        reward_points: '20',
+        state: 'active',
         repeatable: 5,
         is_resettable: true,
     },
     {
         name: 'Achievement 3',
         description: 'Achievement 3 description',
-        reward_experience: 300,
-        reward_points: 30,
-        state: 1,
+        reward_experience: '300',
+        reward_points: '30',
+        state: 'active',
         repeatable: 5,
         is_resettable: true,
     }
diff --git a/src/db/seeds/collection-stats.seed.ts b/src/db/seeds/collection-stats.seed.ts
index 2306cbe9c43a36eb170fe34066e8e6b3d7cad8bd..6fdf2411ef2338eca8a0e724326ee42f43dc02dd 100644
--- a/src/db/seeds/collection-stats.seed.ts
+++ b/src/db/seeds/collection-stats.seed.ts
@@ -8,30 +8,27 @@ export default async function seed(db:db) {
 
 const collectionStatsData: CollectionStatsInput[] = [
     {
-        collectionId: 1,
         views: 100,
         downloads: 50,
         likes: 20,
         shares: 10,
-        score: 4,
+        score: '4',
         follows: 5,
     },
     {
-        collectionId: 2,
         views: 200,
         downloads: 100,
         likes: 40,
         shares: 20,
-        score: 4,
+        score: '4',
         follows: 10,
     },
     {
-        collectionId: 3,
         views: 300,
         downloads: 150,
         likes: 60,
         shares: 30,
-        score: 4,
+        score: '4',
         follows: 15,
     }
 
diff --git a/src/db/seeds/collections.seed.ts b/src/db/seeds/collections.seed.ts
index e5fce56f4b94da88fbe70ffeb71cc8f60c1e3a28..0447040892006c3301a3db059ee043d6a1f4407b 100644
--- a/src/db/seeds/collections.seed.ts
+++ b/src/db/seeds/collections.seed.ts
@@ -12,17 +12,23 @@ const collectionData: CollectionInput[] = [
         description: 'Collection 1 description',
         is_private: false,
         thumbnail: 'https://www.google.com',
+        collection_stats_id: 1,
+        user_id: 1,
     },
     {
         name: 'Collection 2',
         description: 'Collection 2 description',
         is_private: true,
         thumbnail: 'https://www.google.com',
+        collection_stats_id: 2,
+        user_id: 1,
     },
     {
         name: 'Collection 3',
         description: 'Collection 3 description',
         is_private: false,
         thumbnail: 'https://www.google.com',
+        collection_stats_id: 3,
+        user_id: 1,
     }
 ]
diff --git a/src/db/seeds/complaints.seed.ts b/src/db/seeds/complaints.seed.ts
index 3fe32e2de68537d69aa4c25409e2dc63da7ebc08..04640e89fc577f9c01490657fd78a316609f3cce 100644
--- a/src/db/seeds/complaints.seed.ts
+++ b/src/db/seeds/complaints.seed.ts
@@ -9,9 +9,9 @@ export default async function seed(db: db){
 
 const complaintData: ComplaintInput[] = [
     {
-        state: 0,
+        state: 'under_review',
         description: 'I do not like this resource',
-        evaluatedUser_id: 1,
+        denouncer_id: 1,
         resource_id: 1,
         collection_id: null,
         user_id: null,
@@ -21,9 +21,9 @@ const complaintData: ComplaintInput[] = [
         q4: false,
     },
     {
-        state: 0,
+        state: 'under_review',
         description: 'I do not like this resource',
-        evaluatedUser_id: 1,
+        denouncer_id: 1,
         resource_id: 1,
         collection_id: null,
         user_id: null,
@@ -33,9 +33,9 @@ const complaintData: ComplaintInput[] = [
         q4: false,
     },
     {
-        state: 0,
+        state: 'under_review',
         description: 'I do not like this resource',
-        evaluatedUser_id: 1,
+        denouncer_id: 1,
         resource_id: 1,
         collection_id: null,
         user_id: null,
diff --git a/src/db/seeds/resource-educational-stages.seed.ts b/src/db/seeds/resource-educational-stages.seed.ts
index d3e274ba7ce97e003d3dc5e590603d4577f2ae36..5e830cf051aa3f1f651a7a8d9f5131b8bc53892d 100644
--- a/src/db/seeds/resource-educational-stages.seed.ts
+++ b/src/db/seeds/resource-educational-stages.seed.ts
@@ -1,5 +1,6 @@
 import type db from "..";
-import resourceEducationalStagesTable, { type ResourceEducationalStagesInput } from "../relations/resource-educational-stage.relation";
+import { resourceEducationalStagesTable } from "../schema";
+import type { ResourceEducationalStagesInput } from "../relations/resource-educational-stage.relation";
 
 export default async function seed(db: db) {
     await db.insert(resourceEducationalStagesTable).values(resourceEducationalStagesData);
diff --git a/src/db/seeds/resource.seed.ts b/src/db/seeds/resource.seed.ts
index e9ed442849858d6e80d6332026401ecf56cd7789..c51975ce38d2e70af97b7cddf99e388d6a701914 100644
--- a/src/db/seeds/resource.seed.ts
+++ b/src/db/seeds/resource.seed.ts
@@ -13,7 +13,11 @@ const resourceData: ResourceInput[] = [
         author: 'author 1',
         bucket_key: 'bucket_key 1',
         link: 'link 1',
-        thumbnail: 'thumbnail 1'
+        thumbnail: 'thumbnail 1',
+        user_id: 1,
+        resource_stats_id: 1,
+        object_type_id: 1,
+        license_id: 1
     },
     {
         name: 'recurso 2',
@@ -21,6 +25,10 @@ const resourceData: ResourceInput[] = [
         author: 'author 2',
         bucket_key: 'bucket_key 2',
         link: 'link 2',
-        thumbnail: 'thumbnail 2'
+        thumbnail: 'thumbnail 2',
+        user_id: 1,
+        resource_stats_id: 2,
+        object_type_id: 1,
+        license_id: 1
     }
 ]
diff --git a/src/db/seeds/resourceStats.seed.ts b/src/db/seeds/resourceStats.seed.ts
index 874752c7ca9d2807943a03c19e03d4979d7274fd..e5926180862772db025752675cd29ab8919b2a8b 100644
--- a/src/db/seeds/resourceStats.seed.ts
+++ b/src/db/seeds/resourceStats.seed.ts
@@ -9,17 +9,15 @@ export default async function seed(db: db) {
 
 const statsResourceData: ResourceStatsInput[] = [
     {
-        resource_id: 1,
         views: 0,
         downloads: 0,
         shares: 0,
-        score: 0
+        score: '0'
     },
     {
-        resource_id: 2,
         views: 0,
         downloads: 0,
         shares: 0,
-        score: 0
+        score: '0'
     }
 ]
diff --git a/src/index.ts b/src/index.ts
index 6ab19a2e2d5da25368538551c96b35c077925caf..5f9c51395795753ba85bfc86c4c915a627b64b95 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -10,7 +10,7 @@ import { bodyLimit } from 'hono/body-limit'
 import { HttpStatus, createApexError } from './services/error.service'
 import { userStatsRouter } from './routes/user-stats.route'
 import { publicResourceRouter, resourceRouter } from './routes/resource.route'
-import { publicStatsResourceRouter, statsResourceRouter } from './routes/stats-resource.route'
+import { publicResourceStatsRouter, resourceStatsRouter } from './routes/resource-stats.route'
 import { collectionsRouter, getCollections } from './routes/collections.route'
 import { signUpRouter, userRouter } from './routes/user.route'
 import { uploaderRouter } from './routes/uploader.route'
@@ -19,7 +19,7 @@ import { publicSubjectsRouter, subjectsRouter } from './routes/subjects.route'
 import { submissionRouter } from './routes/submission.route'
 import { licenseRouter, publicLicenseRouter } from './routes/license.route'
 import { languageRouter, publicLanguageRouter } from './routes/language.route'
-import { educationalStageRouter, publicEducationalStageRouter } from './routes/educational-stage.routes'
+import { educationalStageRouter, publicEducationalStageRouter } from './routes/educational-stage.route'
 import { passRouter } from './routes/password.route'
 import { objectTypeRouter, publicObjectTypeRouter } from './routes/object-type.route'
 import { roleRouter } from './routes/role.route'
@@ -80,7 +80,7 @@ app
   .route('/signup', signUpRouter)
   .route('/reset-password', passRouter)
   .route('/resource', publicResourceRouter)
-  .route('/statsResource', publicStatsResourceRouter)
+  .route('/statsResource', publicResourceStatsRouter)
   .route('/subjects', publicSubjectsRouter)
   .route('/get-collections', getCollections)
   .route('/get-collection-stats', getCollectionsStats)
@@ -104,7 +104,7 @@ app
   .route('/upload', uploaderRouter)
   .route('/user-stats', userStatsRouter)
   .route('/resource', resourceRouter)
-  .route('/statsResource', statsResourceRouter)
+  .route('/statsResource', resourceStatsRouter)
   .route('/subjects', subjectsRouter)
   .route('/collection', collectionsRouter)
   .route('/collection-stats', collectionsStatsRouter)
diff --git a/src/routes/achievement.route.ts b/src/routes/achievement.route.ts
index 90a8e66095d5beddb45b1d5c2e839bc37a51df1c..57180c4352771206fcec35cf1bec7ce8cba2721c 100644
--- a/src/routes/achievement.route.ts
+++ b/src/routes/achievement.route.ts
@@ -1,5 +1,5 @@
 import { AchievementService } from "@/services/achievement.service";
-import Container, { ContainerInstance } from "typedi";
+import Container from "typedi";
 import { honoWithJwt } from "..";
 import { zValidator } from "@hono/zod-validator";
 import { achievementSchemas } from "@/db/schema/achievement.schema";
diff --git a/src/routes/collection-stats.route.ts b/src/routes/collection-stats.route.ts
index 7e84b1a667a49dda60c796fcea67bb0779603b7c..d1e88d84f709ee6a87273c30dff0707388b74282 100644
--- a/src/routes/collection-stats.route.ts
+++ b/src/routes/collection-stats.route.ts
@@ -14,10 +14,9 @@ export const collectionsStatsRouter = honoWithJwt()
     zValidator('json', collectionStatsSchemas.collectionStatsInputSchema),
     async (c) => {
       try {
-        const input = await c.req.valid('json')
 
         const collectionStats = collectionStatsSchemas.collectionStatsDtoSchema.parse(
-          await service.create(input)
+          await service.create()
         )
 
         return c.json({ collectionStats })
diff --git a/src/routes/collections.route.ts b/src/routes/collections.route.ts
index effe7fa70ecef455074025168b5e5a5c75d3fa33..a0a964e2d5cffc59ed67276fb9764d149e35e561 100644
--- a/src/routes/collections.route.ts
+++ b/src/routes/collections.route.ts
@@ -19,12 +19,13 @@ export const collectionsRouter = honoWithJwt()
       try {
         const input = await c.req.valid('json')
 
-        const collection = collectionSchemas.collectionDtoSchema.parse(
-          await service.create(input)
+        const collectionStats = collectionStatsSchemas.collectionStatsDtoSchema.parse(
+          await serviceStats.create()
         )
 
-        const collectionStats = collectionStatsSchemas.collectionStatsDtoSchema.parse(
-          await serviceStats.create({ collectionId: collection.id })
+        input.collection_stats_id = collectionStats.id
+        const collection = collectionSchemas.collectionDtoSchema.parse(
+          await service.create(input)
         )
 
         return c.json({ collection, collectionStats })
diff --git a/src/routes/educational-stage.routes.ts b/src/routes/educational-stage.route.ts
similarity index 100%
rename from src/routes/educational-stage.routes.ts
rename to src/routes/educational-stage.route.ts
diff --git a/src/routes/stats-resource.route.ts b/src/routes/resource-stats.route.ts
similarity index 95%
rename from src/routes/stats-resource.route.ts
rename to src/routes/resource-stats.route.ts
index cc7aa053295f7c631145a5985808fa036072d977..db325bf9b15cf770d3faa49e705ee9de8c634d6a 100644
--- a/src/routes/stats-resource.route.ts
+++ b/src/routes/resource-stats.route.ts
@@ -1,4 +1,4 @@
-import { StatsResourceService } from "@/services/stats-resources.service";
+import { ResourceStatsService } from "@/services/resource-stats.service";
 import { zValidator } from "@hono/zod-validator";
 import Container from "typedi";
 import { honoWithJwt } from '..';
@@ -7,16 +7,18 @@ import { Hono } from "hono";
 import { resourceStatsSchema } from "@/db/schema/resource-stats.schema";
 
 
-const service = Container.get(StatsResourceService)
+const service = Container.get(ResourceStatsService)
 
-export const statsResourceRouter = honoWithJwt()
+export const resourceStatsRouter = honoWithJwt()
     // rota para criar as stats de um recurso
     .post('/create',
         zValidator('json', resourceStatsSchema.input),
         async (c) => {
             try {
-                const input = await c.req.valid('json')
-                const statsResource = resourceStatsSchema.dto.parse(await service.create(input))
+                
+                const statsResource = resourceStatsSchema.dto.parse(
+                    await service.create()
+                )
 
                 return c.json({ statsResource })
             } catch (e) {
@@ -82,7 +84,7 @@ export const statsResourceRouter = honoWithJwt()
         }
     )
 
-export const publicStatsResourceRouter = new Hono()
+export const publicResourceStatsRouter = new Hono()
 //rota para atualizar as views de um recurso, cada chamada soma 1 as views
     .post('/viewUpdate/:id',
         async (c) => {
diff --git a/src/routes/resource.route.ts b/src/routes/resource.route.ts
index cdb725b44275041a19cb1cdfc06db64adf21f50f..8dcdc0bfea0854891a7f001bb901b94ac4965305 100644
--- a/src/routes/resource.route.ts
+++ b/src/routes/resource.route.ts
@@ -6,10 +6,10 @@ import Container from "typedi";
 import { createApexError, HttpStatus } from "@/services/error.service";
 import { Hono } from "hono";
 import { resourceStatsSchema } from "@/db/schema/resource-stats.schema";
-import { StatsResourceService } from "@/services/stats-resources.service";
+import { ResourceStatsService } from "@/services/resource-stats.service";
 
 const service = Container.get(ResourceService);
-const serviceStats = Container.get(StatsResourceService);
+const serviceStats = Container.get(ResourceStatsService);
 
 export const resourceRouter = honoWithJwt()
     // rota para criar um recurso
@@ -19,10 +19,15 @@ export const resourceRouter = honoWithJwt()
         async (c) => {
             try {
                 const input = await c.req.valid('json')
-                const resource = resourceSchema.dto.parse(await service.create(input))
-
                 //cria o stats do recurso correspondente
-                const stats = resourceStatsSchema.dto.parse(await serviceStats.create({ resource_id: resource.id }))
+                const stats = resourceStatsSchema.dto.parse(
+                    await serviceStats.create()
+                )
+
+                input.resource_stats_id = stats.id
+                const resource = resourceSchema.dto.parse(
+                    await service.create(input)
+                )
 
                 return c.json({ resource, stats })
             } catch (e) {
diff --git a/src/routes/user-role.route.ts b/src/routes/user-role.route.ts
index 0b4ed7780d698a3537b6ce9faf088cde34aada5a..c2caaf8f537fe22f3b5f86da4a9ee11c6e0073d6 100644
--- a/src/routes/user-role.route.ts
+++ b/src/routes/user-role.route.ts
@@ -19,9 +19,9 @@ export const userRoleRouter = honoWithJwt()
     async (c) => {
       try{
         const input = await c.req.valid('json')
-        let user = await userService.findById(input.user_id)
-        let role = await roleService.findById(input.role_id) //tinha que ver questão de um usuario sem ser admin poder criar um admin
-        let alreadyRole = await service.findByUserRole(input) != 0        
+        const user = await userService.findById(input.user_id)
+        const role = await roleService.findById(input.role_id) //tinha que ver questão de um usuario sem ser admin poder criar um admin
+        const alreadyRole = await service.findByUserRole(input) != 0        
         if(user == null || role == null || alreadyRole){
           throw new Error()
         }
@@ -47,10 +47,10 @@ export const userRoleRouter = honoWithJwt()
     try{
       const user_id = +c.req.param('user_id')
       const roles_by_user = z.array(userRoleRelationSchemas.model).parse(await service.findByUserId(user_id))
-      var roles: RoleModel[] = []
+      const roles: RoleModel[] = []
 
-      for(var element of roles_by_user){
-        let role = await roleService.findById(element.role_id)
+      for(const element of roles_by_user){
+        const role = await roleService.findById(element.role_id)
         if(role != null)
           roles.push(roleSchemas.dto.parse(role))
       }
@@ -66,10 +66,10 @@ export const userRoleRouter = honoWithJwt()
       const role_id = +c.req.param('role_id')
       const users_by_role = z.array(userRoleRelationSchemas.model).parse(await service.findByRoleId(role_id))
       
-      var users: UserProfile[] = []
+      const users: UserProfile[] = []
 
-      for(var element of users_by_role){
-        let user = await userService.findById(element.user_id)
+      for(const element of users_by_role){
+        const user = await userService.findById(element.user_id)
         if(user != null)
           users.push(userSchemas.userProfileSchema.parse(user))
       }
diff --git a/src/routes/user.route.ts b/src/routes/user.route.ts
index cd81b42495fc80184a105dbe910cbf35702a1e7d..20948f434403db2a381d97f08bd4c3a321ee9826 100644
--- a/src/routes/user.route.ts
+++ b/src/routes/user.route.ts
@@ -1,4 +1,4 @@
-import { userSchemas, type UserDto, type UserProfile } from '@/db/schema/user.schema'
+import { userSchemas, type UserProfile } from '@/db/schema/user.schema'
 import { UserService } from '@/services/user.service'
 import { Container } from 'typedi'
 import { z } from 'zod'
@@ -24,7 +24,6 @@ export const signUpRouter = new Hono()
         
         const userStats = userStatsSchemas.dto.parse(await userStatsService.create())
         input.user_stats_id = userStats.id
-        console.log(userStats)
         const user = userSchemas.userDtoSchema.parse(
           await service.create(input)
         )
@@ -41,9 +40,9 @@ export const userRouter = honoWithJwt()
   async (c) => {
     try {
       const input = await c.req.valid('json')
-      let follower = await userStatsService.findById(input.follower_id)
-      let following = await userStatsService.findById(input.user_id)
-      let alreadyFollow = await followService.findByFollow(input) != 0
+      const follower = await userStatsService.findById(input.follower_id)
+      const following = await userStatsService.findById(input.user_id)
+      const alreadyFollow = await followService.findByFollow(input) != 0
       if(follower == null || following == null || input.follower_id == input.user_id || alreadyFollow){
         throw new Error()
       }
@@ -85,8 +84,8 @@ export const userRouter = honoWithJwt()
       const follow = await followService.findByFollow(input)
         
         
-      let follower = await userStatsService.findById(input.follower_id)
-      let following = await userStatsService.findById(input.user_id)
+      const follower = await userStatsService.findById(input.follower_id)
+      const following = await userStatsService.findById(input.user_id)
       
       
 
@@ -121,10 +120,10 @@ export const userRouter = honoWithJwt()
     try{
       const id = +c.req.param('id')
       const follows_id = z.array(followRelationSchemas.model).parse(await followService.findByUserId(id))
-      var follows: UserProfile[] = []
+      const follows: UserProfile[] = []
       
-      for(var element of follows_id){
-        let follow = await service.findById(element.follower_id)
+      for(const element of follows_id){
+        const follow = await service.findById(element.follower_id)
         if(follow != null)
           follows.push(userSchemas.userProfileSchema.parse(follow))
       }
@@ -139,10 +138,10 @@ export const userRouter = honoWithJwt()
     try{
       const id = +c.req.param('id')
       const followers_id = z.array(followRelationSchemas.model).parse(await followService.findByFollowerId(id))
-      var followers: UserProfile[] = []
+      const followers: UserProfile[] = []
       
-      for(var element of followers_id){
-        let follow = await service.findById(element.follower_id)
+      for(const element of followers_id){
+        const follow = await service.findById(element.follower_id)
         if(follow != null)
           followers.push(userSchemas.userProfileSchema.parse(follow))
       }
@@ -205,13 +204,13 @@ export const userRouter = honoWithJwt()
     async (c) => {
       try {
         const email: string = c.req.param('email')
-        let user = await service.findByEmail(email)
+        const user = await service.findByEmail(email)
         if(user == null)
           throw new Error()
 
         user.confirmed_at = service.getUpdateTime()
         
-        let confirmed_user = userSchemas.userDtoSchema.parse(
+        const confirmed_user = userSchemas.userDtoSchema.parse(
           await service.update(user)
         )
 
@@ -233,7 +232,7 @@ export const userRouter = honoWithJwt()
     async (c) => {
       try {
         const email: string = c.req.param('email')
-        let user = await service.findByEmail(email)
+        const user = await service.findByEmail(email)
         if(user == null)
           throw new Error()
         
@@ -241,7 +240,7 @@ export const userRouter = honoWithJwt()
         
         user.reactivated_at = service.getUpdateTime()
         
-        let reactivated_user = userSchemas.userDtoSchema.parse(
+        const reactivated_user = userSchemas.userDtoSchema.parse(
           await service.update(user)
         )
 
@@ -263,7 +262,7 @@ export const userRouter = honoWithJwt()
     async (c) => {
       try {
         const id: number = +c.req.param('id')
-        let user = await service.findById(id)
+        const user = await service.findById(id)
         if(user == null)
           throw new Error()
         
@@ -271,7 +270,7 @@ export const userRouter = honoWithJwt()
         
         user.deleted_at = service.getUpdateTime()
         
-        let deleted_user = userSchemas.userDtoSchema.parse(
+        const deleted_user = userSchemas.userDtoSchema.parse(
           await service.update(user)
         )
 
diff --git a/src/services/collection-stats.service.ts b/src/services/collection-stats.service.ts
index 0729d7b4a0e6ec6af9d1d463f9f650b56e3d6465..11d04514b77be1e2c0c7f62dd14bc853f3d13e23 100644
--- a/src/services/collection-stats.service.ts
+++ b/src/services/collection-stats.service.ts
@@ -1,5 +1,5 @@
 import { CollectionStatsRepo } from "@/db/repo/collection-stats.repo";
-import type { CollectionStatsInput, CollectionStatsModel, CollectionStatsUpdate } from "@/db/schema/collection-stats.schema";
+import type { CollectionStatsModel } from "@/db/schema/collection-stats.schema";
 import { Inject, Service } from "typedi";
 
 @Service()
@@ -7,8 +7,8 @@ export class CollectionStatsService {
   @Inject()
   private readonly repo: CollectionStatsRepo
 
-  async create(collectionStats: CollectionStatsInput): Promise<CollectionStatsModel> {
-    return this.repo.create(collectionStats)
+  async create(): Promise<CollectionStatsModel> {
+    return this.repo.create()
   }
 
   async updateViews(id: CollectionStatsModel['id']): Promise<CollectionStatsModel> {
diff --git a/src/services/object-type.service.ts b/src/services/object-type.service.ts
index a2de95998bbcf144d5b3d2ddb57de3eae2a69142..9fe8e4defa2eafc287120e70b363dedf75792978 100644
--- a/src/services/object-type.service.ts
+++ b/src/services/object-type.service.ts
@@ -1,4 +1,4 @@
-import { objectTypeRepo } from "@/db/repo/object-type.schema";
+import { objectTypeRepo } from "@/db/repo/object-type.repo";
 import type { ObjectTypeInput, ObjectTypeModel, ObjectTypeUpdate } from "@/db/schema/object-type.schema";
 import { Inject, Service } from "typedi";
 
diff --git a/src/services/resource-stats.service.ts b/src/services/resource-stats.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e5f7928d52bad956de47e66de09af68470dc6e5b
--- /dev/null
+++ b/src/services/resource-stats.service.ts
@@ -0,0 +1,42 @@
+import { statsResourceRepo } from '@/db/repo/resource-stats.repo'
+import type { ResourceStatsModel, ResourceStatsUpdate } from '@/db/schema/resource-stats.schema'
+import { Inject, Service } from 'typedi'
+
+@Service()
+export class ResourceStatsService {
+  @Inject()
+  private readonly repo: statsResourceRepo
+
+  async create(): Promise<ResourceStatsModel> {
+    return this.repo.create()
+  }
+
+  async update(statsResource: ResourceStatsUpdate): Promise<ResourceStatsModel> {
+    return this.repo.update(statsResource)
+  }
+
+  async viewUpdate(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
+    return this.repo.viewUpdate(id)
+  }
+
+  async downloadUpdate(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
+    return this.repo.downloadUpdate(id)
+  }
+
+  async sharesUpdate(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
+    return this.repo.sharesUpdate(id)
+  }
+
+  async delete(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
+    return this.repo.delete(id)
+  }
+
+  async findById(id: ResourceStatsModel['id']): Promise<ResourceStatsModel | undefined> {
+    return this.repo.find(id)
+  }
+
+  async findMany(): Promise<ResourceStatsModel[]> {
+
+    return this.repo.findMany()
+  }
+}
\ No newline at end of file
diff --git a/src/services/stats-resources.service.ts b/src/services/stats-resources.service.ts
deleted file mode 100644
index cb517b98fb5006e6d94681fa4f001d6f3a8477df..0000000000000000000000000000000000000000
--- a/src/services/stats-resources.service.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { statsResourceRepo } from '@/db/repo/stats-resources.repo'
-import type { ResourceStatsInput, ResourceStatsModel, ResourceStatsUpdate } from '@/db/schema/resource-stats.schema'
-import { Inject, Service } from 'typedi'
-
-@Service()
-export class StatsResourceService {
-  @Inject()
-  private readonly repo: statsResourceRepo
-
-  async create(id: ResourceStatsInput): Promise<ResourceStatsModel> {
-    return this.repo.create(id)
-  }
-
-  async update(statsResource: ResourceStatsUpdate): Promise<ResourceStatsModel> {
-    return this.repo.update(statsResource)
-  }
-
-  async viewUpdate(resource_id: ResourceStatsModel['resource_id']): Promise<ResourceStatsModel> {
-    return this.repo.viewUpdate(resource_id)
-  }
-
-  async downloadUpdate(resource_id: ResourceStatsModel['resource_id']): Promise<ResourceStatsModel> {
-    return this.repo.downloadUpdate(resource_id)
-  }
-
-  async sharesUpdate(resource_id: ResourceStatsModel['resource_id']): Promise<ResourceStatsModel> {
-    return this.repo.sharesUpdate(resource_id)
-  }
-
-  async delete(id: ResourceStatsModel['id']): Promise<ResourceStatsModel> {
-    return this.repo.delete(id)
-  }
-
-  async findById(id: ResourceStatsModel['id']): Promise<ResourceStatsModel | undefined> {
-    return this.repo.find(id)
-  }
-
-  async findMany(): Promise<ResourceStatsModel[]> {
-
-    return this.repo.findMany()
-  }
-}
\ No newline at end of file