@ysk-kit/cli 1.0.0

package/templates/capabilities/team/apps/web/src/features/orgs/org-detail-page.tsx

@@ -0,0 +1,138 @@
+import { useNavigate } from '@tanstack/react-router';
+import { InviteMemberCommandSchema } from '@ysk-kit/contracts';
+import {
+  Button,
+  Input,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@ysk-kit/ui';
+import { orgRoleCan } from '@ysk-kit/ui-logic';
+import { createOrganizationHooks } from '@ysk-kit/web-sdk';
+import { type FormEvent, useState } from 'react';
+import { api, userHooks } from '../../lib/client';
+
+const orgHooks = createOrganizationHooks(api);
+
+export function OrgDetailPage({ organizationId }: { organizationId: string }) {
+  const me = userHooks.useMe();
+  const org = orgHooks.useOrganization(organizationId);
+  const members = orgHooks.useOrganizationMembers(organizationId);
+  const myRole = members.data?.find((row) => row.userId === me.data?.id)?.role;
+  const canInvite = myRole ? orgRoleCan(myRole, 'org.invite') : false;
+  const canRemove = myRole ? orgRoleCan(myRole, 'org.member.remove') : false;
+  const canBill = myRole ? orgRoleCan(myRole, 'org.billing') : false;
+  const invites = orgHooks.useOrganizationInvites(organizationId, canInvite);
+  const invite = orgHooks.useInviteMember(organizationId);
+  const removeMember = orgHooks.useRemoveMember(organizationId);
+  const leave = orgHooks.useLeaveOrganization();
+  const navigate = useNavigate();
+  const [email, setEmail] = useState('');
+  const [formError, setFormError] = useState<string | null>(null);
+
+  const onInvite = (event: FormEvent) => {
+    event.preventDefault();
+    const parsed = InviteMemberCommandSchema.safeParse({ email, role: 'MEMBER' });
+    if (!parsed.success) {
+      setFormError(parsed.error.issues[0]?.message ?? 'Invalid');
+      return;
+    }
+    setFormError(null);
+    invite.mutate(parsed.data, {
+      onSuccess: () => setEmail(''),
+      onError: (error) => setFormError(error.message),
+    });
+  };
+
+  return (
+    <section className="space-y-6">
+      <h1 className="text-2xl font-semibold">{org.data?.name ?? 'Organization'}</h1>
+      {canBill ? (
+        <a
+          href={`/orgs/${organizationId}/billing`}
+          className="text-sm text-zinc-600 hover:text-zinc-900"
+        >
+          Billing
+        </a>
+      ) : null}
+      {formError ? <p className="text-sm text-red-600">{formError}</p> : null}
+      {canInvite ? (
+        <form onSubmit={onInvite} className="flex flex-wrap items-end gap-3">
+          <label className="grid gap-1 text-sm" htmlFor="invite-email">
+            Invite email
+            <Input
+              id="invite-email"
+              type="email"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              required
+            />
+          </label>
+          <Button type="submit" disabled={invite.isPending}>
+            Invite
+          </Button>
+        </form>
+      ) : null}
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Name</TableHead>
+            <TableHead>Email</TableHead>
+            <TableHead>Role</TableHead>
+            <TableHead />
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {(members.data ?? []).map((member) => (
+            <TableRow key={member.id}>
+              <TableCell>{member.displayName}</TableCell>
+              <TableCell>{member.email}</TableCell>
+              <TableCell>{member.role}</TableCell>
+              <TableCell>
+                {canRemove && member.userId !== me.data?.id ? (
+                  <Button
+                    type="button"
+                    variant="outline"
+                    size="sm"
+                    onClick={() => removeMember.mutate(member.userId)}
+                  >
+                    Remove
+                  </Button>
+                ) : null}
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+      {canInvite && (invites.data?.length ?? 0) > 0 ? (
+        <div className="space-y-2">
+          <h2 className="text-lg font-medium">Pending invites</h2>
+          <ul className="text-sm text-zinc-600">
+            {(invites.data ?? []).map((row) => (
+              <li key={row.id}>
+                {row.email} · {row.role}
+              </li>
+            ))}
+          </ul>
+        </div>
+      ) : null}
+      <Button
+        type="button"
+        variant="outline"
+        onClick={() =>
+          leave.mutate(organizationId, {
+            onSuccess: () => {
+              void navigate({ to: '/orgs' });
+            },
+            onError: (error) => setFormError(error.message),
+          })
+        }
+      >
+        Leave
+      </Button>
+    </section>
+  );
+}

package/templates/capabilities/team/apps/web/src/features/orgs/orgs-page.tsx

@@ -0,0 +1,73 @@
+import { Link } from '@tanstack/react-router';
+import { CreateOrganizationCommandSchema } from '@ysk-kit/contracts';
+import {
+  Button,
+  Input,
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@ysk-kit/ui';
+import { createOrganizationHooks } from '@ysk-kit/web-sdk';
+import { type FormEvent, useState } from 'react';
+import { api } from '../../lib/client';
+
+const orgHooks = createOrganizationHooks(api);
+
+export function OrgsPage() {
+  const orgs = orgHooks.useOrganizations();
+  const createOrg = orgHooks.useCreateOrganization();
+  const [name, setName] = useState('');
+  const [formError, setFormError] = useState<string | null>(null);
+
+  const onSubmit = (event: FormEvent) => {
+    event.preventDefault();
+    const parsed = CreateOrganizationCommandSchema.safeParse({ name });
+    if (!parsed.success) {
+      setFormError(parsed.error.issues[0]?.message ?? 'Invalid');
+      return;
+    }
+    setFormError(null);
+    createOrg.mutate(parsed.data, {
+      onSuccess: () => setName(''),
+      onError: (error) => setFormError(error.message),
+    });
+  };
+
+  return (
+    <section className="space-y-6">
+      <h1 className="text-2xl font-semibold">Organizations</h1>
+      <form onSubmit={onSubmit} className="flex flex-wrap items-end gap-3">
+        <label className="grid gap-1 text-sm" htmlFor="org-name">
+          Name
+          <Input id="org-name" value={name} onChange={(e) => setName(e.target.value)} required />
+        </label>
+        <Button type="submit" disabled={createOrg.isPending}>
+          Create
+        </Button>
+      </form>
+      {formError ? <p className="text-sm text-red-600">{formError}</p> : null}
+      {orgs.error ? <p className="text-sm text-red-600">{orgs.error.message}</p> : null}
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Name</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {(orgs.data ?? []).map((org) => (
+            <TableRow key={org.id}>
+              <TableCell>
+                <Link to="/orgs/$organizationId" params={{ organizationId: org.id }}>
+                  {org.name}
+                </Link>
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </section>
+  );
+}

package/templates/capabilities/team/packages/contracts/src/api/organizations.ts

@@ -0,0 +1,154 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  AcceptedInviteDtoSchema,
+  AcceptInviteCommandSchema,
+  CreateOrganizationCommandSchema,
+  InviteMemberCommandSchema,
+  MembershipDtoSchema,
+  OrganizationDtoSchema,
+  OrgInviteDtoSchema,
+  UpdateOrganizationCommandSchema,
+} from '../dto/organization';
+import { ErrSchema, OkSchema } from '../errors/envelope';
+
+const c = initContract();
+const orgIdParams = z.object({ organizationId: z.string().uuid() });
+const memberParams = z.object({
+  organizationId: z.string().uuid(),
+  userId: z.string().uuid(),
+});
+const inviteParams = z.object({
+  organizationId: z.string().uuid(),
+  id: z.string().uuid(),
+});
+
+export const organizationsContract = c.router({
+  create: {
+    method: 'POST',
+    path: '/v1/organizations',
+    body: CreateOrganizationCommandSchema,
+    responses: { 201: OkSchema(OrganizationDtoSchema), 401: ErrSchema, 422: ErrSchema },
+    summary: 'Create an organization',
+  },
+  list: {
+    method: 'GET',
+    path: '/v1/organizations',
+    responses: { 200: OkSchema(z.array(OrganizationDtoSchema)), 401: ErrSchema },
+    summary: 'List my organizations',
+  },
+  acceptInvite: {
+    method: 'POST',
+    path: '/v1/organizations/invites/accept',
+    body: AcceptInviteCommandSchema,
+    responses: {
+      200: OkSchema(AcceptedInviteDtoSchema),
+      401: ErrSchema,
+      409: ErrSchema,
+      422: ErrSchema,
+    },
+    summary: 'Accept an organization invite',
+  },
+  get: {
+    method: 'GET',
+    path: '/v1/organizations/:organizationId',
+    pathParams: orgIdParams,
+    responses: {
+      200: OkSchema(OrganizationDtoSchema),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'Get an organization',
+  },
+  update: {
+    method: 'PATCH',
+    path: '/v1/organizations/:organizationId',
+    pathParams: orgIdParams,
+    body: UpdateOrganizationCommandSchema,
+    responses: {
+      200: OkSchema(OrganizationDtoSchema),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+      422: ErrSchema,
+    },
+    summary: 'Rename an organization',
+  },
+  members: {
+    method: 'GET',
+    path: '/v1/organizations/:organizationId/members',
+    pathParams: orgIdParams,
+    responses: {
+      200: OkSchema(z.array(MembershipDtoSchema)),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'List members',
+  },
+  invite: {
+    method: 'POST',
+    path: '/v1/organizations/:organizationId/invites',
+    pathParams: orgIdParams,
+    body: InviteMemberCommandSchema,
+    responses: {
+      200: OkSchema(OrgInviteDtoSchema),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+      409: ErrSchema,
+      422: ErrSchema,
+    },
+    summary: 'Invite a member by email',
+  },
+  invites: {
+    method: 'GET',
+    path: '/v1/organizations/:organizationId/invites',
+    pathParams: orgIdParams,
+    responses: {
+      200: OkSchema(z.array(OrgInviteDtoSchema)),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'List pending invites',
+  },
+  revokeInvite: {
+    method: 'DELETE',
+    path: '/v1/organizations/:organizationId/invites/:id',
+    pathParams: inviteParams,
+    responses: {
+      200: OkSchema(z.object({ removed: z.literal(true) })),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'Revoke a pending invite',
+  },
+  removeMember: {
+    method: 'DELETE',
+    path: '/v1/organizations/:organizationId/members/:userId',
+    pathParams: memberParams,
+    responses: {
+      200: OkSchema(z.object({ removed: z.literal(true) })),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'Remove a member',
+  },
+  leave: {
+    method: 'POST',
+    path: '/v1/organizations/:organizationId/leave',
+    pathParams: orgIdParams,
+    body: z.object({}).optional(),
+    responses: {
+      200: OkSchema(z.object({ left: z.literal(true) })),
+      401: ErrSchema,
+      403: ErrSchema,
+      404: ErrSchema,
+    },
+    summary: 'Leave an organization',
+  },
+});

package/templates/capabilities/team/packages/contracts/src/dto/organization.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { InviteOrgRoleSchema, OrgRoleSchema } from '../enums/org-role';
+
+export const OrganizationDtoSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).max(80),
+  createdAt: z.iso.datetime(),
+});
+export type OrganizationDto = z.infer<typeof OrganizationDtoSchema>;
+
+export const MembershipDtoSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  userId: z.string().uuid(),
+  email: z.string().email().nullable(),
+  displayName: z.string().min(1).max(80),
+  role: OrgRoleSchema,
+  createdAt: z.iso.datetime(),
+});
+export type MembershipDto = z.infer<typeof MembershipDtoSchema>;
+
+export const OrgInviteDtoSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  email: z.string().email(),
+  role: InviteOrgRoleSchema,
+  createdAt: z.iso.datetime(),
+  expiresAt: z.iso.datetime(),
+});
+export type OrgInviteDto = z.infer<typeof OrgInviteDtoSchema>;
+
+export const CreateOrganizationCommandSchema = z.object({
+  name: z.string().min(1).max(80),
+});
+export type CreateOrganizationCommand = z.infer<typeof CreateOrganizationCommandSchema>;
+
+export const UpdateOrganizationCommandSchema = z.object({
+  name: z.string().min(1).max(80),
+});
+export type UpdateOrganizationCommand = z.infer<typeof UpdateOrganizationCommandSchema>;
+
+export const InviteMemberCommandSchema = z.object({
+  email: z.string().email(),
+  role: InviteOrgRoleSchema,
+});
+export type InviteMemberCommand = z.infer<typeof InviteMemberCommandSchema>;
+
+export const AcceptInviteCommandSchema = z.object({
+  token: z.string().min(16),
+  password: z.string().min(8).max(128).optional(),
+  displayName: z.string().min(1).max(80).optional(),
+});
+export type AcceptInviteCommand = z.infer<typeof AcceptInviteCommandSchema>;
+
+export const AcceptedInviteDtoSchema = z.object({
+  accepted: z.literal(true),
+});
+export type AcceptedInviteDto = z.infer<typeof AcceptedInviteDtoSchema>;

package/templates/capabilities/team/packages/sdk/src/resources/organizations.ts

@@ -0,0 +1,53 @@
+import type {
+  AcceptInviteCommand,
+  CreateOrganizationCommand,
+  InviteMemberCommand,
+  MembershipDto,
+  OrganizationDto,
+  OrgInviteDto,
+  UpdateOrganizationCommand,
+} from '@ysk-kit/contracts';
+import type { HttpClient } from '../http';
+
+export const organizationsResource = (http: HttpClient) => ({
+  create: (body: CreateOrganizationCommand) =>
+    http.request<OrganizationDto>('/v1/organizations', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    }),
+  list: () => http.request<OrganizationDto[]>('/v1/organizations'),
+  get: (organizationId: string) =>
+    http.request<OrganizationDto>(`/v1/organizations/${organizationId}`),
+  update: (organizationId: string, body: UpdateOrganizationCommand) =>
+    http.request<OrganizationDto>(`/v1/organizations/${organizationId}`, {
+      method: 'PATCH',
+      body: JSON.stringify(body),
+    }),
+  members: (organizationId: string) =>
+    http.request<MembershipDto[]>(`/v1/organizations/${organizationId}/members`),
+  invite: (organizationId: string, body: InviteMemberCommand) =>
+    http.request<OrgInviteDto>(`/v1/organizations/${organizationId}/invites`, {
+      method: 'POST',
+      body: JSON.stringify(body),
+    }),
+  invites: (organizationId: string) =>
+    http.request<OrgInviteDto[]>(`/v1/organizations/${organizationId}/invites`),
+  revokeInvite: (organizationId: string, id: string) =>
+    http.request<{ removed: true }>(`/v1/organizations/${organizationId}/invites/${id}`, {
+      method: 'DELETE',
+    }),
+  removeMember: (organizationId: string, userId: string) =>
+    http.request<{ removed: true }>(`/v1/organizations/${organizationId}/members/${userId}`, {
+      method: 'DELETE',
+    }),
+  leave: (organizationId: string) =>
+    http.request<{ left: true }>(`/v1/organizations/${organizationId}/leave`, {
+      method: 'POST',
+      body: '{}',
+    }),
+  acceptInvite: (body: AcceptInviteCommand) =>
+    http.request<{ accepted: true }>('/v1/organizations/invites/accept', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    }),
+});

package/templates/capabilities/team/packages/web-sdk/src/organizations-hooks.ts

@@ -0,0 +1,80 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import type {
+  AcceptInviteCommand,
+  CreateOrganizationCommand,
+  InviteMemberCommand,
+} from '@ysk-kit/contracts';
+import type { YskClient } from '@ysk-kit/sdk';
+
+export const organizationsQueryKey = ['organizations'] as const;
+export const organizationQueryKey = (id: string) => ['organization', id] as const;
+
+export function createOrganizationHooks(client: YskClient) {
+  return {
+    useOrganizations: () =>
+      useQuery({
+        queryKey: organizationsQueryKey,
+        queryFn: () => client.organizations.list(),
+      }),
+    useOrganization: (id: string) =>
+      useQuery({
+        queryKey: organizationQueryKey(id),
+        queryFn: () => client.organizations.get(id),
+        enabled: id.length > 0,
+      }),
+    useOrganizationMembers: (id: string) =>
+      useQuery({
+        queryKey: [...organizationQueryKey(id), 'members'],
+        queryFn: () => client.organizations.members(id),
+        enabled: id.length > 0,
+      }),
+    useOrganizationInvites: (id: string, enabled = true) =>
+      useQuery({
+        queryKey: [...organizationQueryKey(id), 'invites'],
+        queryFn: () => client.organizations.invites(id),
+        enabled: id.length > 0 && enabled,
+        retry: false,
+      }),
+    useCreateOrganization: () => {
+      const qc = useQueryClient();
+      return useMutation({
+        mutationFn: (body: CreateOrganizationCommand) => client.organizations.create(body),
+        onSuccess: () => {
+          void qc.invalidateQueries({ queryKey: organizationsQueryKey });
+        },
+      });
+    },
+    useInviteMember: (organizationId: string) => {
+      const qc = useQueryClient();
+      return useMutation({
+        mutationFn: (body: InviteMemberCommand) =>
+          client.organizations.invite(organizationId, body),
+        onSuccess: () => {
+          void qc.invalidateQueries({ queryKey: organizationQueryKey(organizationId) });
+        },
+      });
+    },
+    useRemoveMember: (organizationId: string) => {
+      const qc = useQueryClient();
+      return useMutation({
+        mutationFn: (userId: string) => client.organizations.removeMember(organizationId, userId),
+        onSuccess: () => {
+          void qc.invalidateQueries({ queryKey: organizationQueryKey(organizationId) });
+        },
+      });
+    },
+    useLeaveOrganization: () => {
+      const qc = useQueryClient();
+      return useMutation({
+        mutationFn: (organizationId: string) => client.organizations.leave(organizationId),
+        onSuccess: () => {
+          void qc.invalidateQueries({ queryKey: organizationsQueryKey });
+        },
+      });
+    },
+    useAcceptInvite: () =>
+      useMutation({
+        mutationFn: (body: AcceptInviteCommand) => client.organizations.acceptInvite(body),
+      }),
+  };
+}

package/templates/module/api.ts.tmpl

@@ -0,0 +1,32 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  Create{{pascal}}CommandSchema,
+  Paginated{{pascal}}Schema,
+  {{pascal}}DtoSchema,
+} from '../dto/{{kebab}}';
+import { PageQuerySchema } from '../dto/user';
+import { ErrSchema, OkSchema } from '../errors/envelope';
+
+const c = initContract();
+
+export const {{camel}}Contract = c.router({
+  list: {
+    method: 'GET',
+    path: '/v1/{{kebab}}',
+    query: PageQuerySchema,
+    responses: { 200: OkSchema(Paginated{{pascal}}Schema), 401: ErrSchema },
+    summary: 'List my {{kebab}}',
+  },
+  create: {
+    method: 'POST',
+    path: '/v1/{{kebab}}',
+    body: Create{{pascal}}CommandSchema,
+    responses: {
+      201: OkSchema({{pascal}}DtoSchema),
+      401: ErrSchema,
+      422: ErrSchema,
+    },
+    summary: 'Create a {{kebab}} row',
+  },
+});

package/templates/module/application-service.ts.tmpl

@@ -0,0 +1,9 @@
+import type { Create{{pascal}}Command, PageQuery } from '@ysk-kit/contracts';
+import type { I{{pascal}}Repository } from '../domain/{{kebab}}-repository';
+
+export const create{{pascal}}Service = (repo: I{{pascal}}Repository) => ({
+  list: (authorId: string, query: PageQuery) => repo.listForAuthor(authorId, query),
+  create: (authorId: string, input: Create{{pascal}}Command) => repo.create(authorId, input),
+});
+
+export type {{pascal}}Service = ReturnType<typeof create{{pascal}}Service>;

package/templates/module/domain-repository.ts.tmpl

@@ -0,0 +1,15 @@
+import type { Create{{pascal}}Command, PageQuery, Paginated{{pascal}}, {{pascal}}Dto } from '@ysk-kit/contracts';
+
+export type {{pascal}}Record = {
+  id: string;
+  title: string;
+  body: string;
+  authorId: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+export interface I{{pascal}}Repository {
+  create(authorId: string, input: Create{{pascal}}Command): Promise<{{pascal}}Dto>;
+  listForAuthor(authorId: string, query: PageQuery): Promise<Paginated{{pascal}}>;
+}

package/templates/module/dto.ts.tmpl

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { PaginatedSchema } from './user';
+
+export const {{pascal}}DtoSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1).max(200),
+  body: z.string().max(8000),
+  authorId: z.string().uuid(),
+  createdAt: z.iso.datetime(),
+  updatedAt: z.iso.datetime(),
+});
+export type {{pascal}}Dto = z.infer<typeof {{pascal}}DtoSchema>;
+
+export const Paginated{{pascal}}Schema = PaginatedSchema({{pascal}}DtoSchema);
+export type Paginated{{pascal}} = z.infer<typeof Paginated{{pascal}}Schema>;
+
+export const Create{{pascal}}CommandSchema = z.object({
+  title: z.string().min(1).max(200),
+  body: z.string().max(8000).default(''),
+});
+export type Create{{pascal}}Command = z.infer<typeof Create{{pascal}}CommandSchema>;

package/templates/module/memory-repository.ts.tmpl

@@ -0,0 +1,36 @@
+import { slicePage } from '@ysk-kit/application';
+import type { {{pascal}}Dto } from '@ysk-kit/contracts';
+import type { I{{pascal}}Repository, {{pascal}}Record } from '../domain/{{kebab}}-repository';
+
+const toDto = (row: {{pascal}}Record): {{pascal}}Dto => ({
+  id: row.id,
+  title: row.title,
+  body: row.body,
+  authorId: row.authorId,
+  createdAt: row.createdAt.toISOString(),
+  updatedAt: row.updatedAt.toISOString(),
+});
+
+export const createMemory{{pascal}}Repository = (): I{{pascal}}Repository => {
+  const rows: {{pascal}}Record[] = [];
+  return {
+    async create(authorId, input) {
+      const now = new Date();
+      const row: {{pascal}}Record = {
+        id: crypto.randomUUID(),
+        title: input.title,
+        body: input.body,
+        authorId,
+        createdAt: now,
+        updatedAt: now,
+      };
+      rows.unshift(row);
+      return toDto(row);
+    },
+    async listForAuthor(authorId, query) {
+      const mine = rows.filter((row) => row.authorId === authorId);
+      const page = slicePage(mine, query.limit);
+      return { items: page.items.map(toDto), nextCursor: page.nextCursor };
+    },
+  };
+};

package/templates/module/model.prisma.tmpl

@@ -0,0 +1,8 @@
+model {{pascal}} {
+  id        String   @id @default(uuid())
+  title     String
+  body      String   @default("")
+  authorId  String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}