@m5kdev/backend 0.1.0 → 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

@@ -0,0 +1,309 @@
+import type { AuthService } from "#modules/auth/auth.service";
+export declare function createAuthTRPC(authService: AuthService): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        session: {
+            id: string;
+            userId: string;
+            updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
+            token: string;
+            ipAddress: string | null;
+            userAgent: string | null;
+            impersonatedBy: string | null;
+            activeOrganizationId: string | null;
+            activeOrganizationRole: string | null;
+            activeTeamId: string | null;
+            activeTeamRole: string | null;
+        };
+        user: {
+            name: string;
+            id: string;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
+            role: string | null;
+            banned: boolean | null;
+            banReason: string | null;
+            banExpires: Date | null;
+            stripeCustomerId: string | null;
+            paymentCustomerId: string | null;
+            paymentPlanTier: string | null;
+            paymentPlanExpiresAt: Date | null;
+            preferences: string | null;
+            metadata: Record<string, unknown>;
+            onboarding: number | null;
+            flags: string | null;
+        };
+    };
+    meta: import("trpc-to-openapi").OpenApiMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getUserWaitlistCount: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: number;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    createInvitationCode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name?: string | undefined;
+        };
+        output: {
+            id: string;
+            name: string | null;
+            email: string | null;
+            createdAt: Date;
+            updatedAt: Date | null;
+            status: string;
+            code: string | null;
+            expiresAt: Date | null;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    createAccountClaimCode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            userId: string;
+            expiresInHours?: number | undefined;
+        };
+        output: {
+            id: string;
+            claimUserId: string | null;
+            code: string | null;
+            status: string;
+            expiresAt: Date | null;
+            claimedAt: Date | null;
+            claimedEmail: string | null;
+            createdAt: Date;
+            updatedAt: Date | null;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    listAccountClaims: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            updatedAt: Date | null;
+            createdAt: Date;
+            expiresAt: Date | null;
+            status: string;
+            claimUserId: string | null;
+            claimedAt: Date | null;
+            claimedEmail: string | null;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    generateAccountClaimMagicLink: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            claimId: string;
+            email?: string | undefined;
+        };
+        output: {
+            id: string;
+            userId: string;
+            email: string;
+            createdAt: Date;
+            expiresAt: Date | null;
+            claimId: string;
+            url: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    listAccountClaimMagicLinks: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            claimId: string;
+        };
+        output: {
+            id: string;
+            userId: string;
+            email: string;
+            createdAt: Date;
+            expiresAt: Date | null;
+            claimId: string;
+            url: string;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    getMyAccountClaimStatus: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            claimUserId: string | null;
+            code: string | null;
+            status: string;
+            expiresAt: Date | null;
+            claimedAt: Date | null;
+            claimedEmail: string | null;
+            createdAt: Date;
+            updatedAt: Date | null;
+        } | null;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    setMyAccountClaimEmail: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+        };
+        output: {
+            status: boolean;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    acceptMyAccountClaim: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            status: boolean;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    listWaitlist: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            name: string | null;
+            email: string | null;
+            createdAt: Date;
+            updatedAt: Date | null;
+            status: string;
+            code: string | null;
+            expiresAt: Date | null;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    listAdminWaitlist: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            name: string | null;
+            id: string;
+            updatedAt: Date | null;
+            email: string | null;
+            createdAt: Date;
+            status: string;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    addToWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+        };
+        output: {
+            name: string | null;
+            id: string;
+            updatedAt: Date | null;
+            email: string | null;
+            createdAt: Date;
+            status: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    inviteToWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+            name?: string | undefined;
+        };
+        output: {
+            id: string;
+            name: string | null;
+            email: string | null;
+            createdAt: Date;
+            updatedAt: Date | null;
+            status: string;
+            code: string | null;
+            expiresAt: Date | null;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    inviteFromWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            name: string | null;
+            id: string;
+            updatedAt: Date | null;
+            email: string | null;
+            createdAt: Date;
+            status: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    removeFromWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            name: string | null;
+            id: string;
+            updatedAt: Date | null;
+            email: string | null;
+            createdAt: Date;
+            status: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    joinWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+        };
+        output: {
+            name: string | null;
+            id: string;
+            updatedAt: Date | null;
+            email: string | null;
+            createdAt: Date;
+            status: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    getOnboarding: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: number;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    setOnboarding: import("@trpc/server").TRPCMutationProcedure<{
+        input: number;
+        output: number;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    getPreferences: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, unknown>;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    setPreferences: import("@trpc/server").TRPCMutationProcedure<{
+        input: Record<string, unknown>;
+        output: Record<string, unknown>;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    getMetadata: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, unknown>;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    setMetadata: import("@trpc/server").TRPCMutationProcedure<{
+        input: Record<string, unknown>;
+        output: Record<string, unknown>;
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    getFlags: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: string[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    setFlags: import("@trpc/server").TRPCMutationProcedure<{
+        input: string[];
+        output: string[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    validateWaitlistCode: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            code: string;
+        };
+        output: {
+            status: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+}>>;
+//# sourceMappingURL=auth.trpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.trpc.d.ts","sourceRoot":"","sources":["../../../../src/modules/auth/auth.trpc.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAG9D,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoMtD"}

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