@fragno-dev/db 0.2.2 → 0.4.1

package/src/schema/create.test.ts

@@ -1,4 +1,11 @@
 import { describe, expect, expectTypeOf, it } from "vitest";
+
+import type {
+  RawColumnValues,
+  TableToColumnValues,
+  TableToInsertValues,
+  TableToUpdateValues,
+} from "../query/simple-query-interface";
 import {
   column,
   FragnoId,
@@ -8,15 +15,10 @@ import {
   schema,
   SchemaBuilder,
 } from "./create";
-import type {
-  RawColumnValues,
-  TableToColumnValues,
-  TableToInsertValues,
-} from "../query/simple-query-interface";
 
 describe("create", () => {
   it("should create a table with columns using callback pattern", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s.addTable("users", (t) => {
         return t
           .addColumn("id", idColumn())
@@ -45,7 +47,7 @@ describe("create", () => {
   });
 
   it("should create a schema with multiple tables using callback pattern", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -61,12 +63,12 @@ describe("create", () => {
     expect(userSchema.version).toBe(2); // Two addTable calls
     expect(userSchema.tables.users).toBeDefined();
     expect(userSchema.tables.posts).toBeDefined();
-    expect(userSchema.tables.users.ormName).toBe("users");
-    expect(userSchema.tables.posts.ormName).toBe("posts");
+    expect(userSchema.tables.users.name).toBe("users");
+    expect(userSchema.tables.posts.name).toBe("posts");
   });
 
   it("should generate default values for columns", () => {
-    const testSchema = schema((s) => {
+    const testSchema = schema("test", (s) => {
       return s.addTable("test", (t) => {
         return t
           .addColumn("id", idColumn())
@@ -91,7 +93,7 @@ describe("create", () => {
   });
 
   it("should increment schema version on each schema-level operation", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t
@@ -108,7 +110,7 @@ describe("create", () => {
   });
 
   it("should support unique constraints on tables via unique method", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s.addTable("users", (t) => {
         return t
           .addColumn("id", idColumn())
@@ -129,7 +131,7 @@ describe("create", () => {
   });
 
   it("should support creating indexes on tables", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s.addTable("users", (t) => {
         return t
           .addColumn("id", idColumn())
@@ -157,9 +159,54 @@ describe("create", () => {
     expect(usernameIndex!.unique).toBe(true);
   });
 
+  it("should throw on duplicate table names", () => {
+    expect(() =>
+      schema("dup", (s) => {
+        return s
+          .addTable("users", (t) => {
+            return t.addColumn("id", idColumn());
+          })
+          .addTable("users", (t) => {
+            return t.addColumn("id", idColumn());
+          });
+      }),
+    ).toThrow(/Duplicate table name "users"/);
+  });
+
+  it("should throw on duplicate index names across tables", () => {
+    expect(() =>
+      schema("dup", (s) => {
+        return s
+          .addTable("users", (t) => {
+            return t.addColumn("id", idColumn()).createIndex("idx_shared", ["id"]);
+          })
+          .addTable("posts", (t) => {
+            return t.addColumn("id", idColumn()).createIndex("idx_shared", ["id"]);
+          });
+      }),
+    ).toThrow(/Duplicate index name "idx_shared"/);
+  });
+
+  it("should throw on duplicate index names added via alterTable", () => {
+    expect(() =>
+      schema("dup", (s) => {
+        return s
+          .addTable("users", (t) => {
+            return t.addColumn("id", idColumn()).createIndex("idx_email", ["id"]);
+          })
+          .addTable("posts", (t) => {
+            return t.addColumn("id", idColumn());
+          })
+          .alterTable("posts", (t) => {
+            return t.createIndex("idx_email", ["id"]);
+          });
+      }),
+    ).toThrow(/Duplicate index name "idx_email"/);
+  });
+
   it("should demonstrate manual many-to-many relation setup", () => {
     // For many-to-many, create a junction table manually
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -211,7 +258,7 @@ describe("create", () => {
   });
 
   it("should create a foreign key reference using addReference", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -251,8 +298,137 @@ describe("create", () => {
     expect(addReferenceOps[0].config.to).toEqual({ table: "users", column: "_internalId" });
   });
 
+  it("should coerce external-id target columns to _internalId in addReference operations", () => {
+    const catalogSchema = schema("catalog", (s) => {
+      return s
+        .addTable("products", (t) => {
+          return t.addColumn("productId", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("orders", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("productRef", referenceColumn());
+        })
+        .addReference("product", {
+          type: "one",
+          from: { table: "orders", column: "productRef" },
+          to: { table: "products", column: "productId" },
+        });
+    });
+
+    const addReferenceOps = catalogSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.to).toEqual({ table: "products", column: "_internalId" });
+  });
+
+  it("should support join-only references with foreignKey:false", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .createIndex("idx_users_email", ["email"]);
+        })
+        .addTable("invitations", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .createIndex("idx_inv_email", ["email"]);
+        })
+        .addReference("invitedUser", {
+          type: "one",
+          from: { table: "invitations", column: "email" },
+          to: { table: "users", column: "email" },
+          foreignKey: false,
+        });
+    });
+
+    const invitationsTable = userSchema.tables.invitations;
+    const invitedRelation = invitationsTable.relations["invitedUser"];
+    expect(invitedRelation).toBeDefined();
+    expect(invitedRelation.foreignKey).toBe(false);
+    expect(invitedRelation.on).toEqual([["email", "email"]]);
+
+    const addReferenceOps = userSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.to).toEqual({ table: "users", column: "email" });
+    expect(addReferenceOps[0].config.foreignKey).toBe(false);
+  });
+
+  it("should coerce id to _internalId for join-only references", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("sessions", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("userId", referenceColumn())
+            .createIndex("idx_sessions_user", ["userId"]);
+        })
+        .addReference("sessionUser", {
+          type: "one",
+          from: { table: "sessions", column: "userId" },
+          to: { table: "users", column: "id" },
+          foreignKey: false,
+        });
+    });
+
+    const addReferenceOps = userSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.to).toEqual({ table: "users", column: "_internalId" });
+  });
+
+  it("should coerce left-side id to _internalId for join-only references", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("memberships", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("userId", referenceColumn())
+            .createIndex("idx_memberships_user", ["userId"]);
+        })
+        .addReference("memberships", {
+          type: "many",
+          from: { table: "users", column: "id" },
+          to: { table: "memberships", column: "userId" },
+          foreignKey: false,
+        });
+    });
+
+    const addReferenceOps = userSchema.operations.filter((op) => op.type === "add-reference");
+    expect(addReferenceOps).toHaveLength(1);
+    expect(addReferenceOps[0].config.from).toEqual({ table: "users", column: "_internalId" });
+
+    const userRelation = userSchema.tables.users.relations["memberships"];
+    expect(userRelation.on).toEqual([["_internalId", "userId"]]);
+  });
+
+  it("should require indexes for join-only references", () => {
+    expect(() =>
+      schema("user", (s) => {
+        return s
+          .addTable("users", (t) => {
+            return t.addColumn("id", idColumn()).addColumn("email", column("string"));
+          })
+          .addTable("invitations", (t) => {
+            return t.addColumn("id", idColumn()).addColumn("email", column("string"));
+          })
+          .addReference("invitedUser", {
+            type: "one",
+            from: { table: "invitations", column: "email" },
+            to: { table: "users", column: "email" },
+            foreignKey: false,
+          });
+      }),
+    ).toThrow(/indexed join columns/);
+  });
+
   it("should support multiple references by calling addReference multiple times", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -305,7 +481,7 @@ describe("create", () => {
   });
 
   it("should support self-referencing foreign keys", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t
@@ -340,7 +516,7 @@ describe("create", () => {
   });
 
   it("should allow altering an existing table to add columns", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -381,7 +557,7 @@ describe("create", () => {
   });
 
   it("should allow altering an existing table to add indexes", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t
@@ -406,7 +582,7 @@ describe("create", () => {
   });
 
   it("should allow multiple alterTable calls on the same table", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -444,8 +620,36 @@ describe("create", () => {
     expect(userSchema.version).toBe(3);
   });
 
+  it("should preserve user-defined columns after alterTable type updates", () => {
+    const userSchema = schema("user", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("email", column("string"))
+            .addColumn("passwordHash", column("string"));
+        })
+        .alterTable("users", (t) => {
+          expectTypeOf(t.alterColumn).parameter(0).toEqualTypeOf<"email" | "passwordHash">();
+          return t.alterColumn("passwordHash").nullable();
+        });
+    });
+
+    type UserColumns = typeof userSchema.tables.users.columns;
+    type UserColumnKeys = keyof UserColumns;
+
+    expectTypeOf<UserColumnKeys>().not.toEqualTypeOf<string>();
+    expectTypeOf<UserColumnKeys>().toEqualTypeOf<"id" | "email" | "passwordHash">();
+
+    type UpdateValues = TableToUpdateValues<typeof userSchema.tables.users>;
+    expectTypeOf<UpdateValues>().toMatchObjectType<{
+      email?: string;
+      passwordHash?: string | null;
+    }>();
+  });
+
   it("should preserve indexes when altering a table", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t
@@ -476,7 +680,7 @@ describe("create", () => {
   });
 
   it("should not duplicate existing indexes when altering a table", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t
@@ -514,7 +718,7 @@ describe("create", () => {
   });
 
   it("should only add new indexes when altering a table with additional indexes", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t
@@ -558,7 +762,7 @@ describe("create", () => {
   });
 
   it("Simple user table types", () => {
-    const _userSchema = schema((s) => {
+    const _userSchema = schema("_user", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -585,7 +789,7 @@ describe("create", () => {
   });
 
   it("Simple user table types after alter table statements", () => {
-    const _userSchema = schema((s) => {
+    const _userSchema = schema("_user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -636,13 +840,13 @@ describe("referenceColumn", () => {
 
 describe("SchemaBuilder with existing schema", () => {
   it("should initialize with an existing schema", () => {
-    const existingSchema = schema((s) => {
+    const existingSchema = schema("existing", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const extendedSchema = new SchemaBuilder(existingSchema)
+    const extendedSchema = new SchemaBuilder(existingSchema.name, existingSchema)
       .addTable("posts", (t) => {
         return t.addColumn("id", idColumn()).addColumn("title", column("string"));
       })
@@ -655,7 +859,7 @@ describe("SchemaBuilder with existing schema", () => {
   });
 
   it("should preserve operations from existing schema", () => {
-    const existingSchema = schema((s) => {
+    const existingSchema = schema("existing", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -665,7 +869,7 @@ describe("SchemaBuilder with existing schema", () => {
         });
     });
 
-    const extendedSchema = new SchemaBuilder(existingSchema)
+    const extendedSchema = new SchemaBuilder(existingSchema.name, existingSchema)
       .addTable("comments", (t) => {
         return t.addColumn("id", idColumn()).addColumn("text", column("string"));
       })
@@ -681,19 +885,19 @@ describe("SchemaBuilder with existing schema", () => {
   });
 
   it("should merge multiple schemas using mergeWithExistingSchema", () => {
-    const schema1 = schema((s) => {
+    const schema1 = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const schema2 = schema((s) => {
+    const schema2 = schema("schema2", (s) => {
       return s.addTable("posts", (t) => {
         return t.addColumn("id", idColumn()).addColumn("title", column("string"));
       });
     });
 
-    const mergedSchema = new SchemaBuilder()
+    const mergedSchema = new SchemaBuilder("merged")
       .mergeWithExistingSchema(schema1)
       .mergeWithExistingSchema(schema2)
       .build();
@@ -704,20 +908,62 @@ describe("SchemaBuilder with existing schema", () => {
     expect(mergedSchema.operations).toHaveLength(2);
   });
 
+  it("should throw on duplicate table names when merging schemas", () => {
+    const schema1 = schema("schema1", (s) => {
+      return s.addTable("users", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+      });
+    });
+
+    const schema2 = schema("schema2", (s) => {
+      return s.addTable("users", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("title", column("string"));
+      });
+    });
+
+    expect(() =>
+      new SchemaBuilder("merged").mergeWithExistingSchema(schema1).mergeWithExistingSchema(schema2),
+    ).toThrow(/Duplicate table name "users"/);
+  });
+
+  it("should throw on duplicate index names when merging schemas", () => {
+    const schema1 = schema("schema1", (s) => {
+      return s.addTable("users", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .createIndex("idx_shared", ["name"]);
+      });
+    });
+
+    const schema2 = schema("schema2", (s) => {
+      return s.addTable("posts", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("title", column("string"))
+          .createIndex("idx_shared", ["title"]);
+      });
+    });
+
+    expect(() =>
+      new SchemaBuilder("merged").mergeWithExistingSchema(schema1).mergeWithExistingSchema(schema2),
+    ).toThrow(/Duplicate index name "idx_shared"/);
+  });
+
   it("should extend merged schema with new tables", () => {
-    const schema1 = schema((s) => {
+    const schema1 = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const schema2 = schema((s) => {
+    const schema2 = schema("schema2", (s) => {
       return s.addTable("posts", (t) => {
         return t.addColumn("id", idColumn()).addColumn("title", column("string"));
       });
     });
 
-    const extended = new SchemaBuilder()
+    const extended = new SchemaBuilder("extended")
       .mergeWithExistingSchema(schema1)
       .mergeWithExistingSchema(schema2)
       .addTable("comments", (t) => {
@@ -733,19 +979,19 @@ describe("SchemaBuilder with existing schema", () => {
   });
 
   it("should use mergeWithExistingSchema method to merge schemas", () => {
-    const schema1 = schema((s) => {
+    const schema1 = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const schema2 = schema((s) => {
+    const schema2 = schema("schema2", (s) => {
       return s.addTable("posts", (t) => {
         return t.addColumn("id", idColumn()).addColumn("title", column("string"));
       });
     });
 
-    const combined = new SchemaBuilder()
+    const combined = new SchemaBuilder("combined")
       .mergeWithExistingSchema(schema1)
       .mergeWithExistingSchema(schema2)
       .addTable("comments", (t) => {
@@ -761,13 +1007,13 @@ describe("SchemaBuilder with existing schema", () => {
   });
 
   it("should merge operations from multiple schemas in order", () => {
-    const schema1 = schema((s) => {
+    const schema1 = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const schema2 = schema((s) => {
+    const schema2 = schema("schema2", (s) => {
       return s
         .addTable("posts", (t) => {
           return t.addColumn("id", idColumn()).addColumn("title", column("string"));
@@ -777,7 +1023,7 @@ describe("SchemaBuilder with existing schema", () => {
         });
     });
 
-    const mergedSchema = new SchemaBuilder()
+    const mergedSchema = new SchemaBuilder("merged")
       .mergeWithExistingSchema(schema1)
       .mergeWithExistingSchema(schema2)
       .build();
@@ -790,25 +1036,25 @@ describe("SchemaBuilder with existing schema", () => {
   });
 
   it("should merge three or more schemas", () => {
-    const schema1 = schema((s) => {
+    const schema1 = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const schema2 = schema((s) => {
+    const schema2 = schema("schema2", (s) => {
       return s.addTable("posts", (t) => {
         return t.addColumn("id", idColumn()).addColumn("title", column("string"));
       });
     });
 
-    const schema3 = schema((s) => {
+    const schema3 = schema("schema3", (s) => {
       return s.addTable("comments", (t) => {
         return t.addColumn("id", idColumn()).addColumn("text", column("string"));
       });
     });
 
-    const mergedSchema = new SchemaBuilder()
+    const mergedSchema = new SchemaBuilder("merged")
       .mergeWithExistingSchema(schema1)
       .mergeWithExistingSchema(schema2)
       .mergeWithExistingSchema(schema3)
@@ -822,13 +1068,13 @@ describe("SchemaBuilder with existing schema", () => {
   });
 
   it("should handle single schema merge", () => {
-    const schema1 = schema((s) => {
+    const schema1 = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const mergedSchema = new SchemaBuilder().mergeWithExistingSchema(schema1).build();
+    const mergedSchema = new SchemaBuilder("merged").mergeWithExistingSchema(schema1).build();
 
     expect(mergedSchema.tables.users).toBeDefined();
     expect(mergedSchema.version).toBe(1);