@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/types.d.ts

@@ -0,0 +1,486 @@
+import type { Mastra } from "@mastra/core";
+import type { AIService } from "#modules/ai/ai.service";
+import type { AuthService } from "#modules/auth/auth.service";
+import type { BillingService } from "#modules/billing/billing.service";
+export declare const createAuthTRPCRouter: <MastraInstance extends Mastra>(authService: AuthService, aiService: AIService<MastraInstance>, billingService: BillingService) => 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<{
+    auth: 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;
+        }>;
+    }>>;
+    ai: 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<{
+        getUserUsage: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                userId: string;
+            };
+            output: {
+                inputTokens: number | null;
+                outputTokens: number | null;
+                totalTokens: number | null;
+                cost: number | null;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
+    billing: 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<{
+        getActiveSubscription: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                plan: string;
+                referenceId: string;
+                status: string;
+                stripeCustomerId?: string | null | undefined;
+                stripeSubscriptionId?: string | null | undefined;
+                periodStart?: Date | null | undefined;
+                periodEnd?: Date | null | undefined;
+                cancelAtPeriodEnd?: boolean | null | undefined;
+                cancelAt?: Date | null | undefined;
+                canceledAt?: Date | null | undefined;
+                seats?: number | null | undefined;
+                trialStart?: Date | null | undefined;
+                trialEnd?: Date | null | undefined;
+                priceId?: string | null | undefined;
+                interval?: string | null | undefined;
+                unitAmount?: number | null | undefined;
+                discounts?: string[] | null | undefined;
+            } | null;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        listInvoices: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: import("stripe").Stripe.Invoice[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
+}>>;
+export type BackendTRPCRouter = ReturnType<typeof createAuthTRPCRouter>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,oBAAoB,GAAI,cAAc,SAAS,MAAM,EAChE,aAAa,WAAW,EACxB,WAAW,SAAS,CAAC,cAAc,CAAC,EACpC,gBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM5B,CAAC;AAEL,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/src/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthTRPCRouter = void 0;
+const ai_trpc_1 = require("#modules/ai/ai.trpc");
+const auth_trpc_1 = require("#modules/auth/auth.trpc");
+const billing_trpc_1 = require("#modules/billing/billing.trpc");
+const _trpc_1 = require("#trpc");
+const createAuthTRPCRouter = (authService, aiService, billingService) => (0, _trpc_1.router)({
+    auth: (0, auth_trpc_1.createAuthTRPC)(authService),
+    ai: (0, ai_trpc_1.createAITRPC)(aiService),
+    billing: (0, billing_trpc_1.createBillingTRPC)(billingService),
+});
+exports.createAuthTRPCRouter = createAuthTRPCRouter;

package/dist/src/utils/errors.d.ts

@@ -0,0 +1,50 @@
+import type { captureException } from "@sentry/node";
+import { type TRPC_ERROR_CODE_KEY, TRPCError } from "@trpc/server";
+import type { ServerErrorLayer } from "#modules/base/base.types";
+export type { ServerErrorLayer };
+export declare class ServerError extends Error {
+    readonly code: TRPC_ERROR_CODE_KEY;
+    readonly layer: ServerErrorLayer;
+    readonly layerName: string;
+    readonly clientMessage?: string;
+    readonly context?: Record<string, unknown>;
+    readonly boundaryStack?: string;
+    constructor({ code, layer, layerName, message, clientMessage, cause, context, captureBoundary, }: {
+        code: TRPC_ERROR_CODE_KEY;
+        layer?: ServerErrorLayer;
+        layerName?: string;
+        message?: string;
+        clientMessage?: string;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+        captureBoundary?: boolean;
+    });
+    is5xxError(): boolean;
+    getHTTPStatusCode(): number;
+    toTRPC(): TRPCError;
+    toJSON(): {
+        code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+        layer: ServerErrorLayer;
+        layerName: string;
+        message: string;
+        context: Record<string, unknown> | undefined;
+        stack: string | undefined;
+        boundaryStack: string | undefined;
+        cause: unknown;
+    };
+    static fromUnknown(code: TRPC_ERROR_CODE_KEY, cause: unknown, opts?: {
+        layer?: ServerErrorLayer;
+        layerName?: string;
+        context?: Record<string, unknown>;
+    }): ServerError;
+}
+export type ErrorReporter = {
+    captureException: (err: Parameters<typeof captureException>[0], hint?: Parameters<typeof captureException>[1]) => string;
+};
+declare global {
+    var m5ErrorReporter: ErrorReporter | undefined;
+}
+export declare function getErrorReporter(): ErrorReporter | undefined;
+export declare function setErrorReporter(reporter: ErrorReporter): void;
+export declare function reportError(err: ServerError | Error | unknown, hint?: Parameters<typeof captureException>[1]): string | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/utils/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,KAAK,mBAAmB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,YAAY,EAAE,gBAAgB,EAAE,CAAC;AACjC,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;gBAEpB,EACV,IAAI,EACJ,KAAK,EACL,SAAS,EACT,OAAO,EACP,aAAa,EACb,KAAK,EACL,OAAO,EACP,eAAsB,GACvB,EAAE;QACD,IAAI,EAAE,mBAAmB,CAAC;QAC1B,KAAK,CAAC,EAAE,gBAAgB,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B;IAiBD,UAAU,IAAI,OAAO;IAKrB,iBAAiB,IAAI,MAAM;IAI3B,MAAM,IAAI,SAAS;IAQnB,MAAM;;;;;;;;;;IAiBN,MAAM,CAAC,WAAW,CAChB,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;CAa7F;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,gBAAgB,EAAE,CAChB,GAAG,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAC3C,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAC1C,MAAM,CAAC;CACb,CAAC;AACF,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,eAAe,EAAE,aAAa,GAAG,SAAS,CAAC;CAChD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAE5D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,QAEvD;AAED,wBAAgB,WAAW,CACzB,GAAG,EAAE,WAAW,GAAG,KAAK,GAAG,OAAO,EAClC,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC5C,MAAM,GAAG,SAAS,CAsBpB"}

package/dist/src/utils/errors.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerError = void 0;
+exports.getErrorReporter = getErrorReporter;
+exports.setErrorReporter = setErrorReporter;
+exports.reportError = reportError;
+const server_1 = require("@trpc/server");
+const http_1 = require("@trpc/server/http");
+const radashi_1 = require("radashi");
+const logger_1 = require("./logger");
+class ServerError extends Error {
+    code;
+    layer;
+    layerName;
+    clientMessage;
+    context;
+    boundaryStack; // where we wrapped it
+    constructor({ code, layer, layerName, message, clientMessage, cause, context, captureBoundary = true, }) {
+        // keep native cause chain when the cause is an Error
+        super(message ?? `server.error.${layer}.${(0, radashi_1.camel)(code)}`, {
+            cause: cause instanceof Error ? cause : undefined,
+        });
+        this.code = code;
+        this.layer = layer ?? "unknown";
+        this.layerName = layerName ?? "UnknownLayer";
+        this.clientMessage = clientMessage ?? `server.error.${layer}.${(0, radashi_1.camel)(code)}`;
+        this.context = context;
+        if (captureBoundary)
+            this.boundaryStack = new Error().stack;
+        Error.captureStackTrace?.(this, ServerError);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    is5xxError() {
+        const statusCode = this.getHTTPStatusCode();
+        return statusCode >= 500 && statusCode < 600;
+    }
+    getHTTPStatusCode() {
+        return (0, http_1.getHTTPStatusCodeFromError)(this.toTRPC());
+    }
+    toTRPC() {
+        return new server_1.TRPCError({
+            code: this.code,
+            message: this.message,
+            cause: this.cause,
+        });
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            layer: this.layer,
+            layerName: this.layerName,
+            message: this.message,
+            context: this.context,
+            stack: process.env.NODE_ENV !== "production" ? this.stack : undefined,
+            boundaryStack: process.env.NODE_ENV !== "production" ? this.boundaryStack : undefined,
+            // Shallow representation of cause to avoid cycles
+            cause: this.cause instanceof Error
+                ? { name: this.cause.name, message: this.cause.message, stack: this.cause.stack }
+                : this.cause,
+        };
+    }
+    static fromUnknown(code, cause, opts) {
+        const msg = cause instanceof Error ? cause.message : undefined;
+        return new ServerError({
+            code,
+            layer: opts?.layer,
+            layerName: opts?.layerName,
+            message: msg,
+            cause,
+            context: opts?.context,
+            captureBoundary: true,
+        });
+    }
+}
+exports.ServerError = ServerError;
+function getErrorReporter() {
+    return globalThis.m5ErrorReporter;
+}
+function setErrorReporter(reporter) {
+    globalThis.m5ErrorReporter = reporter;
+}
+function reportError(err, hint) {
+    let eventHint = hint;
+    const reporter = getErrorReporter();
+    if (!reporter) {
+        logger_1.logger.error("[reportError] No error reporter set!");
+        return;
+    }
+    if (err instanceof ServerError) {
+        // Merge - don't clobber caller-provided hint
+        eventHint = {
+            ...hint,
+            captureContext: {
+                ...hint?.captureContext,
+                extra: {
+                    ...(hint?.captureContext?.extra ?? {}),
+                    layer: err.layer,
+                    layerName: err.layerName,
+                },
+            },
+        };
+    }
+    return reporter.captureException(err, eventHint);
+}

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").Logger<never, boolean>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,uCAKjB,CAAC"}

package/dist/src/utils/logger.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const tslib_1 = require("tslib");
+const pino_1 = tslib_1.__importDefault(require("pino"));
+exports.logger = (0, pino_1.default)({
+    transport: {
+        target: "pino-pretty",
+    },
+    level: "debug",
+});