@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/workflow/workflow.utils.d.ts

@@ -0,0 +1,22 @@
+import type { WorkflowReadOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
+import { type JobsOptions, type Queue, Worker, type WorkerOptions } from "bullmq";
+import type { ServerResultAsync } from "../base/base.dto";
+import type { WorkflowService } from "./workflow.service";
+import type { WorkflowDataType, WorkflowJob, WorkflowMeta } from "./workflow.types";
+export declare function createWorkflowTrigger<Jobs extends Record<string, WorkflowJob<WorkflowDataType<any>, any, string>>>(service: WorkflowService, queues: Record<string, Queue>, defaultQueue: string): {
+    trigger: ({ name, payload, meta, options, }: {
+        name: string;
+        payload: Parameters<Jobs[keyof Jobs & string]["run"]>[0]["data"]["payload"];
+        meta?: WorkflowMeta;
+        options?: JobsOptions;
+    }) => ServerResultAsync<WorkflowReadOutputSchema>;
+    triggerMany: ({ name, payload, meta, options, }: {
+        name: string;
+        payload: Parameters<Jobs[keyof Jobs & string]["run"]>[0]["data"]["payload"][];
+        meta?: WorkflowMeta;
+        options?: JobsOptions;
+    }) => ServerResultAsync<WorkflowReadOutputSchema[]>;
+};
+export declare function createWorkflowWorker<Jobs extends Record<string, WorkflowJob<WorkflowDataType<any>, any, string>>>(service: WorkflowService, queueName: string, workerOptions: WorkerOptions, jobs: Jobs, errorHandler?: (error: unknown) => void): Worker<any, any, string>;
+export declare function createWorkflowWorkers<Jobs extends Record<string, WorkflowJob<WorkflowDataType<any>, any, string>>>(service: WorkflowService, workerSettings: Record<string, WorkerOptions>, jobs: Jobs, errorHandler?: (error: unknown) => void): Record<string, Worker<any, any, string>>;
+//# sourceMappingURL=workflow.utils.d.ts.map

package/dist/src/modules/workflow/workflow.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.utils.d.ts","sourceRoot":"","sources":["../../../../src/modules/workflow/workflow.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kDAAkD,CAAC;AACjG,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAMlF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAuBpF,wBAAgB,qBAAqB,CACnC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,EAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,YAAY,EAAE,MAAM;iDAM1E;QACD,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC;QAC5E,IAAI,CAAC,EAAE,YAAY,CAAC;QACpB,OAAO,CAAC,EAAE,WAAW,CAAC;KACvB,KAAG,iBAAiB,CAAC,wBAAwB,CAAC;qDAwD5C;QACD,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,UAAU,CAAC,IAAI,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9E,IAAI,CAAC,EAAE,YAAY,CAAC;QACpB,OAAO,CAAC,EAAE,WAAW,CAAC;KACvB,KAAG,iBAAiB,CAAC,wBAAwB,EAAE,CAAC;EAwDlD;AAED,wBAAgB,oBAAoB,CAClC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,EAE5E,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,IAAI,EACV,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,4BAkExC;AAED,wBAAgB,qBAAqB,CACnC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,EAE5E,OAAO,EAAE,eAAe,EACxB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EAC7C,IAAI,EAAE,IAAI,EACV,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,4CAaxC"}

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

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowTrigger = createWorkflowTrigger;
+exports.createWorkflowWorker = createWorkflowWorker;
+exports.createWorkflowWorkers = createWorkflowWorkers;
+const bullmq_1 = require("bullmq");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("#utils/errors");
+const logger_1 = require("#utils/logger");
+const posthog_1 = require("#utils/posthog");
+const errorOptions = {
+    layer: "workflow",
+    layerName: "WorkflowTrigger",
+};
+function shouldDisablePosthogFromPayload(payload) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const session = payload.ctx?.session;
+    return Boolean(session?.impersonatedBy);
+}
+function createWorkflowTrigger(service, queues, defaultQueue) {
+    const trigger = async ({ name, payload, meta, options, }) => {
+        const { queue: queueName, userId, tags, timeout = 60 * 60 * 1000 } = meta || {};
+        const disablePosthogCapture = meta?.disablePosthogCapture ?? shouldDisablePosthogFromPayload(payload);
+        const compiledQueueName = queueName || defaultQueue;
+        if (!compiledQueueName || !Object.keys(queues).includes(compiledQueueName)) {
+            return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "NOT_FOUND", ...errorOptions }));
+        }
+        const queue = queues[compiledQueueName];
+        if (!queue) {
+            return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "NOT_FOUND", ...errorOptions }));
+        }
+        try {
+            const job = await queue.add(name, {
+                payload,
+                meta: { ...meta, timeout, disablePosthogCapture },
+            }, {
+                removeOnComplete: {
+                    age: 24 * 3600, // keep up to 24 hours
+                },
+                removeOnFail: {
+                    age: 7 * 24 * 3600, // keep up to week
+                },
+                ...options,
+            });
+            if (!job || !job.id) {
+                return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
+            }
+            return await service.added({
+                userId,
+                jobId: job.id,
+                jobName: name,
+                input: payload,
+                timeout,
+                queueName: compiledQueueName,
+                tags,
+            });
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
+        }
+    };
+    const triggerMany = async ({ name, payload, meta, options, }) => {
+        const { queue: queueName, userId, tags, timeout = 60 * 60 * 1000 } = meta || {};
+        const compiledQueueName = queueName || defaultQueue;
+        if (!compiledQueueName || !Object.keys(queues).includes(compiledQueueName)) {
+            return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "NOT_FOUND", ...errorOptions }));
+        }
+        const queue = queues[compiledQueueName];
+        if (!queue) {
+            return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "NOT_FOUND", ...errorOptions }));
+        }
+        try {
+            const jobs = await queue.addBulk(payload.map((p) => {
+                const disablePosthogCapture = meta?.disablePosthogCapture ?? shouldDisablePosthogFromPayload(p);
+                return {
+                    name,
+                    data: { payload: p, meta: { ...meta, timeout, disablePosthogCapture } },
+                    options: {
+                        removeOnComplete: {
+                            age: 24 * 3600, // keep up to 24 hours
+                        },
+                        removeOnFail: {
+                            age: 7 * 24 * 3600, // keep up to week
+                        },
+                        ...options,
+                    },
+                };
+            }));
+            if (!jobs || jobs.length === 0) {
+                return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
+            }
+            return await service.addedMany(jobs.map((j) => ({
+                userId,
+                jobId: j.id,
+                jobName: name,
+                input: j.data.payload,
+                timeout,
+                queueName: compiledQueueName,
+                tags,
+            })));
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(new errors_1.ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
+        }
+    };
+    return { trigger, triggerMany };
+}
+function createWorkflowWorker(service, queueName, workerOptions, jobs, errorHandler) {
+    const logger = logger_1.logger.child({ layer: "worker" });
+    const worker = new bullmq_1.Worker(queueName, async (job) => {
+        const { meta } = job.data;
+        return await (0, posthog_1.runWithPosthogRequestState)({ disableCapture: Boolean(meta?.disablePosthogCapture) }, async () => {
+            const timer = meta?.timeout &&
+                setTimeout(() => {
+                    const error = new Error("Job timed out");
+                    errorHandler?.(error);
+                    throw error;
+                }, job.data.meta.timeout);
+            const handler = jobs[job.name];
+            if (!handler) {
+                const error = new Error(`Unknown job: ${job.name}`);
+                errorHandler?.(error);
+                throw error;
+            }
+            try {
+                await service.started(job);
+                const result = await handler.run(job);
+                if (result.isErr()) {
+                    await handler.onFailure?.(job, result.error);
+                    const error = new Error(result.error.message);
+                    errorHandler?.(error);
+                    throw error;
+                }
+                await handler.onSuccess?.(job).catch((err) => {
+                    const error = new Error(`Job ${job.id}:${job.name} failed to run onSuccess: ${err}`);
+                    logger.error(error.message);
+                    errorHandler?.(error);
+                });
+                return result.value ?? null;
+            }
+            catch (err) {
+                await handler.onFailure?.(job, err).catch((err) => {
+                    const error = new Error(`Job ${job.id}:${job.name} failed to run onFailure: ${err}`);
+                    logger.error(error.message);
+                    errorHandler?.(error);
+                });
+                if (err instanceof Error && err.message === "Job timed out")
+                    logger.error(`Job ${job.id}:${job.name} timed out`);
+                throw err;
+            }
+            finally {
+                await handler.onComplete?.(job).catch((err) => {
+                    const error = new Error(`Job ${job.id}:${job.name} failed to run onComplete: ${err}`);
+                    logger.error(error.message);
+                    errorHandler?.(error);
+                });
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }, workerOptions);
+    worker.on("completed", service.completed.bind(service));
+    worker.on("failed", service.failed.bind(service));
+    return worker;
+}
+function createWorkflowWorkers(service, workerSettings, jobs, errorHandler) {
+    const workers = {};
+    for (const [queueName, workerOptions] of Object.entries(workerSettings)) {
+        workers[queueName] = createWorkflowWorker(service, queueName, workerOptions, jobs, errorHandler);
+    }
+    return workers;
+}

package/dist/src/test/stubs/utils.d.ts

@@ -0,0 +1,3 @@
+export * from "../../utils/errors";
+export * from "../../utils/logger";
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/test/stubs/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/test/stubs/utils.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

package/dist/src/test/stubs/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../../utils/errors"), exports);
+tslib_1.__exportStar(require("../../utils/logger"), exports);

package/dist/src/trpc/context.d.ts

@@ -0,0 +1,42 @@
+import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
+import type { BetterAuth } from "#modules/auth/auth.lib";
+export type Context = Awaited<ReturnType<typeof createAuthContext>>;
+export declare function createAuthContext(auth: BetterAuth): ({ req }: CreateExpressContextOptions) => Promise<{
+    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;
+    };
+}>;
+//# sourceMappingURL=context.d.ts.map

package/dist/src/trpc/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/trpc/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAEjF,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,wBAAwB,CAAC;AAExE,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC;AAEpE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,IACZ,SAAS,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAazE"}

package/dist/src/trpc/context.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthContext = createAuthContext;
+const node_1 = require("better-auth/node");
+function createAuthContext(auth) {
+    return async function createContext({ req }) {
+        const data = await auth.api.getSession({
+            headers: (0, node_1.fromNodeHeaders)(req.headers),
+        });
+        const user = data?.user || null;
+        const session = data?.session || null;
+        return {
+            session,
+            user,
+        };
+    };
+}

package/dist/src/trpc/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./context";
+export * from "./procedures";
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/trpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trpc/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/src/trpc/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./context"), exports);
+tslib_1.__exportStar(require("./procedures"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/dist/src/trpc/procedures.d.ts

@@ -0,0 +1,234 @@
+import type { OpenApiMeta } from "trpc-to-openapi";
+export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
+    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;
+    };
+}, OpenApiMeta, {}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const procedure: import("@trpc/server").TRPCProcedureBuilder<{
+    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;
+    };
+}, OpenApiMeta, {
+    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;
+    };
+    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;
+    };
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const adminProcedure: import("@trpc/server").TRPCProcedureBuilder<{
+    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;
+    };
+}, OpenApiMeta, {
+    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;
+    };
+    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;
+    };
+}, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const mergeRouters: <TRouters extends import("@trpc/server").AnyRouter[]>(...routerList: TRouters) => import("@trpc/server").TRPCMergeRouters<TRouters>;
+export declare const router: import("@trpc/server").TRPCRouterBuilder<{
+    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: OpenApiMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}>;
+//# sourceMappingURL=procedures.d.ts.map

package/dist/src/trpc/procedures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../../src/trpc/procedures.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAiBnD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0LAAgB,CAAC;AAE7C,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yKAMpB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yKAUzB,CAAC;AAEH,eAAO,MAAM,YAAY,qIAAiB,CAAC;AAC3C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAW,CAAC"}

package/dist/src/trpc/procedures.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.router = exports.mergeRouters = exports.adminProcedure = exports.procedure = exports.publicProcedure = void 0;
+const trpc_1 = require("@m5kdev/commons/utils/trpc");
+const server_1 = require("@trpc/server");
+const errors_1 = require("#utils/errors");
+const posthog_1 = require("#utils/posthog");
+const errorOptions = {
+    layer: "controller",
+    layerName: "TRPCController",
+};
+const t = server_1.initTRPC.meta().context().create({ transformer: trpc_1.transformer });
+// Base router and procedure helpers
+const baseProcedure = t.procedure.use(({ ctx, next }) => (0, posthog_1.runWithPosthogRequestState)({ disableCapture: Boolean(ctx.session?.impersonatedBy) }, () => next()));
+exports.publicProcedure = baseProcedure;
+exports.procedure = baseProcedure.use(({ ctx: { user, session }, next }) => {
+    if (!user || !session) {
+        throw new errors_1.ServerError({ code: "UNAUTHORIZED", ...errorOptions }).toTRPC();
+    }
+    return next({ ctx: { user, session } });
+});
+exports.adminProcedure = baseProcedure.use(({ ctx: { user, session }, next }) => {
+    if (!user || !session) {
+        throw new errors_1.ServerError({ code: "UNAUTHORIZED", ...errorOptions }).toTRPC();
+    }
+    if (user.role !== "admin") {
+        throw new errors_1.ServerError({ code: "FORBIDDEN", ...errorOptions }).toTRPC();
+    }
+    return next({ ctx: { user, session } });
+});
+exports.mergeRouters = t.mergeRouters;
+exports.router = t.router;

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

@@ -0,0 +1,5 @@
+import type { Result } from "neverthrow";
+import type { ServerError } from "#utils/errors";
+export declare function handleAsyncTRPCResult<T>(result: Promise<Result<T, ServerError>>): Promise<T>;
+export declare function handleTRPCResult<T>(result: Result<T, ServerError>): T;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/trpc/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,cAErF;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,KAWjE"}

package/dist/src/trpc/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAsyncTRPCResult = handleAsyncTRPCResult;
+exports.handleTRPCResult = handleTRPCResult;
+const logger_1 = require("#utils/logger");
+async function handleAsyncTRPCResult(result) {
+    return handleTRPCResult(await result);
+}
+function handleTRPCResult(result) {
+    if (result.isErr()) {
+        logger_1.logger.debug("Is tRPC Error");
+        logger_1.logger.error({
+            layer: result.error.layer,
+            layerName: result.error.layerName,
+            error: result.error.toJSON(),
+        });
+        throw result.error.toTRPC();
+    }
+    return result.value;
+}