agnes-cli 0.0.5 → 0.0.6

package/README.md

@@ -92,6 +92,11 @@ schema/
   index.ts   ← import { schema } from "./schema"
 ```
 
+**Defaults & auto-increment.** `pull` renders defaults in the column's type
+(`bool("x").default(true)`, `int("n").default(1)` — not strings). Serial /
+identity / `AUTO_INCREMENT` columns become `.autoincrement()`, and SQL
+expressions that can't be a literal (e.g. `CURRENT_TIMESTAMP`) are omitted.
+
 ### `migrate` — versioned SQL files
 
 1. Diffs schema vs DB and, if there's drift, writes a timestamped file to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agnes-cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Schema migration CLI for agnes-rs — push, pull and migrate from schema.ts",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agnes-library": "0.0.5"
+    "agnes-library": "0.0.6"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/diff.ts

@@ -22,7 +22,12 @@ function byName<T extends { name: string }>(items: T[]): Map<string, T> {
 }
 
 function columnChanged(a: ColumnIR, b: ColumnIR): boolean {
-  return a.type !== b.type || a.nullable !== b.nullable || a.primary !== b.primary;
+  return (
+    a.type !== b.type ||
+    a.nullable !== b.nullable ||
+    a.primary !== b.primary ||
+    !!a.autoincrement !== !!b.autoincrement
+  );
 }
 
 /**

package/src/generate.ts

@@ -3,7 +3,24 @@ import { qualifiedName, type ColumnIR, type ForeignKeyIR, type TableIR } from ".
 import type { Operation } from "./diff";
 
 function columnDef(dialect: Dialect, col: ColumnIR): string {
-  let s = `${ident(dialect, col.name)} ${physicalType(dialect, col.type)}`;
+  const name = ident(dialect, col.name);
+  const type = physicalType(dialect, col.type);
+
+  if (col.autoincrement) {
+    // SQLite only auto-increments an INTEGER PRIMARY KEY.
+    if (dialect === "sqlite") return `${name} INTEGER PRIMARY KEY AUTOINCREMENT`;
+    if (dialect === "postgres") {
+      let s = `${name} ${type} GENERATED BY DEFAULT AS IDENTITY`;
+      if (col.primary) s += " PRIMARY KEY";
+      return s;
+    }
+    // mysql
+    let s = `${name} ${type} NOT NULL AUTO_INCREMENT`;
+    if (col.primary) s += " PRIMARY KEY";
+    return s;
+  }
+
+  let s = `${name} ${type}`;
   if (col.primary) s += " PRIMARY KEY";
   if (!col.nullable && !col.primary) s += " NOT NULL";
   if (col.default !== undefined) s += ` DEFAULT ${defaultLiteral(dialect, col.default)}`;

package/src/introspect.ts

@@ -64,13 +64,19 @@ async function introspectPostgres(db: QueryClient, schemas: string[]): Promise<D
       );
       const pkSet = new Set(pks.map((r) => str(r.column_name)));
 
-      const columns: ColumnIR[] = cols.map((c) => ({
-        name: str(c.column_name),
-        type: logicalType(str(c.data_type)),
-        nullable: str(c.is_nullable) === "YES",
-        primary: pkSet.has(str(c.column_name)),
-        default: c.column_default == null ? undefined : str(c.column_default),
-      }));
+      const columns: ColumnIR[] = cols.map((c) => {
+        const rawDefault = c.column_default == null ? undefined : str(c.column_default);
+        // serial/identity columns default to nextval(...) — surface them as autoincrement.
+        const autoincrement = rawDefault != null && /nextval\(/i.test(rawDefault);
+        return {
+          name: str(c.column_name),
+          type: logicalType(str(c.data_type)),
+          nullable: str(c.is_nullable) === "YES",
+          primary: pkSet.has(str(c.column_name)),
+          default: autoincrement ? undefined : rawDefault,
+          autoincrement,
+        };
+      });
 
       const idxRows = await db.query<Row>(
         `SELECT i.relname AS index_name, a.attname AS column_name,

package/src/ir.ts

@@ -11,6 +11,8 @@ export interface ColumnIR {
   primary: boolean;
   /** default value as a literal; undefined = no default. */
   default?: unknown;
+  /** DB assigns the value (serial/identity/AUTO_INCREMENT). Mutually exclusive with `default`. */
+  autoincrement?: boolean;
 }
 
 export interface IndexIR {
@@ -59,6 +61,7 @@ interface DslColumn {
     primary?: boolean;
     nullable?: boolean;
     default?: unknown;
+    autoincrement?: boolean;
     index?: { name: string; unique: boolean };
   };
 }
@@ -115,12 +118,15 @@ export function schemaToIR(schema: DslSchema): DatabaseIR {
     for (const fieldKey in def) {
       const field = def[fieldKey]!;
       if (field._kind === "column") {
+        const autoincrement = field.flags.autoincrement ?? false;
         columns.push({
           name: field.name,
           type: field.type,
           nullable: field.flags.nullable ?? false,
           primary: field.flags.primary ?? false,
-          default: field.flags.default,
+          // Auto-increment supplies the value; never emit an explicit default too.
+          default: autoincrement ? undefined : field.flags.default,
+          autoincrement,
         });
         if (field.flags.index) {
           indexes.push({

package/src/print.ts

@@ -25,10 +25,42 @@ function onAction(rule: string): string {
   return ON_ACTION[rule.toUpperCase()] ?? "OnAction.None";
 }
 
-function literal(v: unknown): string {
-  if (typeof v === "boolean") return String(v);
-  if (typeof v === "number" || typeof v === "bigint") return String(v);
-  return JSON.stringify(String(v));
+/**
+ * Render a raw DB default into the `.default(...)` argument for a given column
+ * type, or `null` to omit it. Introspection hands us raw strings ("true", "1",
+ * "'x'::text", "CURRENT_TIMESTAMP"); we coerce them to the type the DSL expects
+ * and drop SQL expressions we can't represent as a literal.
+ */
+function renderDefault(type: ColumnType, raw: unknown): string | null {
+  if (raw === undefined || raw === null) return null;
+  const s = String(raw).trim();
+  // Strip a trailing type cast: 'x'::text, 5::integer, 'a'::character varying.
+  const cast = s.replace(/::[\w\s"]+$/, "").trim();
+  const quoted = cast.match(/^'([\s\S]*)'$/);
+  const inner = quoted ? quoted[1]!.replace(/''/g, "'") : undefined;
+  const scalar = inner ?? cast;
+
+  switch (type) {
+    case "bool": {
+      const t = scalar.toLowerCase();
+      if (t === "true" || t === "t" || t === "1") return "true";
+      if (t === "false" || t === "f" || t === "0") return "false";
+      return null;
+    }
+    case "int":
+    case "float": {
+      const n = Number(scalar);
+      return scalar !== "" && Number.isFinite(n) ? String(n) : null;
+    }
+    case "bigint":
+      return /^-?\d+$/.test(scalar) ? `${scalar}n` : null;
+    case "text":
+    case "json":
+      // Only string literals; skip expressions (CURRENT_TIMESTAMP, now(), …).
+      return inner !== undefined ? JSON.stringify(inner) : null;
+    default:
+      return null; // bytes
+  }
 }
 
 /** A qualified name → a valid JS identifier (for the `schema` object keys / relation keys). */
@@ -45,7 +77,12 @@ function tableSource(t: TableIR): string {
     let expr = `${HELPER[col.type]}(${JSON.stringify(col.name)})`;
     if (col.primary) expr += ".primary()";
     else if (col.nullable) expr += ".nullable()";
-    if (col.default !== undefined) expr += `.default(${literal(col.default)})`;
+    if (col.autoincrement) {
+      expr += ".autoincrement()";
+    } else {
+      const d = renderDefault(col.type, col.default);
+      if (d !== null) expr += `.default(${d})`;
+    }
     for (const idx of t.indexes) {
       if (idx.columns.length === 1 && idx.columns[0] === col.name) {
         expr += idx.unique