agnes-cli 0.0.6 → 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:
@@ -143,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.6",
+  "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.6"
+    "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/ir.ts

@@ -88,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}`;
@@ -100,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[] = [];
@@ -137,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

@@ -68,11 +68,24 @@ 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()";
@@ -90,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. */