create-m5kdev 0.32.8 → 0.34.0

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

@@ -0,0 +1,43 @@
+import type { ServerResultAsync } from "@m5kdev/backend/modules/base/base.dto";
+import { BaseService } from "@m5kdev/backend/modules/base/base.service";
+import type { WorkflowService } from "@m5kdev/backend/modules/workflow/workflow.service";
+import type { FireAndForgetJobDefinition } from "@m5kdev/backend/modules/workflow/workflow.types";
+import type { Context } from "@m5kdev/backend/utils/trpc";
+import { workflowTriggerOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
+import { ok } from "neverthrow";
+
+const DEMO_PING_JOB_NAME = "demo.ping";
+
+interface DemoPingJobPayload {
+  readonly userId: string;
+}
+
+export class DemoWorkflowService extends BaseService<
+  Record<string, never>,
+  { workflow: WorkflowService },
+  Context
+> {
+  readonly demoPingJob: FireAndForgetJobDefinition<DemoPingJobPayload>;
+
+  constructor(services: { workflow: WorkflowService }) {
+    super({}, services);
+
+    this.demoPingJob = this.service.workflow
+      .job<DemoPingJobPayload>({
+        name: DEMO_PING_JOB_NAME,
+        queue: "fast",
+        meta: (payload) => ({ userId: payload.userId }),
+      })
+      .handle(async () => {
+        // Completes immediately so the Starter webapp can observe a finished run.
+      });
+  }
+
+  readonly runDemo = this.procedure("runDemo")
+    .output(workflowTriggerOutputSchema)
+    .requireAuth()
+    .handle(async ({ ctx }): ServerResultAsync<{ jobId: string }> => {
+      const jobId = await this.demoPingJob.trigger({ userId: ctx.actor.userId });
+      return ok({ jobId });
+    });
+}

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

@@ -0,0 +1,16 @@
+import { handleTRPCResult, type TRPCMethods } from "@m5kdev/backend/utils/trpc";
+import { workflowTriggerOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
+import type { DemoWorkflowService } from "./demo-workflow.service";
+
+export function createDemoWorkflowTRPC(
+  { router, privateProcedure }: TRPCMethods,
+  demoWorkflowService: DemoWorkflowService
+) {
+  return router({
+    run: privateProcedure
+      .output(workflowTriggerOutputSchema)
+      .mutation(async ({ ctx }) =>
+        handleTRPCResult(await demoWorkflowService.runDemo(undefined, ctx))
+      ),
+  });
+}

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

@@ -1,28 +1,28 @@
-import { members, 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",
-  }),
-  memberId: text("member_id").references(() => members.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 { members, 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",
+  }),
+  memberId: text("member_id").references(() => members.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.grants.ts.tpl

@@ -1,30 +1,28 @@
-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",
-      },
-    },
-  },
-});
+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: "org",
+        write: "org",
+        delete: "org",
+        publish: "org",
+      },
+      member: {
+        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,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,115 +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()
-    .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()
-    .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()
-    .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 });
-    });
-}
+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 });
+    });
+}