⭐ feat(core): Implement Steam library sync with metadata extraction and image processing (#278)

## Description
<!-- Briefly describe the purpose and scope of your changes -->


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Added AWS queue infrastructure and SQS handler for processing Steam
game libraries and images.
- Introduced event-driven handling for new credentials and game
additions, including image uploads to S3.
- Added client functions to fetch Steam user libraries, friends lists,
app info, and related images.
- Added new database columns and schema updates to track game
acquisition, playtime, and family sharing.
  - Added utility function for chunking arrays.
- Added new event notifications for library queue processing and game
creation.
  - Added new lookup functions for categories and teams by slug.
- Introduced a new Team API with endpoints to list and fetch teams by
slug.
  - Added a new Steam library page displaying game images.

- **Enhancements**
  - Improved game creation with event notifications and upsert logic.
  - Enhanced category and team retrieval with new lookup functions.
  - Renamed and refined image categories for clearer classification.
  - Expanded dependencies for image processing and AWS SDK integration.
- Improved image processing utilities with caching, ranking, and
metadata extraction.
  - Refined Steam client utilities for concurrency and error handling.

- **Bug Fixes**
- Fixed event publishing timing and removed deprecated credential
retrieval methods.

- **Chores**
- Updated infrastructure configurations with increased timeouts, memory,
and resource linking.
- Added new dependencies for image processing, caching, and AWS SDK
clients.
  - Refined internal code structure and imports for clarity.
  - Removed Steam provider and related UI components from the frontend.
- Disabled authentication providers and Steam-related routes in the
frontend.
  - Updated API fetch handler to accept environment bindings.

- **Refactor**
- Simplified query result handling and renamed functions for better
clarity.
- Removed outdated event handler in favor of consolidated event
subscriber.
- Consolidated and simplified database relationships and permission
queries.

- **Tests**
  - No explicit test changes included in this release.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

packages/core/src/base-game/index.ts

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import { fn } from "../utils";
+import { Resource } from "sst";
+import { bus } from "sst/aws/bus";
 import { Common } from "../common";
 import { Examples } from "../examples";
-import { eq, isNull, or, and } from "drizzle-orm";
-import { createTransaction } from "../drizzle/transaction";
+import { createEvent } from "../event";
+import { eq, isNull, and } from "drizzle-orm";
+import { afterTx, createTransaction, useTransaction } from "../drizzle/transaction";
 import { CompatibilityEnum, baseGamesTable, Size, ControllerEnum } from "./base-game.sql";
 
 export namespace BaseGame {
@@ -56,32 +59,53 @@ export namespace BaseGame {
 
     export type Info = z.infer<typeof Info>;
 
+    export const Events = {
+        New: createEvent(
+            "new_game.added",
+            z.object({
+                appID: Info.shape.id,
+            }),
+        ),
+    };
+
     export const create = fn(
         Info,
         (input) =>
             createTransaction(async (tx) => {
-                const results = await tx
+                await tx
+                    .insert(baseGamesTable)
+                    .values(input)
+                    .onConflictDoUpdate({
+                        target: baseGamesTable.id,
+                        set: {
+                            timeDeleted: null
+                        }
+                    })
+
+                await afterTx(async () => {
+                    await bus.publish(Resource.Bus, Events.New, { appID: input.id })
+                })
+
+                return input.id
+            })
+    )
+
+    export const fromID = fn(
+        Info.shape.id,
+        (id) =>
+            useTransaction(async (tx) =>
+                tx
                     .select()
                     .from(baseGamesTable)
                     .where(
                         and(
-                            or(
-                                eq(baseGamesTable.slug, input.slug),
-                                eq(baseGamesTable.id, input.id),
-                            ),
+                            eq(baseGamesTable.id, id),
                             isNull(baseGamesTable.timeDeleted)
                         )
                     )
-                    .execute()
-
-                if (results.length > 0) return null
-
-                await tx
-                    .insert(baseGamesTable)
-                    .values(input)
-
-                return input.id
-            })
+                    .limit(1)
+                    .then(rows => rows.map(serialize).at(0))
+            )
     )
 
     export function serialize(