@fragno-dev/db 0.1.1 → 0.1.3

package/src/adapters/drizzle/generate.ts

@@ -8,6 +8,8 @@ import {
 } from "../../schema/create";
 import type { SQLProvider } from "../../shared/providers";
 import { schemaToDBType, type DBTypeLiteral } from "../../schema/serialize";
+import { createTableNameMapper } from "./shared";
+import { settingsSchema, SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
 
 // ============================================================================
 // PROVIDER CONFIGURATION
@@ -246,12 +248,16 @@ function generateColumnDefinition(
 
   // Primary key for internal ID
   if (column instanceof InternalIdColumn || column.role === "internal-id") {
-    parts.push("primaryKey()");
-
-    // Auto-increment based on provider
-    // Note: PostgreSQL uses bigserial/serial which handle auto-increment automatically
-    if (ctx.provider === "mysql" || ctx.provider === "sqlite") {
+    if (ctx.provider === "sqlite") {
+      // SQLite uses primaryKey({ autoIncrement: true })
+      parts.push("primaryKey({ autoIncrement: true })");
+    } else if (ctx.provider === "mysql") {
+      // MySQL uses primaryKey().autoincrement()
+      parts.push("primaryKey()");
       parts.push("autoincrement()");
+    } else {
+      // PostgreSQL just uses primaryKey()
+      parts.push("primaryKey()");
     }
   }
 
@@ -263,6 +269,7 @@ function generateColumnDefinition(
   // Default values
   if (column.default) {
     if ("value" in column.default) {
+      // Static defaults: defaultTo(value)
       let value: string;
       if (typeof column.default.value === "bigint") {
         ctx.imports.addImport("sql", "drizzle-orm");
@@ -271,12 +278,22 @@ function generateColumnDefinition(
         value = JSON.stringify(column.default.value);
       }
       parts.push(`default(${value})`);
-    } else if (column.default.runtime === "auto") {
-      const idGen = ctx.idGeneratorImport ?? { name: "createId", from: "@fragno-dev/db/id" };
-      ctx.imports.addImport(idGen.name, idGen.from);
-      parts.push(`$defaultFn(() => ${idGen.name}())`);
-    } else if (column.default.runtime === "now") {
-      parts.push("defaultNow()");
+    } else if ("dbSpecial" in column.default) {
+      // Database-level special functions: defaultTo(b => b.now())
+      if (column.default.dbSpecial === "now") {
+        parts.push("defaultNow()");
+      }
+    } else if ("runtime" in column.default) {
+      // Runtime defaults: defaultTo$()
+      if (column.default.runtime === "cuid") {
+        const idGen = ctx.idGeneratorImport ?? { name: "createId", from: "@fragno-dev/db/id" };
+        ctx.imports.addImport(idGen.name, idGen.from);
+        parts.push(`$defaultFn(() => ${idGen.name}())`);
+      } else if (column.default.runtime === "now") {
+        // Runtime-generated timestamp (not database-level)
+        parts.push("$defaultFn(() => new Date())");
+      }
+      // Note: Custom functions in defaultTo$(() => ...) are not supported in schema generation
     }
   }
 
@@ -297,7 +314,8 @@ function generateAllColumns(
 // CONSTRAINT GENERATION
 // ============================================================================
 
-function generateForeignKeys(ctx: GeneratorContext, table: AnyTable): string[] {
+function generateForeignKeys(ctx: GeneratorContext, table: AnyTable, namespace?: string): string[] {
+  const mapper = namespace ? createTableNameMapper(namespace) : undefined;
   const keys: string[] = [];
 
   for (const relation of Object.values(table.relations)) {
@@ -319,12 +337,19 @@ function generateForeignKeys(ctx: GeneratorContext, table: AnyTable): string[] {
       if (isSelfReference) {
         foreignColumns.push(`table.${actualRefCol}`);
       } else {
-        foreignColumns.push(`${relation.table.ormName}.${actualRefCol}`);
+        // Suffix the foreign table reference with namespace if provided
+        const foreignTableRef =
+          mapper && namespace ? mapper.toPhysical(relation.table.ormName) : relation.table.ormName;
+        foreignColumns.push(`${foreignTableRef}.${actualRefCol}`);
       }
     }
 
     ctx.imports.addImport("foreignKey", ctx.importSource);
-    const fkName = `${table.ormName}_${relation.table.ormName}_${relation.name}_fk`;
+    // Include namespace in FK name to avoid collisions
+    const fkName =
+      namespace && mapper
+        ? "fk_" + mapper.toPhysical(`${table.ormName}_${relation.table.ormName}_${relation.name}`)
+        : `${table.ormName}_${relation.table.ormName}_${relation.name}_fk`;
 
     keys.push(`foreignKey({
   columns: [${columns.join(", ")}],
@@ -336,53 +361,74 @@ function generateForeignKeys(ctx: GeneratorContext, table: AnyTable): string[] {
   return keys;
 }
 
-function generateIndexes(ctx: GeneratorContext, table: AnyTable): string[] {
+function generateIndexes(ctx: GeneratorContext, table: AnyTable, namespace?: string): string[] {
   const indexes: string[] = [];
 
   for (const idx of Object.values(table.indexes)) {
     const columns = idx.columns.map((col) => `table.${col.ormName}`).join(", ");
 
+    // Include namespace in index name to avoid collisions
+    const indexName = namespace ? `${idx.name}_${namespace}` : idx.name;
+
     if (idx.unique) {
       ctx.imports.addImport("uniqueIndex", ctx.importSource);
-      indexes.push(`uniqueIndex("${idx.name}").on(${columns})`);
+      indexes.push(`uniqueIndex("${indexName}").on(${columns})`);
     } else {
       ctx.imports.addImport("index", ctx.importSource);
-      indexes.push(`index("${idx.name}").on(${columns})`);
+      indexes.push(`index("${indexName}").on(${columns})`);
     }
   }
 
   return indexes;
 }
 
-function generateTableConstraints(ctx: GeneratorContext, table: AnyTable): string[] {
-  return [...generateForeignKeys(ctx, table), ...generateIndexes(ctx, table)];
+function generateTableConstraints(
+  ctx: GeneratorContext,
+  table: AnyTable,
+  namespace?: string,
+): string[] {
+  return [...generateForeignKeys(ctx, table, namespace), ...generateIndexes(ctx, table, namespace)];
 }
 
 // ============================================================================
 // TABLE GENERATION
 // ============================================================================
 
-function generateTable(ctx: GeneratorContext, table: AnyTable, customTypes: string[]): string {
+function generateTable(
+  ctx: GeneratorContext,
+  table: AnyTable,
+  customTypes: string[],
+  namespace?: string,
+): string {
   const tableFn = PROVIDER_TABLE_FUNCTIONS[ctx.provider];
   ctx.imports.addImport(tableFn, ctx.importSource);
 
   const columns = generateAllColumns(ctx, table, customTypes);
-  const constraints = generateTableConstraints(ctx, table);
+  const constraints = generateTableConstraints(ctx, table, namespace);
+
+  // Suffix table name with namespace if provided
+  const physicalTableName = namespace ? `${table.ormName}_${namespace}` : table.ormName;
+  // Sanitize namespace for use in export name (valid JS identifier)
+  const exportName = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
 
-  const args: string[] = [`"${table.ormName}"`, `{\n${columns.join(",\n")}\n}`];
+  const args: string[] = [`"${physicalTableName}"`, `{\n${columns.join(",\n")}\n}`];
 
   if (constraints.length > 0) {
     args.push(`(table) => [\n${ident(constraints.join(",\n"))}\n]`);
   }
 
-  return `export const ${table.ormName} = ${tableFn}(${args.join(", ")})`;
+  return `export const ${exportName} = ${tableFn}(${args.join(", ")})`;
 }
 
 // ============================================================================
 // RELATION GENERATION
 // ============================================================================
 
-function generateRelation(ctx: GeneratorContext, table: AnyTable): string | undefined {
+function generateRelation(
+  ctx: GeneratorContext,
+  table: AnyTable,
+  namespace?: string,
+): string | undefined {
   const relations: string[] = [];
   let hasOne = false;
   let hasMany = false;
@@ -402,17 +448,29 @@ function generateRelation(ctx: GeneratorContext, table: AnyTable): string | unde
       const fields: string[] = [];
       const references: string[] = [];
 
+      // Use sanitized namespace for identifier references
+      const tableRef = namespace
+        ? `${table.ormName}_${sanitizeNamespace(namespace)}`
+        : table.ormName;
+      const relatedTableRef = namespace
+        ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
+        : relation.table.ormName;
+
       for (const [left, right] of relation.on) {
-        fields.push(`${table.ormName}.${left}`);
+        fields.push(`${tableRef}.${left}`);
         // Relations reference internal IDs
         const actualRight = right === "id" ? "_internalId" : right;
-        references.push(`${relation.table.ormName}.${actualRight}`);
+        references.push(`${relatedTableRef}.${actualRight}`);
       }
 
       options.push(`fields: [${fields.join(", ")}]`, `references: [${references.join(", ")}]`);
     }
 
-    const args: string[] = [relation.table.ormName];
+    const relatedTableRef = namespace
+      ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
+      : relation.table.ormName;
+
+    const args: string[] = [relatedTableRef];
     if (options.length > 0) {
       args.push(`{\n${ident(options.join(",\n"))}\n}`);
     }
@@ -434,12 +492,59 @@ function generateRelation(ctx: GeneratorContext, table: AnyTable): string | unde
   }
   const relationParams = params.length > 0 ? `{ ${params.join(", ")} }` : "{}";
 
+  const tableRef = namespace ? `${table.ormName}_${sanitizeNamespace(namespace)}` : table.ormName;
+  const relationsName = namespace
+    ? `${table.ormName}_${sanitizeNamespace(namespace)}Relations`
+    : `${table.ormName}Relations`;
+
   ctx.imports.addImport("relations", "drizzle-orm");
-  return `export const ${table.ormName}Relations = relations(${table.ormName}, (${relationParams}) => ({
+  return `export const ${relationsName} = relations(${tableRef}, (${relationParams}) => ({
 ${relations.join(",\n")}
 }));`;
 }
 
+// ============================================================================
+// UTILITIES
+// ============================================================================
+
+/**
+ * Sanitize a namespace to be a valid JavaScript identifier
+ * Replaces hyphens and other invalid characters with underscores
+ */
+function sanitizeNamespace(namespace: string): string {
+  return namespace.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+/**
+ * Generate a schema export object for a fragment
+ * This groups all tables by their logical names for easier access
+ */
+function generateFragmentSchemaExport(schema: AnySchema, namespace: string): string {
+  const entries: string[] = [];
+
+  for (const table of Object.values(schema.tables)) {
+    const physicalExportName = namespace
+      ? `${table.ormName}_${sanitizeNamespace(namespace)}`
+      : table.ormName;
+
+    if (namespace) {
+      const physicalTableName = namespace ? `${table.ormName}_${namespace}` : table.ormName;
+      // Use physical table name as key for Drizzle schema lookups
+      entries.push(`  "${physicalTableName}": ${physicalExportName}`);
+    }
+
+    // Also provide logical name for convenience
+    entries.push(`  ${table.ormName}: ${physicalExportName}`);
+  }
+
+  // Add schema version as a number
+  entries.push(`  schemaVersion: ${schema.version}`);
+
+  const exportName = namespace ? `${sanitizeNamespace(namespace)}_schema` : "_schema";
+
+  return `export const ${exportName} = {\n${entries.join(",\n")}\n}`;
+}
+
 // ============================================================================
 // MAIN GENERATION
 // ============================================================================
@@ -454,28 +559,78 @@ export interface GenerateSchemaOptions {
   };
 }
 
+/**
+ * Generate a settings table for storing fragment versions
+ */
+function generateSettingsTable(ctx: GeneratorContext): string {
+  // Use centralized settings schema
+
+  // Extract the table from the schema
+  const settingsTable =
+    settingsSchema.tables[SETTINGS_TABLE_NAME as keyof typeof settingsSchema.tables];
+
+  // Generate the table using the existing generateTable function
+  const customTypes: string[] = [];
+  return generateTable(ctx, settingsTable, customTypes);
+}
+
+/**
+ * Generate a schema file from one or more fragments with a shared settings table
+ */
 export function generateSchema(
-  schema: AnySchema,
+  fragments: { namespace: string; schema: AnySchema }[],
   provider: SupportedProvider,
   options?: GenerateSchemaOptions,
 ): string {
   const ctx = createContext(provider, options?.idGeneratorImport);
   const customTypes: string[] = [];
-  const tables: string[] = [];
+  const sections: string[] = [];
+
+  // Generate settings table first
+  sections.push("");
+  sections.push("// ============================================================================");
+  sections.push("// Settings Table (shared across all fragments)");
+  sections.push("// ============================================================================");
+  sections.push("");
+  sections.push(generateSettingsTable(ctx));
+  sections.push("");
+  sections.push(`export const fragnoDbSettingSchemaVersion = ${settingsSchema.version};`);
+
+  // Generate each fragment's tables
+  for (const { namespace, schema } of fragments) {
+    const fragmentTables: string[] = [];
+
+    // Add section header
+    fragmentTables.push("");
+    fragmentTables.push(
+      "// ============================================================================",
+    );
+    fragmentTables.push(`// Fragment: ${namespace}`);
+    fragmentTables.push(
+      "// ============================================================================",
+    );
+
+    // Generate tables for this fragment
+    for (const table of Object.values(schema.tables)) {
+      const tableCode = generateTable(ctx, table, customTypes, namespace);
+      fragmentTables.push("");
+      fragmentTables.push(tableCode);
+
+      const relationCode = generateRelation(ctx, table, namespace);
+      if (relationCode) {
+        fragmentTables.push("");
+        fragmentTables.push(relationCode);
+      }
+    }
 
-  // Generate tables and collect custom types
-  for (const table of Object.values(schema.tables)) {
-    // Custom types might be generated during column processing
-    const tableCode = generateTable(ctx, table, customTypes);
-    tables.push(tableCode);
+    // Generate schema export object
+    fragmentTables.push("");
+    fragmentTables.push(generateFragmentSchemaExport(schema, namespace));
 
-    const relationCode = generateRelation(ctx, table);
-    if (relationCode) {
-      tables.push(relationCode);
-    }
+    sections.push(...fragmentTables);
   }
 
   // Assemble final output
-  const lines: string[] = [ctx.imports.format(), ...customTypes, ...tables];
-  return lines.join("\n\n");
+  const lines: string[] = [ctx.imports.format(), ...customTypes, ...sections];
+  return lines.join("\n");
 }

package/src/adapters/drizzle/migrate-drizzle.test.ts

@@ -19,8 +19,14 @@ describe("generateSchema and migrate", () => {
           .addColumn("age", column("integer").nullable())
           .addColumn("isActive", column("bool").defaultTo(true))
           .addColumn("bio", column("string").nullable())
-          .addColumn("createdAt", column("timestamp").defaultTo$("now"))
-          .addColumn("updatedAt", column("timestamp").defaultTo$("now"))
+          .addColumn(
+            "createdAt",
+            column("timestamp").defaultTo((b) => b.now()),
+          )
+          .addColumn(
+            "updatedAt",
+            column("timestamp").defaultTo((b) => b.now()),
+          )
           .createIndex("idx_users_email", ["email"], { unique: true })
           .createIndex("idx_users_name", ["name"])
           .createIndex("idx_users_active", ["isActive"]);
@@ -40,7 +46,10 @@ describe("generateSchema and migrate", () => {
           .addColumn("metadata", column("json").nullable())
           .addColumn("rating", column("decimal").nullable())
           .addColumn("thumbnail", column("binary").nullable())
-          .addColumn("createdAt", column("timestamp").defaultTo$("now"))
+          .addColumn(
+            "createdAt",
+            column("timestamp").defaultTo((b) => b.now()),
+          )
           .createIndex("idx_posts_user", ["userId"])
           .createIndex("idx_posts_title", ["title"])
           .createIndex("idx_posts_slug", ["slug"], { unique: true })
@@ -53,7 +62,10 @@ describe("generateSchema and migrate", () => {
           .addColumn("postId", referenceColumn())
           .addColumn("userId", referenceColumn())
           .addColumn("parentId", referenceColumn().nullable())
-          .addColumn("createdAt", column("timestamp").defaultTo$("now"))
+          .addColumn(
+            "createdAt",
+            column("timestamp").defaultTo((b) => b.now()),
+          )
           .addColumn("editedAt", column("timestamp").nullable())
           .addColumn("isDeleted", column("bool").defaultTo(false))
           .createIndex("idx_comments_post", ["postId"])
@@ -77,7 +89,10 @@ describe("generateSchema and migrate", () => {
           .addColumn("postId", referenceColumn())
           .addColumn("tagId", referenceColumn())
           .addColumn("order", column("integer").defaultTo(0))
-          .addColumn("createdAt", column("timestamp").defaultTo$("now"))
+          .addColumn(
+            "createdAt",
+            column("timestamp").defaultTo((b) => b.now()),
+          )
           .createIndex("idx_postTags_post_tag", ["postId", "tagId"], { unique: true })
           .createIndex("idx_postTags_tag", ["tagId"]);
       })
@@ -135,7 +150,15 @@ describe("generateSchema and migrate", () => {
     );
 
     expect(migrationStatements.join("\n")).toMatchInlineSnapshot(`
-      "CREATE TABLE "users" (
+      "CREATE TABLE "fragno_db_settings" (
+      	"id" varchar(30) NOT NULL,
+      	"key" text NOT NULL,
+      	"value" text NOT NULL,
+      	"_internalId" bigserial PRIMARY KEY NOT NULL,
+      	"_version" integer DEFAULT 0 NOT NULL
+      );
+
+      CREATE TABLE "users" (
       	"id" varchar(30) NOT NULL,
       	"name" text NOT NULL,
       	"email" text NOT NULL,
@@ -207,6 +230,7 @@ describe("generateSchema and migrate", () => {
       ALTER TABLE "comments" ADD CONSTRAINT "comments_comments_parent_fk" FOREIGN KEY ("parentId") REFERENCES "public"."comments"("_internalId") ON DELETE no action ON UPDATE no action;
       ALTER TABLE "postTags" ADD CONSTRAINT "postTags_posts_post_fk" FOREIGN KEY ("postId") REFERENCES "public"."posts"("_internalId") ON DELETE no action ON UPDATE no action;
       ALTER TABLE "postTags" ADD CONSTRAINT "postTags_tags_tag_fk" FOREIGN KEY ("tagId") REFERENCES "public"."tags"("_internalId") ON DELETE no action ON UPDATE no action;
+      CREATE UNIQUE INDEX "unique_key" ON "fragno_db_settings" USING btree ("key");
       CREATE UNIQUE INDEX "idx_users_email" ON "users" USING btree ("email");
       CREATE INDEX "idx_users_name" ON "users" USING btree ("name");
       CREATE INDEX "idx_users_active" ON "users" USING btree ("isActive");

package/src/adapters/drizzle/shared.ts

@@ -13,10 +13,40 @@ export type DBType = MySQL.MySqlDatabase<
 export function parseDrizzle(drizzle: unknown) {
   const db = drizzle as DBType;
   const drizzleTables = db._.fullSchema as Record<string, TableType>;
-  if (!drizzleTables || Object.keys(drizzleTables).length === 0)
+  if (!drizzleTables || Object.keys(drizzleTables).length === 0) {
     throw new Error(
       "Drizzle adapter requires query mode, make sure to configure it following their guide: https://orm.drizzle.team/docs/rqb.",
     );
+  }
 
   return [db, drizzleTables] as const;
 }
+
+/**
+ * Maps logical table names (used by fragment authors) to physical table names (with namespace suffix)
+ */
+export interface TableNameMapper {
+  toPhysical(logicalName: string): string;
+  toLogical(physicalName: string): string;
+}
+
+/**
+ * Creates a table name mapper for a given namespace.
+ * Physical names have format: {logicalName}_{namespace}
+ */
+export function createTableNameMapper(namespace: string): TableNameMapper {
+  return {
+    toPhysical: (logicalName: string) => `${logicalName}_${namespace}`,
+    toLogical: (physicalName: string) => {
+      if (physicalName.endsWith(`_${namespace}`)) {
+        return physicalName.slice(0, -(namespace.length + 1));
+      }
+      return physicalName;
+    },
+  };
+}
+
+export interface DrizzleResult {
+  rows: Record<string, unknown>[];
+  affectedRows: number;
+}

package/src/adapters/drizzle/test-utils.ts

@@ -18,6 +18,7 @@ export async function writeAndLoadSchema(
   testFileName: string,
   schema: Schema,
   dialect: SupportedProvider,
+  namespace?: string,
 ) {
   // Create test-specific directory inside _generated
   const baseDir = join(import.meta.dirname, "_generated");
@@ -37,7 +38,8 @@ export async function writeAndLoadSchema(
   );
 
   // Generate and write the Drizzle schema to file
-  const drizzleSchemaTs = generateSchema(schema, dialect);
+  // Use empty namespace for tests to avoid table name prefixing
+  const drizzleSchemaTs = generateSchema([{ namespace: namespace ?? "", schema }], dialect);
   await writeFile(schemaFilePath, drizzleSchemaTs, "utf-8");
 
   // Dynamically import the generated schema (with cache busting)

package/src/adapters/kysely/kysely-adapter-pglite.test.ts

@@ -116,57 +116,55 @@ describe("KyselyAdapter PGLite", () => {
     expect(schemaVersion).toBeUndefined();
 
     const migrator = adapter.createMigrationEngine(testSchema, "test");
-    const preparedMigration = await migrator.prepareMigration();
+    const preparedMigration = await migrator.prepareMigration({
+      updateSettings: false,
+    });
     assert(preparedMigration.getSQL);
 
     expect(preparedMigration.getSQL()).toMatchInlineSnapshot(`
-      "create table "fragno_db_settings" ("key" varchar(255) primary key, "value" text not null);
-
-      insert into "fragno_db_settings" ("key", "value") values ('test.schema_version', '12');
-
-      create table "users" ("id" varchar(30) not null unique, "name" text not null, "age" integer, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      "create table "users_test" ("id" varchar(30) not null unique, "name" text not null, "age" integer, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      create index "name_idx" on "users" ("name");
+      create index "name_idx" on "users_test" ("name");
 
-      create index "age_idx" on "users" ("age");
+      create index "age_idx" on "users_test" ("age");
 
-      create table "emails" ("id" varchar(30) not null unique, "user_id" bigint not null, "email" text not null, "is_primary" boolean default false not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "emails_test" ("id" varchar(30) not null unique, "user_id" bigint not null, "email" text not null, "is_primary" boolean default false not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      create unique index "unique_email" on "emails" ("email");
+      create unique index "unique_email" on "emails_test" ("email");
 
-      create index "user_emails" on "emails" ("user_id");
+      create index "user_emails" on "emails_test" ("user_id");
 
-      create table "posts" ("id" varchar(30) not null unique, "user_id" bigint not null, "title" text not null, "content" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "posts_test" ("id" varchar(30) not null unique, "user_id" bigint not null, "title" text not null, "content" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      create index "posts_user_idx" on "posts" ("user_id");
+      create index "posts_user_idx" on "posts_test" ("user_id");
 
-      create table "tags" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "tags_test" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      create index "tag_name" on "tags" ("name");
+      create index "tag_name" on "tags_test" ("name");
 
-      create table "post_tags" ("id" varchar(30) not null unique, "post_id" bigint not null, "tag_id" bigint not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "post_tags_test" ("id" varchar(30) not null unique, "post_id" bigint not null, "tag_id" bigint not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      create index "pt_post" on "post_tags" ("post_id");
+      create index "pt_post" on "post_tags_test" ("post_id");
 
-      create index "pt_tag" on "post_tags" ("tag_id");
+      create index "pt_tag" on "post_tags_test" ("tag_id");
 
-      create table "comments" ("id" varchar(30) not null unique, "post_id" bigint not null, "user_id" bigint not null, "text" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "comments_test" ("id" varchar(30) not null unique, "post_id" bigint not null, "user_id" bigint not null, "text" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      create index "comments_post_idx" on "comments" ("post_id");
+      create index "comments_post_idx" on "comments_test" ("post_id");
 
-      create index "comments_user_idx" on "comments" ("user_id");
+      create index "comments_user_idx" on "comments_test" ("user_id");
 
-      alter table "emails" add constraint "emails_users_user_fk" foreign key ("user_id") references "users" ("_internalId") on delete restrict on update restrict;
+      alter table "emails_test" add constraint "emails_users_user_fk" foreign key ("user_id") references "users_test" ("_internalId") on delete restrict on update restrict;
 
-      alter table "posts" add constraint "posts_users_author_fk" foreign key ("user_id") references "users" ("_internalId") on delete restrict on update restrict;
+      alter table "posts_test" add constraint "posts_users_author_fk" foreign key ("user_id") references "users_test" ("_internalId") on delete restrict on update restrict;
 
-      alter table "post_tags" add constraint "post_tags_posts_post_fk" foreign key ("post_id") references "posts" ("_internalId") on delete restrict on update restrict;
+      alter table "post_tags_test" add constraint "post_tags_posts_post_fk" foreign key ("post_id") references "posts_test" ("_internalId") on delete restrict on update restrict;
 
-      alter table "post_tags" add constraint "post_tags_tags_tag_fk" foreign key ("tag_id") references "tags" ("_internalId") on delete restrict on update restrict;
+      alter table "post_tags_test" add constraint "post_tags_tags_tag_fk" foreign key ("tag_id") references "tags_test" ("_internalId") on delete restrict on update restrict;
 
-      alter table "comments" add constraint "comments_posts_post_fk" foreign key ("post_id") references "posts" ("_internalId") on delete restrict on update restrict;
+      alter table "comments_test" add constraint "comments_posts_post_fk" foreign key ("post_id") references "posts_test" ("_internalId") on delete restrict on update restrict;
 
-      alter table "comments" add constraint "comments_users_commenter_fk" foreign key ("user_id") references "users" ("_internalId") on delete restrict on update restrict;"
+      alter table "comments_test" add constraint "comments_users_commenter_fk" foreign key ("user_id") references "users_test" ("_internalId") on delete restrict on update restrict;"
     `);
 
     await preparedMigration.execute();