@ysk-kit/cli 1.0.0

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

@@ -0,0 +1,38 @@
+import { slicePage } from '@ysk-kit/application';
+import type { I{{pascal}}Repository } from '../domain/{{kebab}}-repository';
+import type { PrismaClient } from '../../../generated/prisma/client';
+
+const toDto = (row: {
+  id: string;
+  title: string;
+  body: string;
+  authorId: string;
+  createdAt: Date;
+  updatedAt: Date;
+}) => ({
+  id: row.id,
+  title: row.title,
+  body: row.body,
+  authorId: row.authorId,
+  createdAt: row.createdAt.toISOString(),
+  updatedAt: row.updatedAt.toISOString(),
+});
+
+export const createPrisma{{pascal}}Repository = (prisma: PrismaClient): I{{pascal}}Repository => ({
+  async create(authorId, input) {
+    const row = await prisma.{{camel}}.create({
+      data: { title: input.title, body: input.body, authorId },
+    });
+    return toDto(row);
+  },
+  async listForAuthor(authorId, query) {
+    const rows = await prisma.{{camel}}.findMany({
+      where: { authorId },
+      orderBy: { createdAt: 'desc' },
+      take: query.limit + 1,
+      ...(query.cursor ? { cursor: { id: query.cursor }, skip: 1 } : {}),
+    });
+    const page = slicePage(rows, query.limit);
+    return { items: page.items.map(toDto), nextCursor: page.nextCursor };
+  },
+});

package/templates/module/router.ts.tmpl

@@ -0,0 +1,32 @@
+import { type HttpHandler, mountContract } from '@ysk-kit/api-express';
+import { appContract, type Create{{pascal}}Command, type PageQuery } from '@ysk-kit/contracts';
+import { AppError } from '@ysk-kit/domain-kernel';
+import type { Express } from 'express';
+import type { {{pascal}}Service } from '../application/{{kebab}}-service';
+
+export const {{camel}}Handlers = (service: {{pascal}}Service): Record<string, HttpHandler> => ({
+  list: {
+    auth: 'required',
+    handle: async ({ query, auth }) => {
+      if (!auth) throw new AppError('UNAUTHENTICATED');
+      return {
+        status: 200,
+        body: { ok: true, data: await service.list(auth.sub, query as PageQuery) },
+      };
+    },
+  },
+  create: {
+    auth: 'required',
+    handle: async ({ body, auth }) => {
+      if (!auth) throw new AppError('UNAUTHENTICATED');
+      return {
+        status: 201,
+        body: { ok: true, data: await service.create(auth.sub, body as Create{{pascal}}Command) },
+      };
+    },
+  },
+});
+
+export const register{{pascal}}Routes = (app: Express, service: {{pascal}}Service): void => {
+  mountContract(app, appContract.{{camel}}, {{camel}}Handlers(service));
+};

package/templates/module/sdk-resource.ts.tmpl

@@ -0,0 +1,17 @@
+import type { Create{{pascal}}Command, Paginated{{pascal}}, {{pascal}}Dto } from '@ysk-kit/contracts';
+import type { HttpClient } from '../http';
+
+const toQuery = (query?: { cursor?: string; limit?: number }): string => {
+  const params = new URLSearchParams();
+  if (query?.cursor) params.set('cursor', query.cursor);
+  if (query?.limit) params.set('limit', String(query.limit));
+  const encoded = params.toString();
+  return encoded.length > 0 ? `?${encoded}` : '';
+};
+
+export const {{camel}}Resource = (http: HttpClient) => ({
+  list: (query?: { cursor?: string; limit?: number }) =>
+    http.request<Paginated{{pascal}}>(`/v1/{{kebab}}${toQuery(query)}`),
+  create: (body: Create{{pascal}}Command) =>
+    http.request<{{pascal}}Dto>('/v1/{{kebab}}', { method: 'POST', body: JSON.stringify(body) }),
+});

package/templates/module/service.test.ts.tmpl

@@ -0,0 +1,33 @@
+import request from 'supertest';
+import { describe, expect, it } from 'vitest';
+import { createApp } from '../../../app';
+import { createMemoryInput } from '../../../create-memory-input';
+import { create{{pascal}}Service } from '../application/{{kebab}}-service';
+import { createMemory{{pascal}}Repository } from './memory-{{kebab}}-repository';
+
+describe('{{kebab}} service', () => {
+  it('creates and lists rows for the author', async () => {
+    const service = create{{pascal}}Service(createMemory{{pascal}}Repository());
+    const created = await service.create('11111111-1111-1111-1111-111111111111', {
+      title: 'Hello',
+      body: 'World',
+    });
+    expect(created.title).toBe('Hello');
+    expect(created.body).toBe('World');
+    const page = await service.list('11111111-1111-1111-1111-111111111111', { limit: 20 });
+    expect(page.items).toHaveLength(1);
+    expect(page.items[0]?.id).toBe(created.id);
+    const other = await service.list('22222222-2222-2222-2222-222222222222', { limit: 20 });
+    expect(other.items).toHaveLength(0);
+  });
+});
+
+describe('{{kebab}} HTTP', () => {
+  it('returns UNAUTHENTICATED without a session', async () => {
+    const mem = createMemoryInput();
+    const app = createApp(mem.input);
+    const res = await request(app).post('/v1/{{kebab}}').send({ title: 'Hello', body: 'World' });
+    expect(res.status).toBe(401);
+    expect(res.body).toMatchObject({ ok: false, error: { code: 'UNAUTHENTICATED' } });
+  });
+});

package/templates/module/web-hooks.ts.tmpl

@@ -0,0 +1,24 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import type { Create{{pascal}}Command } from '@ysk-kit/contracts';
+import type { YskClient } from '@ysk-kit/sdk';
+
+export const {{camel}}QueryKey = ['{{kebab}}'] as const;
+
+export function create{{pascal}}Hooks(client: YskClient) {
+  return {
+    useList: (query?: { cursor?: string; limit?: number }) =>
+      useQuery({
+        queryKey: [...{{camel}}QueryKey, query],
+        queryFn: () => client.{{camel}}.list(query),
+      }),
+    useCreate: () => {
+      const qc = useQueryClient();
+      return useMutation({
+        mutationFn: (body: Create{{pascal}}Command) => client.{{camel}}.create(body),
+        onSuccess: () => {
+          void qc.invalidateQueries({ queryKey: {{camel}}QueryKey });
+        },
+      });
+    },
+  };
+}

package/templates/module/web-page.tsx.tmpl

@@ -0,0 +1,69 @@
+import { Create{{pascal}}CommandSchema } from '@ysk-kit/contracts';
+import { Button, Input, Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@ysk-kit/ui';
+import { create{{pascal}}Hooks } from '@ysk-kit/web-sdk';
+import { type FormEvent, useState } from 'react';
+import { api } from '../../lib/client';
+
+const hooks = create{{pascal}}Hooks(api);
+
+export function {{pascal}}Page() {
+  const list = hooks.useList();
+  const create = hooks.useCreate();
+  const [title, setTitle] = useState('');
+  const [body, setBody] = useState('');
+  const [formError, setFormError] = useState<string | null>(null);
+
+  const onSubmit = (event: FormEvent) => {
+    event.preventDefault();
+    const parsed = Create{{pascal}}CommandSchema.safeParse({ title, body });
+    if (!parsed.success) {
+      setFormError(parsed.error.issues[0]?.message ?? 'Invalid');
+      return;
+    }
+    create.mutate(parsed.data, {
+      onSuccess: () => {
+        setTitle('');
+        setBody('');
+        setFormError(null);
+      },
+      onError: (error) => setFormError(error.message),
+    });
+  };
+
+  return (
+    <section className="space-y-4">
+      <h1 className="text-2xl font-semibold">{{pascal}}</h1>
+      {list.error ? <p className="text-sm text-red-600">{list.error.message}</p> : null}
+      {formError ? <p className="text-sm text-red-600">{formError}</p> : null}
+      <form onSubmit={onSubmit} className="grid max-w-md gap-3">
+        <label className="grid gap-1 text-sm" htmlFor="{{kebab}}-title">
+          Title
+          <Input id="{{kebab}}-title" value={title} onChange={(e) => setTitle(e.target.value)} required />
+        </label>
+        <label className="grid gap-1 text-sm" htmlFor="{{kebab}}-body">
+          Body
+          <Input id="{{kebab}}-body" value={body} onChange={(e) => setBody(e.target.value)} />
+        </label>
+        <Button type="submit" disabled={create.isPending}>
+          Create
+        </Button>
+      </form>
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Title</TableHead>
+            <TableHead>Body</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {(list.data?.items ?? []).map((item) => (
+            <TableRow key={item.id}>
+              <TableCell>{item.title}</TableCell>
+              <TableCell>{item.body}</TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </section>
+  );
+}