create-m5kdev 0.25.3 → 0.26.2

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

@@ -1,25 +1,25 @@
-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 { 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" }),
+});

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

@@ -0,0 +1,23 @@
+import { createZodSchemas } from "@m5kdev/backend/modules/base/base.dto";
+import {
+  postCreateInputSchema,
+  postUpdateInputSchema,
+} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
+import { z } from "zod";
+import { posts } from "./posts.db";
+
+const { output, input } = createZodSchemas(posts);
+
+export const postSchemas = {
+  output,
+  input: {
+    ...input,
+    // create/update come from shared: the same schemas validate the webapp form,
+    // so the API contract and the frontend validation cannot drift apart
+    create: postCreateInputSchema,
+    update: postUpdateInputSchema,
+    publish: z.object({
+      id: z.string(),
+    }),
+  },
+};

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

@@ -1,40 +1,30 @@
-import type { ResourceGrant } from "@m5kdev/backend/modules/base/base.grants";
-
-export const postsGrants: ResourceGrant[] = [
-  {
-    action: "write",
-    level: "team",
-    role: "owner",
-    access: "own",
-  },
-  {
-    action: "publish",
-    level: "team",
-    role: "owner",
-    access: "own",
-  },
-  {
-    action: "delete",
-    level: "team",
-    role: "owner",
-    access: "own",
-  },
-  {
-    action: "write",
-    level: "organization",
-    role: "owner",
-    access: "own",
-  },
-  {
-    action: "publish",
-    level: "organization",
-    role: "owner",
-    access: "own",
-  },
-  {
-    action: "delete",
-    level: "organization",
-    role: "owner",
-    access: "own",
-  },
-];
+import { flattenNestedGrants } from "@m5kdev/backend/modules/base/base.grants";
+
+export const postsGrants = flattenNestedGrants({
+  cash: {
+    user: {
+      admin: {
+        read: "all",
+        write: "all",
+        delete: "all",
+        publish: "all",
+      },
+    },
+    organization: {
+      owner: {
+        read: "own",
+        write: "own",
+        delete: "own",
+        publish: "own",
+      },
+    },
+    team: {
+      owner: {
+        read: "own",
+        write: "own",
+        delete: "own",
+        publish: "own",
+      },
+    },
+  },
+});

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

@@ -1,54 +1,54 @@
-import { createBackendRouterMap } from "@m5kdev/backend/app";
-import {
-  BaseModule,
-  type ModuleRepositoriesContext,
-  type ModuleServicesContext,
-  type ModuleTRPCContext,
-} from "@m5kdev/backend/modules/base/base.module";
-import type * as postsTables from "./posts.db";
-import { postsGrants } from "./posts.grants";
-import { PostsRepository } from "./posts.repository";
-import { PostsService } from "./posts.service";
-import { createPostsTRPC } from "./posts.trpc";
-
-type PostsModuleTables = typeof postsTables;
-type PostsModuleRepositories = {
-  posts: PostsRepository;
-};
-type PostsModuleServices = {
-  posts: PostsService;
-};
-type PostsModuleRouters = {
-  posts: ReturnType<typeof createPostsTRPC>;
-};
-
-export class PostsModule extends BaseModule<
-  never,
-  PostsModuleTables,
-  PostsModuleRepositories,
-  PostsModuleServices,
-  PostsModuleRouters
-> {
-  readonly id = "posts";
-  override readonly dbDependsOn = ["auth"] as const;
-
-  override repositories({ db }: ModuleRepositoriesContext<never, PostsModuleTables>) {
-    return {
-      posts: new PostsRepository({
-        orm: db.orm,
-        schema: db.schema,
-        table: db.schema.posts,
-      }),
-    };
-  }
-
-  override services({ repositories }: ModuleServicesContext<never, PostsModuleRepositories>) {
-    return {
-      posts: new PostsService({ posts: repositories.posts }, {}, postsGrants),
-    };
-  }
-
-  override trpc({ trpc, services }: ModuleTRPCContext<never, PostsModuleServices>) {
-    return createBackendRouterMap("posts", createPostsTRPC(trpc, services.posts));
-  }
-}
+import { createBackendRouterMap } from "@m5kdev/backend/app";
+import {
+  BaseModule,
+  type ModuleRepositoriesContext,
+  type ModuleServicesContext,
+  type ModuleTRPCContext,
+} from "@m5kdev/backend/modules/base/base.module";
+import type * as postsTables from "./posts.db";
+import { postsGrants } from "./posts.grants";
+import { PostsRepository } from "./posts.repository";
+import { PostsService } from "./posts.service";
+import { createPostsTRPC } from "./posts.trpc";
+
+type PostsModuleTables = typeof postsTables;
+type PostsModuleRepositories = {
+  posts: PostsRepository;
+};
+type PostsModuleServices = {
+  posts: PostsService;
+};
+type PostsModuleRouters = {
+  posts: ReturnType<typeof createPostsTRPC>;
+};
+
+export class PostsModule extends BaseModule<
+  never,
+  PostsModuleTables,
+  PostsModuleRepositories,
+  PostsModuleServices,
+  PostsModuleRouters
+> {
+  readonly id = "posts";
+  override readonly dbDependsOn = ["auth"] as const;
+
+  override repositories({ db }: ModuleRepositoriesContext<never, PostsModuleTables>) {
+    return {
+      posts: new PostsRepository({
+        orm: db.orm,
+        schema: db.schema,
+        table: db.schema.posts,
+      }),
+    };
+  }
+
+  override services({ repositories }: ModuleServicesContext<never, PostsModuleRepositories>) {
+    return {
+      posts: new PostsService({ posts: repositories.posts }, {}, postsGrants),
+    };
+  }
+
+  override trpc({ trpc, services }: ModuleTRPCContext<never, PostsModuleServices>) {
+    return createBackendRouterMap("posts", createPostsTRPC(trpc, services.posts));
+  }
+}

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

@@ -1,112 +1,67 @@
-import { BaseTableRepository } from "@m5kdev/backend/modules/base/base.repository";
-import type { ServerResultAsync } from "@m5kdev/backend/utils/types";
-import type {
-  PostSchema,
-  PostsListInputSchema,
-  PostsListOutputSchema,
-} from "{{PACKAGE_SCOPE}}/shared/modules/posts/posts.schema";
-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,
-  Schema,
-  Record<string, never>,
-  Schema["posts"]
-> {
-  async list(input: PostsListInputSchema = {}): ServerResultAsync<PostsListOutputSchema> {
-    const page = input.page ?? 1;
-    const limit = input.limit ?? 6;
-    const search = input.search?.trim();
-    const conditions = [isNull(this.table.deletedAt)];
-
-    if (input.status) {
-      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),
-        like(this.table.slug, pattern),
-        like(this.table.excerpt, pattern),
-        like(this.table.content, pattern)
-      );
-      if (searchCondition) {
-        conditions.push(searchCondition);
-      }
-    }
-
-    const whereClause = and(...conditions);
-    const ordering =
-      input.sort === "title"
-        ? input.order === "asc"
-          ? asc(this.table.title)
-          : desc(this.table.title)
-        : input.sort === "publishedAt"
-          ? input.order === "asc"
-            ? asc(this.table.publishedAt)
-            : desc(this.table.publishedAt)
-          : input.order === "asc"
-            ? asc(this.table.updatedAt)
-            : desc(this.table.updatedAt);
-
-    const rowsQuery = this.orm
-      .select()
-      .from(this.table)
-      .where(whereClause)
-      .orderBy(ordering, desc(this.table.createdAt))
-      .limit(limit)
-      .offset((page - 1) * limit);
-
-    const countQuery = this.orm.select({ count: count() }).from(this.table).where(whereClause);
-
-    const result = await this.throwableQuery(() => Promise.all([rowsQuery, countQuery]));
-    if (result.isErr()) return err(result.error);
-    const [rows, [totalRow]] = result.value;
-
-    return ok({
-      rows: rows as PostSchema[],
-      total: totalRow?.count ?? 0,
-    });
-  }
-
-  async findBySlug(slug: string, excludeId?: string) {
-    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);
-  }
-
-  async resolveUniqueSlug(candidate: string, excludeId?: string) {
-    let slug = candidate;
-    let suffix = 2;
-
-    while (true) {
-      const existing = await this.findBySlug(slug, excludeId);
-      if (existing.isErr()) {
-        return existing;
-      }
-
-      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;
+      }
+    });
+}