Codegen: splice only @generated interior; TableClass in table.ts

Update mode no longer rebuilds imports or the class shell — only the
span between @generated-start/end is rewritten (@expose state preserved).
Move TableClass to table.ts and use it on from/insert/scope; drop unused
RelationQuery from relation.ts.

Author: ryanrasti

src/relation.ts

@@ -16,12 +16,9 @@
 // Step 1: thread parent context unchanged (incl. undefined → same as
 // `scope(undefined)` today). Attenuation / mapContext is a later step.
 
-import type { TableBase } from "./table";
+import type { TableBase, TableClass } from "./table";
 import type { SqlValue } from "./types/sql-value";
-import type { QueryBuilder, RowType } from "./builder/query";
-
-// Concrete table class: statics from TableBase + constructible instance.
-type TableClass = typeof TableBase & (new () => TableBase);
+import type { QueryBuilder } from "./builder/query";
 
 // Column keys on a table instance — only fields that hold SqlValue
 // (methods / constructor / non-column fields are excluded).
@@ -111,7 +108,3 @@ export const Relation = {
     return relate(row, Target, fk as { [k: string]: SqlValue<any> }, card);
   },
 };
-
-// Re-export the shape name so callers can annotate without importing QueryBuilder guts.
-export type RelationQuery<T extends TableClass, Card extends "one" | "maybe" | "many"> =
-  QueryBuilder<{ [K in T["tsAlias"]]: InstanceType<T> }, InstanceType<T> & RowType, [], Card>;

src/table.ts

@@ -77,8 +77,8 @@ export abstract class TableBase {
     return this.database.scopedIdent(name);
   }
 
-  // Entry point for query builders: e.g., `Users.from()` 
-  static from<T extends typeof TableBase & (new () => TableBase)>(this: T) {
+  // Entry point for query builders: e.g., `Users.from()`
+  static from<T extends TableClass>(this: T) {
     return new QueryBuilder<
       { [K in T["tsAlias"]]: InstanceType<T> },
       InstanceType<T>,
@@ -90,7 +90,7 @@ export abstract class TableBase {
     });
   }
 
-  static insert<T extends typeof TableBase & (new () => TableBase)>(
+  static insert<T extends TableClass>(
     this: T,
     ...rows: [InsertRow<InstanceType<T>>, ...InsertRow<InstanceType<T>>[]]
   ): InsertBuilder<T["tableName"], InstanceType<T>> {
@@ -102,13 +102,13 @@ export abstract class TableBase {
     });
   }
 
-  static update<T extends typeof TableBase & (new () => TableBase)>(
+  static update<T extends TableClass>(
     this: T,
   ): UpdateBuilder<T["tableName"], InstanceType<T>> {
     return new UpdateBuilder({ instance: this.rowType() });
   }
 
-  static delete<T extends typeof TableBase & (new () => TableBase)>(
+  static delete<T extends TableClass>(
     this: T,
   ): DeleteBuilder<T["tableName"], InstanceType<T>> {
     return new DeleteBuilder({ instance: this.rowType() });
@@ -134,7 +134,7 @@ export abstract class TableBase {
   // `Database<C>.Table`). Tables declared with the default `C =
   // undefined` accept anything via the `unknown` widening; tables that
   // pin a `C` reject mismatched scopes at compile time.
-  static scope<T extends typeof TableBase & (new () => TableBase)>(
+  static scope<T extends TableClass>(
     this: T,
     ctx: T["context"] | undefined,
   ) {
@@ -194,6 +194,10 @@ export const Table = <Name extends string, C = undefined>(
   return obj[name] as NonNullable<Obj[Name]>;
 };
 
-export const isTableClass = (x: unknown): x is typeof TableBase => {
+// Concrete table class: TableBase statics + constructible row instance.
+// Used by Relation helpers, from/insert/scope, and Fromable checks.
+export type TableClass = typeof TableBase & (new () => TableBase);
+
+export const isTableClass = (x: unknown): x is TableClass => {
   return typeof x === "function" && x.prototype instanceof TableBase;
 };

src/tables/generate.test.ts

@@ -150,9 +150,7 @@ export class Dogs extends db.Table("dogs") {
     await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { Relation, expose } from "typegres";
-      import { Int8, Text } from "typegres/postgres";
-      import { Teams } from "./teams";
+      import { Int8, Text } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
@@ -184,9 +182,8 @@ export class Dogs extends db.Table("dogs") {
     await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { Relation, expose } from "typegres";
-      import { Int8, Text } from "typegres/postgres";
-      import { Teams } from "./teams";
+      import { Int8, Text } from "typegres";
+      import { expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
@@ -217,9 +214,7 @@ export class Dogs extends db.Table("dogs") {
     await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { Relation, expose } from "typegres";
-      import { Int8, Text } from "typegres/postgres";
-      import { Teams } from "./teams";
+      import { Int8, Text, expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
@@ -254,7 +249,6 @@ export class Dogs extends db.Table("dogs") {
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
       import { expose } from "typegres";
-      import { Int8, Text } from "typegres/postgres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
@@ -285,8 +279,7 @@ export class Dogs extends db.Table("dogs") {
     await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { expose } from "typegres";
-      import { Int8, Text } from "typegres/postgres";
+      import { Int8, Text, expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
@@ -298,9 +291,9 @@ export class Dogs extends db.Table("dogs") {
     `);
   });
 
-  test("update mode rewrites managed imports; preserves post-block user methods", async () => {
+  test("update mode preserves header and post-block methods; only the block changes", async () => {
     // Stale imports + a hand-written method after the generated block.
-    // Regen rebuilds imports from schema and keeps the user method.
+    // Header (including comments) is byte-preserved; only the generated interior is rewritten.
     const existing = `import { db } from "../db";
 import { Int8 } from "typegres";
 // my custom comment (header comments are not preserved)
@@ -321,8 +314,8 @@ export class Dogs extends db.Table("dogs") {
     await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { expose } from "typegres";
-      import { Int8 } from "typegres/postgres";
+      import { Int8 } from "typegres";
+      // my custom comment (header comments are not preserved)
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start

src/tables/generate.ts

@@ -223,34 +223,29 @@ const parseExistingDecorations = (
 const START_MARKER = "// @generated-start";
 const END_MARKER = "// @generated-end";
 
-// Pure generation entry point — no DB, no fs. `existing` (if provided)
-// must contain @generated-start/@generated-end markers; only content
-// between them is replaced, and per-entry `@expose()` state is preserved.
-// Without `existing`, returns a brand-new full file.
+// Pure generation entry point — no DB, no fs.
+//
+// New file: full skeleton (managed imports + class shell + generated body).
+// Update (`existing`): **only** the interior of @generated-start/end is
+// rewritten (plus per-entry `@expose()` preservation). Header imports,
+// class declaration, and everything after @generated-end are left alone.
+// Callers are responsible for imports when the schema gains types/relations
+// (tsc will fail until they add them — better than clobbering the header).
 export const generateTable = (
   tableName: string,
   columns: ColumnInfo[],
   relations: Relation[],
   opts: { typeImportPath: string; dbImport: string; existing?: string },
 ): string => {
   if (opts.existing !== undefined) {
-    return updateFile(
-      opts.existing,
-      tableName,
-      columns,
-      relations,
-      opts.typeImportPath,
-      opts.dbImport,
-    );
+    return updateBlock(opts.existing, columns, relations);
   }
-  return emitFile(
+  return emitNewFile(
     tableName,
     columns,
     relations,
     opts.typeImportPath,
     opts.dbImport,
-    bodyLines(columns, relations, () => true),
-    `${END_MARKER}\n}\n`,
   );
 };
 
@@ -296,41 +291,37 @@ const bodyLines = (
     : colLines;
 };
 
-// Assemble a full table file. `tail` is END_MARKER through EOF — for new
-// files that's just the end marker + class close; for updates it's the
-// preserved user methods after the generated block.
-const emitFile = (
+// Brand-new table file: managed imports + class shell + empty user tail.
+const emitNewFile = (
   tableName: string,
   columns: ColumnInfo[],
   relations: Relation[],
   typeImportPath: string,
   dbImport: string,
-  body: string[],
-  tail: string,
 ): string => {
   const imports = buildImportLines(tableName, columns, relations, typeImportPath, dbImport);
+  const body = bodyLines(columns, relations, () => true);
   return `${imports.join("\n")}
 
 export class ${pgNameToClassName(tableName)} extends db.Table("${tableName}") {
   ${START_MARKER}
 ${body.join("\n")}
-  ${tail}`;
+  ${END_MARKER}
+}
+`;
 };
 
-// Update mode: rebuild managed imports + generated block from schema;
-// preserve only the post-END_MARKER tail (user methods after the block).
-// Per-entry `@expose()` state inside the block is preserved.
-const updateFile = (
+// Update mode: splice only between the markers. Prefix (imports, comments,
+// class line) and suffix (END_MARKER through EOF, including user methods)
+// are byte-preserved. `@expose` on/off inside the prior block is preserved.
+const updateBlock = (
   existing: string,
-  tableName: string,
   columns: ColumnInfo[],
   relations: Relation[],
-  typeImportPath: string,
-  dbImport: string,
 ): string => {
   const startIdx = existing.indexOf(START_MARKER);
   const endIdx = existing.indexOf(END_MARKER);
-  if (startIdx === -1 || endIdx === -1) {
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
     throw new Error("Missing @generated-start or @generated-end markers");
   }
 
@@ -340,9 +331,12 @@ const updateFile = (
   const body = bodyLines(columns, relations, (name, kind) =>
     kind === "col" ? (prior.cols.get(name) ?? true) : (prior.rels.get(name) ?? true),
   );
-  // From END_MARKER through EOF — keeps hand-written methods below the block.
-  const tail = existing.slice(endIdx);
-  return emitFile(tableName, columns, relations, typeImportPath, dbImport, body, tail);
+
+  const prefix = existing.slice(0, startIdx + START_MARKER.length);
+  const suffix = existing.slice(endIdx); // begins with END_MARKER
+  // Normalize interior to "\n" + indented lines + "\n  " before end marker,
+  // matching emitNewFile layout regardless of prior whitespace.
+  return `${prefix}\n${body.join("\n")}\n  ${suffix}`;
 };
 
 // --- Main ---