@fragno-dev/db 0.1.1 → 0.1.3

package/src/adapters/drizzle/generate.test.ts

@@ -33,13 +33,33 @@ describe("generateSchema", () => {
 
   describe("postgresql", () => {
     it("should generate PostgreSQL schema", () => {
-      const generated = generateSchema(testSchema, "postgresql");
+      const generated = generateSchema([{ namespace: "test", schema: testSchema }], "postgresql");
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, integer, bigserial, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const users = pgTable("users", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const users_test = pgTable("users_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
@@ -47,11 +67,11 @@ describe("generateSchema", () => {
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email").on(table.email),
-          index("idx_name").on(table.name)
+          uniqueIndex("idx_email_test").on(table.email),
+          index("idx_name_test").on(table.name)
         ])
 
-        export const posts = pgTable("posts", {
+        export const posts_test = pgTable("posts_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
@@ -62,33 +82,61 @@ describe("generateSchema", () => {
         }, (table) => [
           foreignKey({
             columns: [table.userId],
-            foreignColumns: [users._internalId],
-            name: "posts_users_author_fk"
+            foreignColumns: [users_test._internalId],
+            name: "fk_posts_users_author_test"
           }),
-          index("idx_user").on(table.userId),
-          index("idx_title").on(table.title)
+          index("idx_user_test").on(table.userId),
+          index("idx_title_test").on(table.title)
         ])
 
-        export const postsRelations = relations(posts, ({ one }) => ({
-          author: one(users, {
+        export const posts_testRelations = relations(posts_test, ({ one }) => ({
+          author: one(users_test, {
             relationName: "posts_users",
-            fields: [posts.userId],
-            references: [users._internalId]
+            fields: [posts_test.userId],
+            references: [users_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "users_test": users_test,
+          users: users_test,
+          "posts_test": posts_test,
+          posts: posts_test,
+          schemaVersion: 3
+        }"
       `);
     });
   });
 
   describe("mysql", () => {
     it("should generate MySQL schema", () => {
-      const generated = generateSchema(testSchema, "mysql");
+      const generated = generateSchema([{ namespace: "test", schema: testSchema }], "mysql");
       expect(generated).toMatchInlineSnapshot(`
-        "import { mysqlTable, varchar, text, integer, bigint, uniqueIndex, index, foreignKey } from "drizzle-orm/mysql-core"
+        "import { mysqlTable, varchar, text, bigint, integer, uniqueIndex, index, foreignKey } from "drizzle-orm/mysql-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const users = mysqlTable("users", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = mysqlTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigint("_internalId").primaryKey().autoincrement().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const users_test = mysqlTable("users_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
@@ -96,11 +144,11 @@ describe("generateSchema", () => {
           _internalId: bigint("_internalId").primaryKey().autoincrement().notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email").on(table.email),
-          index("idx_name").on(table.name)
+          uniqueIndex("idx_email_test").on(table.email),
+          index("idx_name_test").on(table.name)
         ])
 
-        export const posts = mysqlTable("posts", {
+        export const posts_test = mysqlTable("posts_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
@@ -111,69 +159,105 @@ describe("generateSchema", () => {
         }, (table) => [
           foreignKey({
             columns: [table.userId],
-            foreignColumns: [users._internalId],
-            name: "posts_users_author_fk"
+            foreignColumns: [users_test._internalId],
+            name: "fk_posts_users_author_test"
           }),
-          index("idx_user").on(table.userId),
-          index("idx_title").on(table.title)
+          index("idx_user_test").on(table.userId),
+          index("idx_title_test").on(table.title)
         ])
 
-        export const postsRelations = relations(posts, ({ one }) => ({
-          author: one(users, {
+        export const posts_testRelations = relations(posts_test, ({ one }) => ({
+          author: one(users_test, {
             relationName: "posts_users",
-            fields: [posts.userId],
-            references: [users._internalId]
+            fields: [posts_test.userId],
+            references: [users_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "users_test": users_test,
+          users: users_test,
+          "posts_test": posts_test,
+          posts: posts_test,
+          schemaVersion: 3
+        }"
       `);
     });
   });
 
   describe("sqlite", () => {
     it("should generate SQLite schema", () => {
-      const generated = generateSchema(testSchema, "sqlite");
+      const generated = generateSchema([{ namespace: "test", schema: testSchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, index, blob, foreignKey } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, index, foreignKey } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const users = sqliteTable("users", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = sqliteTable("fragno_db_settings", {
+          id: text("id").notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const users_test = sqliteTable("users_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: integer("age"),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
-          uniqueIndex("idx_email").on(table.email),
-          index("idx_name").on(table.name)
+          uniqueIndex("idx_email_test").on(table.email),
+          index("idx_name_test").on(table.name)
         ])
 
-        export const posts = sqliteTable("posts", {
+        export const posts_test = sqliteTable("posts_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
-          userId: blob("userId", { mode: "bigint" }).notNull(),
+          userId: integer("userId").notNull(),
           viewCount: integer("viewCount").notNull().default(0),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
             columns: [table.userId],
-            foreignColumns: [users._internalId],
-            name: "posts_users_author_fk"
+            foreignColumns: [users_test._internalId],
+            name: "fk_posts_users_author_test"
           }),
-          index("idx_user").on(table.userId),
-          index("idx_title").on(table.title)
+          index("idx_user_test").on(table.userId),
+          index("idx_title_test").on(table.title)
         ])
 
-        export const postsRelations = relations(posts, ({ one }) => ({
-          author: one(users, {
+        export const posts_testRelations = relations(posts_test, ({ one }) => ({
+          author: one(users_test, {
             relationName: "posts_users",
-            fields: [posts.userId],
-            references: [users._internalId]
+            fields: [posts_test.userId],
+            references: [users_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "users_test": users_test,
+          users: users_test,
+          "posts_test": posts_test,
+          posts: posts_test,
+          schemaVersion: 3
+        }"
       `);
     });
   });
@@ -182,23 +266,106 @@ describe("generateSchema", () => {
     it("should handle runtime default values", () => {
       const timestampSchema = schema((s) => {
         return s.addTable("events", (t) => {
-          return t
-            .addColumn("id", idColumn())
-            .addColumn("createdAt", column("timestamp").defaultTo$("now"));
+          return t.addColumn("id", idColumn()).addColumn(
+            "createdAt",
+            column("timestamp").defaultTo$((b) => b.now()),
+          );
+        });
+      });
+
+      const generated = generateSchema(
+        [{ namespace: "test", schema: timestampSchema }],
+        "postgresql",
+      );
+      expect(generated).toMatchInlineSnapshot(`
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, timestamp } from "drizzle-orm/pg-core"
+        import { createId } from "@fragno-dev/db/id"
+
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const events_test = pgTable("events_test", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          createdAt: timestamp("createdAt").notNull().$defaultFn(() => new Date()),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        })
+
+        export const test_schema = {
+          "events_test": events_test,
+          events: events_test,
+          schemaVersion: 1
+        }"
+      `);
+    });
+
+    it("should handle database-level default values", () => {
+      const timestampSchema = schema((s) => {
+        return s.addTable("events", (t) => {
+          return t.addColumn("id", idColumn()).addColumn(
+            "createdAt",
+            column("timestamp").defaultTo((b) => b.now()),
+          );
         });
       });
 
-      const generated = generateSchema(timestampSchema, "postgresql");
+      const generated = generateSchema(
+        [{ namespace: "test", schema: timestampSchema }],
+        "postgresql",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, timestamp, bigserial, integer } from "drizzle-orm/pg-core"
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, timestamp } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
 
-        export const events = pgTable("events", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const events_test = pgTable("events_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           createdAt: timestamp("createdAt").notNull().defaultNow(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
-        })"
+        })
+
+        export const test_schema = {
+          "events_test": events_test,
+          events: events_test,
+          schemaVersion: 1
+        }"
       `);
     });
   });
@@ -211,11 +378,10 @@ describe("generateSchema", () => {
         });
       });
 
-      const generated = generateSchema(binarySchema, "postgresql");
+      const generated = generateSchema([{ namespace: "test", schema: binarySchema }], "postgresql");
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, customType, bigserial, integer } from "drizzle-orm/pg-core"
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, customType } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
-
         const customBinary = customType<
           {
             data: Uint8Array;
@@ -233,12 +399,38 @@ describe("generateSchema", () => {
           }
         });
 
-        export const files = pgTable("files", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const files_test = pgTable("files_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           data: customBinary("data").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
-        })"
+        })
+
+        export const test_schema = {
+          "files_test": files_test,
+          files: files_test,
+          schemaVersion: 1
+        }"
       `);
     });
   });
@@ -269,26 +461,49 @@ describe("generateSchema", () => {
     });
 
     it("should generate PostgreSQL schema with many relations", () => {
-      const generated = generateSchema(oneToManySchema, "postgresql");
+      const generated = generateSchema(
+        [{ namespace: "test", schema: oneToManySchema }],
+        "postgresql",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigserial, integer, bigint, foreignKey, index } from "drizzle-orm/pg-core"
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, bigint, foreignKey, index } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const users = pgTable("users", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const users_test = pgTable("users_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
-        export const usersRelations = relations(users, ({ many }) => ({
-          posts: many(posts, {
+        export const users_testRelations = relations(users_test, ({ many }) => ({
+          posts: many(posts_test, {
             relationName: "users_posts"
           })
         }));
 
-        export const posts = pgTable("posts", {
+        export const posts_test = pgTable("posts_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: bigint("userId", { mode: "number" }).notNull(),
@@ -297,43 +512,71 @@ describe("generateSchema", () => {
         }, (table) => [
           foreignKey({
             columns: [table.userId],
-            foreignColumns: [users._internalId],
-            name: "posts_users_author_fk"
+            foreignColumns: [users_test._internalId],
+            name: "fk_posts_users_author_test"
           }),
-          index("idx_user").on(table.userId)
+          index("idx_user_test").on(table.userId)
         ])
 
-        export const postsRelations = relations(posts, ({ one }) => ({
-          author: one(users, {
+        export const posts_testRelations = relations(posts_test, ({ one }) => ({
+          author: one(users_test, {
             relationName: "posts_users",
-            fields: [posts.userId],
-            references: [users._internalId]
+            fields: [posts_test.userId],
+            references: [users_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "users_test": users_test,
+          users: users_test,
+          "posts_test": posts_test,
+          posts: posts_test,
+          schemaVersion: 4
+        }"
       `);
     });
 
     it("should generate MySQL schema with many relations", () => {
-      const generated = generateSchema(oneToManySchema, "mysql");
+      const generated = generateSchema([{ namespace: "test", schema: oneToManySchema }], "mysql");
       expect(generated).toMatchInlineSnapshot(`
-        "import { mysqlTable, varchar, text, bigint, integer, foreignKey, index } from "drizzle-orm/mysql-core"
+        "import { mysqlTable, varchar, text, bigint, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/mysql-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const users = mysqlTable("users", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = mysqlTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigint("_internalId").primaryKey().autoincrement().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const users_test = mysqlTable("users_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: bigint("_internalId").primaryKey().autoincrement().notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
-        export const usersRelations = relations(users, ({ many }) => ({
-          posts: many(posts, {
+        export const users_testRelations = relations(users_test, ({ many }) => ({
+          posts: many(posts_test, {
             relationName: "users_posts"
           })
         }));
 
-        export const posts = mysqlTable("posts", {
+        export const posts_test = mysqlTable("posts_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           userId: bigint("userId").notNull(),
@@ -342,64 +585,100 @@ describe("generateSchema", () => {
         }, (table) => [
           foreignKey({
             columns: [table.userId],
-            foreignColumns: [users._internalId],
-            name: "posts_users_author_fk"
+            foreignColumns: [users_test._internalId],
+            name: "fk_posts_users_author_test"
           }),
-          index("idx_user").on(table.userId)
+          index("idx_user_test").on(table.userId)
         ])
 
-        export const postsRelations = relations(posts, ({ one }) => ({
-          author: one(users, {
+        export const posts_testRelations = relations(posts_test, ({ one }) => ({
+          author: one(users_test, {
             relationName: "posts_users",
-            fields: [posts.userId],
-            references: [users._internalId]
+            fields: [posts_test.userId],
+            references: [users_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "users_test": users_test,
+          users: users_test,
+          "posts_test": posts_test,
+          posts: posts_test,
+          schemaVersion: 4
+        }"
       `);
     });
 
     it("should generate SQLite schema with many relations", () => {
-      const generated = generateSchema(oneToManySchema, "sqlite");
+      const generated = generateSchema([{ namespace: "test", schema: oneToManySchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, blob, 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"
 
-        export const users = sqliteTable("users", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = sqliteTable("fragno_db_settings", {
+          id: text("id").notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const users_test = sqliteTable("users_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
-        export const usersRelations = relations(users, ({ many }) => ({
-          posts: many(posts, {
+        export const users_testRelations = relations(users_test, ({ many }) => ({
+          posts: many(posts_test, {
             relationName: "users_posts"
           })
         }));
 
-        export const posts = sqliteTable("posts", {
+        export const posts_test = sqliteTable("posts_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
-          userId: blob("userId", { mode: "bigint" }).notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          userId: integer("userId").notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
             columns: [table.userId],
-            foreignColumns: [users._internalId],
-            name: "posts_users_author_fk"
+            foreignColumns: [users_test._internalId],
+            name: "fk_posts_users_author_test"
           }),
-          index("idx_user").on(table.userId)
+          index("idx_user_test").on(table.userId)
         ])
 
-        export const postsRelations = relations(posts, ({ one }) => ({
-          author: one(users, {
+        export const posts_testRelations = relations(posts_test, ({ one }) => ({
+          author: one(users_test, {
             relationName: "posts_users",
-            fields: [posts.userId],
-            references: [users._internalId]
+            fields: [posts_test.userId],
+            references: [users_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "users_test": users_test,
+          users: users_test,
+          "posts_test": posts_test,
+          posts: posts_test,
+          schemaVersion: 4
+        }"
       `);
     });
 
@@ -422,44 +701,78 @@ describe("generateSchema", () => {
           });
       });
 
-      const generated = generateSchema(manyOnlySchema, "postgresql");
+      const generated = generateSchema(
+        [{ 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 = pgTable\("categories", \{[^}]+\}\)/,
+        /export const categories_test = pgTable\("categories_test", \{[^}]+\}\)/,
       );
       expect(categoriesTableMatch).toBeTruthy();
 
       // Should have relations with many
       expect(generated).toContain(
-        "export const categoriesRelations = relations(categories, ({ many }) => ({",
+        "export const categories_testRelations = relations(categories_test, ({ many }) => ({",
       );
-      expect(generated).toContain("products: many(products");
+      expect(generated).toContain("products: many(products_test");
+
+      // 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 { pgTable, varchar, text, bigserial, integer, uniqueIndex, bigint } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const categories = pgTable("categories", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const categories_test = pgTable("categories_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
-        export const categoriesRelations = relations(categories, ({ many }) => ({
-          products: many(products, {
+        export const categories_testRelations = relations(categories_test, ({ many }) => ({
+          products: many(products_test, {
             relationName: "categories_products"
           })
         }));
 
-        export const products = pgTable("products", {
+        export const products_test = pgTable("products_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           categoryId: bigint("categoryId", { mode: "number" }).notNull(),
           _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
           _version: integer("_version").notNull().default(0)
-        })"
+        })
+
+        export const test_schema = {
+          "categories_test": categories_test,
+          categories: categories_test,
+          "products_test": products_test,
+          products: products_test,
+          schemaVersion: 3
+        }"
       `);
     });
 
@@ -484,22 +797,45 @@ describe("generateSchema", () => {
           });
       });
 
-      const generated = generateSchema(selfManySchema, "postgresql");
+      const generated = generateSchema(
+        [{ namespace: "test", schema: selfManySchema }],
+        "postgresql",
+      );
 
       // Should have both one and many relations
-      expect(generated).toContain("parent: one(category");
-      expect(generated).toContain("children: many(category");
+      expect(generated).toContain("parent: one(category_test");
+      expect(generated).toContain("children: many(category_test");
 
       // Should only have one foreign key (from the "one" relation)
       const fkMatches = generated.match(/foreignKey\(/g);
       expect(fkMatches).toHaveLength(1);
 
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigint, bigserial, integer, foreignKey } from "drizzle-orm/pg-core"
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, bigint, foreignKey } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const category = pgTable("category", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const category_test = pgTable("category_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
@@ -509,20 +845,26 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "category_category_parent_fk"
+            name: "fk_category_category_parent_test"
           })
         ])
 
-        export const categoryRelations = relations(category, ({ one, many }) => ({
-          parent: one(category, {
+        export const category_testRelations = relations(category_test, ({ one, many }) => ({
+          parent: one(category_test, {
             relationName: "category_category",
-            fields: [category.parentId],
-            references: [category._internalId]
+            fields: [category_test.parentId],
+            references: [category_test._internalId]
           }),
-          children: many(category, {
+          children: many(category_test, {
             relationName: "category_category"
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "category_test": category_test,
+          category: category_test,
+          schemaVersion: 3
+        }"
       `);
     });
   });
@@ -545,13 +887,36 @@ describe("generateSchema", () => {
     });
 
     it("should generate PostgreSQL self-referencing foreign key using table parameter", () => {
-      const generated = generateSchema(selfRefSchema, "postgresql");
+      const generated = generateSchema(
+        [{ namespace: "test", schema: selfRefSchema }],
+        "postgresql",
+      );
       expect(generated).toMatchInlineSnapshot(`
-        "import { pgTable, varchar, text, bigint, bigserial, integer, foreignKey, index } from "drizzle-orm/pg-core"
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, bigint, foreignKey, index } from "drizzle-orm/pg-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const comment = pgTable("comment", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const comment_test = pgTable("comment_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: bigint("parentId", { mode: "number" }),
@@ -561,29 +926,55 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "comment_comment_parent_fk"
+            name: "fk_comment_comment_parent_test"
           }),
-          index("idx_parent").on(table.parentId)
+          index("idx_parent_test").on(table.parentId)
         ])
 
-        export const commentRelations = relations(comment, ({ one }) => ({
-          parent: one(comment, {
+        export const comment_testRelations = relations(comment_test, ({ one }) => ({
+          parent: one(comment_test, {
             relationName: "comment_comment",
-            fields: [comment.parentId],
-            references: [comment._internalId]
+            fields: [comment_test.parentId],
+            references: [comment_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "comment_test": comment_test,
+          comment: comment_test,
+          schemaVersion: 2
+        }"
       `);
     });
 
     it("should generate MySQL self-referencing foreign key using table parameter", () => {
-      const generated = generateSchema(selfRefSchema, "mysql");
+      const generated = generateSchema([{ namespace: "test", schema: selfRefSchema }], "mysql");
       expect(generated).toMatchInlineSnapshot(`
-        "import { mysqlTable, varchar, text, bigint, integer, foreignKey, index } from "drizzle-orm/mysql-core"
+        "import { mysqlTable, varchar, text, bigint, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/mysql-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
-        export const comment = mysqlTable("comment", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = mysqlTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigint("_internalId").primaryKey().autoincrement().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const comment_test = mysqlTable("comment_test", {
           id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
           content: text("content").notNull(),
           parentId: bigint("parentId"),
@@ -593,50 +984,82 @@ describe("generateSchema", () => {
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "comment_comment_parent_fk"
+            name: "fk_comment_comment_parent_test"
           }),
-          index("idx_parent").on(table.parentId)
+          index("idx_parent_test").on(table.parentId)
         ])
 
-        export const commentRelations = relations(comment, ({ one }) => ({
-          parent: one(comment, {
+        export const comment_testRelations = relations(comment_test, ({ one }) => ({
+          parent: one(comment_test, {
             relationName: "comment_comment",
-            fields: [comment.parentId],
-            references: [comment._internalId]
+            fields: [comment_test.parentId],
+            references: [comment_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "comment_test": comment_test,
+          comment: comment_test,
+          schemaVersion: 2
+        }"
       `);
     });
 
     it("should generate SQLite self-referencing foreign key using table parameter", () => {
-      const generated = generateSchema(selfRefSchema, "sqlite");
+      const generated = generateSchema([{ namespace: "test", schema: selfRefSchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, blob, 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"
 
-        export const comment = sqliteTable("comment", {
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = sqliteTable("fragno_db_settings", {
+          id: text("id").notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: test
+        // ============================================================================
+
+        export const comment_test = sqliteTable("comment_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           content: text("content").notNull(),
-          parentId: blob("parentId", { mode: "bigint" }),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          parentId: integer("parentId"),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
             columns: [table.parentId],
             foreignColumns: [table._internalId],
-            name: "comment_comment_parent_fk"
+            name: "fk_comment_comment_parent_test"
           }),
-          index("idx_parent").on(table.parentId)
+          index("idx_parent_test").on(table.parentId)
         ])
 
-        export const commentRelations = relations(comment, ({ one }) => ({
-          parent: one(comment, {
+        export const comment_testRelations = relations(comment_test, ({ one }) => ({
+          parent: one(comment_test, {
             relationName: "comment_comment",
-            fields: [comment.parentId],
-            references: [comment._internalId]
+            fields: [comment_test.parentId],
+            references: [comment_test._internalId]
           })
-        }));"
+        }));
+
+        export const test_schema = {
+          "comment_test": comment_test,
+          comment: comment_test,
+          schemaVersion: 2
+        }"
       `);
     });
   });