@fragno-dev/db 0.2.2 → 0.3.0

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

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import { generateSchema } from "./generate";
-import { internalSchema } from "../../fragments/internal-fragment";
+import { column, idColumn, referenceColumn, schema } from "../schema/create";
+import { generateDrizzleSchema } from "./drizzle";
+import { internalSchema } from "../fragments/internal-fragment";
 
-describe("generateSchema", () => {
-  const testSchema = schema((s) => {
+describe("generateDrizzleSchema", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -34,9 +34,12 @@ describe("generateSchema", () => {
 
   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 +47,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: 30 }).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: 30 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -68,10 +73,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 +110,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 +121,19 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const users_test = mysqlTable("users_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 30 }).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: 30 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -139,10 +144,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 +181,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 +195,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 +219,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 +257,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 +266,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: 30 }).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 +296,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 +305,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: 30 }).notNull().unique().$defaultFn(() => createId()),
           createdAt: timestamp("createdAt").notNull().defaultNow(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
@@ -323,15 +337,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 +371,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: 30 }).notNull().unique().$defaultFn(() => createId()),
           data: customBinary("data").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
@@ -371,7 +390,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 +415,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 +428,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: 30 }).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: 30 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -426,9 +447,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 +484,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 +498,14 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const users_test = mysqlTable("users_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 30 }).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: 30 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
           _internalId: bigint("_internalId", { mode: "number" }).primaryKey().autoincrement().notNull(),
@@ -490,9 +514,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 +551,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 +565,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 +583,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 +621,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 +639,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 +659,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 +667,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: 30 }).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: 30 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           categoryId: bigint("categoryId", { mode: "number" }).notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -671,7 +703,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 +723,7 @@ describe("generateSchema", () => {
           });
       });
 
-      const generated = generateSchema(
+      const generated = generateDrizzleSchema(
         [{ namespace: "test", schema: selfManySchema }],
         "postgresql",
       );
@@ -705,7 +737,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 +745,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: 30 }).notNull().unique().$defaultFn(() => createId()),
           name: text("name").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -723,7 +757,7 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "fk_category_category_parent_test"
+            name: "fk_category_category_parent"
           })
         ])
 
@@ -753,7 +787,7 @@ describe("generateSchema", () => {
   });
 
   describe("self-referencing foreign keys", () => {
-    const selfRefSchema = schema((s) => {
+    const selfRefSchema = schema("selfref", (s) => {
       return s
         .addTable("comment", (t) => {
           return t
@@ -770,12 +804,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 +817,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: 30 }).notNull().unique().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
@@ -793,9 +829,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 +856,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 +870,7 @@ describe("generateSchema", () => {
         // ============================================================================
 
         export const comment_test = mysqlTable("comment_test", {
-          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          id: varchar("id", { length: 30 }).notNull().unique().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
           _internalId: bigint("_internalId", { mode: "number" }).primaryKey().autoincrement().notNull(),
@@ -840,9 +879,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 +906,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 +920,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 +929,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 +958,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 +968,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 +994,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 +1010,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 +1028,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 +1042,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: 30 }).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: 30 }).notNull().unique().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -1018,10 +1068,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 +1106,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 +1154,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",
       );