@m5kdev/backend 0.1.1 → 0.1.2

package/dist/src/modules/auth/auth.service.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+const posthog_1 = require("#utils/posthog");
+class AuthService extends base_service_1.BaseService {
+    getBillingService() {
+        if (!("billing" in this.service))
+            return null;
+        return this.service.billing;
+    }
+    async getUserWaitlistCount({ user }) {
+        if (user.role === "admin")
+            return (0, neverthrow_1.ok)(0);
+        return this.repository.auth.getUserWaitlistCount(user.id);
+    }
+    async getOnboarding({ user }) {
+        return this.repository.auth.getOnboarding(user.id);
+    }
+    async setOnboarding(onboarding, { user }) {
+        (0, posthog_1.posthogCapture)({
+            distinctId: user.id,
+            event: "onboarding_set",
+            properties: {
+                onboarding,
+            },
+        });
+        return this.repository.auth.setOnboarding(user.id, onboarding);
+    }
+    async getPreferences({ user }) {
+        return this.repository.auth.getPreferences(user.id);
+    }
+    async setPreferences(preferences, { user }) {
+        (0, posthog_1.posthogCapture)({
+            distinctId: user.id,
+            event: "preferences_set",
+        });
+        return this.repository.auth.setPreferences(user.id, preferences);
+    }
+    async getMetadata({ user }) {
+        return this.repository.auth.getMetadata(user.id);
+    }
+    async setMetadata(metadata, { user }) {
+        (0, posthog_1.posthogCapture)({
+            distinctId: user.id,
+            event: "metadata_set",
+        });
+        return this.repository.auth.setMetadata(user.id, metadata);
+    }
+    async getFlags({ user }) {
+        return this.repository.auth.getFlags(user.id);
+    }
+    async setFlags(flags, { user }) {
+        (0, posthog_1.posthogCapture)({
+            distinctId: user.id,
+            event: "flags_set",
+        });
+        return this.repository.auth.setFlags(user.id, flags);
+    }
+    async listAdminWaitlist() {
+        return this.repository.auth.listAdminWaitlist();
+    }
+    async listWaitlist({ user }) {
+        return this.repository.auth.listWaitlist(user.id);
+    }
+    async addToWaitlist({ email }) {
+        return this.repository.auth.addToWaitlist(email);
+    }
+    async inviteFromWaitlist({ id }) {
+        const waitlist = await this.repository.auth.inviteFromWaitlist(id);
+        if (waitlist.isErr())
+            return (0, neverthrow_1.err)(waitlist.error);
+        if (!waitlist.value.code)
+            return this.repository.auth.error("BAD_REQUEST");
+        if (!waitlist.value.email)
+            return this.repository.auth.error("BAD_REQUEST");
+        await this.service.email.sendWaitlistInvite(waitlist.value.email, waitlist.value.code);
+        return (0, neverthrow_1.ok)(waitlist.value);
+    }
+    async inviteToWaitlist({ email, name }, { user }) {
+        const count = await this.repository.auth.getUserWaitlistCount(user.id);
+        if (count.isErr())
+            return (0, neverthrow_1.err)(count.error);
+        if (count.value >= 3)
+            return this.repository.auth.error("BAD_REQUEST", "Run out of invites");
+        const waitlist = await this.repository.auth.inviteToWaitlist({ email, userId: user.id, name });
+        if (waitlist.isErr())
+            return (0, neverthrow_1.err)(waitlist.error);
+        if (!waitlist.value.code)
+            return this.repository.auth.error("BAD_REQUEST");
+        await this.service.email.sendWaitlistUserInvite(email, waitlist.value.code, user.name, name);
+        (0, posthog_1.posthogCapture)({
+            distinctId: user.id,
+            event: "waitlist_invite_sent",
+            properties: {
+                email,
+                name,
+            },
+        });
+        return (0, neverthrow_1.ok)(waitlist.value);
+    }
+    async createInvitationCode({ name }, { user }) {
+        (0, posthog_1.posthogCapture)({
+            distinctId: user.id,
+            event: "waitlist_invitation_code_created",
+            properties: {
+                name,
+            },
+        });
+        return this.repository.auth.createInvitationCode({ userId: user.id, name });
+    }
+    async joinWaitlist({ email }) {
+        const waitlist = await this.repository.auth.joinWaitlist(email);
+        if (waitlist.isErr())
+            return (0, neverthrow_1.err)(waitlist.error);
+        await this.service.email.sendWaitlistConfirmation(email);
+        return (0, neverthrow_1.ok)(waitlist.value);
+    }
+    async removeFromWaitlist({ id }) {
+        return this.repository.auth.removeFromWaitlist(id);
+    }
+    async validateWaitlistCode(code) {
+        return this.repository.auth.validateWaitlistCode(code);
+    }
+    async createAccountClaimCode({ userId, expiresInHours, }) {
+        return this.repository.auth.createAccountClaimCode({ userId, expiresInHours });
+    }
+    async listAccountClaims() {
+        return this.repository.auth.listAccountClaims();
+    }
+    async getMyAccountClaimStatus({ user }) {
+        return this.repository.auth.findPendingAccountClaimForUser(user.id);
+    }
+    async setMyAccountClaimEmail({ email }, { user }) {
+        return this.repository.auth.setAccountClaimEmail({ userId: user.id, email });
+    }
+    async acceptMyAccountClaim({ user }) {
+        const pendingClaim = await this.repository.auth.findPendingAccountClaimForUser(user.id);
+        if (pendingClaim.isErr())
+            return (0, neverthrow_1.err)(pendingClaim.error);
+        const accepted = await this.repository.auth.acceptAccountClaim(user.id);
+        if (accepted.isErr())
+            return (0, neverthrow_1.err)(accepted.error);
+        if (pendingClaim.value) {
+            const billingService = this.getBillingService();
+            if (billingService) {
+                await billingService.createUserHook({ user });
+            }
+        }
+        return (0, neverthrow_1.ok)(accepted.value);
+    }
+    async generateAccountClaimMagicLink({ claimId, email, }) {
+        const claim = await this.repository.auth.findAccountClaimById(claimId);
+        if (claim.isErr())
+            return (0, neverthrow_1.err)(claim.error);
+        if (!claim.value)
+            return this.repository.auth.error("NOT_FOUND", "Claim not found");
+        if (!claim.value.claimUserId)
+            return this.repository.auth.error("BAD_REQUEST", "Claim has no user");
+        if (claim.value.status !== "INVITED") {
+            return this.repository.auth.error("BAD_REQUEST", "Claim is not pending");
+        }
+        if (claim.value.expiresAt && claim.value.expiresAt < new Date()) {
+            return this.repository.auth.error("BAD_REQUEST", "Claim is expired");
+        }
+        const targetEmail = email ?? claim.value.claimedEmail ?? undefined;
+        if (!targetEmail) {
+            return this.repository.auth.error("BAD_REQUEST", "Email required to generate magic link");
+        }
+        const setEmail = await this.repository.auth.setAccountClaimEmail({
+            userId: claim.value.claimUserId,
+            email: targetEmail,
+        });
+        if (setEmail.isErr())
+            return (0, neverthrow_1.err)(setEmail.error);
+        const response = await fetch(`${process.env.VITE_SERVER_URL}/api/auth/sign-in/magic-link`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                email: targetEmail.toLowerCase(),
+                callbackURL: `${process.env.VITE_APP_URL}/claim-account?claim=${claimId}`,
+            }),
+        });
+        if (!response.ok) {
+            return this.repository.auth.error("INTERNAL_SERVER_ERROR", "Failed to generate magic link");
+        }
+        const latest = await this.repository.auth.latestAccountClaimMagicLink(claimId);
+        if (latest.isErr())
+            return (0, neverthrow_1.err)(latest.error);
+        if (!latest.value)
+            return this.repository.auth.error("INTERNAL_SERVER_ERROR");
+        return (0, neverthrow_1.ok)(latest.value);
+    }
+    async listAccountClaimMagicLinks({ claimId, }) {
+        return this.repository.auth.listAccountClaimMagicLinks(claimId);
+    }
+}
+exports.AuthService = AuthService;

package/dist/src/modules/auth/auth.trpc.d.ts

@@ -4,9 +4,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         session: {
             id: string;
             userId: string;
-            expiresAt: Date;
-            createdAt: Date;
             updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
             token: string;
             ipAddress: string | null;
             userAgent: string | null;
@@ -18,13 +18,12 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         };
         user: {
             name: string;
-            image: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             email: string;
-            metadata: Record<string, unknown>;
             emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
             role: string | null;
             banned: boolean | null;
             banReason: string | null;
@@ -34,6 +33,7 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
             paymentPlanTier: string | null;
             paymentPlanExpiresAt: Date | null;
             preferences: string | null;
+            metadata: Record<string, unknown>;
             onboarding: number | null;
             flags: string | null;
         };
@@ -85,9 +85,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         input: void;
         output: {
             id: string;
-            expiresAt: Date | null;
-            createdAt: Date;
             updatedAt: Date | null;
+            createdAt: Date;
+            expiresAt: Date | null;
             status: string;
             claimUserId: string | null;
             claimedAt: Date | null;
@@ -103,11 +103,11 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             id: string;
             userId: string;
-            expiresAt: Date | null;
-            createdAt: Date;
             email: string;
-            url: string;
+            createdAt: Date;
+            expiresAt: Date | null;
             claimId: string;
+            url: string;
         };
         meta: import("trpc-to-openapi").OpenApiMeta;
     }>;
@@ -118,11 +118,11 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             id: string;
             userId: string;
-            expiresAt: Date | null;
-            createdAt: Date;
             email: string;
-            url: string;
+            createdAt: Date;
+            expiresAt: Date | null;
             claimId: string;
+            url: string;
         }[];
         meta: import("trpc-to-openapi").OpenApiMeta;
     }>;
@@ -176,9 +176,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             name: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date | null;
             email: string | null;
+            createdAt: Date;
             status: string;
         }[];
         meta: import("trpc-to-openapi").OpenApiMeta;
@@ -190,9 +190,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             name: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date | null;
             email: string | null;
+            createdAt: Date;
             status: string;
         };
         meta: import("trpc-to-openapi").OpenApiMeta;
@@ -221,9 +221,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             name: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date | null;
             email: string | null;
+            createdAt: Date;
             status: string;
         };
         meta: import("trpc-to-openapi").OpenApiMeta;
@@ -235,9 +235,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             name: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date | null;
             email: string | null;
+            createdAt: Date;
             status: string;
         };
         meta: import("trpc-to-openapi").OpenApiMeta;
@@ -249,9 +249,9 @@ export declare function createAuthTRPC(authService: AuthService): import("@trpc/
         output: {
             name: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date | null;
             email: string | null;
+            createdAt: Date;
             status: string;
         };
         meta: import("trpc-to-openapi").OpenApiMeta;

package/dist/src/modules/auth/auth.trpc.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthTRPC = createAuthTRPC;
+const zod_1 = require("zod");
+const auth_dto_1 = require("#modules/auth/auth.dto");
+const _trpc_1 = require("#trpc");
+function createAuthTRPC(authService) {
+    return (0, _trpc_1.router)({
+        getUserWaitlistCount: _trpc_1.procedure.output(zod_1.z.number()).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.getUserWaitlistCount(ctx));
+        }),
+        createInvitationCode: _trpc_1.procedure
+            .input(zod_1.z.object({ name: zod_1.z.string().optional() }))
+            .output(auth_dto_1.waitlistSchema)
+            .mutation(async ({ input, ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.createInvitationCode(input, ctx));
+        }),
+        createAccountClaimCode: _trpc_1.adminProcedure
+            .input(zod_1.z.object({
+            userId: zod_1.z.string(),
+            expiresInHours: zod_1.z.number().optional(),
+        }))
+            .output(auth_dto_1.accountClaimSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.createAccountClaimCode(input));
+        }),
+        listAccountClaims: _trpc_1.adminProcedure.output(zod_1.z.array(auth_dto_1.accountClaimOutputSchema)).query(async () => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.listAccountClaims());
+        }),
+        generateAccountClaimMagicLink: _trpc_1.adminProcedure
+            .input(zod_1.z.object({
+            claimId: zod_1.z.string(),
+            email: zod_1.z.string().email().optional(),
+        }))
+            .output(auth_dto_1.accountClaimMagicLinkOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.generateAccountClaimMagicLink(input));
+        }),
+        listAccountClaimMagicLinks: _trpc_1.adminProcedure
+            .input(zod_1.z.object({
+            claimId: zod_1.z.string(),
+        }))
+            .output(zod_1.z.array(auth_dto_1.accountClaimMagicLinkOutputSchema))
+            .query(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.listAccountClaimMagicLinks(input));
+        }),
+        getMyAccountClaimStatus: _trpc_1.procedure.output(auth_dto_1.accountClaimSchema.nullable()).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.getMyAccountClaimStatus(ctx));
+        }),
+        setMyAccountClaimEmail: _trpc_1.procedure
+            .input(zod_1.z.object({
+            email: zod_1.z.string().email(),
+        }))
+            .output(zod_1.z.object({ status: zod_1.z.boolean() }))
+            .mutation(async ({ input, ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.setMyAccountClaimEmail(input, ctx));
+        }),
+        acceptMyAccountClaim: _trpc_1.procedure
+            .output(zod_1.z.object({ status: zod_1.z.boolean() }))
+            .mutation(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.acceptMyAccountClaim(ctx));
+        }),
+        listWaitlist: _trpc_1.procedure.output(zod_1.z.array(auth_dto_1.waitlistSchema)).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.listWaitlist(ctx));
+        }),
+        listAdminWaitlist: _trpc_1.adminProcedure.output(zod_1.z.array(auth_dto_1.waitlistOutputSchema)).query(async () => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.listAdminWaitlist());
+        }),
+        addToWaitlist: _trpc_1.adminProcedure
+            .input(zod_1.z.object({
+            email: zod_1.z.string(),
+        }))
+            .output(auth_dto_1.waitlistOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.addToWaitlist(input));
+        }),
+        inviteToWaitlist: _trpc_1.procedure
+            .input(zod_1.z.object({
+            email: zod_1.z.string(),
+            name: zod_1.z.string().optional(),
+        }))
+            .output(auth_dto_1.waitlistSchema)
+            .mutation(async ({ input, ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.inviteToWaitlist(input, ctx));
+        }),
+        inviteFromWaitlist: _trpc_1.adminProcedure
+            .input(zod_1.z.object({
+            id: zod_1.z.string(),
+        }))
+            .output(auth_dto_1.waitlistOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.inviteFromWaitlist(input));
+        }),
+        removeFromWaitlist: _trpc_1.adminProcedure
+            .input(zod_1.z.object({
+            id: zod_1.z.string(),
+        }))
+            .output(auth_dto_1.waitlistOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.removeFromWaitlist(input));
+        }),
+        joinWaitlist: _trpc_1.publicProcedure
+            .input(zod_1.z.object({
+            email: zod_1.z.string(),
+        }))
+            .output(auth_dto_1.waitlistOutputSchema)
+            .mutation(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.joinWaitlist(input));
+        }),
+        getOnboarding: _trpc_1.procedure.output(zod_1.z.number()).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.getOnboarding(ctx));
+        }),
+        setOnboarding: _trpc_1.procedure
+            .input(zod_1.z.number())
+            .output(zod_1.z.number())
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.setOnboarding(input, ctx));
+        }),
+        getPreferences: _trpc_1.procedure.output(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.getPreferences(ctx));
+        }),
+        setPreferences: _trpc_1.procedure
+            .input(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
+            .output(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.setPreferences(input, ctx));
+        }),
+        getMetadata: _trpc_1.procedure.output(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.getMetadata(ctx));
+        }),
+        setMetadata: _trpc_1.procedure
+            .input(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
+            .output(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.setMetadata(input, ctx));
+        }),
+        getFlags: _trpc_1.procedure.output(zod_1.z.array(zod_1.z.string())).query(async ({ ctx }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.getFlags(ctx));
+        }),
+        setFlags: _trpc_1.procedure
+            .input(zod_1.z.array(zod_1.z.string()))
+            .output(zod_1.z.array(zod_1.z.string()))
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.setFlags(input, ctx));
+        }),
+        validateWaitlistCode: _trpc_1.publicProcedure
+            .input(zod_1.z.object({
+            code: zod_1.z.string(),
+        }))
+            .output(zod_1.z.object({
+            status: zod_1.z.string(),
+        }))
+            .query(async ({ input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await authService.validateWaitlistCode(input.code));
+        }),
+    });
+}

package/dist/src/modules/auth/auth.utils.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveOrganizationAndTeam = getActiveOrganizationAndTeam;
+exports.createOrganizationAndTeam = createOrganizationAndTeam;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const uuid_1 = require("uuid");
+const auth = tslib_1.__importStar(require("#modules/auth/auth.db"));
+const schema = { ...auth };
+async function getActiveOrganizationAndTeam(orm, schema, userId) {
+    let organizationId;
+    let teamId;
+    let organizationRole;
+    let teamRole;
+    const [lastSession] = await orm
+        .select({
+        activeOrganizationId: schema.sessions.activeOrganizationId,
+        activeTeamId: schema.sessions.activeTeamId,
+        activeOrganizationRole: schema.sessions.activeOrganizationRole,
+        activeTeamRole: schema.sessions.activeTeamRole,
+    })
+        .from(schema.sessions)
+        .where((0, drizzle_orm_1.eq)(schema.sessions.userId, userId))
+        .orderBy((0, drizzle_orm_1.desc)(schema.sessions.createdAt))
+        .limit(1);
+    if (lastSession) {
+        organizationId = lastSession.activeOrganizationId ?? undefined;
+        teamId = lastSession.activeTeamId ?? undefined;
+        organizationRole = lastSession.activeOrganizationRole ?? undefined;
+        teamRole = lastSession.activeTeamRole ?? undefined;
+    }
+    if (!organizationId || !organizationRole) {
+        const [member] = await orm
+            .select({ organizationId: schema.members.organizationId, role: schema.members.role })
+            .from(schema.members)
+            .orderBy((0, drizzle_orm_1.desc)(schema.members.createdAt))
+            .where((0, drizzle_orm_1.eq)(schema.members.userId, userId))
+            .limit(1);
+        organizationId = member?.organizationId;
+        organizationRole = member?.role;
+    }
+    if (!teamId || !teamRole) {
+        const [teamMember] = await orm
+            .select({ teamId: schema.teamMembers.teamId, role: schema.teamMembers.role })
+            .from(schema.teamMembers)
+            .orderBy((0, drizzle_orm_1.desc)(schema.teamMembers.createdAt))
+            .where((0, drizzle_orm_1.eq)(schema.teamMembers.userId, userId))
+            .limit(1);
+        teamId = teamMember?.teamId;
+        teamRole = teamMember?.role;
+    }
+    return { organizationId, teamId, organizationRole, teamRole };
+}
+async function createOrganizationAndTeam(orm, schema, user) {
+    const organizationId = (0, uuid_1.v4)();
+    await orm.transaction(async (tx) => {
+        const [organization] = await tx
+            .insert(schema.organizations)
+            .values({
+            id: organizationId,
+            name: organizationId,
+            slug: organizationId,
+        })
+            .returning();
+        if (!organization)
+            throw new Error("createOrganizationAndTeam: Failed to create organization");
+        const [member] = await tx
+            .insert(schema.members)
+            .values({
+            userId: user.id,
+            organizationId: organization.id,
+            role: "owner",
+        })
+            .returning();
+        if (!member)
+            throw new Error("createOrganizationAndTeam: Failed to create member");
+        const [team] = await tx
+            .insert(schema.teams)
+            .values({
+            name: organization.id,
+            organizationId: organization.id,
+        })
+            .returning();
+        if (!team)
+            throw new Error("createOrganizationAndTeam: Failed to create team");
+        const [teamMember] = await tx
+            .insert(schema.teamMembers)
+            .values({
+            userId: user.id,
+            teamId: team.id,
+            role: "owner",
+        })
+            .returning();
+        if (!teamMember)
+            throw new Error("createOrganizationAndTeam: Failed to create team member");
+    });
+}

package/dist/src/modules/base/base.abstract.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("#utils/errors");
+const logger_1 = require("#utils/logger");
+class Base {
+    layer;
+    logger;
+    constructor(layer) {
+        this.layer = layer;
+        this.logger = logger_1.logger.child({ layer: this.layer, layerName: this.constructor.name });
+    }
+    error(code, message, { cause, clientMessage, log = process.env.NODE_ENV === "development", } = {}) {
+        const serverError = new errors_1.ServerError({
+            code,
+            layer: this.layer,
+            layerName: this.constructor.name,
+            message,
+            clientMessage,
+            cause,
+            captureBoundary: true,
+        });
+        if (serverError.is5xxError())
+            (0, errors_1.reportError)(serverError);
+        if (log)
+            logger_1.logger.error(serverError);
+        return (0, neverthrow_1.err)(serverError);
+    }
+    handleUnknownError(error) {
+        return errors_1.ServerError.fromUnknown("INTERNAL_SERVER_ERROR", error, {
+            layer: this.layer,
+            layerName: this.constructor.name,
+        });
+    }
+    throwable(fn) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(this.handleUnknownError(error));
+        }
+    }
+    async throwableAsync(fn) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(this.handleUnknownError(error));
+        }
+    }
+}
+exports.Base = Base;