⭐ feat(infra): Update infra and add support for teams to SST (#186)

## Description
- [x] Adds support for AWS SSO, which makes us (the team) able to use
SST and update the components independently
- [x] Splits the webpage into the landing page (Qwik), and Astro (the
console) in charge of playing. This allows us to pass in Environment
Variables to the console
- ~Migrates the docs from Nuxt to Nextjs, and connects them to SST. This
allows us to use Fumadocs _citation needed_ that's much more beautiful,
and supports OpenApi~
- Cloudflare pages with github integration is not working on our new CF
account. So we will have to push the pages deployment manually with
Github actions
- [x] Moves the current set up from my personal CF and AWS accounts to
dedicated Nestri accounts -

## Related Issues
<!-- List any related issues (e.g., "Closes #123", "Fixes #456") -->

## Type of Change

- [ ] Bug fix (non-breaking change)
- [x] New feature (non-breaking change)
- [ ] Breaking change (fix or feature that changes existing
functionality)
- [x] Documentation update
- [ ] Other (please describe):

## Checklist

- [x] I have updated relevant documentation
- [x] My code follows the project's coding style
- [x] My changes generate no new warnings/errors

## Notes for Reviewers
<!-- Point out areas you'd like reviewers to focus on, questions you
have, or decisions that need discussion -->
Please approve my PR 🥹


## Screenshots/Demo
<!-- If applicable, add screenshots or a GIF demo of your changes
(especially for UI changes) -->

## Additional Context
<!-- Add any other context about the pull request here -->

packages/core/src/user/index.ts

@@ -1,37 +1,219 @@
 import { z } from "zod";
-import databaseClient from "../database"
-import { fn } from "../utils";
+import { bus } from "sst/aws/bus";
 import { Common } from "../common";
+import { createID, fn } from "../utils";
+import { userTable } from "./user.sql";
+import { createEvent } from "../event";
 import { Examples } from "../examples";
+import { Resource } from "sst/resource";
+import { teamTable } from "../team/team.sql";
+import { assertActor, withActor } from "../actor";
+import { memberTable } from "../member/member.sql";
+import { and, eq, isNull, asc, getTableColumns, sql } from "../drizzle";
+import { afterTx, createTransaction, useTransaction } from "../drizzle/transaction";
+import { Team } from "../team";
+
+
+export module User {
+    const MAX_ATTEMPTS = 50;
 
-export module Users {
     export const Info = z
         .object({
             id: z.string().openapi({
                 description: Common.IdDescription,
                 example: Examples.User.id,
             }),
-            email: z.string().nullable().openapi({
-                description: "Email address of the user.",
+            name: z.string().openapi({
+                description: "The user's unique username",
+                example: Examples.User.name,
+            }),
+            polarCustomerID: z.string().or(z.null()).openapi({
+                description: "The polar customer id for this user",
+                example: Examples.User.polarCustomerID,
+            }),
+            email: z.string().openapi({
+                description: "The email address of this user",
                 example: Examples.User.email,
             }),
+            avatarUrl: z.string().or(z.null()).openapi({
+                description: "The url to the profile picture.",
+                example: Examples.User.name,
+            }),
+            discriminator: z.string().or(z.number()).openapi({
+                description: "The (number) discriminator for this user",
+                example: Examples.User.discriminator,
+            }),
         })
         .openapi({
             ref: "User",
-            description: "A Nestri console user.",
+            description: "Represents a user on Nestri",
             example: Examples.User,
         });
 
-    export const fromEmail = fn(z.string(), async (email) => {
-        const db = databaseClient()
-        const res = await db.auth.getUser({ email })
-        return res
+    export type Info = z.infer<typeof Info>;
+
+    export const Events = {
+        Created: createEvent(
+            "user.created",
+            z.object({
+                userID: Info.shape.id,
+            }),
+        ),
+        Updated: createEvent(
+            "user.updated",
+            z.object({
+                userID: Info.shape.id,
+            }),
+        ),
+    };
+
+    export const sanitizeUsername = (username: string): string => {
+        // Remove spaces and numbers
+        return username.replace(/[\s0-9]/g, '');
+    };
+
+    export const generateDiscriminator = (): string => {
+        return Math.floor(Math.random() * 100).toString().padStart(2, '0');
+    };
+
+    export const isValidDiscriminator = (discriminator: string): boolean => {
+        return /^\d{2}$/.test(discriminator);
+    };
+
+    export const findAvailableDiscriminator = fn(z.string(), async (input) => {
+        const username = sanitizeUsername(input);
+
+        for (let i = 0; i < MAX_ATTEMPTS; i++) {
+            const discriminator = generateDiscriminator();
+
+            const users = await useTransaction(async (tx) =>
+                tx
+                    .select()
+                    .from(userTable)
+                    .where(and(eq(userTable.name, username), eq(userTable.discriminator, Number(discriminator))))
+            )
+
+            if (users.length === 0) {
+                return discriminator;
+            }
+        }
+
+        return null;
     })
 
-    export const create = fn(z.string(), async (email) => {
-        const db = databaseClient()
-        const token = await db.auth.createToken(email)
+    export const create = fn(Info.omit({ polarCustomerID: true, discriminator: true }).partial({ avatarUrl: true, id: true }), async (input) => {
+        const userID = createID("user")
 
-        return token
+        //FIXME: Do this much later, as Polar.sh has so many inconsistencies for fuck's sake
+
+        // const customer = await Polar.client.customers.create({
+        //     email: input.email,
+        //     metadata: {
+        //         userID,
+        //     },
+        // });
+
+        const name = sanitizeUsername(input.name);
+
+        // Generate a random available discriminator
+        const discriminator = await findAvailableDiscriminator(name);
+
+        if (!discriminator) {
+            console.error("No available discriminators for this username ")
+            return null
+        }
+
+        createTransaction(async (tx) => {
+            const id = input.id ?? userID;
+            await tx.insert(userTable).values({
+                id,
+                name: input.name,
+                avatarUrl: input.avatarUrl,
+                email: input.email,
+                discriminator: Number(discriminator),
+            })
+            await afterTx(() =>
+                withActor({
+                    type: "user",
+                    properties: {
+                        userID: id,
+                        email: input.email
+                    },
+                },
+                    async () => bus.publish(Resource.Bus, Events.Created, { userID: id }),
+                )
+            );
+        })
+
+        return userID;
     })
+
+    export const fromEmail = fn(z.string(), async (email) =>
+        useTransaction(async (tx) =>
+            tx
+                .select()
+                .from(userTable)
+                .where(and(eq(userTable.email, email), isNull(userTable.timeDeleted)))
+                .orderBy(asc(userTable.timeCreated))
+                .then((rows) => rows.map(serialize))
+                .then((rows) => rows.at(0))
+        ),
+    )
+
+    export const fromID = fn(z.string(), async (id) =>
+        useTransaction(async (tx) =>
+            tx
+                .select()
+                .from(userTable)
+                .where(and(eq(userTable.id, id), isNull(userTable.timeDeleted)))
+                .orderBy(asc(userTable.timeCreated))
+                .then((rows) => rows.map(serialize))
+                .then((rows) => rows.at(0))
+        ),
+    )
+
+    export function serialize(
+        input: typeof userTable.$inferSelect,
+    ): z.infer<typeof Info> {
+        return {
+            id: input.id,
+            name: input.name,
+            email: input.email,
+            avatarUrl: input.avatarUrl,
+            discriminator: input.discriminator,
+            polarCustomerID: input.polarCustomerID,
+        };
+    }
+
+    export const remove = fn(Info.shape.id, (input) =>
+        useTransaction(async (tx) => {
+            await tx
+                .update(userTable)
+                .set({
+                    timeDeleted: sql`CURRENT_TIMESTAMP()`,
+                })
+                .where(and(eq(userTable.id, input)))
+                .execute();
+            return input;
+        }),
+    );
+
+    export function teams() {
+        const actor = assertActor("user");
+        return useTransaction((tx) =>
+            tx
+                .select(getTableColumns(teamTable))
+                .from(teamTable)
+                .innerJoin(memberTable, eq(memberTable.teamID, teamTable.id))
+                .where(
+                    and(
+                        eq(memberTable.email, actor.properties.email),
+                        isNull(memberTable.timeDeleted),
+                        isNull(teamTable.timeDeleted),
+                    ),
+                )
+                .execute()
+                .then((rows) => rows.map(Team.serialize))
+        );
+    }
 }