feat-spaces

apps/platform/app.ts

@@ -6,7 +6,7 @@ import { serve } from '@hono/node-server';
 import { cors } from 'hono/cors';
 import { authApi } from './routes/auth';
 import { realtimeApi } from './routes/realtime';
-import { trpcPlatformRouter } from './trpc';
+import { TRPCError, trpcPlatformRouter } from './trpc';
 import { db } from '@u22n/database';
 import { trpcServer } from '@hono/trpc-server';
 import { authMiddleware, serviceMiddleware } from './middlewares';
@@ -66,7 +66,15 @@ app.use(
         org: null,
         event: c,
         selfHosted: !env.EE_LICENSE_KEY
-      }) satisfies TrpcContext
+      }) satisfies TrpcContext,
+    onError: (err) => {
+      if (err instanceof TRPCError) throw err;
+      console.error(err);
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Something went wrong'
+      });
+    }
   })
 );
 

apps/platform/trpc/index.ts

@@ -21,6 +21,7 @@ import { twoFactorRouter } from './routers/authRouter/twoFactorRouter';
 import { securityRouter } from './routers/userRouter/securityRouter';
 import { storeRouter } from './routers/orgRouter/orgStoreRouter';
 import { iCanHazRouter } from './routers/orgRouter/iCanHaz/iCanHazRouter';
+import { spaceRouter } from './routers/spaceRouter/spaceRouter';
 
 const trpcPlatformAuthRouter = router({
   signup: signupRouter,
@@ -66,7 +67,8 @@ export const trpcPlatformRouter = router({
   auth: trpcPlatformAuthRouter,
   account: trpcPlatformAccountRouter,
   org: trpcPlatformOrgRouter,
-  convos: convoRouter
+  convos: convoRouter,
+  spaces: spaceRouter
 });
 
 export type TrpcPlatformRouter = typeof trpcPlatformRouter;

apps/platform/trpc/routers/convoRouter/convoRouter.ts

@@ -1377,19 +1377,6 @@ export const convoRouter = router({
       };
     }),
 
-  //* get convo entries
-  // getConvoEntries: orgProcedure
-  //   .input(
-  //     z.object({
-  //       convoPublicId: typeIdValidator('convos'),
-  //       cursor: z.object({
-  //         lastUpdatedAt: z.date().optional(),
-  //         lastPublicId: typeIdValidator('convos').optional()
-  //       })
-  //     })
-  //   )
-  //   .query(async () => {}),
-
   getOrgMemberConvos: orgProcedure
     .input(
       z.object({

apps/platform/trpc/routers/orgRouter/iCanHaz/iCanHazRouter.ts

@@ -16,6 +16,16 @@ export const iCanHazRouter = router({
       return true;
     }
     return await billingTrpcClient.iCanHaz.team.query({ orgId: org.id });
+  }),
+  space: orgProcedure.query(async ({ ctx }) => {
+    const { org, selfHosted } = ctx;
+    if (selfHosted) {
+      return {
+        open: true,
+        shared: true
+      };
+    }
+    return await billingTrpcClient.iCanHaz.space.query({ orgId: org.id });
   })
 });
 

apps/platform/trpc/routers/orgRouter/orgCrudRouter.ts

@@ -6,11 +6,14 @@ import {
   orgs,
   orgMembers,
   orgMemberProfiles,
-  accounts
+  accounts,
+  spaces,
+  spaceMembers
 } from '@u22n/database/schema';
 import { typeIdGenerator } from '@u22n/utils/typeid';
 import { TRPCError } from '@trpc/server';
 import { blockedUsernames, reservedUsernames } from '~platform/utils/signup';
+import { validateSpaceShortCode } from '../spaceRouter/spaceRouter';
 
 async function validateOrgShortcode(
   db: DBType,
@@ -94,17 +97,15 @@ export const crudRouter = router({
         });
       }
 
-      const newPublicId = typeIdGenerator('org');
+      const newOrgPublicId = typeIdGenerator('org');
 
       const insertOrgResponse = await db.insert(orgs).values({
         ownerId: accountId,
         name: input.orgName,
         shortcode: input.orgShortcode,
-        publicId: newPublicId
+        publicId: newOrgPublicId
       });
-      const orgId = +insertOrgResponse.insertId;
-
-      const newProfilePublicId = typeIdGenerator('orgMemberProfile');
+      const orgId = Number(insertOrgResponse.insertId);
 
       const { username } =
         (await db.query.accounts.findFirst({
@@ -125,7 +126,7 @@ export const crudRouter = router({
         .insert(orgMemberProfiles)
         .values({
           orgId: orgId,
-          publicId: newProfilePublicId,
+          publicId: typeIdGenerator('orgMemberProfile'),
           accountId: accountId,
           firstName: username,
           lastName: '',
@@ -135,7 +136,7 @@ export const crudRouter = router({
         });
 
       const newOrgMemberPublicId = typeIdGenerator('orgMembers');
-      await db.insert(orgMembers).values({
+      const orgMemberResponse = await db.insert(orgMembers).values({
         orgId: orgId,
         publicId: newOrgMemberPublicId,
         role: 'admin',
@@ -144,8 +145,53 @@ export const crudRouter = router({
         orgMemberProfileId: Number(newOrgMemberProfileInsert.insertId)
       });
 
+      const spaceShortcode = await validateSpaceShortCode({
+        db: db,
+        shortcode: `${username}`,
+        orgId: orgId
+      });
+      const newSpaceResponse = await db.insert(spaces).values({
+        orgId: orgId,
+        publicId: typeIdGenerator('spaces'),
+        name: `${username}'s Personal Space`,
+        type: 'shared',
+        personalSpace: true,
+        color: 'cyan',
+        icon: 'house',
+        createdByOrgMemberId: Number(orgMemberResponse.insertId),
+        shortcode: spaceShortcode.shortcode
+      });
+
+      await db.insert(spaceMembers).values({
+        orgId: orgId,
+        spaceId: Number(newSpaceResponse.insertId),
+        publicId: typeIdGenerator('spaceMembers'),
+        orgMemberId: Number(orgMemberResponse.insertId),
+        addedByOrgMemberId: Number(orgMemberResponse.insertId),
+        role: 'admin',
+        canCreate: true,
+        canRead: true,
+        canComment: true,
+        canReply: true,
+        canDelete: true,
+        canChangeStatus: true,
+        canSetStatusToClosed: true,
+        canAddTags: true,
+        canMoveToAnotherSpace: true,
+        canAddToAnotherSpace: true,
+        canMergeConvos: true,
+        canAddParticipants: true
+      });
+
+      await db
+        .update(orgMembers)
+        .set({
+          personalSpaceId: Number(newSpaceResponse.insertId)
+        })
+        .where(eq(orgMembers.id, Number(orgMemberResponse.insertId)));
+
       return {
-        orgId: newPublicId,
+        orgId: newOrgPublicId,
         orgName: input.orgName
       };
     }),

apps/platform/trpc/routers/orgRouter/users/invitesRouter.ts

@@ -16,7 +16,9 @@ import {
   orgInvitations,
   orgMembers,
   orgMemberProfiles,
-  accounts
+  accounts,
+  spaces,
+  spaceMembers
 } from '@u22n/database/schema';
 import { typeIdGenerator, typeIdValidator } from '@u22n/utils/typeid';
 import { nanoIdToken, zodSchemas } from '@u22n/utils/zodSchemas';
@@ -28,6 +30,7 @@ import { addOrgMemberToTeamHandler } from './teamsHandler';
 import { sendInviteEmail } from '~platform/utils/mail/transactional';
 import { env } from '~platform/env';
 import { ratelimiter } from '~platform/trpc/ratelimit';
+import { validateSpaceShortCode } from '../../spaceRouter/spaceRouter';
 
 export const invitesRouter = router({
   createNewInvite: orgProcedure
@@ -98,6 +101,52 @@ export const invitesRouter = router({
           orgMemberProfileId: orgMemberProfileId
         });
 
+        const spaceShortcode = await validateSpaceShortCode({
+          db: db,
+          shortcode: `${newOrgMember.firstName}${newOrgMember.lastName ? '-' + newOrgMember.lastName : ''}`,
+          orgId: orgId
+        });
+
+        const newSpaceResponse = await db.insert(spaces).values({
+          orgId: orgId,
+          publicId: typeIdGenerator('spaces'),
+          name: 'Personal',
+          type: 'shared',
+          personalSpace: true,
+          color: 'cyan',
+          icon: 'house',
+          createdByOrgMemberId: Number(orgMemberResponse.insertId),
+          shortcode: spaceShortcode.shortcode
+        });
+
+        await db.insert(spaceMembers).values({
+          orgId: orgId,
+          spaceId: Number(newSpaceResponse.insertId),
+          publicId: typeIdGenerator('spaceMembers'),
+          orgMemberId: Number(orgMemberResponse.insertId),
+          addedByOrgMemberId: Number(orgMemberResponse.insertId),
+          role: 'admin',
+          canCreate: true,
+          canRead: true,
+          canComment: true,
+          canReply: true,
+          canDelete: true,
+          canChangeStatus: true,
+          canSetStatusToClosed: true,
+          canAddTags: true,
+          canMoveToAnotherSpace: true,
+          canAddToAnotherSpace: true,
+          canMergeConvos: true,
+          canAddParticipants: true
+        });
+
+        await db
+          .update(orgMembers)
+          .set({
+            personalSpaceId: Number(newSpaceResponse.insertId)
+          })
+          .where(eq(orgMembers.id, Number(orgMemberResponse.insertId)));
+
         // Insert teamMemberships - save ID
         if (teamsInput) {
           for (const teamPublicId of teamsInput.teamsPublicIds) {

apps/platform/trpc/routers/spaceRouter/spaceMemberRouter.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { router, accountProcedure } from '~platform/trpc/trpc';
+import type { DBType } from '@u22n/database';
+import { eq, and } from '@u22n/database/orm';
+import {
+  orgs,
+  orgMembers,
+  orgMemberProfiles,
+  accounts,
+  spaces,
+  spaceMembers
+} from '@u22n/database/schema';
+import { typeIdGenerator } from '@u22n/utils/typeid';
+import { TRPCError } from '@trpc/server';
+import { blockedUsernames, reservedUsernames } from '~platform/utils/signup';
+
+export const spaceMemberRouter = router({});