create-m5kdev 0.33.0 → 0.35.0

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

@@ -1,67 +1,67 @@
-import { BaseTableRepository } from "@m5kdev/backend/modules/base/base.repository";
-
-import { and, eq, isNull, ne } from "drizzle-orm";
-import type { LibSQLDatabase } from "drizzle-orm/libsql";
-import { err, ok } from "neverthrow";
-import { z } from "zod";
-import { posts } from "./posts.db";
-import { postSchemas } from "./posts.dto";
-
-const schema = { posts };
-type Schema = typeof schema;
-type Orm = LibSQLDatabase<Schema>;
-
-export class PostsRepository extends BaseTableRepository<
-  Orm,
-  Schema,
-  Record<string, never>,
-  Schema["posts"]
-> {
-  findBySlug = this.query("findBySlug")
-    .input(
-      z.object({
-        slug: z.string(),
-        excludeId: z.string().optional(),
-      })
-    )
-    .output(postSchemas.output.found)
-    .handle(async ({ excludeId, slug }) => {
-      const whereClause = excludeId
-        ? and(eq(this.table.slug, slug), ne(this.table.id, excludeId), isNull(this.table.deletedAt))
-        : and(eq(this.table.slug, slug), isNull(this.table.deletedAt));
-
-      const result = await this.throwableQuery(() =>
-        this.orm.select().from(this.table).where(whereClause).limit(1)
-      );
-      if (result.isErr()) return err(result.error);
-      const [row] = result.value;
-      return ok(row);
-    });
-
-  resolveUniqueSlug = this.query("resolveUniqueSlug")
-    .input(
-      z.object({
-        candidate: z.string(),
-        excludeId: z.string().optional(),
-      })
-    )
-    .output(z.string())
-    .handle(async ({ candidate, excludeId }) => {
-      let slug = candidate;
-      let suffix = 2;
-
-      while (true) {
-        const existing = await this.findBySlug({ slug, excludeId });
-        if (existing.isErr()) {
-          return err(existing.error);
-        }
-
-        if (!existing.value) {
-          return ok(slug);
-        }
-
-        slug = `${candidate}-${suffix}`;
-        suffix += 1;
-      }
-    });
-}
+import { BaseTableRepository } from "@m5kdev/backend/modules/base/base.repository";
+
+import { and, eq, isNull, ne } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import { err, ok } from "neverthrow";
+import { z } from "zod";
+import { posts } from "./posts.db";
+import { postSchemas } from "./posts.dto";
+
+const schema = { posts };
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+
+export class PostsRepository extends BaseTableRepository<
+  Orm,
+  Schema,
+  Record<string, never>,
+  Schema["posts"]
+> {
+  findBySlug = this.query("findBySlug")
+    .input(
+      z.object({
+        slug: z.string(),
+        excludeId: z.string().optional(),
+      })
+    )
+    .output(postSchemas.output.found)
+    .handle(async ({ excludeId, slug }) => {
+      const whereClause = excludeId
+        ? and(eq(this.table.slug, slug), ne(this.table.id, excludeId), isNull(this.table.deletedAt))
+        : and(eq(this.table.slug, slug), isNull(this.table.deletedAt));
+
+      const result = await this.throwableQuery(() =>
+        this.orm.select().from(this.table).where(whereClause).limit(1)
+      );
+      if (result.isErr()) return err(result.error);
+      const [row] = result.value;
+      return ok(row);
+    });
+
+  resolveUniqueSlug = this.query("resolveUniqueSlug")
+    .input(
+      z.object({
+        candidate: z.string(),
+        excludeId: z.string().optional(),
+      })
+    )
+    .output(z.string())
+    .handle(async ({ candidate, excludeId }) => {
+      let slug = candidate;
+      let suffix = 2;
+
+      while (true) {
+        const existing = await this.findBySlug({ slug, excludeId });
+        if (existing.isErr()) {
+          return err(existing.error);
+        }
+
+        if (!existing.value) {
+          return ok(slug);
+        }
+
+        slug = `${candidate}-${suffix}`;
+        suffix += 1;
+      }
+    });
+}

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

@@ -1,116 +1,116 @@
-import { BasePermissionService } from "@m5kdev/backend/modules/base/base.service";
-import { serializeSpanValue, withSpan } from "@m5kdev/backend/utils/telemetry";
-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("organization")
-    .addContextFilter(["organization"])
-    .handle(async ({ input }) => {
-      return withSpan(
-        {
-          name: "posts.list.query",
-          attributes: { input: serializeSpanValue(input) },
-        },
-        (span) => {
-          span.addEvent("span started");
-          return this.repository.posts.queryList(input, {
-            globalSearchColumns: ["title", "excerpt", "content"],
-          });
-        }
-      );
-    });
-
-  readonly create = this.procedure("create")
-    .requireAuth("organization")
-    .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,
-        memberId: ctx.actor.memberId ?? null,
-        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("organization")
-    .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("organization")
-    .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("organization")
-    .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 });
-    });
-}
+import { BasePermissionService } from "@m5kdev/backend/modules/base/base.service";
+import { serializeSpanValue, withSpan } from "@m5kdev/backend/utils/telemetry";
+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("organization")
+    .addContextFilter(["organization"])
+    .handle(async ({ input }) => {
+      return withSpan(
+        {
+          name: "posts.list.query",
+          attributes: { input: serializeSpanValue(input) },
+        },
+        (span) => {
+          span.addEvent("span started");
+          return this.repository.posts.queryList(input, {
+            globalSearchColumns: ["title", "excerpt", "content"],
+          });
+        }
+      );
+    });
+
+  readonly create = this.procedure("create")
+    .requireAuth("organization")
+    .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,
+        memberId: ctx.actor.memberId ?? null,
+        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("organization")
+    .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("organization")
+    .loadResource("post", ({ input }) => this.repository.posts.findById(input.id))
+    .access({
+      action: "publish",
+      entityStep: "post",
+    })
+    .handle(async ({ 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("organization")
+    .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,37 +1,37 @@
-import { handleTRPCResult, type TRPCMethods } from "@m5kdev/backend/utils/trpc";
-import { postSchemas } from "./posts.dto";
-import type { PostsService } from "./posts.service";
-
-export function createPostsTRPC(
-  { router, organizationProcedure: 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))
-      ),
-  });
-}
+import { handleTRPCResult, type TRPCMethods } from "@m5kdev/backend/utils/trpc";
+import { postSchemas } from "./posts.dto";
+import type { PostsService } from "./posts.service";
+
+export function createPostsTRPC(
+  { router, organizationProcedure: 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))
+      ),
+  });
+}