create-m5kdev 0.16.4 → 0.16.5

package/package.json

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

package/templates/minimal-app/README.md.tpl

@@ -18,8 +18,8 @@ pnpm --filter ./apps/server seed
 pnpm dev
 ```
 
-The starter uses a local LibSQL file by default and writes local auth emails to `apps/server/.emails`.
-Before running `drizzle-kit`, the starter generates `apps/server/src/generated/schema.ts` from the registered backend modules.
+The starter uses a local LibSQL file by default and writes local auth emails to `apps/server/.emails`.
+Before running `drizzle-kit`, the starter generates `apps/server/src/generated/schema.ts` from the registered backend modules.
 
 ## Demo Credentials
 

package/templates/minimal-app/apps/server/drizzle/generate-schema.ts.tpl

@@ -1,33 +1,33 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { collectBackendSchema, generateBackendSchemaSource } from "@m5kdev/backend/app";
-import { backendSchemaModules } from "../src/schema-modules";
-
-export async function generateSchema(): Promise<void> {
-  const collected = collectBackendSchema(backendSchemaModules, {
-    env: process.env,
-  });
-  const outputDirectory = path.resolve(process.cwd(), "src/generated");
-  const outputPath = path.join(outputDirectory, "schema.ts");
-
-  const source = [
-    'import { collectBackendSchema } from "@m5kdev/backend/app";',
-    'import { backendSchemaModules } from "../schema-modules";',
-    "",
-    "const collected = collectBackendSchema(backendSchemaModules, {",
-    "  env: process.env,",
-    "});",
-    "",
-    generateBackendSchemaSource({
-      schema: collected.schema,
-      schemaExpression: "collected.schema",
-    }),
-  ].join("\n");
-
-  await fs.mkdir(outputDirectory, { recursive: true });
-  await fs.writeFile(outputPath, source, "utf8");
-
-  console.info(`Generated Drizzle schema at ${outputPath}`);
-}
-
-void generateSchema();
+import fs from "node:fs/promises";
+import path from "node:path";
+import { collectBackendSchema, generateBackendSchemaSource } from "@m5kdev/backend/app";
+import { backendSchemaModules } from "../src/schema-modules";
+
+export async function generateSchema(): Promise<void> {
+  const collected = collectBackendSchema(backendSchemaModules, {
+    env: process.env,
+  });
+  const outputDirectory = path.resolve(process.cwd(), "src/generated");
+  const outputPath = path.join(outputDirectory, "schema.ts");
+
+  const source = [
+    'import { collectBackendSchema } from "@m5kdev/backend/app";',
+    'import { backendSchemaModules } from "../schema-modules";',
+    "",
+    "const collected = collectBackendSchema(backendSchemaModules, {",
+    "  env: process.env,",
+    "});",
+    "",
+    generateBackendSchemaSource({
+      schema: collected.schema,
+      schemaExpression: "collected.schema",
+    }),
+  ].join("\n");
+
+  await fs.mkdir(outputDirectory, { recursive: true });
+  await fs.writeFile(outputPath, source, "utf8");
+
+  console.info(`Generated Drizzle schema at ${outputPath}`);
+}
+
+void generateSchema();

package/templates/minimal-app/apps/server/drizzle/sync.ts.tpl

@@ -1,12 +1,12 @@
-import { spawnSync } from "node:child_process";
-import { generateSchema } from "./generate-schema";
-
-export async function syncDatabase(): Promise<void> {
-  await generateSchema();
-
-  const command = process.platform === "win32" ? "drizzle-kit.cmd" : "drizzle-kit";
-  const result = spawnSync(command, ["push", "--config", "drizzle.config.ts", "--force"], {
-    cwd: process.cwd(),
+import { spawnSync } from "node:child_process";
+import { generateSchema } from "./generate-schema";
+
+export async function syncDatabase(): Promise<void> {
+  await generateSchema();
+
+  const command = process.platform === "win32" ? "drizzle-kit.cmd" : "drizzle-kit";
+  const result = spawnSync(command, ["push", "--config", "drizzle.config.ts", "--force"], {
+    cwd: process.cwd(),
     env: process.env,
     stdio: "inherit",
   });

package/templates/minimal-app/apps/server/drizzle.config.ts.tpl

@@ -3,9 +3,9 @@ import { defineConfig } from "drizzle-kit";
 
 dotenv.config({ path: "../shared/.env" });
 
-const url = process.env.TURSO_DATABASE_URL || process.env.DATABASE_URL;
-const authToken = process.env.TURSO_AUTH_TOKEN;
-const schema = "./src/generated/schema.ts";
+const url = process.env.TURSO_DATABASE_URL || process.env.DATABASE_URL;
+const authToken = process.env.TURSO_AUTH_TOKEN;
+const schema = "./src/generated/schema.ts";
 
 if (!url) {
   throw new Error("DATABASE_URL or TURSO_DATABASE_URL must be set");

package/templates/minimal-app/apps/server/package.json.tpl

@@ -5,15 +5,15 @@
   "main": "dist/index.js",
   "scripts": {
     "dev": "tsx watch --env-file=../shared/.env src/index.ts",
-    "build": "tsup",
-    "start": "node dist/index.js",
-    "lint": "biome check .",
-    "lint:fix": "biome check . --write",
-    "check-types": "tsc --noEmit",
-    "generate:schema": "tsx --env-file=../shared/.env drizzle/generate-schema.ts",
-    "sync": "tsx --env-file=../shared/.env drizzle/sync.ts",
-    "seed": "tsx --env-file=../shared/.env drizzle/seed.ts"
-  },
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --write",
+    "check-types": "tsc --noEmit",
+    "generate:schema": "tsx --env-file=../shared/.env drizzle/generate-schema.ts",
+    "sync": "tsx --env-file=../shared/.env drizzle/sync.ts",
+    "seed": "tsx --env-file=../shared/.env drizzle/seed.ts"
+  },
   "dependencies": {
     "{{PACKAGE_SCOPE}}/email": "workspace:*",
     "{{PACKAGE_SCOPE}}/shared": "workspace:*",

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

@@ -1,95 +1,95 @@
-import { createBackendApp, type InferBackendAppRouter } from "@m5kdev/backend/app";
-import { createBetterAuth } from "@m5kdev/backend/modules/auth/auth.lib";
-import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
-import cors from "cors";
-import express from "express";
-import {
-  authBackendModule,
-  emailBackendModule,
-  notificationBackendModule,
-  postsBackendModule,
-  workflowBackendModule,
-} from "./modules";
-
-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(emailBackendModule)
-  .use(authBackendModule)
-  .use(workflowBackendModule)
-  .use(notificationBackendModule)
-  .use(postsBackendModule);
-
-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>;
+import { createBackendApp, type InferBackendAppRouter } from "@m5kdev/backend/app";
+import { createBetterAuth } from "@m5kdev/backend/modules/auth/auth.lib";
+import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
+import cors from "cors";
+import express from "express";
+import {
+  authBackendModule,
+  emailBackendModule,
+  notificationBackendModule,
+  postsBackendModule,
+  workflowBackendModule,
+} from "./modules";
+
+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(emailBackendModule)
+  .use(authBackendModule)
+  .use(workflowBackendModule)
+  .use(notificationBackendModule)
+  .use(postsBackendModule);
+
+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,7 +1,7 @@
-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;
+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,21 +1,21 @@
-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) => {
+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);
@@ -33,23 +33,23 @@ process.once("SIGINT", () => {
 process.once("SIGTERM", () => {
   void shutdown();
 });
-
-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();
-    });
+
+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: builtBackendApp.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,6 +1,6 @@
-import { builtBackendApp } from "../app";
-
-export const auth = builtBackendApp.auth!.instance;
-
-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,45 +1,45 @@
-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;
+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

@@ -1,37 +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),
-  }),
-});
+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,18 +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 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>;
+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,
@@ -30,11 +30,11 @@ export class PostsRepository extends BaseTableRepository<
       conditions.push(eq(this.table.status, input.status));
     }
 
-    if (search) {
-      const escapedSearch = search.replace(/[%_]/g, "\\$&");
-      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)
@@ -108,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

@@ -1,155 +1,155 @@
-import type {
-  PostCreateInputSchema,
-  PostCreateOutputSchema,
+import type {
+  PostCreateInputSchema,
+  PostCreateOutputSchema,
   PostPublishInputSchema,
   PostPublishOutputSchema,
   PostSoftDeleteInputSchema,
   PostSoftDeleteOutputSchema,
   PostsListInputSchema,
   PostsListOutputSchema,
-  PostUpdateInputSchema,
-  PostUpdateOutputSchema,
-} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-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";
-
-type RequestContext = Context;
-
-export class PostsService extends BasePermissionService<
-  { posts: PostsRepository },
-  Record<string, never>,
-  RequestContext
-> {
-  readonly list = this.procedure<PostsListInputSchema>("list")
-    .requireAuth()
-    .handle(({ input }): ServerResultAsync<PostsListOutputSchema> => {
-      return this.repository.posts.list(input);
-    });
-
-  readonly create = this.procedure<PostCreateInputSchema>("create")
-    .requireAuth()
-    .access({
-      action: "write",
-      entities: ({ ctx }) => ({
-        organizationId: ctx.session.activeOrganizationId ?? null,
-        teamId: ctx.session.activeTeamId ?? null,
-      }),
-    })
-    .handle(async ({ input, ctx }): ServerResultAsync<PostCreateOutputSchema> => {
-      const uniqueSlug = await this.repository.posts.resolveUniqueSlug(
-        this.slugify(input.slug ?? input.title)
-      );
-      if (uniqueSlug.isErr()) {
-        return err(uniqueSlug.error);
-      }
-
-      return this.repository.posts.create({
-        authorUserId: ctx.user.id,
-        organizationId: ctx.session.activeOrganizationId ?? null,
-        teamId: ctx.session.activeTeamId ?? null,
-        title: input.title.trim(),
-        slug: uniqueSlug.value,
-        excerpt: this.createExcerpt(input.excerpt, input.content),
-        content: input.content.trim(),
-        status: "draft",
-      }) as ServerResultAsync<PostCreateOutputSchema>;
-    });
-
-  readonly update = this.procedure<PostUpdateInputSchema>("update")
-    .requireAuth()
-    .use("post", async ({ input }) => {
-      const current = await this.repository.posts.findById(input.id);
-      if (current.isErr()) {
-        return err(current.error);
-      }
-      if (!current.value || current.value.deletedAt) {
-        return this.error("NOT_FOUND", "Post not found");
-      }
-
-      return current.value;
-    })
-    .access({
-      action: "write",
-      entityStep: "post",
-    })
-    .handle(async ({ input }): ServerResultAsync<PostUpdateOutputSchema> => {
-      const uniqueSlug = await this.repository.posts.resolveUniqueSlug(
-        this.slugify(input.slug ?? input.title),
-        input.id
-      );
-      if (uniqueSlug.isErr()) {
-        return err(uniqueSlug.error);
-      }
-
-      return this.repository.posts.update({
-        id: input.id,
-        title: input.title.trim(),
-        slug: uniqueSlug.value,
-        excerpt: this.createExcerpt(input.excerpt, input.content),
-        content: input.content.trim(),
-      }) as ServerResultAsync<PostUpdateOutputSchema>;
-    });
-
-  readonly publish = this.procedure<PostPublishInputSchema>("publish")
-    .requireAuth()
-    .use("post", async ({ input }) => {
-      const current = await this.repository.posts.findById(input.id);
-      if (current.isErr()) {
-        return err(current.error);
-      }
-      if (!current.value || current.value.deletedAt) {
-        return this.error("NOT_FOUND", "Post not found");
-      }
-
-      return current.value;
-    })
-    .access({
-      action: "publish",
-      entityStep: "post",
-    })
-    .handle(({ input, state }): ServerResultAsync<PostPublishOutputSchema> => {
-      return this.repository.posts.update({
-        id: input.id,
-        status: "published",
-        publishedAt: state.post.publishedAt ?? new Date(),
-      }) as ServerResultAsync<PostPublishOutputSchema>;
-    });
-
-  readonly softDelete = this.procedure<PostSoftDeleteInputSchema>("softDelete")
-    .requireAuth()
-    .use("post", async ({ input }) => {
-      const current = await this.repository.posts.findById(input.id);
-      if (current.isErr()) {
-        return err(current.error);
-      }
-      if (!current.value || current.value.deletedAt) {
-        return this.error("NOT_FOUND", "Post not found");
-      }
-
-      return current.value;
-    })
-    .access({
-      action: "delete",
-      entityStep: "post",
-    })
-    .handle(async ({ input }): ServerResultAsync<PostSoftDeleteOutputSchema> => {
-      const updated = await this.repository.posts.update({
-        id: input.id,
-        deletedAt: new Date(),
-      });
-
-      if (updated.isErr()) {
-        return err(updated.error);
-      }
-
-      return ok({ id: updated.value.id });
-    });
-
-  private slugify(value: string): string {
-    const slug = value
+  PostUpdateInputSchema,
+  PostUpdateOutputSchema,
+} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
+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";
+
+type RequestContext = Context;
+
+export class PostsService extends BasePermissionService<
+  { posts: PostsRepository },
+  Record<string, never>,
+  RequestContext
+> {
+  readonly list = this.procedure<PostsListInputSchema>("list")
+    .requireAuth()
+    .handle(({ input }): ServerResultAsync<PostsListOutputSchema> => {
+      return this.repository.posts.list(input);
+    });
+
+  readonly create = this.procedure<PostCreateInputSchema>("create")
+    .requireAuth()
+    .access({
+      action: "write",
+      entities: ({ ctx }) => ({
+        organizationId: ctx.session.activeOrganizationId ?? null,
+        teamId: ctx.session.activeTeamId ?? null,
+      }),
+    })
+    .handle(async ({ input, ctx }): ServerResultAsync<PostCreateOutputSchema> => {
+      const uniqueSlug = await this.repository.posts.resolveUniqueSlug(
+        this.slugify(input.slug ?? input.title)
+      );
+      if (uniqueSlug.isErr()) {
+        return err(uniqueSlug.error);
+      }
+
+      return this.repository.posts.create({
+        authorUserId: ctx.user.id,
+        organizationId: ctx.session.activeOrganizationId ?? null,
+        teamId: ctx.session.activeTeamId ?? null,
+        title: input.title.trim(),
+        slug: uniqueSlug.value,
+        excerpt: this.createExcerpt(input.excerpt, input.content),
+        content: input.content.trim(),
+        status: "draft",
+      }) as ServerResultAsync<PostCreateOutputSchema>;
+    });
+
+  readonly update = this.procedure<PostUpdateInputSchema>("update")
+    .requireAuth()
+    .use("post", async ({ input }) => {
+      const current = await this.repository.posts.findById(input.id);
+      if (current.isErr()) {
+        return err(current.error);
+      }
+      if (!current.value || current.value.deletedAt) {
+        return this.error("NOT_FOUND", "Post not found");
+      }
+
+      return current.value;
+    })
+    .access({
+      action: "write",
+      entityStep: "post",
+    })
+    .handle(async ({ input }): ServerResultAsync<PostUpdateOutputSchema> => {
+      const uniqueSlug = await this.repository.posts.resolveUniqueSlug(
+        this.slugify(input.slug ?? input.title),
+        input.id
+      );
+      if (uniqueSlug.isErr()) {
+        return err(uniqueSlug.error);
+      }
+
+      return this.repository.posts.update({
+        id: input.id,
+        title: input.title.trim(),
+        slug: uniqueSlug.value,
+        excerpt: this.createExcerpt(input.excerpt, input.content),
+        content: input.content.trim(),
+      }) as ServerResultAsync<PostUpdateOutputSchema>;
+    });
+
+  readonly publish = this.procedure<PostPublishInputSchema>("publish")
+    .requireAuth()
+    .use("post", async ({ input }) => {
+      const current = await this.repository.posts.findById(input.id);
+      if (current.isErr()) {
+        return err(current.error);
+      }
+      if (!current.value || current.value.deletedAt) {
+        return this.error("NOT_FOUND", "Post not found");
+      }
+
+      return current.value;
+    })
+    .access({
+      action: "publish",
+      entityStep: "post",
+    })
+    .handle(({ input, state }): ServerResultAsync<PostPublishOutputSchema> => {
+      return this.repository.posts.update({
+        id: input.id,
+        status: "published",
+        publishedAt: state.post.publishedAt ?? new Date(),
+      }) as ServerResultAsync<PostPublishOutputSchema>;
+    });
+
+  readonly softDelete = this.procedure<PostSoftDeleteInputSchema>("softDelete")
+    .requireAuth()
+    .use("post", async ({ input }) => {
+      const current = await this.repository.posts.findById(input.id);
+      if (current.isErr()) {
+        return err(current.error);
+      }
+      if (!current.value || current.value.deletedAt) {
+        return this.error("NOT_FOUND", "Post not found");
+      }
+
+      return current.value;
+    })
+    .access({
+      action: "delete",
+      entityStep: "post",
+    })
+    .handle(async ({ input }): ServerResultAsync<PostSoftDeleteOutputSchema> => {
+      const updated = await this.repository.posts.update({
+        id: input.id,
+        deletedAt: new Date(),
+      });
+
+      if (updated.isErr()) {
+        return err(updated.error);
+      }
+
+      return ok({ id: updated.value.id });
+    });
+
+  private slugify(value: string): string {
+    const slug = value
       .trim()
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, "-")

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,41 +8,41 @@ import {
   postsListInputSchema,
   postsListOutputSchema,
   postUpdateInputSchema,
-  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))
-      ),
-  });
-}
+  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/modules.ts.tpl

@@ -1,37 +1,37 @@
-import { defineBackendModules } from "@m5kdev/backend/app";
-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 { postsModule } from "./modules/posts/posts.module";
-
-export const emailBackendModule = createEmailBackendModule({
-  templates: templates as never,
-});
-
-export const authBackendModule = createAuthBackendModule({
-  emailModuleId: "email",
-});
-
-export const workflowBackendModule = createWorkflowBackendModule({
-  queues: {
-    fast: { concurrency: 5 },
-  },
-  defaultQueue: "fast",
-  defaults: {
-    timeout: 60_000,
-    jobOptions: { removeOnComplete: { age: 3600 } },
-  },
-});
-
-export const notificationBackendModule = createNotificationBackendModule();
-export const postsBackendModule = postsModule;
-
-export const backendModules = defineBackendModules([
-  emailBackendModule,
-  authBackendModule,
-  workflowBackendModule,
-  notificationBackendModule,
-  postsBackendModule,
-] as const);
+import { defineBackendModules } from "@m5kdev/backend/app";
+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 { postsModule } from "./modules/posts/posts.module";
+
+export const emailBackendModule = createEmailBackendModule({
+  templates: templates as never,
+});
+
+export const authBackendModule = createAuthBackendModule({
+  emailModuleId: "email",
+});
+
+export const workflowBackendModule = createWorkflowBackendModule({
+  queues: {
+    fast: { concurrency: 5 },
+  },
+  defaultQueue: "fast",
+  defaults: {
+    timeout: 60_000,
+    jobOptions: { removeOnComplete: { age: 3600 } },
+  },
+});
+
+export const notificationBackendModule = createNotificationBackendModule();
+export const postsBackendModule = postsModule;
+
+export const backendModules = defineBackendModules([
+  emailBackendModule,
+  authBackendModule,
+  workflowBackendModule,
+  notificationBackendModule,
+  postsBackendModule,
+] as const);

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

@@ -1,6 +1,6 @@
-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;
+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/schema-modules.ts.tpl

@@ -1,14 +1,14 @@
-import { defineBackendModule, defineBackendModules } from "@m5kdev/backend/app";
-import { authBackendModule, notificationBackendModule, postsBackendModule, workflowBackendModule } from "./modules";
-
-export const emailSchemaModule = defineBackendModule({
-  id: "email",
-});
-
-export const backendSchemaModules = defineBackendModules([
-  emailSchemaModule,
-  authBackendModule,
-  workflowBackendModule,
-  notificationBackendModule,
-  postsBackendModule,
-] as const);
+import { defineBackendModule, defineBackendModules } from "@m5kdev/backend/app";
+import { authBackendModule, notificationBackendModule, postsBackendModule, workflowBackendModule } from "./modules";
+
+export const emailSchemaModule = defineBackendModule({
+  id: "email",
+});
+
+export const backendSchemaModules = defineBackendModules([
+  emailSchemaModule,
+  authBackendModule,
+  workflowBackendModule,
+  notificationBackendModule,
+  postsBackendModule,
+] as const);

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

@@ -1,7 +1,7 @@
-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;
+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,6 +1,6 @@
-export {
-  appRouter,
-  type AppRouter,
-  type RouterInputs,
-  type RouterOutputs,
-} from "./app";
+export {
+  appRouter,
+  type AppRouter,
+  type RouterInputs,
+  type RouterOutputs,
+} from "./app";

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

@@ -1,8 +1,8 @@
-import { builtBackendApp } from "../app";
-
-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 trpcObject = builtBackendApp.trpc.methods;
+import { builtBackendApp } from "../app";
+
+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 trpcObject = builtBackendApp.trpc.methods;

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

@@ -1,4 +1,4 @@
-import { builtBackendApp } from "./app";
-
-export const workflowService = builtBackendApp.modules.workflow.services.workflow;
-export const workflowRegistry = builtBackendApp.workflow!.registry;
+import { builtBackendApp } from "./app";
+
+export const workflowService = builtBackendApp.modules.workflow.services.workflow;
+export const workflowRegistry = builtBackendApp.workflow!.registry;