alepha 0.14.1 → 0.14.3

package/src/orm/services/ModelBuilder.spec.ts

@@ -0,0 +1,575 @@
+import { t } from "alepha";
+import { sql } from "drizzle-orm";
+import { beforeEach, describe, expect, test } from "vitest";
+import { $entity } from "../primitives/$entity.ts";
+import { pg } from "../providers/DatabaseTypeProvider.ts";
+import { PostgresModelBuilder } from "../services/PostgresModelBuilder.ts";
+import { SqliteModelBuilder } from "../services/SqliteModelBuilder.ts";
+
+describe("ModelBuilder", () => {
+  describe("PostgresModelBuilder", () => {
+    let builder: PostgresModelBuilder;
+    let options: {
+      tables: Map<string, unknown>;
+      enums: Map<string, unknown>;
+      schema: string;
+    };
+
+    beforeEach(() => {
+      builder = new PostgresModelBuilder();
+      options = {
+        tables: new Map(),
+        enums: new Map(),
+        schema: "public",
+      };
+    });
+
+    test("should build a basic table", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+          email: t.email(),
+        }),
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with single column index", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          email: t.email(),
+          username: t.text(),
+        }),
+        indexes: ["email", "username"],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with unique index", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          email: t.email(),
+          username: t.text(),
+        }),
+        indexes: [
+          {
+            column: "email",
+            unique: true,
+            name: "unique_email_idx",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with composite index", () => {
+      const entity = $entity({
+        name: "posts",
+        schema: t.object({
+          id: pg.primaryKey(),
+          userId: t.text(),
+          createdAt: t.string({ format: "date-time" }),
+          title: t.text(),
+        }),
+        indexes: [
+          {
+            columns: ["userId", "createdAt"],
+            name: "user_created_idx",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("posts")).toBe(true);
+      const table = options.tables.get("posts");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with unique composite index", () => {
+      const entity = $entity({
+        name: "user_roles",
+        schema: t.object({
+          id: pg.primaryKey(),
+          userId: t.text(),
+          roleId: t.text(),
+        }),
+        indexes: [
+          {
+            columns: ["userId", "roleId"],
+            unique: true,
+            name: "unique_user_role",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("user_roles")).toBe(true);
+      const table = options.tables.get("user_roles");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with foreign keys", () => {
+      // First create the users table
+      const usersEntity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+        }),
+      });
+
+      builder.buildTable(usersEntity, options);
+
+      const usersTable = options.tables.get("users") as any;
+
+      // Then create posts table with foreign key
+      const postsEntity = $entity({
+        name: "posts",
+        schema: t.object({
+          id: pg.primaryKey(),
+          userId: t.text(),
+          title: t.text(),
+        }),
+        foreignKeys: [
+          {
+            name: "posts_user_fk",
+            columns: ["userId"],
+            foreignColumns: [() => usersEntity.cols.id],
+          },
+        ],
+      });
+
+      builder.buildTable(postsEntity, options);
+
+      expect(options.tables.has("posts")).toBe(true);
+      const table = options.tables.get("posts");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with unique constraint", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          email: t.email(),
+          username: t.text(),
+        }),
+        constraints: [
+          {
+            columns: ["email"],
+            unique: true,
+            name: "unique_user_email",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with check constraint", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          age: t.integer(),
+        }),
+        constraints: [
+          {
+            columns: ["age"],
+            check: sql`age >= 0 AND age <= 150`,
+            name: "valid_age_range",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with composite unique constraint", () => {
+      const entity = $entity({
+        name: "user_settings",
+        schema: t.object({
+          id: pg.primaryKey(),
+          userId: t.text(),
+          settingKey: t.text(),
+          settingValue: t.text(),
+        }),
+        constraints: [
+          {
+            columns: ["userId", "settingKey"],
+            unique: true,
+            name: "unique_user_setting",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("user_settings")).toBe(true);
+      const table = options.tables.get("user_settings");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with custom config function", () => {
+      const customConfig = () => [];
+
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+        }),
+        config: customConfig,
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      // Config is passed to the table but may not be called immediately
+      // The important thing is that the table is created with the config
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with all options combined", () => {
+      // Create referenced table first
+      const rolesEntity = $entity({
+        name: "roles",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+        }),
+      });
+
+      builder.buildTable(rolesEntity, options);
+
+      const rolesTable = options.tables.get("roles") as any;
+
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          email: t.email(),
+          username: t.text(),
+          age: t.integer(),
+          roleId: t.text(),
+          createdAt: t.string({ format: "date-time" }),
+        }),
+        indexes: [
+          "email",
+          {
+            column: "username",
+            unique: true,
+          },
+          {
+            columns: ["roleId", "createdAt"],
+            name: "role_created_idx",
+          },
+        ],
+        foreignKeys: [
+          {
+            columns: ["roleId"],
+            foreignColumns: [() => rolesEntity.cols.id],
+          },
+        ],
+        constraints: [
+          {
+            columns: ["age"],
+            check: sql`age >= 18`,
+            name: "adult_users_only",
+          },
+          {
+            columns: ["email", "username"],
+            unique: true,
+            name: "unique_email_username",
+          },
+        ],
+        config: (self) => [],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should convert camelCase to snake_case for column names", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          firstName: t.text(),
+          lastName: t.text(),
+          emailAddress: t.email(),
+        }),
+        indexes: ["firstName", "lastName"],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+      // Column names should be converted to snake_case internally
+    });
+
+    test("should not recreate table if it already exists", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+        }),
+      });
+
+      builder.buildTable(entity, options);
+      const firstTable = options.tables.get("users");
+
+      // Try to build again
+      builder.buildTable(entity, options);
+      const secondTable = options.tables.get("users");
+
+      expect(firstTable).toBe(secondTable);
+    });
+  });
+
+  describe("SqliteModelBuilder", () => {
+    let builder: SqliteModelBuilder;
+    let options: {
+      tables: Map<string, unknown>;
+      enums: Map<string, unknown>;
+      schema: string;
+    };
+
+    beforeEach(() => {
+      builder = new SqliteModelBuilder();
+      options = {
+        tables: new Map(),
+        enums: new Map(),
+        schema: "public",
+      };
+    });
+
+    test("should build a basic table", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+          email: t.email(),
+        }),
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with indexes", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          email: t.email(),
+          username: t.text(),
+        }),
+        indexes: [
+          "email",
+          {
+            column: "username",
+            unique: true,
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with composite index", () => {
+      const entity = $entity({
+        name: "posts",
+        schema: t.object({
+          id: pg.primaryKey(),
+          userId: t.text(),
+          createdAt: t.string({ format: "date-time" }),
+        }),
+        indexes: [
+          {
+            columns: ["userId", "createdAt"],
+            unique: false,
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("posts")).toBe(true);
+      const table = options.tables.get("posts");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with foreign keys", () => {
+      // First create the users table
+      const usersEntity = $entity({
+        name: "users",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+        }),
+      });
+
+      builder.buildTable(usersEntity, options);
+
+      const usersTable = options.tables.get("users") as any;
+
+      // Then create posts table with foreign key
+      const postsEntity = $entity({
+        name: "posts",
+        schema: t.object({
+          id: pg.primaryKey(),
+          userId: t.text(),
+          title: t.text(),
+        }),
+        foreignKeys: [
+          {
+            columns: ["userId"],
+            foreignColumns: [() => usersEntity.cols.id],
+          },
+        ],
+      });
+
+      builder.buildTable(postsEntity, options);
+
+      expect(options.tables.has("posts")).toBe(true);
+      const table = options.tables.get("posts");
+      expect(table).toBeDefined();
+    });
+
+    test("should build table with constraints", () => {
+      const entity = $entity({
+        name: "products",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+          sku: t.text(),
+          price: t.number(),
+        }),
+        constraints: [
+          {
+            columns: ["sku"],
+            unique: true,
+            name: "unique_sku",
+          },
+          {
+            columns: ["price"],
+            check: sql`price > 0`,
+            name: "positive_price",
+          },
+        ],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("products")).toBe(true);
+      const table = options.tables.get("products");
+      expect(table).toBeDefined();
+    });
+
+    test("should throw error for sequences", () => {
+      expect(() => {
+        builder.buildSequence({ name: "test_seq", options: {} } as any, {
+          sequences: new Map(),
+          schema: "public",
+        });
+      }).toThrow("SQLite does not support sequences");
+    });
+
+    test("should build table with all options combined", () => {
+      const entity = $entity({
+        name: "complex_table",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.text(),
+          email: t.email(),
+          status: t.text(),
+        }),
+        indexes: [
+          "name",
+          {
+            columns: ["email", "status"],
+            unique: true,
+            name: "unique_email_status",
+          },
+        ],
+        constraints: [
+          {
+            columns: ["status"],
+            check: sql`status IN ('active', 'inactive')`,
+            name: "valid_status",
+          },
+        ],
+        config: (self) => [],
+      });
+
+      builder.buildTable(entity, options);
+
+      expect(options.tables.has("complex_table")).toBe(true);
+      const table = options.tables.get("complex_table");
+      expect(table).toBeDefined();
+    });
+  });
+
+  describe("Abstract ModelBuilder methods", () => {
+    test("should convert camelCase to snake_case correctly", () => {
+      const builder = new PostgresModelBuilder();
+
+      // Access the protected method via type assertion
+      const toColumnName = (builder as any).toColumnName.bind(builder);
+
+      expect(toColumnName("id")).toBe("id");
+      expect(toColumnName("userId")).toBe("user_id");
+      expect(toColumnName("firstName")).toBe("first_name");
+      expect(toColumnName("emailAddress")).toBe("email_address");
+      expect(toColumnName("createdAt")).toBe("created_at");
+      expect(toColumnName("isActiveUser")).toBe("is_active_user");
+    });
+  });
+});

package/src/orm/services/Repository.spec.ts

@@ -0,0 +1,137 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $entity, $repository, pg } from "../index.ts";
+
+const testSchema = t.object({
+  id: pg.primaryKey(),
+  name: t.text(),
+});
+
+const testEntity = $entity({
+  name: "test",
+  schema: testSchema,
+});
+
+describe("Repository", () => {
+  it("should handle serial id operations", async () => {
+    class App {
+      repository = $repository(testEntity);
+    }
+
+    const alepha = Alepha.create();
+
+    const app = alepha.inject(App);
+
+    await alepha.start();
+
+    expect(app.repository.id.key).toEqual("id");
+
+    const it = await app.repository.create({ name: "test" });
+
+    expect(await app.repository.findById(it.id)).toEqual(it);
+    expect(await app.repository.findById(String(it.id))).toEqual(it);
+
+    const update = await app.repository.updateById(it.id, { name: "2" });
+
+    expect(await app.repository.findById(it.id)).toEqual(update);
+
+    await app.repository.deleteById(it.id);
+
+    expect(await app.repository.count()).toBe(0);
+  });
+
+  it("should handle uuid id operations", async () => {
+    const schema = t.object({
+      uuid: pg.uuidPrimaryKey(),
+      name: t.text(),
+    });
+    const entity = $entity({
+      name: "test",
+      schema,
+    });
+    class App {
+      repository = $repository(entity);
+    }
+
+    const alepha = Alepha.create();
+
+    const app = alepha.inject(App);
+
+    await alepha.start();
+
+    expect(app.repository.id.key).toEqual("uuid");
+    expect(app.repository.id.type).toEqual(pg.uuidPrimaryKey());
+
+    const it = await app.repository.create({ name: "test" });
+
+    expect(await app.repository.findById(it.uuid)).toEqual(it);
+
+    const update = await app.repository.updateById(it.uuid, { name: "2" });
+
+    expect(await app.repository.findById(it.uuid)).toEqual(update);
+
+    await app.repository.deleteById(it.uuid);
+
+    expect(await app.repository.count()).toBe(0);
+  });
+
+  it("should handle multiple operators (gte & lte)", async () => {
+    const schema = t.object({
+      id: pg.primaryKey(),
+      name: t.text(),
+      age: t.number(),
+    });
+    const entity = $entity({
+      name: "test_range",
+      schema,
+    });
+    class App {
+      repository = $repository(entity);
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    // Create test data
+    await app.repository.create({ name: "Alice", age: 20 });
+    await app.repository.create({ name: "Bob", age: 25 });
+    await app.repository.create({ name: "Charlie", age: 30 });
+    await app.repository.create({ name: "David", age: 35 });
+    await app.repository.create({ name: "Eve", age: 40 });
+
+    // Test range query with both gte and lte
+    const results = await app.repository.findMany({
+      where: {
+        age: { gte: 25, lte: 35 },
+      },
+    });
+
+    expect(results).toHaveLength(3);
+    expect(results.map((r) => r.name).sort()).toEqual([
+      "Bob",
+      "Charlie",
+      "David",
+    ]);
+
+    // Test with only gte
+    const resultsGte = await app.repository.findMany({
+      where: {
+        age: { gte: 35 },
+      },
+    });
+
+    expect(resultsGte).toHaveLength(2);
+    expect(resultsGte.map((r) => r.name).sort()).toEqual(["David", "Eve"]);
+
+    // Test with only lte
+    const resultsLte = await app.repository.findMany({
+      where: {
+        age: { lte: 25 },
+      },
+    });
+
+    expect(resultsLte).toHaveLength(2);
+    expect(resultsLte.map((r) => r.name).sort()).toEqual(["Alice", "Bob"]);
+  });
+});