@vertz/create-vertz-app 0.2.1 → 0.2.5

package/dist/templates/index.js

@@ -1,115 +1,89 @@
+// ── Config file templates ──────────────────────────────────
 /**
- * Package.json template
+ * Package.json template — full-stack deps + #generated imports map
  */
-export function packageJsonTemplate({ projectName, runtime, }) {
-    const deps = {
-        '@vertz/core': '^0.1.0',
-        '@vertz/schema': '^0.1.0',
-        envsafe: '^2.0.3',
-    };
-    const devDeps = {
-        '@vertz/cli': '^0.1.0',
-        typescript: '^5.9.3',
-    };
-    // Add runtime-specific type dependencies
-    if (runtime === 'bun') {
-        devDeps['bun-types'] = '^1.0.0';
-    }
-    else if (runtime === 'node') {
-        devDeps['@types/node'] = '^20.0.0';
-    }
-    // deno: no additional types needed (built-in)
-    const scripts = {};
-    if (runtime === 'bun') {
-        scripts.dev = 'bun run src/main.ts';
-        scripts.build = 'vertz build';
-        scripts.check = 'vertz check';
-    }
-    else if (runtime === 'node') {
-        deps.tsx = '^4.19.0';
-        scripts.dev = 'tsx watch src/main.ts';
-        scripts.build = 'vertz build';
-        scripts.check = 'vertz check';
-    }
-    else if (runtime === 'deno') {
-        scripts.dev = 'deno run --watch src/main.ts';
-        scripts.build = 'vertz build';
-        scripts.check = 'deno check src/main.ts';
-    }
-    scripts.start = scripts.dev;
+export function packageJsonTemplate(projectName) {
     const pkg = {
         name: projectName,
         version: '0.1.0',
         type: 'module',
         license: 'MIT',
-        scripts,
-        dependencies: deps,
-        devDependencies: devDeps,
+        scripts: {
+            dev: 'vertz dev',
+            build: 'vertz build',
+            codegen: 'vertz codegen',
+        },
+        imports: {
+            '#generated': './.vertz/generated/client.ts',
+            '#generated/types': './.vertz/generated/types/index.ts',
+        },
+        dependencies: {
+            '@vertz/db': '^0.2.0',
+            '@vertz/server': '^0.2.0',
+            '@vertz/theme-shadcn': '^0.2.0',
+            '@vertz/ui': '^0.2.0',
+        },
+        devDependencies: {
+            '@vertz/cli': '^0.2.0',
+            '@vertz/ui-compiler': '^0.2.0',
+            'bun-types': '^1.0.0',
+            typescript: '^5.8.0',
+        },
     };
     return JSON.stringify(pkg, null, 2);
 }
 /**
- * Tsconfig.json template - runtime-specific types
+ * Tsconfig.json template — JSX config for @vertz/ui
  */
-export function tsconfigTemplate(runtime) {
-    let types = [];
-    if (runtime === 'bun') {
-        types = ['bun-types'];
-    }
-    else if (runtime === 'node') {
-        types = ['node'];
-    }
-    // deno: types = [] (deno has built-in types)
+export function tsconfigTemplate() {
     const tsconfig = {
         compilerOptions: {
-            target: 'ES2022',
+            declaration: true,
+            esModuleInterop: true,
+            jsx: 'react-jsx',
+            jsxImportSource: '@vertz/ui',
             module: 'ESNext',
-            lib: ['ES2022'],
             moduleResolution: 'bundler',
-            strict: true,
-            esModuleInterop: true,
+            outDir: 'dist',
+            rootDir: 'src',
             skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-            resolveJsonModule: true,
-            allowJs: true,
-            outDir: './dist',
-            rootDir: './src',
-            types,
+            strict: true,
+            target: 'ES2022',
+            types: ['bun-types'],
         },
-        include: ['src/**/*'],
-        exclude: ['node_modules', 'dist'],
+        include: ['src'],
     };
     return JSON.stringify(tsconfig, null, 2);
 }
 /**
- * vertz.config.ts template
+ * vertz.config.ts template — compiler entry + codegen config
  */
 export function vertzConfigTemplate() {
-    return `import { defineConfig } from '@vertz/core';
+    return `/** @type {import('@vertz/compiler').VertzConfig} */
+export default {
+  compiler: {
+    entryFile: 'src/api/server.ts',
+  },
+};
 
-export default defineConfig({
-  entry: './src/app.ts',
-});
+/** @type {import('@vertz/codegen').CodegenConfig} */
+export const codegen = {
+  generators: ['typescript'],
+};
 `;
 }
 /**
  * .env template
  */
 export function envTemplate() {
-    return `# Database connection string
-DATABASE_URL=
-
-# Add more environment variables below
+    return `PORT=3000
 `;
 }
 /**
  * .env.example template
  */
 export function envExampleTemplate() {
-    return `# Database connection string (leave blank in development)
-DATABASE_URL=
-
-# Add more environment variables below
+    return `PORT=3000
 `;
 }
 /**
@@ -118,16 +92,19 @@ DATABASE_URL=
 export function gitignoreTemplate() {
     return `# Dependencies
 node_modules/
-.pnp/
-.pnp.js
 
 # Build outputs
 dist/
 .vertz/
+
+# Environment
 .env
 .env.local
 .env.*.local
 
+# Database
+*.db
+
 # IDE
 .idea/
 .vscode/
@@ -140,179 +117,281 @@ Thumbs.db
 
 # Logs
 *.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Test coverage
-coverage/
 `;
 }
+// ── Source file templates ───────────────────────────────────
 /**
- * src/env.ts template
+ * src/api/server.ts — createServer with entities + db
  */
-export function envSrcTemplate() {
-    return `import { envsafe, str, port } from 'envsafe';
+export function serverTemplate() {
+    return `import { createServer } from '@vertz/server';
+import { db } from './db';
+import { tasks } from './entities/tasks.entity';
 
-export const env = envsafe({
-  DATABASE_URL: str({
-    default: '',
-    allowEmpty: true,
-  }),
-  PORT: port({
-    default: 3000,
-  }),
+const app = createServer({
+  basePath: '/api',
+  entities: [tasks],
+  db,
 });
+
+export default app;
+
+if (import.meta.main) {
+  const PORT = Number(process.env.PORT) || 3000;
+  app.listen(PORT).then((handle) => {
+    console.log(\`Server running at http://localhost:\${handle.port}/api\`);
+  });
+}
 `;
 }
 /**
- * src/app.ts template
+ * src/api/schema.ts — tasks table + model
  */
-export function appTemplate(includeExample) {
-    const imports = includeExample
-        ? `import { vertz } from '@vertz/core';
-import { healthModule } from './modules/health.module.js';`
-        : `import { vertz } from '@vertz/core';`;
-    const registerModules = includeExample
-        ? `
-  .register(healthModule)`
-        : '';
-    return `${imports}
+export function schemaTemplate() {
+    return `import { d } from '@vertz/db';
 
-const app = vertz
-  .app({ basePath: '/api' })${registerModules};
+export const tasksTable = d.table('tasks', {
+  id: d.uuid().primary({ generate: 'uuid' }),
+  title: d.text(),
+  completed: d.boolean().default(false),
+  createdAt: d.timestamp().default('now').readOnly(),
+  updatedAt: d.timestamp().autoUpdate().readOnly(),
+});
 
-export { app };
+export const tasksModel = d.model(tasksTable);
 `;
 }
 /**
- * src/main.ts template
+ * src/api/db.ts — createSqliteAdapter with autoApply migrations
  */
-export function mainTemplate() {
-    return `import { app } from './app.js';
-import { env } from './env.js';
+export function dbTemplate() {
+    return `import { createSqliteAdapter } from '@vertz/db/sqlite';
+import { tasksTable } from './schema';
 
-app.listen(env.PORT).then((handle) => {
-  console.log(\`✓ Server running at http://localhost:\${handle.port}/api\`);
+export const db = await createSqliteAdapter({
+  schema: tasksTable,
+  migrations: { autoApply: true },
 });
 `;
 }
 /**
- * src/middlewares/request-id.middleware.ts template
+ * src/api/entities/tasks.entity.ts — entity with CRUD access
  */
-export function requestIdMiddlewareTemplate() {
-    return `import type { Middleware } from '@vertz/server';
-import { randomUUID } from 'crypto';
+export function tasksEntityTemplate() {
+    return `import { entity } from '@vertz/server';
+import { tasksModel } from '../schema';
 
-export const requestIdMiddleware: Middleware = {
-  name: 'requestId',
-  handler: async (req, context, next) => {
-    const requestId = req.headers.get('x-request-id') || randomUUID();
-    
-    context.set('requestId', requestId);
-    
-    const response = await next();
-    
-    response.headers.set('x-request-id', requestId);
-    
-    return response;
+export const tasks = entity('tasks', {
+  model: tasksModel,
+  access: {
+    list: () => true,
+    get: () => true,
+    create: () => true,
+    update: () => true,
+    delete: () => true,
   },
-};
+});
 `;
 }
 /**
- * src/modules/health.module-def.ts template
+ * src/client.ts — #generated imports + type re-export
  */
-export function healthModuleDefTemplate() {
-    return `import { vertz } from '@vertz/core';
+export function clientTemplate() {
+    return `import { createClient } from '#generated';
+
+export type * from '#generated/types';
 
-export const healthDef = vertz.moduleDef({ name: 'health' });
+export const api = createClient();
 `;
 }
 /**
- * src/modules/health.module.ts template
+ * src/app.tsx — SSR module exports + ThemeProvider + render HomePage
  */
-export function healthModuleTemplate() {
-    return `import { vertz } from '@vertz/core';
-import { healthDef } from './health.module-def.js';
-import { healthRouter } from './health.router.js';
-import { healthService } from './health.service.js';
+export function appComponentTemplate() {
+    return `import { css, getInjectedCSS, globalCss, ThemeProvider } from '@vertz/ui';
+import { HomePage } from './pages/home';
+import { appTheme, themeGlobals } from './styles/theme';
 
-export const healthModule = vertz.module(healthDef, {
-  services: [healthService],
-  routers: [healthRouter],
+const appGlobals = globalCss({
+  a: {
+    textDecoration: 'none',
+    color: 'inherit',
+  },
 });
+
+const styles = css({
+  shell: ['min-h:screen', 'bg:background', 'text:foreground'],
+  header: [
+    'flex',
+    'items:center',
+    'justify:between',
+    'px:6',
+    'py:4',
+    'border-b:1',
+    'border:border',
+  ],
+  title: ['font:lg', 'font:bold', 'text:foreground'],
+  main: ['max-w:2xl', 'mx:auto', 'px:6', 'py:8'],
+});
+
+export { getInjectedCSS };
+export const theme = appTheme;
+export const globalStyles = [themeGlobals.css, appGlobals.css];
+
+export function App() {
+  return (
+    <div data-testid="app-root">
+      <ThemeProvider theme="light">
+        <div class={styles.shell}>
+          <header class={styles.header}>
+            <div class={styles.title}>My Vertz App</div>
+          </header>
+          <main class={styles.main}>
+            <HomePage />
+          </main>
+        </div>
+      </ThemeProvider>
+    </div>
+  );
+}
 `;
 }
 /**
- * src/modules/health.service.ts template
+ * src/entry-client.ts — mount + HMR self-accept
  */
-export function healthServiceTemplate() {
-    return `import { healthDef } from './health.module-def.js';
+export function entryClientTemplate() {
+    return `import { mount } from '@vertz/ui';
+import { App, globalStyles, theme } from './app';
+
+import.meta.hot.accept();
 
-export const healthService = healthDef.service({
-  methods: () => ({
-    check: () => ({
-      status: 'ok',
-      timestamp: new Date().toISOString(),
-    }),
-  }),
+mount(App, '#app', {
+  theme,
+  styles: globalStyles,
 });
 `;
 }
 /**
- * src/modules/health.router.ts template
+ * src/styles/theme.ts — configureTheme from @vertz/theme-shadcn
  */
-export function healthRouterTemplate() {
-    return `import { s } from '@vertz/schema';
-import { healthDef } from './health.module-def.js';
-import { healthService } from './health.service.js';
+export function themeTemplate() {
+    return `import { configureTheme } from '@vertz/theme-shadcn';
 
-const HealthResponseSchema = s.object({
-  status: s.string(),
-  timestamp: s.string(),
+const { theme, globals } = configureTheme({
+  palette: 'zinc',
+  radius: 'md',
 });
 
-export const healthRouter = healthDef
-  .router({ prefix: '/health', inject: { healthService } })
-  .get('/', {
-    response: HealthResponseSchema,
-    handler: (ctx) => ctx.healthService.check(),
-  })
-  .get('/ready', {
-    response: s.object({ ready: s.boolean() }),
-    handler: () => ({ ready: true }),
-  });
+export const appTheme = theme;
+export const themeGlobals = globals;
 `;
 }
 /**
- * src/modules/schemas/health-check.schema.ts template
+ * src/pages/home.tsx — task list + create form with query + css
  */
-export function healthCheckSchemaTemplate() {
-    return `import { s } from '@vertz/schema';
+export function homePageTemplate() {
+    return `import { css, query, queryMatch } from '@vertz/ui';
+import { api } from '../client';
 
-export const HealthCheckSchema = s.object({
-  status: s.string(),
-  timestamp: s.string(),
+const pageStyles = css({
+  container: ['py:2', 'w:full'],
+  heading: ['font:xl', 'font:bold', 'text:foreground', 'mb:4'],
+  form: ['flex', 'gap:2', 'mb:6'],
+  input: [
+    'flex-1',
+    'px:3',
+    'py:2',
+    'rounded:md',
+    'border:1',
+    'border:border',
+    'bg:background',
+    'text:foreground',
+  ],
+  button: [
+    'px:4',
+    'py:2',
+    'rounded:md',
+    'bg:primary.600',
+    'text:white',
+    'font:medium',
+    'cursor:pointer',
+  ],
+  list: ['flex', 'flex-col', 'gap:2'],
+  item: [
+    'flex',
+    'items:center',
+    'gap:3',
+    'px:4',
+    'py:3',
+    'rounded:md',
+    'border:1',
+    'border:border',
+    'bg:card',
+  ],
+  loading: ['text:muted-foreground'],
+  error: ['text:destructive'],
+  empty: ['text:muted-foreground', 'text:center', 'py:8'],
 });
-`;
+
+export function HomePage() {
+  const tasksQuery = query(api.tasks.list());
+
+  const handleSubmit = async (e: SubmitEvent) => {
+    e.preventDefault();
+    const form = e.target as HTMLFormElement;
+    const data = new FormData(form);
+    const title = data.get('title') as string;
+    if (!title.trim()) return;
+
+    await api.tasks.create({ title });
+    form.reset();
+    tasksQuery.refetch();
+  };
+
+  return (
+    <div class={pageStyles.container} data-testid="home-page">
+      <h1 class={pageStyles.heading}>Tasks</h1>
+
+      <form class={pageStyles.form} onSubmit={handleSubmit}>
+        <input
+          name="title"
+          class={pageStyles.input}
+          placeholder="What needs to be done?"
+          required
+        />
+        <button type="submit" class={pageStyles.button}>
+          Add
+        </button>
+      </form>
+
+      {queryMatch(tasksQuery, {
+        loading: () => (
+          <div class={pageStyles.loading}>Loading tasks...</div>
+        ),
+        error: (err) => (
+          <div class={pageStyles.error}>
+            {err instanceof Error ? err.message : String(err)}
+          </div>
+        ),
+        data: (response) => (
+          <>
+            {response.items.length === 0 && (
+              <div class={pageStyles.empty}>
+                No tasks yet. Add one above!
+              </div>
+            )}
+            <div data-testid="task-list" class={pageStyles.list}>
+              {response.items.map((task) => (
+                <div key={task.id} class={pageStyles.item}>
+                  <span>{task.title}</span>
+                </div>
+              ))}
+            </div>
+          </>
+        ),
+      })}
+    </div>
+  );
 }
-/**
- * deno.json template for Deno runtime
- */
-export function denoConfigTemplate() {
-    const config = {
-        imports: {
-            '@vertz/server': 'jsr:@vertz/server@^0.1.0',
-            '@vertz/schema': 'jsr:@vertz/schema@^0.1.0',
-        },
-        tasks: {
-            dev: 'deno run --watch src/main.ts',
-            check: 'deno check src/main.ts',
-        },
-        compilerOptions: {
-            strict: true,
-        },
-    };
-    return JSON.stringify(config, null, 2);
+`;
 }

package/dist/types.d.ts

@@ -1,17 +1,9 @@
-/**
- * Runtime options for the scaffolded project
- */
-export type Runtime = 'bun' | 'node' | 'deno';
 /**
  * Options for the scaffold function
  */
 export interface ScaffoldOptions {
     /** Name of the project to create */
     projectName: string;
-    /** Target runtime (bun, node, or deno) */
-    runtime: Runtime;
-    /** Whether to include example health module */
-    includeExample: boolean;
 }
 /**
  * CLI options parsed from command line flags
@@ -19,9 +11,5 @@ export interface ScaffoldOptions {
 export interface CliOptions {
     /** Project name (positional argument or --name) */
     projectName?: string;
-    /** Target runtime */
-    runtime?: Runtime;
-    /** Whether to include example module */
-    includeExample?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,+CAA+C;IAC/C,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,wCAAwC;IACxC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/create-vertz-app",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "type": "module",
   "license": "MIT",
   "description": "Create a new Vertz application",