@m5kdev/backend 0.1.4 → 0.2.0

package/src/modules/workflow/workflow.repository.ts

@@ -1,171 +0,0 @@
-import type {
-  WorkflowListInputSchema,
-  WorkflowListOutputSchema,
-  WorkflowReadOutputSchema,
-} from "@m5kdev/commons/modules/workflow/workflow.schema";
-import { and, eq, inArray } from "drizzle-orm";
-import type { LibSQLDatabase } from "drizzle-orm/libsql";
-import { ok } from "neverthrow";
-import type { ServerResultAsync } from "#modules/base/base.dto";
-import { BaseRepository } from "#modules/base/base.repository";
-import * as workflow from "#modules/workflow/workflow.db";
-
-const schema = { ...workflow };
-
-type Schema = typeof schema;
-type Orm = LibSQLDatabase<Schema>;
-
-export class WorkflowRepository extends BaseRepository<Orm, Schema, Record<string, never>> {
-  async read({
-    jobId,
-    userId,
-  }: {
-    jobId: string;
-    userId: string;
-  }): ServerResultAsync<WorkflowReadOutputSchema> {
-    return this.throwableAsync(async () => {
-      const [wf] = await this.orm
-        .select()
-        .from(this.schema.workflows)
-        .where(
-          and(eq(this.schema.workflows.jobId, jobId), eq(this.schema.workflows.userId, userId))
-        );
-      if (!wf) return this.error("NOT_FOUND");
-      return ok(wf);
-    });
-  }
-
-  async list({
-    userId,
-    status,
-    jobName,
-  }: WorkflowListInputSchema & {
-    userId: string;
-  }): ServerResultAsync<WorkflowListOutputSchema> {
-    return this.throwableAsync(async () => {
-      const { ConditionBuilder } = this.helpers;
-      const condition = new ConditionBuilder([eq(this.schema.workflows.userId, userId)]);
-      if (status) condition.push(inArray(this.schema.workflows.status, status));
-      if (jobName) condition.push(eq(this.schema.workflows.jobName, jobName));
-
-      const workflows = await this.orm.select().from(this.schema.workflows).where(condition.join());
-
-      return ok(workflows);
-    });
-  }
-
-  async added({
-    userId,
-    jobId,
-    jobName,
-    queueName,
-    timeout,
-    tags,
-    input,
-  }: {
-    userId?: string;
-    jobId: string;
-    jobName: string;
-    queueName: string;
-    timeout?: number;
-    tags?: string[];
-    input: unknown;
-  }): ServerResultAsync<WorkflowReadOutputSchema> {
-    return this.throwableAsync(async () => {
-      const [wf] = await this.orm
-        .insert(this.schema.workflows)
-        .values({
-          userId,
-          jobId,
-          jobName,
-          input,
-          status: "queued",
-          queueName,
-          timeout,
-          tags,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        })
-        .returning();
-      return ok(wf);
-    });
-  }
-
-  async addedMany(
-    data: {
-      userId?: string;
-      jobId: string;
-      jobName: string;
-      queueName: string;
-      timeout?: number;
-      tags?: string[];
-      input: unknown;
-    }[]
-  ): ServerResultAsync<WorkflowReadOutputSchema[]> {
-    return this.throwableAsync(async () => {
-      const wfs = await this.orm
-        .insert(this.schema.workflows)
-        .values(
-          data.map((d) => ({
-            userId: d.userId,
-            jobId: d.jobId,
-            jobName: d.jobName,
-            queueName: d.queueName,
-            timeout: d.timeout,
-            tags: d.tags,
-            input: d.input,
-            status: "queued" as const,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          }))
-        )
-        .returning();
-      return ok(wfs);
-    });
-  }
-
-  async started({ jobId }: { jobId: string }): ServerResultAsync<WorkflowReadOutputSchema> {
-    return this.throwableAsync(async () => {
-      const [wf] = await this.orm
-        .update(this.schema.workflows)
-        .set({ status: "running", updatedAt: new Date(), processedAt: new Date() })
-        .where(eq(this.schema.workflows.jobId, jobId))
-        .returning();
-      return ok(wf);
-    });
-  }
-
-  async failed({
-    jobId,
-    error,
-  }: {
-    jobId: string;
-    error: string;
-  }): ServerResultAsync<WorkflowReadOutputSchema> {
-    return this.throwableAsync(async () => {
-      const [wf] = await this.orm
-        .update(this.schema.workflows)
-        .set({ status: "failed", error, updatedAt: new Date(), finishedAt: new Date() })
-        .where(eq(this.schema.workflows.jobId, jobId))
-        .returning();
-      return ok(wf);
-    });
-  }
-
-  async completed({
-    jobId,
-    output,
-  }: {
-    jobId: string;
-    output: unknown;
-  }): ServerResultAsync<WorkflowReadOutputSchema> {
-    return this.throwableAsync(async () => {
-      const [wf] = await this.orm
-        .update(this.schema.workflows)
-        .set({ status: "completed", updatedAt: new Date(), finishedAt: new Date(), output })
-        .where(eq(this.schema.workflows.jobId, jobId))
-        .returning();
-      return ok(wf);
-    });
-  }
-}

package/src/modules/workflow/workflow.service.ts

@@ -1,56 +0,0 @@
-import type {
-  WorkflowListInputSchema,
-  WorkflowListOutputSchema,
-  WorkflowReadInputSchema,
-  WorkflowReadOutputSchema,
-} from "@m5kdev/commons/modules/workflow/workflow.schema";
-import type { Job } from "bullmq";
-import type { User } from "#modules/auth/auth.lib";
-import type { ServerResultAsync } from "#modules/base/base.dto";
-import { BaseService } from "#modules/base/base.service";
-import type { WorkflowRepository } from "#modules/workflow/workflow.repository";
-export class WorkflowService extends BaseService<{ workflow: WorkflowRepository }, never> {
-  async read(
-    input: WorkflowReadInputSchema,
-    { user }: { user: User }
-  ): ServerResultAsync<WorkflowReadOutputSchema> {
-    return await this.repository.workflow.read({ ...input, userId: user.id });
-  }
-
-  async list(
-    input: WorkflowListInputSchema,
-    { user }: { user: User }
-  ): ServerResultAsync<WorkflowListOutputSchema> {
-    return await this.repository.workflow.list({ ...input, userId: user.id });
-  }
-
-  async added(
-    params: Parameters<WorkflowRepository["added"]>[0]
-  ): ServerResultAsync<WorkflowReadOutputSchema> {
-    return this.repository.workflow.added(params);
-  }
-
-  async addedMany(
-    params: Parameters<WorkflowRepository["addedMany"]>[0]
-  ): ServerResultAsync<WorkflowReadOutputSchema[]> {
-    return this.repository.workflow.addedMany(params);
-  }
-
-  async started(job: Job): ServerResultAsync<WorkflowReadOutputSchema> {
-    if (!job.id) return this.error("INTERNAL_SERVER_ERROR");
-    return this.repository.workflow.started({ jobId: job.id });
-  }
-
-  async failed(job?: Job, error?: Error): ServerResultAsync<WorkflowReadOutputSchema> {
-    if (!job?.id) return this.error("INTERNAL_SERVER_ERROR");
-    return this.repository.workflow.failed({
-      jobId: job.id,
-      error: error?.message || "Unknown error",
-    });
-  }
-
-  async completed(job: Job): ServerResultAsync<WorkflowReadOutputSchema> {
-    if (!job.id) return this.error("INTERNAL_SERVER_ERROR");
-    return this.repository.workflow.completed({ jobId: job.id, output: job.returnvalue });
-  }
-}

package/src/modules/workflow/workflow.trpc.ts

@@ -1,26 +0,0 @@
-import {
-  workflowListInputSchema,
-  workflowListOutputSchema,
-  workflowReadInputSchema,
-  workflowReadOutputSchema,
-} from "@m5kdev/commons/modules/workflow/workflow.schema";
-import type { WorkflowService } from "#modules/workflow/workflow.service";
-import { handleTRPCResult, procedure, router } from "#trpc";
-
-export function createWorkflowTRPC(workflowService: WorkflowService) {
-  return router({
-    read: procedure
-      .input(workflowReadInputSchema)
-      .output(workflowReadOutputSchema)
-      .query(async ({ ctx, input }) => {
-        return handleTRPCResult(await workflowService.read(input, ctx));
-      }),
-
-    list: procedure
-      .input(workflowListInputSchema)
-      .output(workflowListOutputSchema)
-      .query(async ({ ctx, input }) => {
-        return handleTRPCResult(await workflowService.list(input, ctx));
-      }),
-  });
-}

package/src/modules/workflow/workflow.types.ts

@@ -1,30 +0,0 @@
-import type { Job, JobsOptions } from "bullmq";
-import type { ServerResultAsync } from "#modules/base/base.dto";
-import type { ServerError } from "#utils/errors";
-
-export type WorkflowMeta = {
-  queue?: string;
-  userId?: string;
-  tags?: string[];
-  timeout?: number;
-  disablePosthogCapture?: boolean;
-};
-
-export type WorkflowDataType<Payload> = {
-  payload: Payload;
-  meta: WorkflowMeta;
-};
-
-export type WorkflowJob<
-  DataType extends WorkflowDataType<any>,
-  ReturnType extends ServerResultAsync<any>,
-  Name extends string,
-> = JobsOptions & {
-  run: (job: Job<DataType, ReturnType, Name>) => ReturnType;
-  onComplete?: (job: Job<DataType, ReturnType, Name>) => ReturnType;
-  onSuccess?: (job: Job<DataType, ReturnType, Name>) => ServerResultAsync<any>;
-  onFailure?: (
-    job: Job<DataType, ReturnType, Name>,
-    error?: ServerError | unknown
-  ) => ServerResultAsync<any>;
-};

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

@@ -1,259 +0,0 @@
-import type { WorkflowReadOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
-import { type JobsOptions, type Queue, Worker, type WorkerOptions } from "bullmq";
-import { err } from "neverthrow";
-import type { ServerErrorLayer } from "#modules/base/base.types";
-import { ServerError } from "#utils/errors";
-import { logger as rootLogger } from "#utils/logger";
-import { runWithPosthogRequestState } from "#utils/posthog";
-import type { ServerResultAsync } from "../base/base.dto";
-import type { WorkflowService } from "./workflow.service";
-import type { WorkflowDataType, WorkflowJob, WorkflowMeta } from "./workflow.types";
-
-const errorOptions = {
-  layer: "workflow" as ServerErrorLayer,
-  layerName: "WorkflowTrigger",
-};
-
-function shouldDisablePosthogFromPayload(payload: unknown): boolean {
-  if (!payload || typeof payload !== "object") return false;
-
-  const session = (
-    payload as {
-      ctx?: {
-        session?: {
-          impersonatedBy?: string | null;
-        };
-      };
-    }
-  ).ctx?.session;
-
-  return Boolean(session?.impersonatedBy);
-}
-
-export function createWorkflowTrigger<
-  Jobs extends Record<string, WorkflowJob<WorkflowDataType<any>, any, string>>,
->(service: WorkflowService, queues: Record<string, Queue>, defaultQueue: string) {
-  const trigger = async ({
-    name,
-    payload,
-    meta,
-    options,
-  }: {
-    name: string;
-    payload: Parameters<Jobs[keyof Jobs & string]["run"]>[0]["data"]["payload"];
-    meta?: WorkflowMeta;
-    options?: JobsOptions;
-  }): ServerResultAsync<WorkflowReadOutputSchema> => {
-    const { queue: queueName, userId, tags, timeout = 60 * 60 * 1000 } = meta || {};
-    const disablePosthogCapture =
-      meta?.disablePosthogCapture ?? shouldDisablePosthogFromPayload(payload);
-    const compiledQueueName = queueName || (defaultQueue as string);
-
-    if (!compiledQueueName || !Object.keys(queues).includes(compiledQueueName)) {
-      return err(new ServerError({ code: "NOT_FOUND", ...errorOptions }));
-    }
-
-    const queue = queues[compiledQueueName as string];
-
-    if (!queue) {
-      return err(new 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 err(new 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 err(new ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
-    }
-  };
-
-  const triggerMany = async ({
-    name,
-    payload,
-    meta,
-    options,
-  }: {
-    name: string;
-    payload: Parameters<Jobs[keyof Jobs & string]["run"]>[0]["data"]["payload"][];
-    meta?: WorkflowMeta;
-    options?: JobsOptions;
-  }): ServerResultAsync<WorkflowReadOutputSchema[]> => {
-    const { queue: queueName, userId, tags, timeout = 60 * 60 * 1000 } = meta || {};
-    const compiledQueueName = queueName || (defaultQueue as string);
-
-    if (!compiledQueueName || !Object.keys(queues).includes(compiledQueueName)) {
-      return err(new ServerError({ code: "NOT_FOUND", ...errorOptions }));
-    }
-
-    const queue = queues[compiledQueueName as string];
-
-    if (!queue) {
-      return err(new 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 err(new ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
-      }
-
-      return await service.addedMany(
-        jobs.map((j) => ({
-          userId,
-          jobId: j.id as string,
-          jobName: name,
-          input: j.data.payload,
-          timeout,
-          queueName: compiledQueueName,
-          tags,
-        }))
-      );
-    } catch (error) {
-      return err(new ServerError({ code: "INTERNAL_SERVER_ERROR", ...errorOptions }));
-    }
-  };
-
-  return { trigger, triggerMany };
-}
-
-export function createWorkflowWorker<
-  Jobs extends Record<string, WorkflowJob<WorkflowDataType<any>, any, string>>,
->(
-  service: WorkflowService,
-  queueName: string,
-  workerOptions: WorkerOptions,
-  jobs: Jobs,
-  errorHandler?: (error: unknown) => void
-) {
-  const logger = rootLogger.child({ layer: "worker" });
-
-  const worker = new Worker(
-    queueName,
-    async (job) => {
-      const { meta } = job.data as { meta: WorkflowMeta; payload: any };
-      return await 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 as keyof Jobs];
-          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: unknown) => {
-              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: unknown) => {
-              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: unknown) => {
-              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 as WorkerOptions
-  );
-  worker.on("completed", service.completed.bind(service));
-  worker.on("failed", service.failed.bind(service));
-
-  return worker;
-}
-
-export function createWorkflowWorkers<
-  Jobs extends Record<string, WorkflowJob<WorkflowDataType<any>, any, string>>,
->(
-  service: WorkflowService,
-  workerSettings: Record<string, WorkerOptions>,
-  jobs: Jobs,
-  errorHandler?: (error: unknown) => void
-) {
-  const workers: Record<string, Worker> = {} as Record<string, Worker>;
-  for (const [queueName, workerOptions] of Object.entries(workerSettings)) {
-    workers[queueName] = createWorkflowWorker(
-      service,
-      queueName,
-      workerOptions as WorkerOptions,
-      jobs,
-      errorHandler
-    );
-  }
-  return workers;
-}

package/src/test/stubs/utils.ts

@@ -1,2 +0,0 @@
-export * from "../../utils/errors";
-export * from "../../utils/logger";

package/src/trpc/context.ts

@@ -1,21 +0,0 @@
-import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
-import { fromNodeHeaders } from "better-auth/node";
-import type { BetterAuth, Session, User } from "#modules/auth/auth.lib";
-
-export type Context = Awaited<ReturnType<typeof createAuthContext>>;
-
-export function createAuthContext(auth: BetterAuth) {
-  return async function createContext({ req }: CreateExpressContextOptions) {
-    const data = await auth.api.getSession({
-      headers: fromNodeHeaders(req.headers),
-    });
-
-    const user = (data?.user as User) || null;
-    const session = (data?.session as Session) || null;
-
-    return {
-      session,
-      user,
-    };
-  };
-}

package/src/trpc/index.ts

@@ -1,3 +0,0 @@
-export * from "./context";
-export * from "./procedures";
-export * from "./utils";

package/src/trpc/procedures.ts

@@ -1,43 +0,0 @@
-import { transformer } from "@m5kdev/commons/utils/trpc";
-import { initTRPC } from "@trpc/server";
-import type { OpenApiMeta } from "trpc-to-openapi";
-import { ServerError } from "#utils/errors";
-import { runWithPosthogRequestState } from "#utils/posthog";
-import type { Context } from "./context";
-
-const errorOptions = {
-  layer: "controller" as const,
-  layerName: "TRPCController",
-};
-
-const t = initTRPC.meta<OpenApiMeta>().context<Context>().create({ transformer });
-
-// Base router and procedure helpers
-const baseProcedure = t.procedure.use(({ ctx, next }) =>
-  runWithPosthogRequestState({ disableCapture: Boolean(ctx.session?.impersonatedBy) }, () => next())
-);
-
-export const publicProcedure = baseProcedure;
-
-export const procedure = baseProcedure.use(({ ctx: { user, session }, next }) => {
-  if (!user || !session) {
-    throw new ServerError({ code: "UNAUTHORIZED", ...errorOptions }).toTRPC();
-  }
-
-  return next({ ctx: { user, session } });
-});
-
-export const adminProcedure = baseProcedure.use(({ ctx: { user, session }, next }) => {
-  if (!user || !session) {
-    throw new ServerError({ code: "UNAUTHORIZED", ...errorOptions }).toTRPC();
-  }
-
-  if (user.role !== "admin") {
-    throw new ServerError({ code: "FORBIDDEN", ...errorOptions }).toTRPC();
-  }
-
-  return next({ ctx: { user, session } });
-});
-
-export const mergeRouters = t.mergeRouters;
-export const router = t.router;

package/src/trpc/utils.ts

@@ -1,20 +0,0 @@
-import type { Result } from "neverthrow";
-import type { ServerError } from "#utils/errors";
-import { logger } from "#utils/logger";
-
-export async function handleAsyncTRPCResult<T>(result: Promise<Result<T, ServerError>>) {
-  return handleTRPCResult(await result);
-}
-
-export function handleTRPCResult<T>(result: Result<T, ServerError>) {
-  if (result.isErr()) {
-    logger.debug("Is tRPC Error");
-    logger.error({
-      layer: result.error.layer,
-      layerName: result.error.layerName,
-      error: result.error.toJSON(),
-    });
-    throw result.error.toTRPC();
-  }
-  return result.value;
-}

package/src/types.ts

@@ -1,22 +0,0 @@
-// Create a faux router that includes the auth router for use in the web-ui types
-import type { Mastra } from "@mastra/core";
-import type { AIService } from "#modules/ai/ai.service";
-import { createAITRPC } from "#modules/ai/ai.trpc";
-import type { AuthService } from "#modules/auth/auth.service";
-import { createAuthTRPC } from "#modules/auth/auth.trpc";
-import type { BillingService } from "#modules/billing/billing.service";
-import { createBillingTRPC } from "#modules/billing/billing.trpc";
-import { router } from "#trpc";
-
-export const createAuthTRPCRouter = <MastraInstance extends Mastra>(
-  authService: AuthService,
-  aiService: AIService<MastraInstance>,
-  billingService: BillingService
-) =>
-  router({
-    auth: createAuthTRPC(authService),
-    ai: createAITRPC(aiService),
-    billing: createBillingTRPC(billingService),
-  });
-
-export type BackendTRPCRouter = ReturnType<typeof createAuthTRPCRouter>;