create-m5kdev 0.25.3 → 0.26.2

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

@@ -1,170 +1,104 @@
-import { BasePermissionService } from "@m5kdev/backend/modules/base/base.service";
-import type { Context } from "@m5kdev/backend/utils/trpc";
-import type { ServerResultAsync } from "@m5kdev/backend/utils/types";
-import type {
-  PostCreateInputSchema,
-  PostCreateOutputSchema,
-  PostPublishInputSchema,
-  PostPublishOutputSchema,
-  PostSoftDeleteInputSchema,
-  PostSoftDeleteOutputSchema,
-  PostsListInputSchema,
-  PostsListOutputSchema,
-  PostUpdateInputSchema,
-  PostUpdateOutputSchema,
-} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-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, "-")
-      .replace(/^-+/g, "")
-      .replace(/-+$/g, "")
-      .replace(/-{2,}/g, "-");
-
-    return slug || "post";
-  }
-
-  private createExcerpt(excerpt: string | undefined, content: string): string {
-    if (excerpt?.trim()) {
-      return excerpt.trim();
-    }
-
-    return content.replace(/\s+/g, " ").trim().slice(0, 180);
-  }
-}
+import { BasePermissionService } from "@m5kdev/backend/modules/base/base.service";
+import type { Context } from "@m5kdev/backend/utils/trpc";
+import { err, ok } from "neverthrow";
+import { postSchemas } from "./posts.dto";
+import type { PostsRepository } from "./posts.repository";
+import { createExcerpt, slugify } from "./posts.utils";
+
+export class PostsService extends BasePermissionService<
+  { posts: PostsRepository },
+  Record<string, never>,
+  Context
+> {
+  readonly list = this.procedure("list")
+    .input(postSchemas.input.list)
+    .output(postSchemas.output.list)
+    .requireAuth()
+    .handle(({ input }) => {
+      return this.repository.posts.queryList(input, {
+        globalSearchColumns: ["title", "excerpt", "content"],
+      });
+    });
+
+  readonly create = this.procedure("create")
+    .requireAuth()
+    .input(postSchemas.input.create)
+    .output(postSchemas.output.single)
+    .access({
+      action: "write",
+    })
+    .handle(async ({ input, ctx }) => {
+      const uniqueSlug = await this.repository.posts.resolveUniqueSlug({
+        candidate: 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: createExcerpt(input.excerpt, input.content),
+        content: input.content.trim(),
+        status: "draft",
+      });
+    });
+
+  readonly update = this.procedure("update")
+    .requireAuth()
+    .input(postSchemas.input.update)
+    .output(postSchemas.output.single)
+    .loadResource("post", ({ input }) => this.repository.posts.findById(input.id))
+    .access({
+      action: "write",
+      entityStep: "post",
+    })
+    .handle(async ({ input, state }) => {
+      const content = input.content?.trim() ?? state.post.content;
+
+      return this.repository.posts.update({
+        id: input.id,
+        title: input.title ? input.title.trim() : state.post.title,
+        excerpt: createExcerpt(input.excerpt, content),
+        content: content.trim(),
+      });
+    });
+
+  readonly publish = this.procedure("publish")
+    .input(postSchemas.input.publish)
+    .output(postSchemas.output.single)
+    .requireAuth()
+    .loadResource("post", ({ input }) => this.repository.posts.findById(input.id))
+    .access({
+      action: "publish",
+      entityStep: "post",
+    })
+    .handle(({ input, state }) => {
+      return this.repository.posts.update({
+        id: input.id,
+        status: "published",
+        publishedAt: state.post?.publishedAt ?? new Date(),
+      });
+    });
+
+  readonly softDelete = this.procedure("softDelete")
+    .input(postSchemas.input.delete)
+    .output(postSchemas.output.uuid)
+    .requireAuth()
+    .loadResource("post", ({ input }) => this.repository.posts.findById(input.id))
+    .access({
+      action: "delete",
+      entityStep: "post",
+    })
+    .handle(async ({ input }) => {
+      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 });
+    });
+}

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

@@ -1,48 +1,37 @@
-import { handleTRPCResult, type TRPCMethods } from "@m5kdev/backend/utils/trpc";
-import {
-  postCreateInputSchema,
-  postCreateOutputSchema,
-  postPublishInputSchema,
-  postPublishOutputSchema,
-  postSoftDeleteInputSchema,
-  postSoftDeleteOutputSchema,
-  postsListInputSchema,
-  postsListOutputSchema,
-  postUpdateInputSchema,
-  postUpdateOutputSchema,
-} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-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))
-      ),
-  });
-}
+import { handleTRPCResult, type TRPCMethods } from "@m5kdev/backend/utils/trpc";
+import { postSchemas } from "./posts.dto";
+import type { PostsService } from "./posts.service";
+
+export function createPostsTRPC(
+  { router, privateProcedure: procedure }: TRPCMethods,
+  postsService: PostsService
+) {
+  return router({
+    list: procedure
+      .input(postSchemas.input.list)
+      .output(postSchemas.output.list)
+      .query(async ({ ctx, input }) => handleTRPCResult(await postsService.list(input ?? {}, ctx))),
+
+    create: procedure
+      .input(postSchemas.input.create)
+      .output(postSchemas.output.single)
+      .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.create(input, ctx))),
+
+    update: procedure
+      .input(postSchemas.input.update)
+      .output(postSchemas.output.single)
+      .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.update(input, ctx))),
+
+    publish: procedure
+      .input(postSchemas.input.publish)
+      .output(postSchemas.output.single)
+      .mutation(async ({ ctx, input }) => handleTRPCResult(await postsService.publish(input, ctx))),
+
+    softDelete: procedure
+      .input(postSchemas.input.delete)
+      .output(postSchemas.output.uuid)
+      .mutation(async ({ ctx, input }) =>
+        handleTRPCResult(await postsService.softDelete(input, ctx))
+      ),
+  });
+}

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

@@ -0,0 +1,19 @@
+export function slugify(value: string): string {
+  const slug = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+/g, "")
+    .replace(/-+$/g, "")
+    .replace(/-{2,}/g, "-");
+
+  return slug || "post";
+}
+
+export function createExcerpt(excerpt: string | null | undefined, content: string): string {
+  if (excerpt?.trim()) {
+    return excerpt.trim();
+  }
+
+  return content.replace(/\s+/g, " ").trim().slice(0, 180);
+}

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

@@ -0,0 +1,279 @@
+import {
+  BaseModule,
+  type ModuleExpressContext,
+  type TableMap,
+} from "@m5kdev/backend/modules/base/base.module";
+import { and, desc, eq, isNotNull } from "drizzle-orm";
+import type { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+type TestHarnessTables = TableMap;
+
+function normalizedEmail(value: unknown) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function normalizedText(value: unknown, fallback: string) {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+
+function slugPart(value: string) {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 48);
+}
+
+function sendJson(res: Response, status: number, body: unknown) {
+  res
+    .status(status)
+    .type("application/json")
+    .send(JSON.stringify(body, null, 2));
+}
+
+export class TestHarnessModule extends BaseModule<
+  Record<string, never>,
+  TestHarnessTables,
+  Record<string, never>,
+  Record<string, never>,
+  never
+> {
+  readonly id = "auth-e2e-test-harness";
+  override readonly dbDependsOn = ["auth"] as const;
+
+  override express({ db, infra }: ModuleExpressContext<Record<string, never>>) {
+    infra.express.get("/__auth-e2e/user.json", async (req: Request, res: Response) => {
+      const email = normalizedEmail(req.query.email);
+      if (!email) {
+        sendJson(res, 400, { error: "email is required" });
+        return;
+      }
+
+      const [user] = await db.orm
+        .select({
+          id: db.schema.users.id,
+          name: db.schema.users.name,
+          email: db.schema.users.email,
+          emailVerified: db.schema.users.emailVerified,
+          role: db.schema.users.role,
+          banned: db.schema.users.banned,
+        })
+        .from(db.schema.users)
+        .where(eq(db.schema.users.email, email))
+        .limit(1);
+
+      if (!user) {
+        sendJson(res, 404, { error: "user not found" });
+        return;
+      }
+
+      const organizations = await db.orm
+        .select({
+          id: db.schema.organizations.id,
+          name: db.schema.organizations.name,
+          slug: db.schema.organizations.slug,
+          type: db.schema.organizations.type,
+          parentId: db.schema.organizations.parentId,
+          role: db.schema.members.role,
+        })
+        .from(db.schema.members)
+        .innerJoin(
+          db.schema.organizations,
+          eq(db.schema.members.organizationId, db.schema.organizations.id)
+        )
+        .where(eq(db.schema.members.userId, user.id));
+
+      const [credentialAccount] = await db.orm
+        .select({ id: db.schema.accounts.id })
+        .from(db.schema.accounts)
+        .where(
+          and(
+            eq(db.schema.accounts.userId, user.id),
+            eq(db.schema.accounts.providerId, "credential"),
+            isNotNull(db.schema.accounts.password)
+          )
+        )
+        .limit(1);
+
+      const accountClaims = await db.orm
+        .select({
+          id: db.schema.waitlist.id,
+          status: db.schema.waitlist.status,
+          claimUserId: db.schema.waitlist.claimUserId,
+          claimedEmail: db.schema.waitlist.claimedEmail,
+          claimedAt: db.schema.waitlist.claimedAt,
+          expiresAt: db.schema.waitlist.expiresAt,
+        })
+        .from(db.schema.waitlist)
+        .where(
+          and(
+            eq(db.schema.waitlist.type, "ACCOUNT_CLAIM"),
+            eq(db.schema.waitlist.claimUserId, user.id)
+          )
+        )
+        .orderBy(desc(db.schema.waitlist.createdAt));
+
+      const [latestSession] = await db.orm
+        .select({
+          id: db.schema.sessions.id,
+          userId: db.schema.sessions.userId,
+          activeOrganizationId: db.schema.sessions.activeOrganizationId,
+          activeOrganizationRole: db.schema.sessions.activeOrganizationRole,
+          activeOrganizationMemberId: db.schema.sessions.activeOrganizationMemberId,
+          activeOrganizationType: db.schema.sessions.activeOrganizationType,
+          activeTeamId: db.schema.sessions.activeTeamId,
+          impersonatedBy: db.schema.sessions.impersonatedBy,
+          createdAt: db.schema.sessions.createdAt,
+        })
+        .from(db.schema.sessions)
+        .where(eq(db.schema.sessions.userId, user.id))
+        .orderBy(desc(db.schema.sessions.createdAt))
+        .limit(1);
+
+      sendJson(res, 200, {
+        user,
+        organizations,
+        credentialAccount: Boolean(credentialAccount),
+        accountClaims,
+        pendingAccountClaims: accountClaims.filter((claim) => claim.status === "INVITED").length,
+        acceptedAccountClaims: accountClaims.filter((claim) => claim.status === "ACCEPTED").length,
+        latestSession: latestSession ?? null,
+      });
+    });
+
+    infra.express.post(
+      "/__auth-e2e/provisioned-claim-user",
+      async (req: Request, res: Response) => {
+        const email = normalizedEmail((req.body as { email?: unknown }).email);
+        const expiresInHours =
+          typeof (req.body as { expiresInHours?: unknown }).expiresInHours === "number"
+            ? (req.body as { expiresInHours: number }).expiresInHours
+            : 24 * 14;
+        const createClaim = (req.body as { createClaim?: unknown }).createClaim === true;
+
+        if (!email.endsWith("@provisioned.auth-e2e.local")) {
+          sendJson(res, 400, { error: "email must use the provisioned auth-e2e domain" });
+          return;
+        }
+
+        const [existing] = await db.orm
+          .select({ id: db.schema.users.id })
+          .from(db.schema.users)
+          .where(eq(db.schema.users.email, email))
+          .limit(1);
+
+        if (existing) {
+          sendJson(res, 409, { error: "user already exists" });
+          return;
+        }
+
+        const now = new Date();
+        const userId = uuidv4();
+        const organizationId = uuidv4();
+        const teamId = uuidv4();
+        const claimId = createClaim ? uuidv4() : null;
+
+        await db.orm.transaction(async (tx) => {
+          await tx.insert(db.schema.users).values({
+            id: userId,
+            name: `Provisioned ${email}`,
+            email,
+            emailVerified: false,
+            role: "user",
+            createdAt: now,
+            updatedAt: now,
+          });
+
+          await tx.insert(db.schema.organizations).values({
+            id: organizationId,
+            name: `Provisioned ${userId.slice(0, 8)}`,
+            slug: `provisioned-${userId.slice(0, 8)}`,
+            type: "organization",
+            createdAt: now,
+          });
+
+          await tx.insert(db.schema.members).values({
+            id: uuidv4(),
+            organizationId,
+            userId,
+            role: "owner",
+            createdAt: now,
+          });
+
+          await tx.insert(db.schema.teams).values({
+            id: teamId,
+            name: "Editorial",
+            organizationId,
+            createdAt: now,
+            updatedAt: now,
+          });
+
+          await tx.insert(db.schema.teamMembers).values({
+            id: uuidv4(),
+            teamId,
+            userId,
+            role: "owner",
+            createdAt: now,
+          });
+
+          if (claimId) {
+            await tx.insert(db.schema.waitlist).values({
+              id: claimId,
+              type: "ACCOUNT_CLAIM",
+              status: "INVITED",
+              claimUserId: userId,
+              code: uuidv4(),
+              expiresAt: new Date(Date.now() + expiresInHours * 60 * 60 * 1000),
+              createdAt: now,
+              updatedAt: now,
+            });
+          }
+        });
+
+        sendJson(res, 201, {
+          user: { id: userId, email },
+          organization: { id: organizationId },
+          claim: claimId ? { id: claimId } : null,
+        });
+      }
+    );
+
+    infra.express.post("/__auth-e2e/organizations", async (req: Request, res: Response) => {
+      const body = req.body as { count?: unknown; prefix?: unknown };
+      const count = typeof body.count === "number" ? Math.trunc(body.count) : 12;
+      const prefix = normalizedText(body.prefix, "Harness Organization");
+
+      if (count < 1 || count > 50) {
+        sendJson(res, 400, { error: "count must be between 1 and 50" });
+        return;
+      }
+
+      const now = Date.now();
+      const slugPrefix = slugPart(prefix) || "organization";
+      const organizations = Array.from({ length: count }, (_, index) => {
+        const id = uuidv4();
+        const displayIndex = String(index + 1).padStart(2, "0");
+
+        return {
+          id,
+          name: `${prefix} ${displayIndex}`,
+          slug: `${slugPrefix}-${displayIndex}-${id.slice(0, 8)}`,
+          type: "organization",
+          createdAt: new Date(now + index),
+        };
+      });
+
+      await db.orm.insert(db.schema.organizations).values(organizations);
+
+      sendJson(res, 201, {
+        organizations: organizations.map((organization) => ({
+          id: organization.id,
+          name: organization.name,
+          slug: organization.slug,
+        })),
+      });
+    });
+  }
+}