@b9g/zen 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.3] - 2025-12-22
+
+### Added
+
+- Validation that compound constraints (`indexes`, `unique`, `references` options) have 2+ fields
+  - Single-field constraints now throw `TableDefinitionError` with helpful message pointing to field-level API
+
+### Fixed
+
+- **TypeScript types now work in published package** - Updated libuild to fix module augmentation and `.d.ts` path resolution
+
+### Changed
+
+- New tagline: "Define Zod tables. Write raw SQL. Get typed objects."
+
+### Documentation
+
+- Added `.db.inserted()`, `.db.updated()`, `.db.upserted()` documentation with examples
+- Added compound unique constraints example
+- Fixed table naming consistency (all plural)
+- Various README cleanups and improvements
+
+## [0.1.2] - 2025-12-22
+
+### Added
+
+- New type exports: `PartialTable`, `DerivedTable`, `SetValues`, `FieldDBMeta`, `ReferenceInfo`, `CompoundReference`, `TaggedQuery`, `SQLDialect`, `isTable`
+- Views documentation section in README
+- `EnsureError` and `SchemaDriftError` documented in error types
+
+### Changed
+
+- Reorganized `zen.ts` exports into logical groups
+- README Types section now accurately reflects actual exports (removed non-existent `SQLFragment`, `DDLFragment`, `DBExpression`)
+
+### Fixed
+
+- `isTable` type guard now exported (was missing)
+
 ## [0.1.1] - 2025-12-21
 
 ### Added

package/README.md

@@ -1,9 +1,8 @@
 # ZenDB
-The simple database client.
 
-Define tables. Write SQL. Get objects.
+Define Zod tables. Write raw SQL. Get typed objects.
 
-Cultivate your data.
+[Website](https://zendb.org) · [GitHub](https://github.com/bikeshaving/zen) · [npm](https://www.npmjs.com/package/@b9g/zen)
 
 ## Installation
 
@@ -48,7 +47,7 @@ import SQLiteDriver from "@b9g/zen/sqlite";
 const driver = new SQLiteDriver("file:app.db");
 
 // 1. Define tables
-const Users = table("users", {
+let Users = table("users", {
   id: z.string().uuid().db.primary().db.auto(),
   email: z.string().email().db.unique(),
   name: z.string(),
@@ -58,7 +57,7 @@ const Posts = table("posts", {
   id: z.string().uuid().db.primary().db.auto(),
   authorId: z.string().uuid().db.references(Users, "author"),
   title: z.string(),
-  published: z.boolean().default(false),
+  published: z.boolean().db.inserted(() => false),
 });
 
 // 2. Create database with migrations
@@ -74,14 +73,14 @@ db.addEventListener("upgradeneeded", (e) => {
     }
     if (e.oldVersion < 2) {
       // Evolve schema: add avatar column (safe, additive)
-      const UsersV2 = table("users", {
+      Users = table("users", {
         id: z.string().uuid().db.primary().db.auto(),
         email: z.string().email().db.unique(),
         name: z.string(),
-        avatar: z.string().optional(),
+        avatar: z.string().optional(), // new field
       });
-      await db.ensureTable(UsersV2);          // adds missing columns/indexes
-      await db.ensureConstraints(UsersV2);    // applies new constraints on existing data
+      await db.ensureTable(Users); // adds missing columns/indexes
+      await db.ensureConstraints(Users); // applies new constraints on existing data
     }
   })());
 });
@@ -111,6 +110,23 @@ const post = await db.get(Posts, posts[0].id);
 await db.update(Users, {name: "Alice Smith"}, user.id);
 ```
 
+## Why Zen?
+
+Zen is the missing link between SQL and typed data. By writing tables with Zod schema, you get idempotent migration helpers, typed CRUD, normalized object references, and many features other database clients cannot provide.
+
+### What Zen is not:
+- **Zen is not a query builder** — Rather than building SQL with fluent chains `.where().orderBy().limit()`, you write it directly with templates: `` db.all(Posts)`WHERE published = ${true} ORDER BY created_at DESC LIMIT 20` `` Helper functions help you write the tedious parts of SQL without hiding it or limiting your queries.
+- **Zen is not an ORM** — Tables are not classes. They are Zod-powered singletons which provide schema-aware utilities. These tables can be used to validate writes, generate DDL, and deduplicate joined data.
+- **Zen is not a startup** — Zen is an open-source library, not a venture-backed SaaS. There will never be a managed “ZenDB” instance or a “Zen Studio.” The library is a thin wrapper around Zod and JavaScript SQL drivers, with a focus on runtime abstractions rather than complicated tooling.
+
+### Safety
+
+- **No lazy loading** — Related data comes from your JOINs
+- **No ORM identity map** — Normalization is per-query, not session-wide
+- **No down migrations** — Forward-only versioning (1 → 2 → 3)
+- **No destructive helpers** — No `dropColumn()`, `dropTable()`, `renameColumn()`
+- **No automatic migrations** — Schema changes are explicit in upgrade events
+
 ## Table Definitions
 
 ```typescript
@@ -121,7 +137,7 @@ const Users = table("users", {
   id: z.string().uuid().db.primary().db.auto(),
   email: z.string().email().db.unique(),
   name: z.string().max(100),
-  role: z.enum(["user", "admin"]).default("user"),
+  role: z.enum(["user", "admin"]).db.inserted(() => "user"),
   createdAt: z.date().db.auto(),
 });
 
@@ -130,10 +146,23 @@ const Posts = table("posts", {
   title: z.string(),
   content: z.string().optional(),
   authorId: z.string().uuid().db.references(Users, "author", {onDelete: "cascade"}),
-  published: z.boolean().default(false),
+  published: z.boolean().db.inserted(() => false),
 });
 ```
 
+**Zod to Database Behavior:**
+
+| Zod Method | Effect |
+|------------|--------|
+| `.optional()` | Column allows `NULL`; field omittable on insert |
+| `.nullable()` | Column allows `NULL`; must explicitly pass `null` or value |
+| `.string().max(n)` | `VARCHAR(n)` in DDL (if n ≤ 255) |
+| `.string().uuid()` | Used by `.db.auto()` to generate UUIDs |
+| `.number().int()` | `INTEGER` column type |
+| `.date()` | `TIMESTAMPTZ` / `DATETIME` / `TEXT` depending on dialect |
+| `.object()` / `.array()` | Stored as JSON, auto-encoded/decoded |
+| `.default()` | **Throws error** — use `.db.inserted()` instead |
+
 **The `.db` namespace:**
 
 The `.db` property is available on all Zod types imported from `@b9g/zen`. It provides database-specific modifiers:
@@ -176,10 +205,37 @@ const Users = table("users", {
 
 // id and createdAt are optional - auto-generated if not provided
 const user = await db.insert(Users, {name: "Alice"});
-user.id;        // "550e8400-e29b-41d4-a716-446655440000"
+user.id; // "550e8400-e29b-41d4-a716-446655440000"
 user.createdAt; // 2024-01-15T10:30:00.000Z
 ```
 
+**Default values with `.db.inserted()`, `.db.updated()`, `.db.upserted()`:**
+
+These methods set default values for write operations. They accept JS functions or SQL builtins (`NOW`, `TODAY`, `CURRENT_TIMESTAMP`, `CURRENT_DATE`, `CURRENT_TIME`):
+
+```typescript
+import {z, table, NOW} from "@b9g/zen";
+
+const Posts = table("posts", {
+  id: z.string().uuid().db.primary().db.auto(),
+  title: z.string(),
+  // JS function — runs client-side
+  slug: z.string().db.inserted(() => generateSlug()),
+  // SQL builtin — runs database-side
+  createdAt: z.date().db.inserted(NOW),
+  updatedAt: z.date().db.upserted(NOW),  // set on insert AND update
+  viewCount: z.number().db.inserted(() => 0).db.updated(() => 0), // reset on update
+});
+```
+
+| Method | When applied | Field becomes optional for |
+|--------|--------------|---------------------------|
+| `.db.inserted(value)` | INSERT only | insert |
+| `.db.updated(value)` | UPDATE only | update |
+| `.db.upserted(value)` | INSERT and UPDATE | insert and update |
+
+**Why not Zod's `.default()`?** Zod's `.default()` applies at *parse time*, not *write time*. This means defaults would be applied when reading data, not when inserting. Zen throws an error if you use `.default()` — use `.db.inserted()` instead.
+
 **Automatic JSON encoding/decoding:**
 
 Objects (`z.object()`) and arrays (`z.array()`) are automatically serialized to JSON when stored and parsed back when read:
@@ -200,7 +256,7 @@ const settings = await db.insert(Settings, {
 
 // On read: JSON strings are parsed back to objects/arrays
 settings.config.theme; // "dark" (object, not string)
-settings.tags[0];      // "admin" (array, not string)
+settings.tags[0]; // "admin" (array, not string)
 ```
 
 **Custom encoding/decoding:**
@@ -208,7 +264,7 @@ settings.tags[0];      // "admin" (array, not string)
 Override automatic JSON encoding with custom transformations:
 
 ```typescript
-const Custom = table("custom", {
+const Articles = table("articles", {
   id: z.string().db.primary(),
   // Store array as CSV instead of JSON
   tags: z.array(z.string())
@@ -217,8 +273,8 @@ const Custom = table("custom", {
     .db.type("TEXT"), // Required: explicit column type for DDL
 });
 
-await db.insert(Custom, {id: "c1", tags: ["a", "b", "c"]});
-// Stored as: tags='a,b,c' (not '["a","b","c"]')
+await db.insert(Articles, {id: "a1", tags: ["news", "tech", "featured"]});
+// Stored as: tags='news,tech,featured' (not '["news","tech","featured"]')
 ```
 
 **Explicit column types:**
@@ -263,14 +319,38 @@ const posts = await db.all([Posts, Users.active])`
 `;
 ```
 
-**Compound indexes** via table options:
+**Compound indexes and unique constraints** via table options:
 ```typescript
 const Posts = table("posts", {
   id: z.string().db.primary(),
   authorId: z.string(),
+  slug: z.string(),
   createdAt: z.date(),
 }, {
   indexes: [["authorId", "createdAt"]],
+  unique: [["authorId", "slug"]],  // unique together
+});
+```
+
+**Compound foreign keys** for composite primary keys:
+```typescript
+const OrderProducts = table("order_products", {
+  orderId: z.string().uuid(),
+  productId: z.string().uuid(),
+  // ... compound primary key
+});
+
+const OrderItems = table("order_items", {
+  id: z.string().uuid().db.primary(),
+  orderId: z.string().uuid(),
+  productId: z.string().uuid(),
+  quantity: z.number(),
+}, {
+  references: [{
+    fields: ["orderId", "productId"],
+    table: OrderProducts,
+    as: "orderProduct",
+  }],
 });
 ```
 
@@ -286,39 +366,94 @@ const Posts = table("posts", {
   derive: {
     // Pure functions only (no I/O, no side effects)
     titleUpper: (post) => post.title.toUpperCase(),
-    tags: (post) => post.postTags?.map(pt => pt.tag) ?? [],
+    // Traverse relationships (requires JOIN in query)
+    tags: (post) => post.postTags?.map(pt => pt.tag?.name) ?? [],
   }
 });
 
-const posts = await db.all([Posts, Users])`
-  JOIN "users" ON ${Users.on(Posts)}
+type Post = Row<typeof Posts>;
+// Post includes: id, title, authorId, titleUpper, tags
+
+const posts = await db.all([Posts, Users, PostTags, Tags])`
+  JOIN ${Users} ON ${Users.on(Posts)}
+  LEFT JOIN ${PostTags} ON ${PostTags.cols.postId} = ${Posts.cols.id}
+  LEFT JOIN ${Tags} ON ${Tags.on(PostTags)}
 `;
 
-type PostWithDerived = Row<typeof Posts> & {titleUpper: string; tags: string[]};
-const post = posts[0] as PostWithDerived;
-post.titleUpper;  // ✅ "HELLO WORLD"
-Object.keys(post);  // ["id", "title", "authorId", "author"] (no "titleUpper")
-JSON.stringify(post);  // ✅ Excludes derived properties (non-enumerable)
+const post = posts[0];
+post.titleUpper;  // "HELLO WORLD" — typed as string
+post.tags; // ["javascript", "typescript"] — traverses relationships
+Object.keys(post); // ["id", "title", "authorId", "author"] (no derived props)
+JSON.stringify(post); // Excludes derived properties (non-enumerable)
 ```
 
 Derived properties:
 - Are lazy getters (computed on access, not stored)
 - Are non-enumerable (hidden from `Object.keys()` and `JSON.stringify()`)
 - Must be pure functions (no I/O, no database queries)
-- Only transform data already in the entity
-- Are NOT part of TypeScript type inference
+- Can traverse resolved relationships from the same query
+- Are fully typed via `Row<T>` inference
 
 **Partial selects** with `pick()`:
 ```typescript
-const UserSummary = Users.pick("id", "name");
-const posts = await db.all([Posts, UserSummary])`
-  JOIN "users" ON ${UserSummary.on(Posts)}
+const UserSummaries = Users.pick("id", "name");
+const posts = await db.all([Posts, UserSummaries])`
+  JOIN ${UserSummaries} ON ${UserSummaries.on(Posts)}
 `;
 // posts[0].author has only id and name
 ```
 
 **Table identity**: A table definition is a singleton value which is passed to database methods for validation, normalization, schema management, and convenient CRUD operations. It is not a class.
 
+## Views
+
+Views are read-only projections of tables with predefined WHERE clauses:
+
+```typescript
+import {z, table, view} from "@b9g/zen";
+
+const Users = table("users", {
+  id: z.string().db.primary(),
+  name: z.string(),
+  role: z.enum(["user", "admin"]),
+  deletedAt: z.date().nullable().db.softDelete(),
+});
+
+// Define views with explicit names
+const ActiveUsers = view("active_users", Users)`
+  WHERE ${Users.cols.deletedAt} IS NULL
+`;
+
+const AdminUsers = view("admin_users", Users)`
+  WHERE ${Users.cols.role} = ${"admin"}
+`;
+
+// Query from views (same API as tables)
+const admins = await db.all(AdminUsers)``;
+const admin = await db.get(AdminUsers, "u1");
+
+// Views are read-only — mutations throw errors
+await db.insert(AdminUsers, {...});  // ✗ Error
+await db.update(AdminUsers, {...});  // ✗ Error
+await db.delete(AdminUsers, "u1");   // ✗ Error
+```
+
+**Auto-generated `.active` view:** Tables with a `.db.softDelete()` field automatically get an `.active` view:
+
+```typescript
+// Equivalent to: view("users_active", Users)`WHERE deletedAt IS NULL`
+const activeUsers = await db.all(Users.active)``;
+```
+
+**Views preserve table relationships:** Views inherit references from their base table, so JOINs work identically:
+
+```typescript
+const posts = await db.all([Posts, AdminUsers])`
+  JOIN "admin_users" ON ${AdminUsers.on(Posts)}
+`;
+posts[0].author?.role; // "admin"
+```
+
 ## Queries
 
 Tagged templates with automatic parameterization:
@@ -355,6 +490,29 @@ await db.exec`CREATE INDEX idx_posts_author ON ${Posts}(${Posts.cols.authorId})`
 const count = await db.val<number>`SELECT COUNT(*) FROM ${Posts}`;
 ```
 
+## CRUD Helpers
+```typescript
+// Insert with Zod validation (uses RETURNING to get actual row)
+const user = await db.insert(Users, {
+  email: "alice@example.com",
+  name: "Alice",
+});
+// Returns actual row from DB, including auto-generated id and DB-computed defaults
+const userId = user.id;
+
+// Update by primary key (uses RETURNING)
+const updated = await db.update(Users, {name: "Bob"}, userId);
+
+// Delete by primary key
+await db.delete(Users, userId);
+
+// Soft delete (sets deletedAt timestamp, requires softDelete() field)
+await db.softDelete(Users, userId);
+```
+
+**RETURNING support:** `insert()` and `update()` use `RETURNING *` on SQLite and PostgreSQL to return the actual row from the database, including DB-computed defaults and triggers. MySQL falls back to a separate SELECT.
+
+
 ## Fragment Helpers
 
 Type-safe SQL fragments as methods on Table objects:
@@ -404,29 +562,6 @@ const posts = await db.all(Posts)`WHERE ${Posts.in("id", [])}`;
 // → WHERE 1 = 0
 ```
 
-## CRUD Helpers
-
-```typescript
-// Insert with Zod validation (uses RETURNING to get actual row)
-const user = await db.insert(Users, {
-  email: "alice@example.com",
-  name: "Alice",
-});
-// Returns actual row from DB, including auto-generated id and DB-computed defaults
-const userId = user.id;
-
-// Update by primary key (uses RETURNING)
-const updated = await db.update(Users, {name: "Bob"}, userId);
-
-// Delete by primary key
-await db.delete(Users, userId);
-
-// Soft delete (sets deletedAt timestamp, requires softDelete() field)
-await db.softDelete(Users, userId);
-```
-
-**RETURNING support:** `insert()` and `update()` use `RETURNING *` on SQLite and PostgreSQL to return the actual row from the database, including DB-computed defaults and triggers. MySQL falls back to a separate SELECT.
-
 ## Transactions
 
 ```typescript
@@ -492,7 +627,7 @@ zen provides idempotent helpers that encourage safe, additive-only migrations:
 const Posts = table("posts", {
   id: z.string().db.primary(),
   title: z.string(),
-  views: z.number().default(0), // NEW - add to schema
+  views: z.number().db.inserted(() => 0), // NEW - add to schema
 });
 
 if (e.oldVersion < 2) {
@@ -703,6 +838,7 @@ const refs = Posts.references();      // [{fieldName: "authorId", table: Users,
 - Tagged template queries are cached by template object identity (compiled once per call site)
 - Normalization cost is O(rows) with hash maps per table
 - Reference resolution is zero-cost after deduplication
+- Zod validation happens on writes, never on reads.
 
 ## Driver Interface
 
@@ -734,6 +870,8 @@ interface Driver {
 
 **Migration locking**: If the driver provides `withMigrationLock()`, migrations run atomically (PostgreSQL uses advisory locks, MySQL uses `GET_LOCK`, SQLite uses exclusive transactions).
 
+**Connection pooling**: Handled by the underlying driver. `postgres.js` and `mysql2` pool automatically; `better-sqlite3` uses a single connection (SQLite is single-writer anyway).
+
 ## Error Handling
 
 All errors extend `DatabaseError` with typed error codes:
@@ -783,6 +921,8 @@ await db.transaction(async (tx) => {
 - `AlreadyExistsError` — Unique constraint violated (tableName, field, value)
 - `QueryError` — SQL execution failed (sql)
 - `MigrationError` / `MigrationLockError` — Migration failures (fromVersion, toVersion)
+- `EnsureError` — Schema ensure operation failed (operation, table, step)
+- `SchemaDriftError` — Existing schema doesn't match definition (table, drift)
 - `ConnectionError` / `TransactionError` — Connection/transaction issues
 
 ## Debugging
@@ -851,40 +991,41 @@ Override with `.db.type("CUSTOM")` when using custom encode/decode.
 ```typescript
 import {
   // Zod (extended with .db namespace)
-  z,                  // Re-exported Zod with .db already available
+  z,                        // Re-exported Zod with .db already available
+  extendZod,                // Extend a separate Zod instance (advanced)
 
-  // Table definition
-  table,              // Create a table definition from Zod schema
-  isTable,            // Type guard for Table objects
-  extendZod,          // Extend a separate Zod instance (advanced)
+  // Table and view definition
+  table,                    // Create a table definition from Zod schema
+  view,                     // Create a read-only view from a table
+  isTable,                  // Type guard for Table objects
+  isView,                   // Type guard for View objects
 
   // Database
-  Database,           // Main database class
-  Transaction,        // Transaction context (passed to transaction callbacks)
-  DatabaseUpgradeEvent, // Event object for "upgradeneeded" handler
+  Database,                 // Main database class
+  Transaction,              // Transaction context (passed to transaction callbacks)
+  DatabaseUpgradeEvent,     // Event object for "upgradeneeded" handler
 
-  // DB expressions
-  db,                 // Runtime DB expressions (db.now(), db.json(), etc.)
-  isDBExpression,     // Type guard for DBExpression objects
-
-  // Custom field helpers
-  setDBMeta,          // Set database metadata on a Zod schema
-  getDBMeta,          // Get database metadata from a Zod schema
+  // SQL builtins (for .db.inserted() / .db.updated())
+  NOW,                      // CURRENT_TIMESTAMP alias
+  TODAY,                    // CURRENT_DATE alias
+  CURRENT_TIMESTAMP,        // SQL CURRENT_TIMESTAMP
+  CURRENT_DATE,             // SQL CURRENT_DATE
+  CURRENT_TIME,             // SQL CURRENT_TIME
 
   // Errors
-  DatabaseError,        // Base error class
-  ValidationError,    // Schema validation failed
-  TableDefinitionError, // Invalid table definition
-  MigrationError,     // Migration failed
-  MigrationLockError, // Failed to acquire migration lock
-  QueryError,         // SQL execution failed
-  NotFoundError,      // Entity not found
-  AlreadyExistsError, // Unique constraint violated
+  DatabaseError,            // Base error class
+  ValidationError,          // Schema validation failed
+  TableDefinitionError,     // Invalid table definition
+  MigrationError,           // Migration failed
+  MigrationLockError,       // Failed to acquire migration lock
+  QueryError,               // SQL execution failed
+  NotFoundError,            // Entity not found
+  AlreadyExistsError,       // Unique constraint violated
   ConstraintViolationError, // Database constraint violated
-  ConnectionError,    // Connection failed
-  TransactionError,   // Transaction failed
-  isDatabaseError,      // Type guard for DatabaseError
-  hasErrorCode,       // Check error code
+  ConnectionError,          // Connection failed
+  TransactionError,         // Transaction failed
+  isDatabaseError,          // Type guard for DatabaseError
+  hasErrorCode,             // Check error code
 } from "@b9g/zen";
 ```
 
@@ -893,38 +1034,34 @@ import {
 ```typescript
 import type {
   // Table types
-  Table,              // Table definition object
-  PartialTable,       // Table created via .pick()
-  DerivedTable,       // Table with derived fields via .derive()
-  TableOptions,       // Options for table()
-  ReferenceInfo,      // Foreign key reference metadata
-  CompoundReference,  // Compound foreign key reference
+  Table,             // Table definition object
+  PartialTable,      // Table created via .pick()
+  DerivedTable,      // Table with derived fields via .derive()
+  TableOptions,      // Options for table()
+  ReferenceInfo,     // Foreign key reference metadata
+  CompoundReference, // Compound foreign key reference
 
   // Field types
-  FieldMeta,          // Field metadata for form generation
-  FieldType,          // Field type enum
-  FieldDBMeta,        // Database-specific field metadata
+  FieldMeta,         // Field metadata for form generation
+  FieldType,         // Field type enum
+  FieldDBMeta,       // Database-specific field metadata
 
   // Type inference
-  Row,                // Infer row type from Table (after read)
-  Insert,             // Infer insert type from Table (respects defaults/.db.auto())
-  Update,             // Infer update type from Table (all fields optional)
+  Row,               // Infer row type from Table (after read)
+  Insert,            // Infer insert type from Table (respects defaults/.db.auto())
+  Update,            // Infer update type from Table (all fields optional)
 
   // Fragment types
-  SetValues,          // Values accepted by Table.set()
-  SQLFragment,        // SQL fragment object
-  DDLFragment,        // DDL fragment object
-  SQLDialect,         // "sqlite" | "postgresql" | "mysql"
+  SetValues,         // Values accepted by Table.set()
+  SQLTemplate,       // SQL template object (return type of set(), on(), etc.)
+  SQLDialect,        // "sqlite" | "postgresql" | "mysql"
 
   // Driver types
-  Driver,             // Driver interface for adapters
-  TaggedQuery,        // Tagged template query function
-
-  // Expression types
-  DBExpression,       // Runtime database expression
+  Driver,            // Driver interface for adapters
+  TaggedQuery,       // Tagged template query function
 
   // Error types
-  DatabaseErrorCode,    // Error code string literals
+  DatabaseErrorCode, // Error code string literals
 } from "@b9g/zen";
 ```
 
@@ -1040,25 +1177,3 @@ import PostgresDriver from "@b9g/zen/postgres";
 // MySQL (mysql2)
 import MySQLDriver from "@b9g/zen/mysql";
 ```
-
-## What This Library Does Not Do
-
-**Query Generation:**
-- **No model classes** — Tables are plain definitions, not class instances
-- **No hidden JOINs** — You write all SQL explicitly
-- **No implicit query building** — No `.where().orderBy().limit()` chains
-- **No lazy loading** — Related data comes from your JOINs
-- **No ORM identity map** — Normalization is per-query, not session-wide
-
-**Migrations:**
-- **No down migrations** — Forward-only, monotonic versioning (1 → 2 → 3)
-- **No destructive helpers** — No `dropColumn()`, `dropTable()`, `renameColumn()` methods
-- **No automatic migrations** — DDL must be written explicitly in upgrade events
-- **No migration files** — Event handlers replace traditional migration folders
-- **No branching versions** — Linear version history only
-
-**Safety Philosophy:**
-- Migrations are **additive and idempotent** by design
-- Use `ensureColumn()`, `ensureIndex()`, `copyColumn()` for safe schema changes
-- Breaking changes require multi-step migrations (add, migrate data, deprecate)
-- Version numbers never decrease — rollbacks are new forward migrations

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@b9g/zen",
-  "version": "0.1.1",
-  "description": "The simple database client. Define tables. Write SQL. Get objects.",
+  "version": "0.1.3",
+  "description": "Define Zod tables. Write raw SQL. Get typed objects.",
   "keywords": [
     "database",
     "sql",
@@ -12,12 +12,21 @@
     "postgres",
     "mysql"
   ],
+  "author": "Brian Kim <briankimdev@gmail.com>",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bikeshaving/zen.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bikeshaving/zen/issues"
+  },
+  "homepage": "https://zendb.org",
   "dependencies": {
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.20",
+    "@b9g/libuild": "^0.1.21",
     "@eslint/js": "^9.39.2",
     "@types/better-sqlite3": "^7.6.0",
     "@types/bun": "^1.3.4",

package/{chunk-W7JTNEM4.js → src/_chunks/chunk-2C6KOX4F.js}

@@ -2,7 +2,7 @@ import {
   isSQLBuiltin,
   isSQLIdentifier,
   resolveSQLBuiltin
-} from "./chunk-XHXMCOSW.js";
+} from "./chunk-DKLSJISE.js";
 
 // src/impl/sql.ts
 function quoteIdent(name, dialect) {

package/{chunk-CHF7L5PC.js → src/_chunks/chunk-2R6FDKLS.js}

@@ -4,7 +4,7 @@ import {
   getViewMeta,
   ident,
   makeTemplate
-} from "./chunk-XHXMCOSW.js";
+} from "./chunk-DKLSJISE.js";
 
 // src/impl/ddl.ts
 import { z } from "zod";