@fragno-dev/db 0.2.2 → 0.4.1

package/src/{adapters/drizzle/generate.test.ts → schema-output/drizzle.test.ts}

@@ -1,10 +1,11 @@
 import { describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import { generateSchema } from "./generate";
-import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("generateSchema", () => {
-  const testSchema = schema((s) => {
+import { internalSchema } from "../fragments/internal-fragment";
+import { column, idColumn, referenceColumn, schema } from "../schema/create";
+import { generateDrizzleSchema } from "./drizzle";
+
+describe("generateDrizzleSchema", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -32,11 +33,34 @@ describe("generateSchema", () => {
       });
   });
 
+  it("should reflect alterColumn nullable changes", () => {
+    const alteredSchema = schema("altered", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .alterTable("users", (t) => {
+          return t.alterColumn("name").nullable();
+        });
+    });
+
+    const generated = generateDrizzleSchema(
+      [{ namespace: "altered", schema: alteredSchema }],
+      "postgresql",
+    );
+
+    expect(generated).toContain(`name: text("name")`);
+    expect(generated).not.toContain(`name: text("name").notNull()`);
+  });
+
   describe("postgresql", () => {
     it("should generate PostgreSQL schema", () => {
-      const generated = generateSchema([{ namespace: "test", schema: testSchema }], "postgresql");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: testSchema }],
+        "postgresql",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, integer, bigserial, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, text, integer, bigserial, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -44,20 +68,22 @@ describe("generateSchema", () => {
         // Fragment: test
         // ============================================================================
 
-        export const users_test = pgTable("users_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const users_test = schema_test.table("users", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: integer("age"),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email_test").on(table.email),
-          index("idx_name_test").on(table.name)
+          uniqueIndex("idx_email").on(table.email),
+          index("idx_name").on(table.name)
         ])
 
-        export const posts_test = pgTable("posts_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        export const posts_test = schema_test.table("posts", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -68,10 +94,10 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_test._internalId],
-            name: "fk_posts_users_author_test"
+            name: "fk_posts_users_author"
           }),
-          index("idx_user_test").on(table.userId),
-          index("idx_title_test").on(table.title)
+          index("idx_user").on(table.userId),
+          index("idx_title").on(table.title)
         ])
 
         export const users_testRelations = relations(users_test, ({ many }) => ({
@@ -105,7 +131,7 @@ describe("generateSchema", () => {
 
   describe("mysql", () => {
     it("should generate MySQL schema", () => {
-      const generated = generateSchema([{ namespace: "test", schema: testSchema }], "mysql");
+      const generated = generateDrizzleSchema([{ namespace: "test", schema: testSchema }], "mysql");
       expect(generated).toMatchInlineSnapshot(`
         "import { mysqlTable, varchar, text, int, bigint, uniqueIndex, index, foreignKey } from "drizzle-orm/mysql-core"
         import { createId } from "@fragno-dev/db/id"
@@ -116,19 +142,19 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const users_test = mysqlTable("users_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: int("age"),
           _internalId: bigint("_internalId", { mode: "number" }).primaryKey().autoincrement().notNull(),
           _version: int("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email_test").on(table.email),
-          index("idx_name_test").on(table.name)
+          uniqueIndex("uidx_users_idx_email_test_3d974845").on(table.email),
+          index("idx_users_idx_name_test_7f36c497").on(table.name)
         ])
 
         export const posts_test = mysqlTable("posts_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -139,10 +165,10 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_test._internalId],
-            name: "fk_posts_users_author_test"
+            name: "fk_posts_users_author_test_8d48035c"
           }),
-          index("idx_user_test").on(table.userId),
-          index("idx_title_test").on(table.title)
+          index("idx_posts_idx_user_test_4a5c5c19").on(table.userId),
+          index("idx_posts_idx_title_test_00e97ff4").on(table.title)
         ])
 
         export const users_testRelations = relations(users_test, ({ many }) => ({
@@ -176,7 +202,10 @@ describe("generateSchema", () => {
 
   describe("sqlite", () => {
     it("should generate SQLite schema", () => {
-      const generated = generateSchema([{ namespace: "test", schema: testSchema }], "sqlite");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: testSchema }],
+        "sqlite",
+      );
       expect(generated).toMatchInlineSnapshot(`
         "import { sqliteTable, text, integer, uniqueIndex, index, foreignKey } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
@@ -187,19 +216,20 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const users_test = sqliteTable("users_test", {
-          id: text("id").notNull().$defaultFn(() => createId()),
+          id: text("id").notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: integer("age"),
           _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email_test").on(table.email),
-          index("idx_name_test").on(table.name)
+          uniqueIndex("uidx_users_idx_email_test_3d974845").on(table.email),
+          index("idx_users_idx_name_test_7f36c497").on(table.name),
+          uniqueIndex("uidx_users_idx_users_external_id_test_8eaf053f").on(table.id)
         ])
 
         export const posts_test = sqliteTable("posts_test", {
-          id: text("id").notNull().$defaultFn(() => createId()),
+          id: text("id").notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: integer("userId").notNull(),
@@ -210,10 +240,11 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_test._internalId],
-            name: "fk_posts_users_author_test"
+            name: "fk_posts_users_author_test_8d48035c"
           }),
-          index("idx_user_test").on(table.userId),
-          index("idx_title_test").on(table.title)
+          index("idx_posts_idx_user_test_4a5c5c19").on(table.userId),
+          index("idx_posts_idx_title_test_00e97ff4").on(table.title),
+          uniqueIndex("uidx_posts_idx_posts_external_id_test_80487638").on(table.id)
         ])
 
         export const users_testRelations = relations(users_test, ({ many }) => ({
@@ -247,7 +278,7 @@ describe("generateSchema", () => {
 
   describe("default values", () => {
     it("should handle runtime default values", () => {
-      const timestampSchema = schema((s) => {
+      const timestampSchema = schema("timestamp", (s) => {
         return s.addTable("events", (t) => {
           return t.addColumn("id", idColumn()).addColumn(
             "createdAt",
@@ -256,20 +287,22 @@ describe("generateSchema", () => {
         });
       });
 
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: timestampSchema }],
         "postgresql",
       );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, timestamp, bigserial, integer } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, timestamp, bigserial, integer } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
 
         // ============================================================================
         // Fragment: test
         // ============================================================================
 
-        export const events_test = pgTable("events_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const events_test = schema_test.table("events", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           createdAt: timestamp("createdAt").notNull().$defaultFn(() => new Date()),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
@@ -284,7 +317,7 @@ describe("generateSchema", () => {
     });
 
     it("should handle database-level default values", () => {
-      const timestampSchema = schema((s) => {
+      const timestampSchema = schema("timestamp", (s) => {
         return s.addTable("events", (t) => {
           return t.addColumn("id", idColumn()).addColumn(
             "createdAt",
@@ -293,20 +326,22 @@ describe("generateSchema", () => {
         });
       });
 
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: timestampSchema }],
         "postgresql",
       );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, timestamp, bigserial, integer } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, timestamp, bigserial, integer } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
 
         // ============================================================================
         // Fragment: test
         // ============================================================================
 
-        export const events_test = pgTable("events_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const events_test = schema_test.table("events", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           createdAt: timestamp("createdAt").notNull().defaultNow(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
@@ -323,15 +358,18 @@ describe("generateSchema", () => {
 
   describe("binary columns", () => {
     it("should generate custom type for binary columns", () => {
-      const binarySchema = schema((s) => {
+      const binarySchema = schema("binary", (s) => {
         return s.addTable("files", (t) => {
           return t.addColumn("id", idColumn()).addColumn("data", column("binary"));
         });
       });
 
-      const generated = generateSchema([{ namespace: "test", schema: binarySchema }], "postgresql");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: binarySchema }],
+        "postgresql",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, customType, bigserial, integer } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, customType, bigserial, integer } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         const customBinary = customType<
           {
@@ -354,8 +392,10 @@ describe("generateSchema", () => {
         // Fragment: test
         // ============================================================================
 
-        export const files_test = pgTable("files_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const files_test = schema_test.table("files", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           data: customBinary("data").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
@@ -371,7 +411,7 @@ describe("generateSchema", () => {
   });
 
   describe("many relations", () => {
-    const oneToManySchema = schema((s) => {
+    const oneToManySchema = schema("onetomany", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -396,12 +436,12 @@ describe("generateSchema", () => {
     });
 
     it("should generate PostgreSQL schema with many relations", () => {
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: oneToManySchema }],
         "postgresql",
       );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigserial, integer, bigint, foreignKey, index } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, text, bigserial, integer, bigint, foreignKey, index } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -409,15 +449,17 @@ describe("generateSchema", () => {
         // Fragment: test
         // ============================================================================
 
-        export const users_test = pgTable("users_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const users_test = schema_test.table("users", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
-        export const posts_test = pgTable("posts_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        export const posts_test = schema_test.table("posts", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -426,9 +468,9 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_test._internalId],
-            name: "fk_posts_users_author_test"
+            name: "fk_posts_users_author"
           }),
-          index("idx_user_test").on(table.userId)
+          index("idx_user").on(table.userId)
         ])
 
         export const users_testRelations = relations(users_test, ({ many }) => ({
@@ -463,7 +505,10 @@ describe("generateSchema", () => {
     });
 
     it("should generate MySQL schema with many relations", () => {
-      const generated = generateSchema([{ namespace: "test", schema: oneToManySchema }], "mysql");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: oneToManySchema }],
+        "mysql",
+      );
       expect(generated).toMatchInlineSnapshot(`
         "import { mysqlTable, varchar, text, bigint, int, foreignKey, index } from "drizzle-orm/mysql-core"
         import { createId } from "@fragno-dev/db/id"
@@ -474,14 +519,14 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const users_test = mysqlTable("users_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: bigint("_internalId", { mode: "number" }).primaryKey().autoincrement().notNull(),
           _version: int("_version").notNull().default(0)
         })
 
         export const posts_test = mysqlTable("posts_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
           _internalId: bigint("_internalId", { mode: "number" }).primaryKey().autoincrement().notNull(),
@@ -490,9 +535,9 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_test._internalId],
-            name: "fk_posts_users_author_test"
+            name: "fk_posts_users_author_test_8d48035c"
           }),
-          index("idx_user_test").on(table.userId)
+          index("idx_posts_idx_user_test_4a5c5c19").on(table.userId)
         ])
 
         export const users_testRelations = relations(users_test, ({ many }) => ({
@@ -527,9 +572,12 @@ describe("generateSchema", () => {
     });
 
     it("should generate SQLite schema with many relations", () => {
-      const generated = generateSchema([{ namespace: "test", schema: oneToManySchema }], "sqlite");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: oneToManySchema }],
+        "sqlite",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, foreignKey, index } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -538,14 +586,16 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const users_test = sqliteTable("users_test", {
-          id: text("id").notNull().$defaultFn(() => createId()),
+          id: text("id").notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
-        })
+        }, (table) => [
+          uniqueIndex("uidx_users_idx_users_external_id_test_8eaf053f").on(table.id)
+        ])
 
         export const posts_test = sqliteTable("posts_test", {
-          id: text("id").notNull().$defaultFn(() => createId()),
+          id: text("id").notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: integer("userId").notNull(),
           _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
@@ -554,9 +604,10 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_test._internalId],
-            name: "fk_posts_users_author_test"
+            name: "fk_posts_users_author_test_8d48035c"
           }),
-          index("idx_user_test").on(table.userId)
+          index("idx_posts_idx_user_test_4a5c5c19").on(table.userId),
+          uniqueIndex("uidx_posts_idx_posts_external_id_test_80487638").on(table.id)
         ])
 
         export const users_testRelations = relations(users_test, ({ many }) => ({
@@ -591,7 +642,7 @@ describe("generateSchema", () => {
     });
 
     it("should handle table with only many relations (no foreign keys)", () => {
-      const manyOnlySchema = schema((s) => {
+      const manyOnlySchema = schema("manyonly", (s) => {
         return s
           .addTable("categories", (t) => {
             return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -609,14 +660,14 @@ describe("generateSchema", () => {
           });
       });
 
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: manyOnlySchema }],
         "postgresql",
       );
 
       // Categories table should NOT have a constraint callback (no foreign keys, no indexes)
       const categoriesTableMatch = generated.match(
-        /export const categories_test = pgTable\("categories_test", \{[^}]+\}\)/,
+        /export const categories_test = schema_test\.table\("categories", \{[^}]+\}\)/,
       );
       expect(categoriesTableMatch).toBeTruthy();
 
@@ -629,7 +680,7 @@ describe("generateSchema", () => {
       // Should have schema export
       expect(generated).toContain("export const test_schema = {");
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigserial, integer, bigint } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, text, bigserial, integer, bigint } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -637,15 +688,17 @@ describe("generateSchema", () => {
         // Fragment: test
         // ============================================================================
 
-        export const categories_test = pgTable("categories_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const categories_test = schema_test.table("categories", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
-        export const products_test = pgTable("products_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        export const products_test = schema_test.table("products", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           categoryId: bigint("categoryId", { mode: "number" }).notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -671,7 +724,7 @@ describe("generateSchema", () => {
     });
 
     it("should handle self-referencing many relations", () => {
-      const selfManySchema = schema((s) => {
+      const selfManySchema = schema("selfmany", (s) => {
         return s
           .addTable("category", (t) => {
             return t
@@ -691,7 +744,7 @@ describe("generateSchema", () => {
           });
       });
 
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: selfManySchema }],
         "postgresql",
       );
@@ -705,7 +758,7 @@ describe("generateSchema", () => {
       expect(fkMatches).toHaveLength(1);
 
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigint, bigserial, integer, foreignKey } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, text, bigint, bigserial, integer, foreignKey } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -713,8 +766,10 @@ describe("generateSchema", () => {
         // Fragment: test
         // ============================================================================
 
-        export const category_test = pgTable("category_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const category_test = schema_test.table("category", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -723,7 +778,7 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "fk_category_category_parent_test"
+            name: "fk_category_category_parent"
           })
         ])
 
@@ -752,8 +807,40 @@ describe("generateSchema", () => {
     });
   });
 
+  it("should skip join-only relations in schema output", () => {
+    const joinOnlySchema = schema("joinonly", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .createIndex("idx_users_email", ["email"]);
+        })
+        .addTable("invitations", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .createIndex("idx_inv_email", ["email"]);
+        })
+        .addReference("invitedUser", {
+          type: "one",
+          from: { table: "invitations", column: "email" },
+          to: { table: "users", column: "email" },
+          foreignKey: false,
+        });
+    });
+
+    const generated = generateDrizzleSchema(
+      [{ namespace: "test", schema: joinOnlySchema }],
+      "postgresql",
+    );
+
+    expect(generated).not.toContain("foreignKey(");
+    expect(generated).not.toContain("relations(");
+  });
+
   describe("self-referencing foreign keys", () => {
-    const selfRefSchema = schema((s) => {
+    const selfRefSchema = schema("selfref", (s) => {
       return s
         .addTable("comment", (t) => {
           return t
@@ -770,12 +857,12 @@ describe("generateSchema", () => {
     });
 
     it("should generate PostgreSQL self-referencing foreign key using table parameter", () => {
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: selfRefSchema }],
         "postgresql",
       );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigint, bigserial, integer, foreignKey, index } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, text, bigint, bigserial, integer, foreignKey, index } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -783,8 +870,10 @@ describe("generateSchema", () => {
         // Fragment: test
         // ============================================================================
 
-        export const comment_test = pgTable("comment_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_test = pgSchema("test");
+
+        export const comment_test = schema_test.table("comment", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -793,9 +882,9 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "fk_comment_comment_parent_test"
+            name: "fk_comment_comment_parent"
           }),
-          index("idx_parent_test").on(table.parentId)
+          index("idx_parent").on(table.parentId)
         ])
 
         export const comment_testRelations = relations(comment_test, ({ one, many }) => ({
@@ -820,7 +909,10 @@ describe("generateSchema", () => {
     });
 
     it("should generate MySQL self-referencing foreign key using table parameter", () => {
-      const generated = generateSchema([{ namespace: "test", schema: selfRefSchema }], "mysql");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: selfRefSchema }],
+        "mysql",
+      );
       expect(generated).toMatchInlineSnapshot(`
         "import { mysqlTable, varchar, text, bigint, int, foreignKey, index } from "drizzle-orm/mysql-core"
         import { createId } from "@fragno-dev/db/id"
@@ -831,7 +923,7 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const comment_test = mysqlTable("comment_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
           _internalId: bigint("_internalId", { mode: "number" }).primaryKey().autoincrement().notNull(),
@@ -840,9 +932,9 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "fk_comment_comment_parent_test"
+            name: "fk_comment_comment_parent_test_af0d05a4"
           }),
-          index("idx_parent_test").on(table.parentId)
+          index("idx_comment_idx_parent_test_3c264dbc").on(table.parentId)
         ])
 
         export const comment_testRelations = relations(comment_test, ({ one, many }) => ({
@@ -867,9 +959,12 @@ describe("generateSchema", () => {
     });
 
     it("should generate SQLite self-referencing foreign key using table parameter", () => {
-      const generated = generateSchema([{ namespace: "test", schema: selfRefSchema }], "sqlite");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "test", schema: selfRefSchema }],
+        "sqlite",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, foreignKey, index } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, foreignKey, index, uniqueIndex } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -878,7 +973,7 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const comment_test = sqliteTable("comment_test", {
-          id: text("id").notNull().$defaultFn(() => createId()),
+          id: text("id").notNull().unique().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: integer("parentId"),
           _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
@@ -887,9 +982,10 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "fk_comment_comment_parent_test"
+            name: "fk_comment_comment_parent_test_af0d05a4"
           }),
-          index("idx_parent_test").on(table.parentId)
+          index("idx_comment_idx_parent_test_3c264dbc").on(table.parentId),
+          uniqueIndex("uidx_comment_idx_comment_external_id_test_6a1c2b8f").on(table.id)
         ])
 
         export const comment_testRelations = relations(comment_test, ({ one, many }) => ({
@@ -915,8 +1011,8 @@ describe("generateSchema", () => {
   });
 
   describe("namespace sanitization", () => {
-    it("should sanitize namespace with hyphens for Drizzle compatibility", () => {
-      const generated = generateSchema(
+    it("should sanitize exports while preserving physical table names", () => {
+      const generated = generateDrizzleSchema(
         [{ namespace: "auth-db", schema: testSchema }],
         "postgresql",
       );
@@ -925,12 +1021,13 @@ describe("generateSchema", () => {
       expect(generated).toContain("export const users_auth_db =");
       expect(generated).toContain("export const posts_auth_db =");
 
-      // Physical table names must also be sanitized for Drizzle's relational query system
-      expect(generated).toContain('pgTable("users_auth_db"');
-      expect(generated).toContain('pgTable("posts_auth_db"');
+      // Physical table names use logical names with schema scoping
+      expect(generated).toContain('const schema_auth_db = pgSchema("auth-db");');
+      expect(generated).toContain('schema_auth_db.table("users"');
+      expect(generated).toContain('schema_auth_db.table("posts"');
 
-      // Foreign key name should use sanitized namespace
-      expect(generated).toContain('name: "fk_posts_users_author_auth_db"');
+      // Foreign key name should use the original namespace with hashed naming
+      expect(generated).toMatch(/name: "fk_posts_users_author"/);
 
       // Relations should reference sanitized table names
       expect(generated).toContain("foreignColumns: [users_auth_db._internalId]");
@@ -950,7 +1047,10 @@ describe("generateSchema", () => {
     });
 
     it("should generate inverse relations for namespaced tables", () => {
-      const generated = generateSchema([{ namespace: "my-app", schema: testSchema }], "postgresql");
+      const generated = generateDrizzleSchema(
+        [{ namespace: "my-app", schema: testSchema }],
+        "postgresql",
+      );
 
       // User should have inverse "many" relation to posts
       expect(generated).toMatch(
@@ -963,8 +1063,8 @@ describe("generateSchema", () => {
       expect(generated).toContain("posts_my_appRelations: posts_my_appRelations");
     });
 
-    it("should sanitize namespace with special characters in foreign key references", () => {
-      const generated = generateSchema(
+    it("should sanitize exports with special characters in foreign key references", () => {
+      const generated = generateDrizzleSchema(
         [{ namespace: "my-fragment-v2", schema: testSchema }],
         "postgresql",
       );
@@ -981,12 +1081,13 @@ describe("generateSchema", () => {
       expect(generated).toContain("fields: [posts_my_fragment_v2.userId]");
       expect(generated).toContain("references: [users_my_fragment_v2._internalId]");
 
-      // Physical table names must also be sanitized for Drizzle's relational query system
-      expect(generated).toContain('pgTable("users_my_fragment_v2"');
-      expect(generated).toContain('pgTable("posts_my_fragment_v2"');
+      // Physical table names use logical names with schema scoping
+      expect(generated).toContain('const schema_my_fragment_v2 = pgSchema("my-fragment-v2");');
+      expect(generated).toContain('schema_my_fragment_v2.table("users"');
+      expect(generated).toContain('schema_my_fragment_v2.table("posts"');
 
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, integer, bigserial, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
+        "import { pgSchema, varchar, text, integer, bigserial, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -994,20 +1095,22 @@ describe("generateSchema", () => {
         // Fragment: my-fragment-v2
         // ============================================================================
 
-        export const users_my_fragment_v2 = pgTable("users_my_fragment_v2", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        const schema_my_fragment_v2 = pgSchema("my-fragment-v2");
+
+        export const users_my_fragment_v2 = schema_my_fragment_v2.table("users", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: integer("age"),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email_my-fragment-v2").on(table.email),
-          index("idx_name_my-fragment-v2").on(table.name)
+          uniqueIndex("idx_email").on(table.email),
+          index("idx_name").on(table.name)
         ])
 
-        export const posts_my_fragment_v2 = pgTable("posts_my_fragment_v2", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+        export const posts_my_fragment_v2 = schema_my_fragment_v2.table("posts", {
+          id: varchar("id", { length: 128 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -1018,10 +1121,10 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.userId],
             foreignColumns: [users_my_fragment_v2._internalId],
-            name: "fk_posts_users_author_my_fragment_v2"
+            name: "fk_posts_users_author"
           }),
-          index("idx_user_my-fragment-v2").on(table.userId),
-          index("idx_title_my-fragment-v2").on(table.title)
+          index("idx_user").on(table.userId),
+          index("idx_title").on(table.title)
         ])
 
         export const users_my_fragment_v2Relations = relations(users_my_fragment_v2, ({ many }) => ({
@@ -1056,23 +1159,23 @@ describe("generateSchema", () => {
   describe("schema generation", () => {
     it("should generate settings schema and multiple user fragments", () => {
       // settingsSchema is imported at the top to simulate what happens with linked internal fragments
-      const fragment1Schema = schema((s) => {
+      const fragment1Schema = schema("fragment1", (s) => {
         return s.addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
         });
       });
 
-      const fragment2Schema = schema((s) => {
+      const fragment2Schema = schema("fragment2", (s) => {
         return s.addTable("posts", (t) => {
           return t.addColumn("id", idColumn()).addColumn("title", column("string"));
         });
       });
 
-      // De-duplication happens in generation-engine.ts before calling generateSchema
-      // This test verifies generateSchema works correctly with already-deduplicated inputs
-      const generated = generateSchema(
+      // De-duplication happens in generation-engine.ts before calling generateDrizzleSchema
+      // This test verifies generateDrizzleSchema works correctly with already-deduplicated inputs
+      const generated = generateDrizzleSchema(
         [
-          { namespace: "", schema: internalSchema }, // Internal fragment (namespace: "")
+          { namespace: null, schema: internalSchema }, // Internal fragment (namespace: null)
           { namespace: "fragment1", schema: fragment1Schema },
           { namespace: "fragment2", schema: fragment2Schema },
         ],
@@ -1104,14 +1207,14 @@ describe("generateSchema", () => {
 
     it("should generate schema for single fragment with custom namespace", () => {
       // Test a simple single-schema generation
-      const sharedSchema = schema((s) => {
+      const sharedSchema = schema("shared", (s) => {
         return s.addTable("shared_table", (t) => {
           return t.addColumn("id", idColumn()).addColumn("data", column("string"));
         });
       });
 
       // De-duplication happens in generation-engine.ts, so we pass pre-deduplicated input
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "namespace1", schema: sharedSchema }],
         "postgresql",
       );