create-m5kdev 0.14.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-m5kdev",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "license": "GPL-3.0-only",
   "repository": {
     "type": "git",

package/templates/minimal-app/apps/server/src/app.ts.tpl

@@ -0,0 +1,113 @@
+import { createBackendApp, type InferBackendAppRouter } from "@m5kdev/backend/app";
+import { createBetterAuth } from "@m5kdev/backend/modules/auth/auth.lib";
+import { createAuthBackendModule } from "@m5kdev/backend/modules/auth/auth.module";
+import { createEmailBackendModule } from "@m5kdev/backend/modules/email/email.module";
+import { createNotificationBackendModule } from "@m5kdev/backend/modules/notification/notification.module";
+import { createWorkflowBackendModule } from "@m5kdev/backend/modules/workflow/workflow.module";
+import { templates } from "{{PACKAGE_SCOPE}}/email";
+import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
+import cors from "cors";
+import express from "express";
+import { postsModule } from "./modules/posts/posts.module";
+
+const app = express();
+const appUrl = process.env.VITE_APP_URL ?? "http://localhost:5173";
+const serverUrl = process.env.VITE_SERVER_URL ?? "http://localhost:8080";
+
+app.use(express.json());
+app.use(
+  cors({
+    origin: [appUrl],
+    credentials: true,
+    methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+  })
+);
+
+const databaseUrl = process.env.DATABASE_URL ?? "file:./local.db";
+const syncUrl = process.env.TURSO_DATABASE_URL;
+const authToken = process.env.TURSO_AUTH_TOKEN;
+const redisUrl = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
+const resendApiKey = process.env.RESEND_API_KEY;
+
+const connection =
+  syncUrl && authToken
+    ? {
+        url: databaseUrl,
+        syncUrl,
+        authToken,
+        syncInterval: 60,
+        readYourWrites: true,
+      }
+    : {
+        url: databaseUrl,
+      };
+
+export const backendApp = createBackendApp({
+  db: connection,
+  express: app,
+  app: {
+    name: "{{APP_NAME}}",
+    urls: {
+      web: appUrl,
+      api: serverUrl,
+    },
+  },
+  redis: {
+    url: redisUrl,
+    options: { maxRetriesPerRequest: null },
+  },
+  resend: resendApiKey ? { apiKey: resendApiKey } : undefined,
+  email: {
+    mode: resendApiKey ? "send" : "store",
+    from: "no-reply@local.m5kdev.test",
+    systemNotificationEmail: "ops@local.m5kdev.test",
+    outputDirectory: ".emails",
+  },
+  auth: {
+    factory({ db, services, appConfig }) {
+      return createBetterAuth({
+        orm: db.orm as never,
+        schema: db.schema as never,
+        services: {
+          email: services.email.email,
+        },
+        app: appConfig,
+        config: {
+          waitlist: false,
+        },
+      });
+    },
+  },
+})
+  .use(
+    createEmailBackendModule({
+      templates: templates as never,
+    })
+  )
+  .use(
+    createAuthBackendModule({
+      emailModuleId: "email",
+    })
+  )
+  .use(
+    createWorkflowBackendModule({
+      queues: {
+        fast: { concurrency: 5 },
+      },
+      defaultQueue: "fast",
+      defaults: {
+        timeout: 60_000,
+        jobOptions: { removeOnComplete: { age: 3600 } },
+      },
+    })
+  )
+  .use(createNotificationBackendModule())
+  .use(postsModule);
+
+export const builtBackendApp = backendApp.build();
+export const appRouter = builtBackendApp.trpc.router;
+
+export type AppRouter = InferBackendAppRouter<typeof backendApp>;
+export type RouterInputs = inferRouterInputs<AppRouter>;
+export type RouterOutputs = inferRouterOutputs<AppRouter>;

package/templates/minimal-app/apps/server/src/db.ts.tpl

@@ -1,37 +1,7 @@
-import * as auth from "@m5kdev/backend/modules/auth/auth.db";
-import * as notification from "@m5kdev/backend/modules/notification/notification.db";
-import * as workflow from "@m5kdev/backend/modules/workflow/workflow.db";
-import { drizzle } from "drizzle-orm/libsql";
-import * as posts from "./modules/posts/posts.db";
-
-export const schema = {
-  ...auth,
-  ...workflow,
-  ...notification,
-  ...posts,
-};
-
-const databaseUrl = process.env.DATABASE_URL ?? "file:./local.db";
-const syncUrl = process.env.TURSO_DATABASE_URL;
-const authToken = process.env.TURSO_AUTH_TOKEN;
-
-const connection =
-  syncUrl && authToken
-    ? {
-        url: databaseUrl,
-        syncUrl,
-        authToken,
-        syncInterval: 60,
-        readYourWrites: true,
-      }
-    : {
-        url: databaseUrl,
-      };
-
-export const orm = drizzle({
-  connection,
-  schema,
-});
-
-export type Orm = typeof orm;
-export type Schema = typeof schema;
+import { builtBackendApp } from "./app";
+
+export const orm = builtBackendApp.db.orm;
+export const schema = builtBackendApp.db.schema;
+
+export type Orm = typeof orm;
+export type Schema = typeof schema;

package/templates/minimal-app/apps/server/src/index.ts.tpl

@@ -1,58 +1,21 @@
-import { createAuthContext } from "@m5kdev/backend/utils/trpc";
-import * as trpcExpress from "@trpc/server/adapters/express";
-import { toNodeHandler } from "better-auth/node";
-import cors from "cors";
-import express from "express";
-import type { Server } from "node:http";
-import { auth } from "./lib/auth";
-import { notificationService } from "./service";
-import { appRouter } from "./trpc";
-import { workflowRegistry, workflowService } from "./workflow";
-
-workflowRegistry.registerService(notificationService);
-
-const app = express();
-const port = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 8080;
-
-let httpServer: Server | undefined;
-
-app.use(express.json());
-app.use(
-  cors({
-    origin: [process.env.VITE_APP_URL ?? "http://localhost:5173"],
-    credentials: true,
-    methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-    allowedHeaders: ["Content-Type", "Authorization"],
-  }),
-);
-
-app.use(
-  "/trpc",
-  trpcExpress.createExpressMiddleware({
-    router: appRouter,
-    createContext: createAuthContext(auth as never),
-  }),
-);
-
-app.all("/api/auth/*", toNodeHandler(auth));
-
-function logError(context: string, error: unknown): void {
-  console.error(`[server] ${context}`, error);
-}
-
-async function shutdown(): Promise<void> {
-  try {
-    await workflowRegistry.stop();
-  } catch (e) {
-    logError("workflowRegistry.stop() failed", e);
-  }
-  try {
-    await workflowService.close();
-  } catch (e) {
-    logError("workflowService.close() failed", e);
-  }
-  if (httpServer) {
-    await new Promise<void>((resolve) => {
+import type { Server } from "node:http";
+import { builtBackendApp } from "./app";
+const port = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 8080;
+
+let httpServer: Server | undefined;
+
+function logError(context: string, error: unknown): void {
+  console.error(`[server] ${context}`, error);
+}
+
+async function shutdown(): Promise<void> {
+  try {
+    await builtBackendApp.shutdown();
+  } catch (e) {
+    logError("builtBackendApp.shutdown() failed", e);
+  }
+  if (httpServer) {
+    await new Promise<void>((resolve) => {
       httpServer?.close((err) => {
         if (err) {
           logError("HTTP server close failed", err);
@@ -70,23 +33,23 @@ process.once("SIGINT", () => {
 process.once("SIGTERM", () => {
   void shutdown();
 });
-
-async function start(): Promise<void> {
-  await workflowRegistry.start();
-  await new Promise<void>((resolve, reject) => {
-    httpServer = app.listen(port, () => {
-      console.info(`Server running at ${process.env.VITE_SERVER_URL ?? `http://localhost:${port}`}`);
-      resolve();
-    });
+
+async function start(): Promise<void> {
+  await builtBackendApp.start();
+  await new Promise<void>((resolve, reject) => {
+    httpServer = builtBackendApp.express.app.listen(port, () => {
+      console.info(`Server running at ${process.env.VITE_SERVER_URL ?? `http://localhost:${port}`}`);
+      resolve();
+    });
     httpServer.on("error", reject);
   });
 }
 
-void (async () => {
-  try {
-    await start();
-  } catch (e) {
-    logError("Fatal: workflowRegistry.start() or HTTP listen failed", e);
-    process.exit(1);
-  }
-})();
+void (async () => {
+  try {
+    await start();
+  } catch (e) {
+    logError("Fatal: builtBackendApp.start() or HTTP listen failed", e);
+    process.exit(1);
+  }
+})();

package/templates/minimal-app/apps/server/src/lib/auth.ts.tpl

@@ -1,172 +1,6 @@
-import {
-  createOrganizationAndTeam,
-  getActiveOrganizationAndTeam,
-} from "@m5kdev/backend/modules/auth/auth.utils";
-import { betterAuth } from "better-auth";
-import { drizzleAdapter } from "better-auth/adapters/drizzle";
-import { admin, lastLoginMethod, organization } from "better-auth/plugins";
-import { orm, schema } from "../db";
-import { emailService } from "../service";
-
-export const auth = betterAuth({
-  secret: process.env.BETTER_AUTH_SECRET,
-  baseURL: process.env.VITE_SERVER_URL ?? "http://localhost:8080",
-  session: {
-    expiresIn: 60 * 60 * 24 * 7,
-    updateAge: 60 * 60 * 24,
-    cookieCache: {
-      enabled: true,
-      maxAge: 60 * 5,
-    },
-    additionalFields: {
-      activeOrganizationRole: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-      },
-      activeTeamRole: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-      },
-    },
-  },
-  user: {
-    additionalFields: {
-      onboarding: {
-        type: "number",
-        required: false,
-        defaultValue: null,
-      },
-      preferences: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-      },
-      flags: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-      },
-      stripeCustomerId: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-        input: false,
-      },
-      paymentCustomerId: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-        input: false,
-      },
-      paymentPlanTier: {
-        type: "string",
-        required: false,
-        defaultValue: null,
-        input: false,
-      },
-      paymentPlanExpiresAt: {
-        type: "number",
-        required: false,
-        defaultValue: null,
-        input: false,
-      },
-    },
-  },
-  database: drizzleAdapter(orm, {
-    provider: "sqlite",
-    schema,
-    usePlural: true,
-  }),
-  emailAndPassword: {
-    enabled: true,
-    requireEmailVerification: false,
-    sendResetPassword: async ({ user, url }) => {
-      await emailService.sendResetPassword(user.email, url);
-    },
-  },
-  emailVerification: {
-    sendVerificationEmail: async ({ user, url }) => {
-      await emailService.sendVerification(user.email, url);
-    },
-  },
-  plugins: [
-    admin(),
-    lastLoginMethod(),
-    organization({
-      allowUserToCreateOrganization: false,
-      teams: {
-        enabled: true,
-        allowRemovingAllTeams: false,
-      },
-      sendInvitationEmail: async (data) => {
-        const invitationUrl = `${process.env.VITE_APP_URL ?? "http://localhost:5173"}/organization/accept-invitation?id=${data.id}`;
-        await emailService.sendOrganizationInvite(
-          data.email,
-          data.organization.name,
-          data.inviter.user.name || data.inviter.user.email,
-          data.role,
-          invitationUrl
-        );
-      },
-      schema: {
-        team: {
-          modelName: "team",
-        },
-        teamMember: {
-          modelName: "teamMember",
-          additionalFields: {
-            role: {
-              type: "string",
-              required: true,
-            },
-          },
-        },
-        member: {
-          modelName: "member",
-        },
-        invitation: {
-          modelName: "invitation",
-        },
-        organization: {
-          modelName: "organization",
-        },
-      },
-    }),
-  ],
-  trustedOrigins: [
-    process.env.VITE_APP_URL ?? "http://localhost:5173",
-    process.env.VITE_SERVER_URL ?? "http://localhost:8080",
-  ],
-  databaseHooks: {
-    user: {
-      create: {
-        after: async (user) => {
-          await createOrganizationAndTeam(orm, schema, user);
-        },
-      },
-    },
-    session: {
-      create: {
-        before: async (session) => {
-          const { organizationId, teamId, organizationRole, teamRole } =
-            await getActiveOrganizationAndTeam(orm, schema, session.userId);
-
-          return {
-            data: {
-              ...session,
-              activeOrganizationId: organizationId,
-              activeTeamId: teamId,
-              activeOrganizationRole: organizationRole,
-              activeTeamRole: teamRole,
-            },
-          };
-        },
-      },
-    },
-  },
-});
-
-export type Session = typeof auth.$Infer.Session;
-export type User = Session["user"];
+import { builtBackendApp } from "../app";
+
+export const auth = builtBackendApp.auth!.instance;
+
+export type Session = typeof auth.$Infer.Session;
+export type User = Session["user"];

package/templates/minimal-app/apps/server/src/modules/posts/posts.db.ts.tpl

@@ -1,23 +1,45 @@
-import { organizations, teams, users } from "@m5kdev/backend/modules/auth/auth.db";
-import { integer, sqliteTable as table, text } from "drizzle-orm/sqlite-core";
-import { v4 as uuidv4 } from "uuid";
-
-export const posts = table("posts", {
-  id: text("id").primaryKey().$default(uuidv4),
-  authorUserId: text("author_user_id").references(() => users.id, { onDelete: "set null" }),
-  organizationId: text("organization_id").references(() => organizations.id, {
-    onDelete: "set null",
-  }),
-  teamId: text("team_id").references(() => teams.id, { onDelete: "set null" }),
-  title: text("title").notNull(),
-  slug: text("slug").notNull().unique(),
-  excerpt: text("excerpt"),
-  content: text("content").notNull(),
-  status: text("status").$type<"draft" | "published">().notNull().default("draft"),
-  publishedAt: integer("published_at", { mode: "timestamp" }),
-  createdAt: integer("created_at", { mode: "timestamp" })
-    .notNull()
-    .$default(() => new Date()),
-  updatedAt: integer("updated_at", { mode: "timestamp" }),
-  deletedAt: integer("deleted_at", { mode: "timestamp" }),
-});
+import { type AnySQLiteColumn, integer, sqliteTable as table, text } from "drizzle-orm/sqlite-core";
+import { organizations, teams, users } from "@m5kdev/backend/modules/auth/auth.db";
+import { v4 as uuidv4 } from "uuid";
+
+export function createPostsTables(
+  references: {
+    users: { id: AnySQLiteColumn };
+    organizations: { id: AnySQLiteColumn };
+    teams: { id: AnySQLiteColumn };
+  } = {
+    users,
+    organizations,
+    teams,
+  }
+) {
+  const posts = table("posts", {
+    id: text("id").primaryKey().$default(uuidv4),
+    authorUserId: text("author_user_id").references(() => references.users.id, {
+      onDelete: "set null",
+    }),
+    organizationId: text("organization_id").references(() => references.organizations.id, {
+      onDelete: "set null",
+    }),
+    teamId: text("team_id").references(() => references.teams.id, { onDelete: "set null" }),
+    title: text("title").notNull(),
+    slug: text("slug").notNull().unique(),
+    excerpt: text("excerpt"),
+    content: text("content").notNull(),
+    status: text("status").$type<"draft" | "published">().notNull().default("draft"),
+    publishedAt: integer("published_at", { mode: "timestamp" }),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .$default(() => new Date()),
+    updatedAt: integer("updated_at", { mode: "timestamp" }),
+    deletedAt: integer("deleted_at", { mode: "timestamp" }),
+  });
+
+  return {
+    posts,
+  };
+}
+
+const postTables = createPostsTables();
+
+export const posts = postTables.posts;

package/templates/minimal-app/apps/server/src/modules/posts/posts.module.ts.tpl

@@ -0,0 +1,37 @@
+import { defineBackendModule } from "@m5kdev/backend/app";
+import { createPostsTRPC } from "./posts.trpc";
+import { createPostsTables } from "./posts.db";
+import { postsGrants } from "./posts.grants";
+import { PostsRepository } from "./posts.repository";
+import { PostsService } from "./posts.service";
+
+export const postsModule = defineBackendModule({
+  id: "posts",
+  dependsOn: ["auth"],
+  db: ({ deps }) => {
+    const authTables = deps.auth.tables as any;
+    return {
+      tables: createPostsTables({
+        users: authTables.users,
+        organizations: authTables.organizations,
+        teams: authTables.teams,
+      }),
+    };
+  },
+  repositories: ({ db }) => {
+    const schema = db.schema as any;
+    return {
+      posts: new PostsRepository({
+        orm: db.orm as never,
+        schema: { posts: schema.posts } as never,
+        table: schema.posts,
+      }),
+    };
+  },
+  services: ({ repositories }) => ({
+    posts: new PostsService({ posts: repositories.posts }, {}, postsGrants),
+  }),
+  trpc: ({ trpc, services }) => ({
+    posts: createPostsTRPC(trpc, services.posts),
+  }),
+});

package/templates/minimal-app/apps/server/src/modules/posts/posts.repository.ts.tpl

@@ -1,13 +1,18 @@
-import type {
-  PostSchema,
-  PostsListInputSchema,
-  PostsListOutputSchema,
-} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-import { BaseTableRepository } from "@m5kdev/backend/modules/base/base.repository";
-import type { ServerResultAsync } from "@m5kdev/backend/utils/types";
-import { and, asc, count, desc, eq, isNull, like, ne, or } from "drizzle-orm";
-import { err, ok } from "neverthrow";
-import type { Orm, Schema } from "../../db";
+import type {
+  PostSchema,
+  PostsListInputSchema,
+  PostsListOutputSchema,
+} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
+import { BaseTableRepository } from "@m5kdev/backend/modules/base/base.repository";
+import type { ServerResultAsync } from "@m5kdev/backend/utils/types";
+import { and, asc, count, desc, eq, isNull, like, ne, or } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import { err, ok } from "neverthrow";
+import { posts } from "./posts.db";
+
+const schema = { posts };
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
 
 export class PostsRepository extends BaseTableRepository<
   Orm,
@@ -25,19 +30,11 @@ export class PostsRepository extends BaseTableRepository<
       conditions.push(eq(this.table.status, input.status));
     }
 
-    if (search) {
-      const escapedSearch = search.replace(/[%_]/g, '\\    if (search) {
-      const pattern = `%${search}%`;
-      const searchCondition = or(
-        like(this.table.title, pattern),
-        like(this.table.slug, pattern),
-        like(this.table.excerpt, pattern),
-        like(this.table.content, pattern)
-      );
-');
-      const pattern = `%${escapedSearch}%`;
-      const searchCondition = or(
-        like(this.table.title, pattern),
+    if (search) {
+      const escapedSearch = search.replace(/[%_]/g, "\\$&");
+      const pattern = `%${escapedSearch}%`;
+      const searchCondition = or(
+        like(this.table.title, pattern),
         like(this.table.slug, pattern),
         like(this.table.excerpt, pattern),
         like(this.table.content, pattern)
@@ -111,5 +108,5 @@ export class PostsRepository extends BaseTableRepository<
       slug = `${candidate}-${suffix}`;
       suffix += 1;
     }
-  }
-}
+  }
+}

package/templates/minimal-app/apps/server/src/modules/posts/posts.service.ts.tpl

@@ -10,9 +10,9 @@ import type {
   PostUpdateInputSchema,
   PostUpdateOutputSchema,
 } from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-import type { Context } from "@m5kdev/backend/modules/auth/auth.lib";
 import { BasePermissionService } from "@m5kdev/backend/modules/base/base.service";
 import type { ServerResultAsync } from "@m5kdev/backend/utils/types";
+import type { Context } from "@m5kdev/backend/utils/trpc";
 import { err, ok } from "neverthrow";
 import type { PostsRepository } from "./posts.repository";
 

package/templates/minimal-app/apps/server/src/modules/posts/posts.trpc.ts.tpl

@@ -1,6 +1,6 @@
-import {
-  postCreateInputSchema,
-  postCreateOutputSchema,
+import {
+  postCreateInputSchema,
+  postCreateOutputSchema,
   postPublishInputSchema,
   postPublishOutputSchema,
   postSoftDeleteInputSchema,
@@ -8,37 +8,41 @@ import {
   postsListInputSchema,
   postsListOutputSchema,
   postUpdateInputSchema,
-  postUpdateOutputSchema,
-} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-import { handleTRPCResult } from "@m5kdev/backend/utils/trpc";
-import { postsService } from "../../service";
-import { procedure, router } from "../../utils/trpc";
-
-export const postsRouter = router({
-  list: procedure
-    .input(postsListInputSchema)
-    .output(postsListOutputSchema)
-    .query(async ({ ctx, input }) => handleTRPCResult(await postsService.list(input ?? {}, ctx))),
-
-  create: procedure
-    .input(postCreateInputSchema)
-    .output(postCreateOutputSchema)
-    .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.create(input, ctx))),
-
-  update: procedure
-    .input(postUpdateInputSchema)
-    .output(postUpdateOutputSchema)
-    .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.update(input, ctx))),
-
-  publish: procedure
-    .input(postPublishInputSchema)
-    .output(postPublishOutputSchema)
-    .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.publish(input, ctx))),
-
-  softDelete: procedure
-    .input(postSoftDeleteInputSchema)
-    .output(postSoftDeleteOutputSchema)
-    .mutation(async ({ ctx, input }) =>
-      handleTRPCResult(await postsService.softDelete(input, ctx))
-    ),
-});
+  postUpdateOutputSchema,
+} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
+import { handleTRPCResult, type TRPCMethods } from "@m5kdev/backend/utils/trpc";
+import type { PostsService } from "./posts.service";
+
+export function createPostsTRPC(
+  { router, privateProcedure: procedure }: TRPCMethods,
+  postsService: PostsService
+) {
+  return router({
+    list: procedure
+      .input(postsListInputSchema)
+      .output(postsListOutputSchema)
+      .query(async ({ ctx, input }) => handleTRPCResult(await postsService.list(input ?? {}, ctx))),
+
+    create: procedure
+      .input(postCreateInputSchema)
+      .output(postCreateOutputSchema)
+      .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.create(input, ctx))),
+
+    update: procedure
+      .input(postUpdateInputSchema)
+      .output(postUpdateOutputSchema)
+      .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.update(input, ctx))),
+
+    publish: procedure
+      .input(postPublishInputSchema)
+      .output(postPublishOutputSchema)
+      .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.publish(input, ctx))),
+
+    softDelete: procedure
+      .input(postSoftDeleteInputSchema)
+      .output(postSoftDeleteOutputSchema)
+      .mutation(async ({ ctx, input }) =>
+        handleTRPCResult(await postsService.softDelete(input, ctx))
+      ),
+  });
+}

package/templates/minimal-app/apps/server/src/repository.ts.tpl

@@ -1,10 +1,6 @@
-import { AuthRepository } from "@m5kdev/backend/modules/auth/auth.repository";
-import { NotificationRepository } from "@m5kdev/backend/modules/notification/notification.repository";
-import { WorkflowRepository } from "@m5kdev/backend/modules/workflow/workflow.repository";
-import { orm, schema } from "./db";
-import { PostsRepository } from "./modules/posts/posts.repository";
-
-export const authRepository = new AuthRepository({ orm, schema });
-export const workflowRepository = new WorkflowRepository({ orm, schema });
-export const notificationRepository = new NotificationRepository({ orm, schema });
-export const postsRepository = new PostsRepository({ orm, schema, table: schema.posts });
+import { builtBackendApp } from "./app";
+
+export const authRepository = builtBackendApp.modules.auth.repositories.auth;
+export const workflowRepository = builtBackendApp.modules.workflow.repositories.workflow;
+export const notificationRepository = builtBackendApp.modules.notification.repositories.notification;
+export const postsRepository = builtBackendApp.modules.posts.repositories.posts;

package/templates/minimal-app/apps/server/src/service.ts.tpl

@@ -1,19 +1,7 @@
-import { AuthService } from "@m5kdev/backend/modules/auth/auth.service";
-import { NotificationService } from "@m5kdev/backend/modules/notification/notification.service";
-import { LocalEmailService } from "./lib/localEmailService";
-import { postsGrants } from "./modules/posts/posts.grants";
-import { PostsService } from "./modules/posts/posts.service";
-import { authRepository, notificationRepository, postsRepository } from "./repository";
-import { workflowService } from "./workflow";
-
-export const emailService = new LocalEmailService({
-  appName: "{{APP_NAME}}",
-  appUrl: process.env.VITE_APP_URL ?? "http://localhost:5173",
-});
-
-export const authService = new AuthService({ auth: authRepository }, { email: emailService });
-export const postsService = new PostsService({ posts: postsRepository }, {}, postsGrants);
-export const notificationService = new NotificationService(
-  { notification: notificationRepository },
-  { workflow: workflowService },
-);
+import { builtBackendApp, emailService } from "./app";
+
+export { emailService };
+
+export const authService = builtBackendApp.modules.auth.services.auth;
+export const postsService = builtBackendApp.modules.posts.services.posts;
+export const notificationService = builtBackendApp.modules.notification.services.notification;

package/templates/minimal-app/apps/server/src/trpc.ts.tpl

@@ -1,16 +1,6 @@
-import { createNotificationTRPC } from "@m5kdev/backend/modules/notification/notification.trpc";
-import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
-import { notificationService } from "./service";
-import { postsRouter as posts } from "./modules/posts/posts.trpc";
-import { router, trpcObject } from "./utils/trpc";
-
-const notification = createNotificationTRPC(trpcObject, notificationService);
-
-export const appRouter = router({
-  posts,
-  notification,
-});
-
-export type AppRouter = typeof appRouter;
-export type RouterInputs = inferRouterInputs<AppRouter>;
-export type RouterOutputs = inferRouterOutputs<AppRouter>;
+export {
+  appRouter,
+  type AppRouter,
+  type RouterInputs,
+  type RouterOutputs,
+} from "./app";

package/templates/minimal-app/apps/server/src/utils/trpc.ts.tpl

@@ -1,31 +1,8 @@
-import {
-  type createAuthContext,
-  verifyAdminProcedureContext,
-  verifyProtectedProcedureContext,
-} from "@m5kdev/backend/utils/trpc";
-import { transformer } from "@m5kdev/commons/utils/trpc";
-import { initTRPC } from "@trpc/server";
-
-type Context = Awaited<ReturnType<ReturnType<typeof createAuthContext>>>;
-
-const t = initTRPC.context<Context>().create({ transformer });
-
-export const publicProcedure = t.procedure;
+import { builtBackendApp } from "../app";
 
-export const procedure = t.procedure.use(({ ctx, next }) => {
-  return next({ ctx: verifyProtectedProcedureContext(ctx) });
-});
+export const router = builtBackendApp.trpc.methods.router;
+export const publicProcedure = builtBackendApp.trpc.methods.publicProcedure;
+export const procedure = builtBackendApp.trpc.methods.privateProcedure;
+export const adminProcedure = builtBackendApp.trpc.methods.adminProcedure;
 
-export const adminProcedure = t.procedure.use(({ ctx, next }) => {
-  return next({ ctx: verifyAdminProcedureContext(ctx) });
-});
-
-export const router = t.router;
-export const mergeRouters = t.mergeRouters;
-
-export const trpcObject = {
-  router,
-  privateProcedure: procedure,
-  adminProcedure,
-  publicProcedure,
-};
+export const trpcObject = builtBackendApp.trpc.methods;

package/templates/minimal-app/apps/server/src/workflow.ts.tpl

@@ -1,21 +1,4 @@
-import { WorkflowRegistry } from "@m5kdev/backend/modules/workflow/workflow.registry";
-import { WorkflowService } from "@m5kdev/backend/modules/workflow/workflow.service";
-import IORedis from "ioredis";
-import { workflowRepository } from "./repository";
-
-const redisUrl = process.env.REDIS_URL ?? "redis://127.0.0.1:6379";
-const connection = new IORedis(redisUrl, { maxRetriesPerRequest: null });
-
-export const workflowService = new WorkflowService(workflowRepository, {
-  connection,
-  queues: {
-    fast: { concurrency: 5 },
-  },
-  defaultQueue: "fast",
-  defaults: {
-    timeout: 60_000,
-    jobOptions: { removeOnComplete: { age: 3600 } },
-  },
-});
-
-export const workflowRegistry = new WorkflowRegistry(workflowService);
+import { builtBackendApp } from "./app";
+
+export const workflowService = builtBackendApp.modules.workflow.services.workflow;
+export const workflowRegistry = builtBackendApp.workflow!.registry;

package/templates/minimal-app/apps/server/src/lib/localEmailService.ts.tpl

@@ -1,58 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { templates } from "{{PACKAGE_SCOPE}}/email";
-import { EmailService } from "@m5kdev/backend/modules/email/email.service";
-import { logger } from "@m5kdev/backend/utils/logger";
-import { ok } from "neverthrow";
-
-interface LocalEmailServiceProps {
-  appName: string;
-  appUrl: string;
-}
-
-export class LocalEmailService extends EmailService {
-  constructor(props: LocalEmailServiceProps) {
-    super({
-      resendApiKey: "local",
-      brand: {
-        name: props.appName,
-        logo: `${props.appUrl}/mark.svg`,
-        tagline: `${props.appName} publishing workspace`,
-      },
-      noReplyFrom: "no-reply@local.m5kdev.test",
-      systemNotificationEmail: "ops@local.m5kdev.test",
-      templates: templates as never,
-    });
-  }
-
-  override async sendTemplate(
-    to: Parameters<EmailService["sendTemplate"]>[0],
-    templateKey: Parameters<EmailService["sendTemplate"]>[1],
-    templateProps: Parameters<EmailService["sendTemplate"]>[2],
-    options?: Parameters<EmailService["sendTemplate"]>[3]
-  ) {
-    const template = this.templates[String(templateKey)];
-    if (!template) {
-      return this.error("NOT_FOUND", `Email template not found: ${String(templateKey)}`);
-    }
-
-    const outputDirectory = path.resolve(process.cwd(), ".emails");
-    await fs.mkdir(outputDirectory, { recursive: true });
-
-    const payload = {
-      to,
-      templateId: template.id,
-      subject: options?.subject ?? template.subject ?? String(templateKey),
-      previewText: options?.previewText ?? template.previewText ?? String(templateKey),
-      props: templateProps,
-      createdAt: new Date().toISOString(),
-    };
-
-    const filename = `${Date.now()}-${template.id}.json`;
-    const outputPath = path.join(outputDirectory, filename);
-    await fs.writeFile(outputPath, JSON.stringify(payload, null, 2), "utf8");
-
-    logger.info(`Local email written to ${outputPath}`);
-    return ok();
-  }
-}