rm american english

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")

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",

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"
 

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"

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",
+        }),
+    })
+)

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),