agnes-cli 0.0.5 → 0.0.7

package/README.md

@@ -27,6 +27,7 @@ export default defineConfig({
   url: process.env.DATABASE_URL!,
   schema,
 
+  stripTimezone: false,        // return timestamps as naive ISO (no tz offset)
   schemas: ["public"],         // PostgreSQL schemas to introspect (default: public)
   pullMode: "singlefile",      // "singlefile" | "multifile"
   out: "./schema.ts",          // where `pull` writes (a directory in multifile mode)
@@ -81,6 +82,21 @@ outside `public` get qualified physical names (`table(def, "auth.users")`):
 schemas: ["public", "auth", "billing"],
 ```
 
+Non-`public` tables are grouped one level deep by schema; `public` tables stay
+at the top level. The group flattens to a dotted key you select by:
+
+```ts
+export const schema = {
+  users: table({ /* … */ }, "users"),          // public → top level
+  legislativo: {                                // grouped by schema
+    etapas: table({ /* … */ }, "legislativo.etapas"),
+  },
+};
+
+db.select("users");
+db.select("legislativo.etapas");   // dotted key = <schema>.<table>
+```
+
 With `pullMode: "multifile"`, `pull` writes one file per DB schema plus an
 `index.ts` that merges them into a single `schema` export — `out` is then a
 directory:
@@ -92,6 +108,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
@@ -138,6 +159,14 @@ bun agnes generate                       # uses config.output
 bun agnes generate --output src/db.js    # override; JS output
 ```
 
+## Timezones
+
+Set `stripTimezone: true` (config, or `stripTimezone` on `AgnesClient.create`)
+to get temporal columns back as **naive ISO strings** with no offset —
+`"2026-07-01T12:00:00"` instead of `"2026-07-01T12:00:00+00:00"`. This sidesteps
+the classic footgun where `new Date(value)` shifts the wall-clock time by the
+runtime's local offset. Postgres only; MySQL/SQLite values are already naive.
+
 ## Options
 
 | Flag | Applies to | Meaning |

package/agnes.config.example.ts

@@ -38,6 +38,9 @@ export default defineConfig({
   url: process.env.DATABASE_URL ?? "postgres://user:pass@localhost/db",
   schema,
 
+  // Return timestamps as naive ISO (no offset) to avoid the JS Date tz shift.
+  stripTimezone: false,
+
   // PostgreSQL schemas to introspect (default: ["public"]). Tables outside the
   // default schema get qualified physical names, e.g. table(def, "auth.users").
   schemas: ["public"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agnes-cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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.7"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/commands/generate.ts

@@ -29,6 +29,8 @@ function renderConfigObject(config: AgnesConfig): string {
   ];
   if (config.maxConnections !== undefined)
     lines.push(`    maxConnections: ${config.maxConnections},`);
+  if (config.stripTimezone !== undefined)
+    lines.push(`    stripTimezone: ${config.stripTimezone},`);
   if (config.cache) {
     const parts = [`enabled: ${config.cache.enabled}`];
     if (config.cache.walPath !== undefined) parts.push(`walPath: ${JSON.stringify(config.cache.walPath)}`);

package/src/commands/init.ts

@@ -20,6 +20,10 @@ export default defineConfig({
   // The schema object exported from your schema.ts.
   schema,
 
+  // Return timestamps without a timezone offset (naive ISO, e.g. 2026-07-01T12:00:00).
+  // Avoids the JS Date tz-shift footgun (the classic Prisma problem). Postgres only.
+  stripTimezone: false,
+
   // ── pull / push ──────────────────────────────────────────────────────────
   // PostgreSQL schemas to introspect. "public" is the default; add more to
   // pull/push tables that live outside it (they get qualified names, "auth.users").

package/src/config.ts

@@ -32,6 +32,11 @@ export interface AgnesConfig {
   /** Directory for versioned migration files (default: ./migrations). */
   migrationsDir?: string;
   maxConnections?: number;
+  /**
+   * Return temporal values without a timezone offset (naive wall-clock ISO) —
+   * avoids the JS `Date` tz-shift footgun. Postgres only; defaults to false.
+   */
+  stripTimezone?: boolean;
   /** Cache config baked into the client generated by `agnes generate`. */
   cache?: CacheConfig;
   /**

package/src/db.ts

@@ -14,6 +14,7 @@ export async function openDb(config: AgnesConfig): Promise<CliDb> {
       driver: config.driver,
       url: config.url,
       maxConnections: config.maxConnections,
+      stripTimezone: config.stripTimezone,
     },
     config.schema as never,
   );

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 };
   };
 }
@@ -85,7 +88,8 @@ interface DslTableEntry {
   tableName: string;
 }
 
-export type DslSchema = Record<string, DslTableEntry>;
+/** Entries may sit at the top level or be grouped one level deep by DB schema. */
+export type DslSchema = Record<string, DslTableEntry | Record<string, DslTableEntry>>;
 
 function fkName(table: string, column: string): string {
   return `fk_${table}_${column}`;
@@ -97,16 +101,47 @@ function colName(def: Record<string, DslField>, key: string): string | undefined
   return f && f._kind === "column" ? f.name : undefined;
 }
 
+function isTableEntry(v: unknown): v is DslTableEntry {
+  return (
+    typeof v === "object" &&
+    v !== null &&
+    typeof (v as DslTableEntry).tableName === "string" &&
+    typeof (v as DslTableEntry).def === "object"
+  );
+}
+
+/** Flatten nested groups; pair each entry with its path key ("grp.tbl" or "tbl"). */
+function flattenDsl(schema: DslSchema): { key: string; entry: DslTableEntry }[] {
+  const out: { key: string; entry: DslTableEntry }[] = [];
+  for (const k in schema) {
+    const v = schema[k];
+    if (isTableEntry(v)) {
+      out.push({ key: k, entry: v });
+    } else if (v && typeof v === "object") {
+      for (const p in v as Record<string, DslTableEntry>) {
+        const e = (v as Record<string, DslTableEntry>)[p];
+        if (isTableEntry(e)) out.push({ key: `${k}.${p}`, entry: e });
+      }
+    }
+  }
+  return out;
+}
+
 /** Convert the user's schema DSL into the canonical DatabaseIR. */
 export function schemaToIR(schema: DslSchema): DatabaseIR {
-  // Map DSL table key → physical name for relation resolution.
-  const physicalName = new Map<string, string>();
-  for (const key in schema) physicalName.set(key, schema[key]!.tableName);
+  const entries = flattenDsl(schema);
+
+  // A relation target may reference either the TS path key or the physical
+  // table name — index by both so both hand-written and pulled schemas resolve.
+  const byRef = new Map<string, DslTableEntry>();
+  for (const { key, entry } of entries) {
+    byRef.set(key, entry);
+    byRef.set(entry.tableName, entry);
+  }
 
   const ir: DatabaseIR = {};
 
-  for (const key in schema) {
-    const entry = schema[key]!;
+  for (const { entry } of entries) {
     const def = entry.def;
     const columns: ColumnIR[] = [];
     const indexes: IndexIR[] = [];
@@ -115,12 +150,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({
@@ -131,9 +169,9 @@ export function schemaToIR(schema: DslSchema): DatabaseIR {
         }
       } else if (field._kind === "one") {
         const localCol = colName(def, field.localKey);
-        const targetDef = schema[field.target]?.def;
-        const refCol = targetDef ? colName(targetDef, field.targetKey) : undefined;
-        const refTable = physicalName.get(field.target);
+        const targetEntry = byRef.get(field.target);
+        const refCol = targetEntry ? colName(targetEntry.def, field.targetKey) : undefined;
+        const refTable = targetEntry?.tableName;
         if (localCol && refCol && refTable) {
           foreignKeys.push({
             name: fkName(entry.tableName, localCol),

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). */
@@ -36,16 +68,34 @@ function idKey(name: string): string {
   return name.replace(/[^A-Za-z0-9_]/g, "_");
 }
 
-function tableSource(t: TableIR): string {
+/** Render the `table({...}, "physical")` expression. `pad` indents column lines. */
+function tableBody(t: TableIR, pad: string): string {
   const physical = qualifiedName(t.name, t.schema);
   const fkByColumn = new Map(t.foreignKeys.map((fk) => [fk.column, fk]));
   const lines: string[] = [];
 
+  // Relation keys must be unique and not collide with column keys. Derive from
+  // the local FK column (dropping a trailing _id) so two FKs to the same table
+  // (e.g. decisor_etapa_sim_id / _nao_id) get distinct, readable keys.
+  const usedKeys = new Set(t.columns.map((c) => c.name));
+  const relKeyFor = (fk: { column: string; refTable: string }): string => {
+    const base = idKey(fk.column.replace(/_?id$/i, "")) || idKey(fk.refTable);
+    let key = base;
+    for (let n = 2; usedKeys.has(key); n++) key = `${base}_${n}`;
+    usedKeys.add(key);
+    return key;
+  };
+
   for (const col of t.columns) {
     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
@@ -53,28 +103,54 @@ function tableSource(t: TableIR): string {
           : `.index(${JSON.stringify(idx.name)})`;
       }
     }
-    lines.push(`    ${col.name}: ${expr},`);
+    lines.push(`${pad}  ${col.name}: ${expr},`);
   }
 
   for (const fk of fkByColumn.values()) {
-    // Relation TS key: derive from referenced table (best effort).
-    const relKey = idKey(fk.refTable);
+    const relKey = relKeyFor(fk);
     lines.push(
-      `    ${relKey}: one(${JSON.stringify(fk.refTable)}, ${JSON.stringify(fk.column)}, ` +
+      `${pad}  ${relKey}: one(${JSON.stringify(fk.refTable)}, ${JSON.stringify(fk.column)}, ` +
         `${JSON.stringify(fk.refColumn)}, ${onAction(fk.onUpdate)}, ${onAction(fk.onDelete)}),`,
     );
   }
 
-  return `  ${idKey(physical)}: table({\n${lines.join("\n")}\n  }, ${JSON.stringify(physical)}),`;
+  return `table({\n${lines.join("\n")}\n${pad}}, ${JSON.stringify(physical)})`;
+}
+
+const byQualified = (a: TableIR, b: TableIR) =>
+  qualifiedName(a.name, a.schema).localeCompare(qualifiedName(b.name, b.schema));
+
+/**
+ * Render the `{ ... }` body of `export const schema`. Default-schema tables sit
+ * at the top level (`users: table(...)`); tables from other schemas are grouped
+ * one level deep (`legislativo: { etapas: table(...) }`), which flattens to the
+ * dotted key `legislativo.etapas` — matching each table's physical name.
+ */
+function schemaObject(tables: TableIR[]): string {
+  const top: TableIR[] = [];
+  const groups = new Map<string, TableIR[]>();
+  for (const t of tables) {
+    if (!t.schema || t.schema === "public") top.push(t);
+    else (groups.get(t.schema) ?? groups.set(t.schema, []).get(t.schema)!).push(t);
+  }
+
+  const lines: string[] = [];
+  for (const t of top.sort(byQualified)) {
+    lines.push(`  ${idKey(t.name)}: ${tableBody(t, "  ")},`);
+  }
+  for (const schema of [...groups.keys()].sort()) {
+    const inner = groups
+      .get(schema)!
+      .sort(byQualified)
+      .map((t) => `    ${idKey(t.name)}: ${tableBody(t, "    ")},`)
+      .join("\n");
+    lines.push(`  ${idKey(schema)}: {\n${inner}\n  },`);
+  }
+  return `export const schema = {\n${lines.join("\n")}\n};\n`;
 }
 
 function schemaBlock(tables: TableIR[]): string {
-  const body = tables
-    .slice()
-    .sort((a, b) => qualifiedName(a.name, a.schema).localeCompare(qualifiedName(b.name, b.schema)))
-    .map(tableSource)
-    .join("\n");
-  return `export const schema = {\n${body}\n};\n`;
+  return schemaObject(tables);
 }
 
 /** Render a full DatabaseIR into a single schema.ts source string. */