schematic-pg 0.1.7 → 0.1.10

package/dist/cli/hooks.js

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { select } from '@inquirer/prompts';
+import { discoverHooks } from '../api-generator/hook-scanner.js';
+import { PACKAGE_NAME } from '../constants.js';
+import { parse } from '../schema-dsl/index.js';
+import { DEFAULT_HOOKS_DIR, resolveSchemaPath } from './paths.js';
+import { createHookFileTemplate } from './templates.js';
+function parseModelFlag(args) {
+    const modelIndex = args.indexOf('--model');
+    if (modelIndex === -1) {
+        return undefined;
+    }
+    const modelName = args[modelIndex + 1];
+    if (!modelName || modelName.startsWith('--')) {
+        throw new Error('Missing value for --model');
+    }
+    return modelName;
+}
+function resolveSchemaArg(args) {
+    const positional = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--model') {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+        }
+    }
+    return positional[0];
+}
+function getHookFilePath(hooksDir, modelName) {
+    return path.join(hooksDir, `${modelName}.ts`);
+}
+function assertModelExists(schema, modelName) {
+    const model = schema.models.find((entry) => entry.name === modelName);
+    if (!model) {
+        throw new Error(`Model "${modelName}" was not found in schema`);
+    }
+    return model;
+}
+function assertHookFileDoesNotExist(hooksDir, modelName) {
+    const hookFilePath = getHookFilePath(hooksDir, modelName);
+    if (existsSync(hookFilePath)) {
+        throw new Error(`Hook file already exists: ${hookFilePath}`);
+    }
+}
+async function promptForModel(models, hooksDir, schema) {
+    const { modelsWithHooks } = discoverHooks(hooksDir, schema);
+    const availableModels = models
+        .map((model) => model.name)
+        .filter((modelName) => !modelsWithHooks.has(modelName))
+        .sort((left, right) => left.localeCompare(right));
+    if (availableModels.length === 0) {
+        throw new Error('All schema models already have hook files in src/hooks/');
+    }
+    return select({
+        message: 'Select a model to scaffold lifecycle hooks',
+        choices: availableModels.map((modelName) => ({
+            name: modelName,
+            value: modelName,
+        })),
+    });
+}
+export async function runHooksAdd(args, options = {}) {
+    const schemaPath = resolveSchemaPath(options.schemaPath ?? resolveSchemaArg(args));
+    const hooksDir = options.hooksDir ?? DEFAULT_HOOKS_DIR;
+    const source = await readFile(schemaPath, 'utf8');
+    const schema = parse(source);
+    if (schema.models.length === 0) {
+        throw new Error('Schema has no models');
+    }
+    const modelName = options.modelName ?? parseModelFlag(args) ?? (await promptForModel(schema.models, hooksDir, schema));
+    assertModelExists(schema, modelName);
+    assertHookFileDoesNotExist(hooksDir, modelName);
+    await mkdir(hooksDir, { recursive: true });
+    const hookFilePath = getHookFilePath(hooksDir, modelName);
+    await writeFile(hookFilePath, createHookFileTemplate(modelName), 'utf8');
+    console.log(`Created ${path.relative(process.cwd(), hookFilePath)}`);
+    console.log(`\nNext step: run \`${PACKAGE_NAME} generate:api\` to wire hooks into generated routes.`);
+    return hookFilePath;
+}

package/dist/cli/init.js

@@ -3,8 +3,9 @@ import { PACKAGE_NAME } from '../constants.js';
 import { existsSync } from 'node:fs';
 import { mkdir, readdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { APP_SCHEMA_TEMPLATE, createPackageJsonTemplate, DOCKER_COMPOSE_TEMPLATE, ENV_TEMPLATE, GITIGNORE_TEMPLATE, HEALTH_ROUTE_TEMPLATE, MAKEFILE_TEMPLATE, TSCONFIG_TEMPLATE, } from './templates.js';
+import { AGENTS_TEMPLATE, APP_SCHEMA_TEMPLATE, AUTH_ROUTE_TEMPLATE, createPackageJsonTemplate, DOCKER_COMPOSE_TEMPLATE, ENV_TEMPLATE, GITIGNORE_TEMPLATE, HEALTH_ROUTE_TEMPLATE, MAKEFILE_TEMPLATE, TSCONFIG_TEMPLATE, } from './templates.js';
 const INIT_FILES = [
+    { relativePath: 'AGENTS.md', content: AGENTS_TEMPLATE },
     { relativePath: 'app.schema', content: APP_SCHEMA_TEMPLATE },
     { relativePath: '.env', content: ENV_TEMPLATE },
     { relativePath: '.gitignore', content: GITIGNORE_TEMPLATE },
@@ -12,6 +13,7 @@ const INIT_FILES = [
     { relativePath: 'Makefile', content: MAKEFILE_TEMPLATE },
     { relativePath: 'tsconfig.json', content: TSCONFIG_TEMPLATE },
     { relativePath: 'src/routes/health.ts', content: HEALTH_ROUTE_TEMPLATE },
+    { relativePath: 'src/routes/auth.ts', content: AUTH_ROUTE_TEMPLATE },
 ];
 function resolveTargetDir(args) {
     const targetArg = args.find((arg) => !arg.startsWith('--'));
@@ -66,6 +68,7 @@ export async function runInit(args) {
     }
     await mkdir(targetDir, { recursive: true });
     await mkdir(path.join(targetDir, 'src/routes'), { recursive: true });
+    await mkdir(path.join(targetDir, 'src/hooks'), { recursive: true });
     for (const file of INIT_FILES) {
         const filePath = path.join(targetDir, file.relativePath);
         if (existsSync(filePath)) {
@@ -108,7 +111,11 @@ export async function runInit(args) {
     console.log('  docker compose up -d --wait');
     console.log(`  npx ${PACKAGE_NAME} dev   # generate + bootstrap + server + schema watch`);
     console.log('');
-    console.log('  # split steps (dev already includes generate, bootstrap, and watch):');
+    console.log('  # production:');
+    console.log(`  npx ${PACKAGE_NAME} generate`);
+    console.log(`  npx ${PACKAGE_NAME} start   # migrate DB + run server`);
+    console.log('');
+    console.log('  # split dev steps (dev already includes generate, bootstrap, and watch):');
     console.log(`  npx ${PACKAGE_NAME} generate`);
     console.log(`  npx ${PACKAGE_NAME} db:bootstrap`);
     console.log(`  npx ${PACKAGE_NAME} dev --no-watch`);

package/dist/cli/paths.d.ts

@@ -1,5 +1,6 @@
 export declare const DEFAULT_SCHEMA_FILE = "app.schema";
 export declare const DEFAULT_OUTPUT_DIR = "generated";
 export declare const DEFAULT_CUSTOM_ROUTES_DIR: string;
+export declare const DEFAULT_HOOKS_DIR: string;
 export declare function resolveSchemaPath(schemaArg?: string): string;
 export declare function resolveOutputDir(): string;

package/dist/cli/paths.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 export const DEFAULT_SCHEMA_FILE = 'app.schema';
 export const DEFAULT_OUTPUT_DIR = 'generated';
 export const DEFAULT_CUSTOM_ROUTES_DIR = path.resolve('src/routes');
+export const DEFAULT_HOOKS_DIR = path.resolve('src/hooks');
 export function resolveSchemaPath(schemaArg) {
     return path.resolve(schemaArg ?? DEFAULT_SCHEMA_FILE);
 }

package/dist/cli/server.d.ts

@@ -0,0 +1,5 @@
+import { type ChildProcess } from 'node:child_process';
+export declare function startAppServer(appPath: string, env?: NodeJS.ProcessEnv): ChildProcess;
+export declare function stopAppServer(serverProcess: ChildProcess | null): Promise<void>;
+export declare function waitForAppServerExit(serverProcess: ChildProcess): Promise<void>;
+export declare function runAppServerUntilExit(appPath: string, env?: NodeJS.ProcessEnv): Promise<number | null>;

package/dist/cli/server.js

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process';
+const SERVER_STOP_TIMEOUT_MS = 5000;
+export function startAppServer(appPath, env) {
+    return spawn(process.execPath, ['--import', 'tsx', appPath], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        env: env ? { ...process.env, ...env } : process.env,
+    });
+}
+export function stopAppServer(serverProcess) {
+    if (!serverProcess || serverProcess.exitCode !== null || serverProcess.killed) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        serverProcess.once('exit', () => resolve());
+        if (process.platform === 'win32') {
+            serverProcess.kill();
+        }
+        else {
+            serverProcess.kill('SIGTERM');
+        }
+        setTimeout(() => {
+            if (serverProcess.exitCode === null && !serverProcess.killed) {
+                serverProcess.kill('SIGKILL');
+            }
+        }, SERVER_STOP_TIMEOUT_MS);
+    });
+}
+export function waitForAppServerExit(serverProcess) {
+    return new Promise((resolve) => {
+        serverProcess.once('exit', () => resolve());
+    });
+}
+export async function runAppServerUntilExit(appPath, env) {
+    let serverProcess = null;
+    let shuttingDown = false;
+    async function shutdown() {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        await stopAppServer(serverProcess);
+    }
+    process.once('SIGINT', () => {
+        void shutdown().finally(() => {
+            process.exit(process.exitCode ?? 0);
+        });
+    });
+    process.once('SIGTERM', () => {
+        void shutdown().finally(() => {
+            process.exit(process.exitCode ?? 0);
+        });
+    });
+    serverProcess = startAppServer(appPath, env);
+    return new Promise((resolve) => {
+        serverProcess.once('exit', (code) => {
+            resolve(code);
+        });
+    });
+}

package/dist/cli/start.d.ts

@@ -0,0 +1,7 @@
+type StartOptions = {
+    schemaPath: string;
+    migrate: boolean;
+};
+export declare function parseStartArgs(args: string[]): StartOptions;
+export declare function runStart(args?: string[]): Promise<void>;
+export {};

package/dist/cli/start.js

@@ -0,0 +1,35 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { runDbMigrate } from './db.js';
+import { DEFAULT_OUTPUT_DIR, resolveSchemaPath } from './paths.js';
+import { runAppServerUntilExit } from './server.js';
+import { waitForDatabase } from './wait-for-database.js';
+export function parseStartArgs(args) {
+    let schemaPath = resolveSchemaPath();
+    let migrate = true;
+    for (const arg of args) {
+        if (arg === '--no-migrate') {
+            migrate = false;
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            schemaPath = resolveSchemaPath(arg);
+        }
+    }
+    return { schemaPath, migrate };
+}
+export async function runStart(args = []) {
+    const { schemaPath, migrate } = parseStartArgs(args);
+    const appPath = path.resolve(DEFAULT_OUTPUT_DIR, 'app.ts');
+    if (!existsSync(appPath)) {
+        throw new Error(`Missing ${appPath}. Run "schematic-pg generate" first to create the app entry point.`);
+    }
+    await waitForDatabase();
+    if (migrate) {
+        await runDbMigrate([schemaPath]);
+    }
+    const exitCode = await runAppServerUntilExit(appPath, { NODE_ENV: 'production' });
+    if (exitCode !== 0 && exitCode !== null) {
+        process.exitCode = exitCode;
+    }
+}

package/dist/cli/templates/agents.md

@@ -0,0 +1,290 @@
+# schematic-pg Agent Guide
+
+Instructions for AI agents working in a schematic-pg project.
+
+## Overview
+
+schematic-pg is a single-file backend framework for PostgreSQL and Node.js. **`app.schema` is the single source of truth** — it drives SQL DDL, the type-safe DB client, REST API routes, Zod validators, and ACL policies.
+
+- One declarative schema file replaces scattered migrations, ORM models, and route handlers.
+- Generated code uses parameterized raw SQL (no ORM).
+- Framework runtime lives in `node_modules/schematic-pg` — it is not copied into your project.
+
+## Golden Rules
+
+1. **Never edit `generated/`** — it is overwritten on every `generate` / `dev` run.
+2. **Regenerate after changes** to `app.schema`, `src/routes/`, or `src/hooks/` (`schematic-pg generate` or `schematic-pg dev`).
+3. **Edit `app.schema`** for models, relations, policies, indexes, and triggers.
+4. **Use extension points** for app-specific logic: `src/routes/` (custom HTTP) and `src/hooks/` (lifecycle hooks).
+5. **Do not hand-write SQL** for CRUD — use the generated DB client or REST API.
+
+## Project Layout
+
+```
+my-app/
+├── app.schema              # Source of truth — edit this
+├── schema.sql              # Generated PostgreSQL DDL (read-only)
+├── AGENTS.md               # This file
+├── .env                    # DATABASE_URL, JWT_* settings
+├── docker-compose.yml      # Local PostgreSQL
+├── generated/              # Generated — do not edit
+│   ├── db.ts               # createDbClient(pool)
+│   ├── db-types.ts         # Model interfaces
+│   ├── app.ts              # Hono server entry point
+│   ├── routes/*.ts         # CRUD routers per model
+│   ├── policies.ts         # ACL from @policy
+│   └── schemas/validation.ts
+└── src/
+    ├── routes/             # Custom Hono routers (hand-written)
+    └── hooks/              # Lifecycle hooks (hand-written)
+```
+
+## Dev Workflow
+
+```bash
+make dev
+# or:
+docker compose up -d --wait
+npx schematic-pg dev
+```
+
+`dev` runs: generate → db:bootstrap → start server → watch `app.schema`.
+
+**Environment variables** (`.env`):
+
+| Variable | Purpose |
+|----------|---------|
+| `DATABASE_URL` | PostgreSQL connection string (required) |
+| `PORT` | HTTP port (default `3000`) |
+| `JWT_SECRET` | HMAC secret for Bearer JWT auth |
+| `JWT_ROLE_CLAIM` | JWT claim for role (default `role`) |
+| `JWT_USER_ID_CLAIM` | JWT claim for user id (default `sub`) |
+
+## Schema DSL Essentials
+
+```ts
+extensions { pgcrypto; uuid-ossp }
+
+enums {
+  UserRole { ADMIN, USER, PUBLIC }
+}
+
+models {
+  model User {
+    id:    UUID @id @default(gen_random_uuid())
+    email: VARCHAR(255) @unique
+    role:  UserRole @default(USER)
+
+    orders: Order[]
+
+    @policy(role: USER, allow: [select, update], where: "id = {{auth.user.id}}")
+    @policy(role: ADMIN, allow: all)
+
+    @@index(fields: [role])
+  }
+
+  model Order {
+    userId: UUID
+    user:   User @relation(fields: [userId], references: [id])
+  }
+}
+```
+
+**Key concepts:**
+
+- **Relations:** Put `@relation(fields: [...], references: [...])` on the FK-owning side. The inverse side is inferred.
+- **Policies:** `@policy(role: ..., allow: [select|insert|update|delete|all], where: "...")` — `where` supports `{{auth.user.id}}`.
+- **Validation:** `@regex(...)`, `@range(min: ..., max: ...)` flow into generated Zod schemas.
+- **Indexes / triggers:** `@@index(...)`, `@@trigger { timing, event, level, execute: """...""" }`.
+
+## Database Client
+
+Generated by `schematic-pg generate:client` (or `generate` / `dev`). Prisma-like API over parameterized SQL.
+
+**Key files:** `generated/db.ts`, `generated/db-types.ts` (do not edit).
+
+### How to Get `db`
+
+| Context | Access |
+|---------|--------|
+| Standalone script / test | `createDbClient(pool)` |
+| Custom route (`src/routes/*.ts`) | `c.get('db')` |
+| Lifecycle hook (`src/hooks/{Model}.ts`) | `ctx.db` |
+
+```typescript
+import { Pool } from 'pg';
+import { createDbClient } from './generated/db.js';
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+const db = createDbClient(pool);
+```
+
+**Model naming:** `User` → `db.user`, `ProductOrder` → `db.productOrder`. API fields are camelCase; SQL columns are snake_case (automatic mapping).
+
+### Per-Model Methods
+
+| Method | Notes |
+|--------|-------|
+| `create(data)` | Returns inserted row |
+| `findUnique(where, opts?)` | Single row by PK/unique; supports `include` |
+| `findFirst({ where, orderBy, include, … })` | First match |
+| `findMany({ where, orderBy, take, skip, include, … })` | List + pagination |
+| `count({ where })` | No `include` |
+| `update({ where, data })` | Returns updated row |
+| `updateMany({ where, data })` | Returns `{ count }` |
+| `delete(where)` / `deleteMany({ where })` | Returns deleted row(s) or count |
+
+### Basic Querying
+
+```typescript
+// Create
+await db.user.create({ email: 'a@b.com', name: 'Alice' });
+
+// Read
+await db.user.findUnique({ id });
+await db.user.findFirst({ where: { role: 'ADMIN' }, orderBy: { createdAt: 'desc' } });
+await db.user.findMany({ where: { isActive: true }, take: 10, skip: 0 });
+await db.user.count({ where: { role: 'ADMIN' } });
+
+// Update / delete
+await db.user.update({ where: { id }, data: { name: 'Bob' } });
+await db.user.delete({ id });
+```
+
+### Where Filters
+
+- Shorthand equality: `{ email: 'a@b.com' }`
+- Operators: `equals`, `contains`, `startsWith`, `endsWith`, `gt`, `gte`, `lt`, `lte`, `in`
+- Logical groups: `AND`, `OR`, `NOT`
+
+```typescript
+await db.user.findMany({
+  where: {
+    AND: [{ role: { in: ['ADMIN', 'USER'] } }, { isActive: true }],
+    NOT: { email: { contains: 'spam' } },
+  },
+});
+```
+
+### Eager Loading (`include`)
+
+Available on `findUnique`, `findFirst`, `findMany` — not on `count`. Use relation **field names** from the schema (`profile`, `orders`).
+
+```typescript
+await db.user.findMany({
+  include: {
+    profile: true,
+    orders: {
+      where: { status: 'PENDING' },
+      orderBy: { createdAt: 'desc' },
+      take: 5,
+      include: { products: { include: { product: true } } },
+    },
+  },
+});
+```
+
+Default strategy is split queries (avoids cartesian explosion). Pass `relationLoadStrategy: 'join'` for fewer round trips.
+
+### Types
+
+Import from `generated/db-types.js`: `{Model}`, `{Model}CreateInput`, `{Model}UpdateInput`, `{Model}WhereInput`, `{Model}Include`.
+
+- Fields with `@default` / auto-generated `@id` are optional on create input.
+- `DECIMAL` maps to `string`; optional fields are `T | null`.
+
+### Errors
+
+```typescript
+import { UniqueConstraintError } from 'schematic-pg/db/errors';
+
+try {
+  await db.user.create({ email: 'taken@b.com', name: 'X' });
+} catch (error) {
+  if (error instanceof UniqueConstraintError) {
+    console.log(error.fields); // ['email']
+  }
+}
+```
+
+Also available: `ForeignKeyConstraintError`, `DatabaseError`.
+
+### DB Access Rules
+
+- Prefer `ctx.db` / `c.get('db')` in routes and hooks — do not create ad-hoc pools.
+- Run `generate` (or `dev`) after schema changes before querying new models or fields.
+- Use generated `{Model}WhereInput` types — do not hand-build SQL strings.
+- Use `ctx.db` in `afterCreate` / `afterUpdate` / `afterDelete` for side effects (audit logs, related rows).
+
+## Extension Points
+
+### Custom Routes (`src/routes/`)
+
+| Rule | Example |
+|------|---------|
+| Location | `src/routes/**/*.ts` |
+| Export | `export default router` (`Hono<AppEnv>`) |
+| Mount path | File path relative to `src/routes/` |
+
+`src/routes/health.ts` → `GET /health`. Regenerate after adding files.
+
+```typescript
+import { Hono } from 'hono';
+import type { AppEnv } from 'schematic-pg/api/types';
+
+const router = new Hono<AppEnv>();
+
+router.get('/me', async (c) => {
+  const db = c.get('db');
+  const auth = c.get('auth');
+  // ...
+});
+
+export default router;
+```
+
+### Lifecycle Hooks (`src/hooks/`)
+
+| Rule | Example |
+|------|---------|
+| Location | `src/hooks/{Model}.ts` (PascalCase) |
+| Export | `export default defineHooks(...)` |
+| Scaffold | `schematic-pg hooks:add --model User` |
+
+Flow: `validate → assertPolicy → beforeHooks → db op → afterHooks → response`.
+
+- `await next()` to proceed; `return ctx.abort(status, msg)` to cancel.
+- `ctx.data` — mutable create/update payload (before hooks).
+- `ctx.result` — DB row (after hooks).
+- `ctx.db`, `ctx.auth` — available in all hooks.
+
+## CLI Cheat Sheet
+
+```bash
+schematic-pg generate              # schema.sql + db client + API
+schematic-pg dev [--no-watch]      # generate + bootstrap + server + watch
+schematic-pg start [--no-migrate]  # production: migrate + run server
+schematic-pg db:bootstrap            # first-time DDL apply
+schematic-pg db:diff [--name label]  # print or write migration
+schematic-pg db:migrate              # apply pending migrations
+schematic-pg hooks:add [--model X]   # scaffold src/hooks/{Model}.ts
+```
+
+## Auth & ACL
+
+- Models **without** `@policy` are open (no ACL checks).
+- Unauthenticated requests default to `{ role: 'PUBLIC' }`.
+- `@policy` `allow` maps to HTTP: GET→select, POST→insert, PUT→update, DELETE→delete.
+- Row-level `where` is injected on read/update/delete; POST checks permission only.
+
+## Generated Outputs (Read-Only)
+
+| Output | Purpose |
+|--------|---------|
+| `schema.sql` | Idempotent PostgreSQL DDL |
+| `generated/db.ts` | `createDbClient(pool)` |
+| `generated/db-types.ts` | TypeScript interfaces |
+| `generated/app.ts` | Hono server entry point |
+| `generated/routes/*.ts` | CRUD routers |
+| `generated/policies.ts` | ACL metadata |
+| `generated/schemas/validation.ts` | Zod validators |

package/dist/cli/templates.d.ts

@@ -1,8 +1,11 @@
-export declare const APP_SCHEMA_TEMPLATE = "extensions {\n\n}\n\nenums {\n\n}\n\nmodels {\n  model User {\n    id:        UUID        @id @default(gen_random_uuid())\n    email:     VARCHAR(255) @unique\n    name:      VARCHAR(150)\n    createdAt: TIMESTAMP   @default(now())\n  }\n}\n";
-export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\n";
+export declare const AGENTS_TEMPLATE: string;
+export declare const APP_SCHEMA_TEMPLATE = "extensions {\n\n}\n\nenums {\n  UserRole { ADMIN, USER }\n}\n\nmodels {\n  model User {\n    id:           UUID         @id @default(gen_random_uuid())\n    email:        VARCHAR(255) @unique\n    name:         VARCHAR(150)?\n    role:         UserRole     @default(USER)\n    passwordHash: VARCHAR(255)? @omit @unfilterable\n    createdAt:    TIMESTAMP    @default(now())\n\n    @policy(role: USER, allow: [select, update], where: \"id = {{auth.user.id}}\")\n    @policy(role: ADMIN, allow: all)\n  }\n}\n";
+export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nAUTH_PEPPER=\nAUTH_ACCESS_TOKEN_TTL=1h\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\n";
 export declare const GITIGNORE_TEMPLATE = "node_modules/\ndist/\n.env\ndocker_data/\n.DS_Store\n*.log\nnpm-debug.log*\n";
-export declare const DOCKER_COMPOSE_TEMPLATE = "services:\n  postgres:\n    image: postgis/postgis:16-3.4\n    container_name: schematic-pg\n    restart: unless-stopped\n    ports:\n      - \"5432:5432\"\n    environment:\n      POSTGRES_USER: postgrest\n      POSTGRES_PASSWORD: postgrest\n      POSTGRES_DB: postgrest\n    volumes:\n      - ./docker_data/postgres:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U postgrest -d postgrest\"]\n      interval: 5s\n      timeout: 5s\n      retries: 5\n";
+export declare const DOCKER_COMPOSE_TEMPLATE = "services:\n  postgres:\n    image: postgres:18.4-bookworm\n    container_name: schematic-pg\n    restart: unless-stopped\n    ports:\n      - \"5432:5432\"\n    environment:\n      POSTGRES_USER: postgrest\n      POSTGRES_PASSWORD: postgrest\n      POSTGRES_DB: postgrest\n    volumes:\n      - ./docker_data/postgres:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U postgrest -d postgrest\"]\n      interval: 5s\n      timeout: 5s\n      retries: 5\n";
 export declare const TSCONFIG_TEMPLATE = "{\n  \"compilerOptions\": {\n    \"target\": \"ES2022\",\n    \"module\": \"NodeNext\",\n    \"moduleResolution\": \"NodeNext\",\n    \"strict\": true,\n    \"esModuleInterop\": true,\n    \"skipLibCheck\": true,\n    \"outDir\": \"dist\",\n    \"rootDir\": \".\"\n  },\n  \"include\": [\"generated/**/*\", \"src/**/*\"]\n}\n";
 export declare const MAKEFILE_TEMPLATE = ".PHONY: dev\n\ndev:\n\tdocker compose up -d --wait\n\tnpx schematic-pg dev\n";
 export declare const HEALTH_ROUTE_TEMPLATE = "import { Hono } from 'hono';\nimport type { AppEnv } from 'schematic-pg/api/types';\n\nconst router = new Hono<AppEnv>();\nrouter.get('/', (c) => c.json({ ok: true }));\nexport default router;\n";
+export declare const AUTH_ROUTE_TEMPLATE = "import { createAuthRouter } from 'schematic-pg/api/auth/routes';\n\nexport default createAuthRouter();\n";
 export declare function createPackageJsonTemplate(projectName: string): string;
+export declare function createHookFileTemplate(modelName: string): string;

package/dist/cli/templates.js

@@ -1,23 +1,35 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
 import { PACKAGE_NAME, PACKAGE_VERSION } from '../constants.js';
+const templatesDir = path.dirname(fileURLToPath(import.meta.url));
+export const AGENTS_TEMPLATE = readFileSync(path.join(templatesDir, 'templates', 'agents.md'), 'utf8');
 export const APP_SCHEMA_TEMPLATE = `extensions {
 
 }
 
 enums {
-
+  UserRole { ADMIN, USER }
 }
 
 models {
   model User {
-    id:        UUID        @id @default(gen_random_uuid())
-    email:     VARCHAR(255) @unique
-    name:      VARCHAR(150)
-    createdAt: TIMESTAMP   @default(now())
+    id:           UUID         @id @default(gen_random_uuid())
+    email:        VARCHAR(255) @unique
+    name:         VARCHAR(150)?
+    role:         UserRole     @default(USER)
+    passwordHash: VARCHAR(255)? @omit @unfilterable
+    createdAt:    TIMESTAMP    @default(now())
+
+    @policy(role: USER, allow: [select, update], where: "id = {{auth.user.id}}")
+    @policy(role: ADMIN, allow: all)
   }
 }
 `;
 export const ENV_TEMPLATE = `DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest
 JWT_SECRET=
+AUTH_PEPPER=
+AUTH_ACCESS_TOKEN_TTL=1h
 JWT_ROLE_CLAIM=role
 JWT_USER_ID_CLAIM=sub
 `;
@@ -31,7 +43,7 @@ npm-debug.log*
 `;
 export const DOCKER_COMPOSE_TEMPLATE = `services:
   postgres:
-    image: postgis/postgis:16-3.4
+    image: postgres:18.4-bookworm
     container_name: schematic-pg
     restart: unless-stopped
     ports:
@@ -75,6 +87,10 @@ const router = new Hono<AppEnv>();
 router.get('/', (c) => c.json({ ok: true }));
 export default router;
 `;
+export const AUTH_ROUTE_TEMPLATE = `import { createAuthRouter } from '${PACKAGE_NAME}/api/auth/routes';
+
+export default createAuthRouter();
+`;
 export function createPackageJsonTemplate(projectName) {
     return JSON.stringify({
         name: projectName,
@@ -83,6 +99,7 @@ export function createPackageJsonTemplate(projectName) {
         type: 'module',
         scripts: {
             dev: `${PACKAGE_NAME} dev`,
+            start: `${PACKAGE_NAME} start`,
             generate: `${PACKAGE_NAME} generate`,
             'db:bootstrap': `${PACKAGE_NAME} db:bootstrap`,
             'db:migrate': `${PACKAGE_NAME} db:migrate`,
@@ -101,3 +118,38 @@ export function createPackageJsonTemplate(projectName) {
         },
     }, null, 2);
 }
+export function createHookFileTemplate(modelName) {
+    return `import { defineHooks } from '${PACKAGE_NAME}/api/hooks';
+import type { ${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput } from '../../generated/db-types.js';
+
+export default defineHooks<${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput>({
+  async beforeCreate(ctx, next) {
+    // ctx.data is the create payload (mutable). Call await next() to proceed.
+    // Cancel without calling next(): return ctx.abort(422, 'reason');
+    await next();
+  },
+
+  async afterCreate(ctx) {
+    // ctx.result is the created row. Use ctx.db / ctx.auth for side effects.
+  },
+
+  async beforeUpdate(ctx, next) {
+    // ctx.params — route params (e.g. id). ctx.data — update payload (mutable).
+    await next();
+  },
+
+  async afterUpdate(ctx) {
+    // ctx.result is the updated row.
+  },
+
+  async beforeDelete(ctx, next) {
+    // ctx.params — route params. No ctx.data on delete.
+    await next();
+  },
+
+  async afterDelete(ctx) {
+    // ctx.result is the deleted row.
+  },
+});
+`;
+}

package/dist/cli/wait-for-database.js

@@ -8,7 +8,7 @@ export async function pingDatabase(client) {
 }
 export async function waitForDatabase(options = {}) {
     const maxAttempts = options.maxAttempts ?? 30;
-    const intervalMs = options.intervalMs ?? 1000;
+    const intervalMs = options.intervalMs ?? 3000;
     const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const ownClient = options.client ? null : new DatabaseClient();
     const client = options.client ?? ownClient;