diff --git a/src/scripts/seed/seed.ts b/src/scripts/seed/seed.ts index 3d384be6..3b8ad941 100644 --- a/src/scripts/seed/seed.ts +++ b/src/scripts/seed/seed.ts @@ -11,8 +11,8 @@ import { gameAssetCategory, userCollection, userCollectionAsset, - userFavorite, - userFavoriteAsset, + userFavourite, + userFavouriteAsset, userFollowing, requestFormUpvotes, requestForm, @@ -519,10 +519,10 @@ async function main() { `[SEED] [userCollectionAsset] inserted ${newUserCollectionAssets.length} rows\n` ) - // only one user favorite per user - console.log("[SEED] [userFavorite] Seeding user favorites...") - const newUserFavorites = await db - .insert(userFavorite) + // only one user favourite per user + console.log("[SEED] [userFavourite] Seeding user favourites...") + const newUserFavourites = await db + .insert(userFavourite) .values([ { userId: newUsers[0].id, @@ -534,31 +534,31 @@ async function main() { ]) .returning() console.log( - `[SEED] [userFavorite] inserted ${newUserFavorites.length} rows\n` + `[SEED] [userFavourite] inserted ${newUserFavourites.length} rows\n` ) console.log( - "[SEED] [userFavoriteAsset] Linking user favorites to assets..." + "[SEED] [userFavouriteAsset] Linking user favourites to assets..." ) - const newUserFavoriteAssets = await db - .insert(userFavoriteAsset) + const newUserFavouriteAssets = await db + .insert(userFavouriteAsset) .values([ { - userFavoriteId: newUserFavorites[0].id, + userFavouriteId: newUserFavourites[0].id, assetId: newAssets[0].id, }, { - userFavoriteId: newUserFavorites[0].id, + userFavouriteId: newUserFavourites[0].id, assetId: newAssets[1].id, }, { - userFavoriteId: newUserFavorites[1].id, + userFavouriteId: newUserFavourites[1].id, assetId: newAssets[2].id, }, ]) .returning() console.log( - `[SEED] [userFavoriteAsset] inserted ${newUserFavoriteAssets.length} rows\n` + `[SEED] [userFavouriteAsset] inserted ${newUserFavouriteAssets.length} rows\n` ) console.log("[SEED] Seeded database successfully") diff --git a/src/v2/db/drizzle.ts b/src/v2/db/drizzle.ts index 0ce3ee56..c4be0202 100644 --- a/src/v2/db/drizzle.ts +++ b/src/v2/db/drizzle.ts @@ -23,8 +23,8 @@ export const tableNames = { passwordResetToken: "passwordResetToken", assetCategory: "assetCategory", assetCategoryLikes: "assetCategoryLikes", - userFavorite: "userFavorite", - userFavoriteAsset: "userFavoriteAsset", + userFavourite: "userFavourite", + userFavouriteAsset: "userFavouriteAsset", userCollection: "userCollection", userCollectionAsset: "userCollectionAsset", socialsConnection: "socialsConnection", diff --git a/src/v2/db/schema.ts b/src/v2/db/schema.ts index 22e99678..068e9e7c 100644 --- a/src/v2/db/schema.ts +++ b/src/v2/db/schema.ts @@ -16,7 +16,7 @@ export * from "./schema/user/user" export * from "./schema/user/user-attributes" export * from "./schema/collections/user-collections" export * from "./schema/user/user-connections" -export * from "./schema/user/user-favorites" +export * from "./schema/user/user-favourites" export * from "./schema/user/user-following" export * from "./schema/user/user-blocked" diff --git a/src/v2/db/schema/asset/asset.ts b/src/v2/db/schema/asset/asset.ts index 94087a0e..e9c63a42 100644 --- a/src/v2/db/schema/asset/asset.ts +++ b/src/v2/db/schema/asset/asset.ts @@ -23,7 +23,7 @@ NOTE: Assets have a lot of relations, and can be quite complex in some cases. - AssetCategory: Linked to the category the asset is in, e.g "charcter sheets" - Game: Linked to the game the asset is for, e.g "genshin-impact" -Then, they are also used as relations when adding to collections or favorites. +Then, they are also used as relations when adding to collections or favourites. */ export type AssetStatus = "pending" | "approved" | "rejected" diff --git a/src/v2/db/schema/user/user-favorites.ts b/src/v2/db/schema/user/user-favorites.ts deleted file mode 100644 index 23eabf83..00000000 --- a/src/v2/db/schema/user/user-favorites.ts +++ /dev/null @@ -1,123 +0,0 @@ -import { tableNames } from "@/v2/db/drizzle" -import { relations } from "drizzle-orm" -import { - sqliteTable, - text, - integer, - // uniqueIndex, - index, -} from "drizzle-orm/sqlite-core" -import { authUser } from "./user" -import { asset } from "../asset/asset" -import { createInsertSchema, createSelectSchema } from "drizzle-zod" -import { generateID } from "@/v2/lib/oslo" - -/* -NOTE: this file is users favorite assets. -- Think of it as being similar to likes, where you can favorite multiple assets but only have one set of favorites. -- Everything else is managed within collections when uers want to organize their assets. -*/ - -export const userFavorite = sqliteTable( - tableNames.userFavorite, - { - id: text("id") - .unique() - .notNull() - .$defaultFn(() => { - return generateID() - }), - userId: text("user_id") - .notNull() - .references(() => authUser.id, { - onUpdate: "cascade", - onDelete: "cascade", - }), - isPublic: integer("is_public", { mode: "boolean" }) - .default(false) - .notNull(), - }, - (userFavorite) => { - return { - favoritedAssetsIdx: index("favorited_assets_id_idx").on( - userFavorite.id - ), - favoritedAssetsUserIdx: index("favorited_assets_user_id_idx").on( - userFavorite.userId - ), - } - } -) - -export type UserFavorite = typeof userFavorite.$inferSelect -export type NewUserFavorite = typeof userFavorite.$inferInsert -export const insertUserFavoriteSchema = createInsertSchema(userFavorite) -export const selectUserFavoriteSchema = createSelectSchema(userFavorite) - -export const userFavoriteAsset = sqliteTable( - tableNames.userFavoriteAsset, - { - id: text("id") - .primaryKey() - .notNull() - .$defaultFn(() => { - return generateID() - }), - userFavoriteId: text("favorited_assets_id") - .notNull() - .references(() => userFavorite.id, { - onUpdate: "cascade", - onDelete: "cascade", - }), - assetId: integer("asset_id") - .notNull() - .references(() => asset.id, { - onUpdate: "cascade", - onDelete: "cascade", - }), - }, - (userFavoriteAsset) => { - return { - favoritedAssetsAssetsIdx: index( - "favorited_assets_assets_id_idx" - ).on(userFavoriteAsset.id), - favoritedAssetsAssetsUserIdx: index( - "favorited_assets_assets_user_id_idx" - ).on(userFavoriteAsset.userFavoriteId), - favoritedAssetsAssetsAssetIdx: index( - "favorited_assets_assets_asset_id_idx" - ).on(userFavoriteAsset.assetId), - } - } -) - -export type UserFavoriteAsset = typeof userFavoriteAsset.$inferSelect -export type NewUserFavoriteAsset = typeof userFavoriteAsset.$inferInsert -export const insertUserFavoriteAssetSchema = - createInsertSchema(userFavoriteAsset) -export const selectUserFavoriteAssetSchema = - createSelectSchema(userFavoriteAsset) - -export const userFavoriteRelations = relations(userFavorite, ({ one }) => ({ - user: one(authUser, { - fields: [userFavorite.userId], - references: [authUser.id], - relationName: "userfavorite_auth_user", - }), -})) - -export const userFavoriteAssetRelations = relations( - userFavoriteAsset, - ({ one }) => ({ - favoritedAssets: one(userFavorite, { - fields: [userFavoriteAsset.userFavoriteId], - references: [userFavorite.id], - relationName: "favoritedassets_userfavorite", - }), - asset: one(asset, { - fields: [userFavoriteAsset.assetId], - references: [asset.id], - relationName: "favoritedassets_asset", - }), - }) -) diff --git a/src/v2/db/schema/user/user-favourites.ts b/src/v2/db/schema/user/user-favourites.ts new file mode 100644 index 00000000..b090e1c4 --- /dev/null +++ b/src/v2/db/schema/user/user-favourites.ts @@ -0,0 +1,123 @@ +import { tableNames } from "@/v2/db/drizzle" +import { relations } from "drizzle-orm" +import { + sqliteTable, + text, + integer, + // uniqueIndex, + index, +} from "drizzle-orm/sqlite-core" +import { authUser } from "./user" +import { asset } from "../asset/asset" +import { createInsertSchema, createSelectSchema } from "drizzle-zod" +import { generateID } from "@/v2/lib/oslo" + +/* +NOTE: this file is users favourite assets. +- Think of it as being similar to likes, where you can favourite multiple assets but only have one set of favourites. +- Everything else is managed within collections when uers want to organize their assets. +*/ + +export const userFavourite = sqliteTable( + tableNames.userFavourite, + { + id: text("id") + .unique() + .notNull() + .$defaultFn(() => { + return generateID() + }), + userId: text("user_id") + .notNull() + .references(() => authUser.id, { + onUpdate: "cascade", + onDelete: "cascade", + }), + isPublic: integer("is_public", { mode: "boolean" }) + .default(false) + .notNull(), + }, + (userFavourite) => { + return { + favouritedAssetsIdx: index("favourited_assets_id_idx").on( + userFavourite.id + ), + favouritedAssetsUserIdx: index("favourited_assets_user_id_idx").on( + userFavourite.userId + ), + } + } +) + +export type UserFavourite = typeof userFavourite.$inferSelect +export type NewUserFavourite = typeof userFavourite.$inferInsert +export const insertUserFavouriteSchema = createInsertSchema(userFavourite) +export const selectUserFavouriteSchema = createSelectSchema(userFavourite) + +export const userFavouriteAsset = sqliteTable( + tableNames.userFavouriteAsset, + { + id: text("id") + .primaryKey() + .notNull() + .$defaultFn(() => { + return generateID() + }), + userFavouriteId: text("favourited_assets_id") + .notNull() + .references(() => userFavourite.id, { + onUpdate: "cascade", + onDelete: "cascade", + }), + assetId: integer("asset_id") + .notNull() + .references(() => asset.id, { + onUpdate: "cascade", + onDelete: "cascade", + }), + }, + (userFavouriteAsset) => { + return { + favouritedAssetsAssetsIdx: index( + "favourited_assets_assets_id_idx" + ).on(userFavouriteAsset.id), + favouritedAssetsAssetsUserIdx: index( + "favourited_assets_assets_user_id_idx" + ).on(userFavouriteAsset.userFavouriteId), + favouritedAssetsAssetsAssetIdx: index( + "favourited_assets_assets_asset_id_idx" + ).on(userFavouriteAsset.assetId), + } + } +) + +export type UserFavouriteAsset = typeof userFavouriteAsset.$inferSelect +export type NewUserFavouriteAsset = typeof userFavouriteAsset.$inferInsert +export const insertUserFavouriteAssetSchema = + createInsertSchema(userFavouriteAsset) +export const selectUserFavouriteAssetSchema = + createSelectSchema(userFavouriteAsset) + +export const userFavouriteRelations = relations(userFavourite, ({ one }) => ({ + user: one(authUser, { + fields: [userFavourite.userId], + references: [authUser.id], + relationName: "userfavourite_auth_user", + }), +})) + +export const userFavouriteAssetRelations = relations( + userFavouriteAsset, + ({ one }) => ({ + favouritedAssets: one(userFavourite, { + fields: [userFavouriteAsset.userFavouriteId], + references: [userFavourite.id], + relationName: "favouritedassets_userfavourite", + }), + asset: one(asset, { + fields: [userFavouriteAsset.assetId], + references: [asset.id], + relationName: "favouritedassets_asset", + }), + }) +) diff --git a/src/v2/db/schema/user/user.ts b/src/v2/db/schema/user/user.ts index 825714ae..cb92ff9a 100644 --- a/src/v2/db/schema/user/user.ts +++ b/src/v2/db/schema/user/user.ts @@ -11,7 +11,7 @@ import { createInsertSchema, createSelectSchema } from "drizzle-zod" import { generateID } from "@/v2/lib/oslo" import { userFollowing } from "./user-following" import { asset } from "../asset/asset" -import { userFavorite } from "./user-favorites" +import { userFavourite } from "./user-favourites" import { socialsConnection } from "./user-connections" import { userCollection } from "../collections/user-collections" import { passwordResetToken } from "./user-attributes" @@ -207,7 +207,7 @@ export const usersRelations = relations(authUser, ({ one, many }) => ({ userSession: many(userSession), asset: many(asset), assetExternalFile: many(assetExternalFile), - userFavorite: one(userFavorite), + userFavourite: one(userFavourite), userCollectionLikes: many(userCollectionLikes), assetLikes: many(assetLikes), assetComments: many(assetComments), diff --git a/src/v2/lib/managers/favorite/favorite-manager.ts b/src/v2/lib/managers/favorite/favorite-manager.ts index 4a7691a0..43f9af57 100644 --- a/src/v2/lib/managers/favorite/favorite-manager.ts +++ b/src/v2/lib/managers/favorite/favorite-manager.ts @@ -1,98 +1,98 @@ -import { userFavorite, userFavoriteAsset } from "@/v2/db/schema" +import { userFavourite, userFavouriteAsset } from "@/v2/db/schema" import { and, eq } from "drizzle-orm" import { DrizzleInstance } from "@/v2/db/turso" import type { - NewUserFavorite, - NewUserFavoriteAsset, - UserFavorite, - UserFavoriteAsset, + NewUserFavourite, + NewUserFavouriteAsset, + UserFavourite, + UserFavouriteAsset, } from "@/v2/db/schema" /** - * Manages operations related to user favorites. + * Manages operations related to user favourites. */ export class FavoriteManager { constructor(private drizzle: DrizzleInstance) {} /** - * Get a user's favorite assets. - * @param userId - The ID of the user to retrieve favorites for. + * Get a user's favourite assets. + * @param userId - The ID of the user to retrieve favourites for. * @param currentUserId - The optional current user's ID. - * @returns A user's favorite assets. + * @returns A user's favourite assets. */ - public async getUserFavorite( + public async getUserFavourite( userId: string, currentUserId?: string - ): Promise { + ): Promise { try { - const favouriteExists = this.checkIfUserFavoriteExists(userId) + const favouriteExists = this.checkIfUserFavouriteExists(userId) if (!favouriteExists) { await this.createInitialFavorite(userId) } - const [favorite] = await this.drizzle + const [favourite] = await this.drizzle .select() - .from(userFavorite) + .from(userFavourite) .where( and( currentUserId - ? eq(userFavorite.userId, currentUserId) - : eq(userFavorite.isPublic, true), - eq(userFavorite.userId, userId) + ? eq(userFavourite.userId, currentUserId) + : eq(userFavourite.isPublic, true), + eq(userFavourite.userId, userId) ) ) - return favorite ?? null + return favourite ?? null } catch (e) { console.error( - `Error in getUserFavorite for userId ${userId} and currentUserId ${currentUserId}`, + `Error in getUserFavourite for userId ${userId} and currentUserId ${currentUserId}`, e ) throw new Error( - `Error in getUserFavorite for userId ${userId} and currentUserId ${currentUserId}` + `Error in getUserFavourite for userId ${userId} and currentUserId ${currentUserId}` ) } } - public async checkIfUserFavoriteExists(userId: string): Promise { + public async checkIfUserFavouriteExists(userId: string): Promise { try { - const [favorite] = await this.drizzle + const [favourite] = await this.drizzle .select({ - id: userFavorite.id, + id: userFavourite.id, }) - .from(userFavorite) - .where(and(eq(userFavorite.userId, userId))) + .from(userFavourite) + .where(and(eq(userFavourite.userId, userId))) - return favorite ? true : false + return favourite ? true : false } catch (e) { console.error( - `Error in checkIfUserFavoriteExists for userId ${userId}`, + `Error in checkIfUserFavouriteExists for userId ${userId}`, e ) throw new Error( - `Error in checkIfUserFavoriteExists for userId ${userId}` + `Error in checkIfUserFavouriteExists for userId ${userId}` ) } } /** - * Create initial user favorite (1 per user!) - * @param userId - The ID of the user to create favorites for. - * @returns A user's favorite item. + * Create initial user favourite (1 per user!) + * @param userId - The ID of the user to create favourites for. + * @returns A user's favourite item. */ public async createInitialFavorite( userId: string - ): Promise { + ): Promise { try { - const [favorite] = await this.drizzle - .insert(userFavorite) + const [favourite] = await this.drizzle + .insert(userFavourite) .values({ userId: userId, }) .returning() - return favorite + return favourite } catch (e) { console.error( `Error in createInitialFavorite for userId ${userId}`, @@ -104,77 +104,77 @@ export class FavoriteManager { } } /** - * Adds an asset to a user's favorites. - * @param assetId - The ID of the asset to add to favorites. - * @param userFavoriteId - User's unique favorite ID. + * Adds an asset to a user's favourites. + * @param assetId - The ID of the asset to add to favourites. + * @param userFavouriteId - User's unique favourite ID. */ public async addAssetToFavorites( assetId: number, userId: string, - userFavoriteId: string - ): Promise { + userFavouriteId: string + ): Promise { try { - const favouriteExists = this.checkIfUserFavoriteExists(userId) + const favouriteExists = this.checkIfUserFavouriteExists(userId) if (!favouriteExists) { await this.createInitialFavorite(userId) } - const [favorite] = await this.drizzle - .insert(userFavoriteAsset) + const [favourite] = await this.drizzle + .insert(userFavouriteAsset) .values({ - userFavoriteId: userFavoriteId, + userFavouriteId: userFavouriteId, assetId: assetId, }) .returning() - return favorite + return favourite } catch (e) { console.error( - `Error in addAssetToFavorites for userFavoriteId ${userFavoriteId} and assetId ${assetId}`, + `Error in addAssetToFavorites for userFavouriteId ${userFavouriteId} and assetId ${assetId}`, e ) throw new Error( - `Error in addAssetToFavorites for userFavoriteId ${userFavoriteId} and assetId ${assetId}` + `Error in addAssetToFavorites for userFavouriteId ${userFavouriteId} and assetId ${assetId}` ) } } /** - * Removes an asset from a user's favorites. - * @param assetId - The ID of the asset to remove from favorites. - * @param userFavoriteId - User's unique favorite ID. + * Removes an asset from a user's favourites. + * @param assetId - The ID of the asset to remove from favourites. + * @param userFavouriteId - User's unique favourite ID. */ public async removeAssetFromFavorites( assetId: number, userId: string, - userFavoriteId: string - ): Promise { + userFavouriteId: string + ): Promise { try { - const favouriteExists = this.checkIfUserFavoriteExists(userId) + const favouriteExists = this.checkIfUserFavouriteExists(userId) if (!favouriteExists) { await this.createInitialFavorite(userId) } - const [favorite] = await this.drizzle - .delete(userFavoriteAsset) + const [favourite] = await this.drizzle + .delete(userFavouriteAsset) .where( and( - eq(userFavoriteAsset.userFavoriteId, userFavoriteId), - eq(userFavoriteAsset.assetId, assetId) + eq(userFavouriteAsset.userFavouriteId, userFavouriteId), + eq(userFavouriteAsset.assetId, assetId) ) ) .returning() - return favorite ?? null + return favourite ?? null } catch (e) { console.error( - `Error in removeAssetFromFavorites for userFavoriteId ${userFavoriteId} and assetId ${assetId}`, + `Error in removeAssetFromFavorites for userFavouriteId ${userFavouriteId} and assetId ${assetId}`, e ) throw new Error( - `Error in removeAssetFromFavorites for userFavoriteId ${userFavoriteId} and assetId ${assetId}` + `Error in removeAssetFromFavorites for userFavouriteId ${userFavouriteId} and assetId ${assetId}` ) } }