alepha 0.14.2 → 0.14.3

package/src/orm/helpers/parseQueryString.spec.ts

@@ -0,0 +1,196 @@
+import { describe, test } from "vitest";
+import { buildQueryString, parseQueryString } from "../index.ts";
+
+describe("parseQueryString with wildcard patterns", () => {
+  test("should parse wildcard patterns with = operator", ({ expect }) => {
+    // Test startsWith pattern
+    const result1 = parseQueryString("name=John*");
+    expect(result1).toEqual({ name: { startsWith: "John" } });
+
+    // Test endsWith pattern
+    const result2 = parseQueryString("name=*Smith");
+    expect(result2).toEqual({ name: { endsWith: "Smith" } });
+
+    // Test contains pattern
+    const result3 = parseQueryString("name=*oh*");
+    expect(result3).toEqual({ name: { contains: "oh" } });
+
+    // Test literal asterisk in the middle (not at beginning or end)
+    const result4 = parseQueryString("name=Jo*hn");
+    expect(result4).toEqual({ name: { eq: "Jo*hn" } });
+
+    // Test literal equals (no wildcards)
+    const result5 = parseQueryString("name=John");
+    expect(result5).toEqual({ name: { eq: "John" } });
+  });
+
+  test("should handle wildcard patterns in complex queries", ({ expect }) => {
+    // Multiple conditions with wildcards
+    const result1 = parseQueryString("name=*John&email=*@example.com");
+    expect(result1).toEqual({
+      and: [
+        { name: { endsWith: "John" } },
+        { email: { endsWith: "@example.com" } },
+      ],
+    });
+
+    // OR conditions with wildcards
+    const result2 = parseQueryString("name=John*|name=*Smith");
+    expect(result2).toEqual({
+      or: [{ name: { startsWith: "John" } }, { name: { endsWith: "Smith" } }],
+    });
+
+    // Nested conditions with wildcards
+    const result3 = parseQueryString("(name=*John*|email=admin*)&age>18");
+    expect(result3).toEqual({
+      and: [
+        {
+          or: [
+            { name: { contains: "John" } },
+            { email: { startsWith: "admin" } },
+          ],
+        },
+        { age: { gt: 18 } },
+      ],
+    });
+  });
+
+  test("should handle wildcard patterns in quoted strings", ({ expect }) => {
+    // Quoted string with wildcards should be treated as wildcards
+    const result1 = parseQueryString('name="*John*"');
+    expect(result1).toEqual({ name: { contains: "John" } });
+
+    // Quoted string with asterisk in middle
+    const result2 = parseQueryString('name="Jo*hn"');
+    expect(result2).toEqual({ name: { eq: "Jo*hn" } });
+
+    // Single quotes
+    const result3 = parseQueryString("name='*Smith'");
+    expect(result3).toEqual({ name: { endsWith: "Smith" } });
+  });
+
+  test("should handle wildcard patterns with special characters", ({
+    expect,
+  }) => {
+    // Wildcard with spaces
+    const result1 = parseQueryString("name=*John Smith*");
+    expect(result1).toEqual({ name: { contains: "John Smith" } });
+
+    // Wildcard with special characters
+    const result2 = parseQueryString("email=*@example.com");
+    expect(result2).toEqual({ email: { endsWith: "@example.com" } });
+
+    // Wildcard with numbers
+    const result3 = parseQueryString("code=ABC*123");
+    expect(result3).toEqual({ code: { eq: "ABC*123" } }); // Asterisk in middle is literal
+  });
+
+  test("should handle wildcard patterns in arrays", ({ expect }) => {
+    // Array values don't support wildcards (treated as literal)
+    const result = parseQueryString("status=[active*,*pending,*idle*]");
+    expect(result).toEqual({
+      status: { inArray: ["active*", "*pending", "*idle*"] },
+    });
+  });
+
+  test("should handle wildcard patterns with != operator", ({ expect }) => {
+    // != operator doesn't support wildcards, treats as literal
+    const result1 = parseQueryString("name!=*John");
+    expect(result1).toEqual({ name: { ne: "*John" } });
+
+    const result2 = parseQueryString("name!=John*");
+    expect(result2).toEqual({ name: { ne: "John*" } });
+  });
+
+  test("should handle empty wildcard patterns", ({ expect }) => {
+    // Just asterisks - a single asterisk at the end means "starts with nothing" = everything
+    const result1 = parseQueryString("name=*");
+    expect(result1).toEqual({ name: { contains: "" } }); // Since * alone has both start and end asterisk
+
+    const result2 = parseQueryString("name=**");
+    expect(result2).toEqual({ name: { contains: "" } });
+
+    const result3 = parseQueryString("name=***");
+    expect(result3).toEqual({ name: { contains: "*" } });
+  });
+
+  test("should handle JSONB nested queries with wildcards", ({ expect }) => {
+    const result = parseQueryString("profile.city=*Paris*&profile.name=John*");
+    expect(result).toEqual({
+      and: [
+        { profile: { city: { contains: "Paris" } } },
+        { profile: { name: { startsWith: "John" } } },
+      ],
+    });
+  });
+
+  test("should not apply wildcards to non-string operators", ({ expect }) => {
+    // Numeric comparison operators don't use wildcards
+    const result1 = parseQueryString("age>18");
+    expect(result1).toEqual({ age: { gt: 18 } });
+
+    // NULL checks don't use wildcards
+    const result2 = parseQueryString("name=null");
+    expect(result2).toEqual({ name: { isNull: true } });
+
+    const result3 = parseQueryString("name!=null");
+    expect(result3).toEqual({ name: { isNotNull: true } });
+  });
+});
+
+describe("buildQueryString with wildcard patterns", () => {
+  test("should build query strings from wildcard conditions", ({ expect }) => {
+    // startsWith
+    const query1 = buildQueryString({ name: { startsWith: "John" } });
+    expect(query1).toBe("name=John*");
+
+    // endsWith
+    const query2 = buildQueryString({ name: { endsWith: "Smith" } });
+    expect(query2).toBe("name=*Smith");
+
+    // contains
+    const query3 = buildQueryString({ name: { contains: "oh" } });
+    expect(query3).toBe("name=*oh*");
+  });
+
+  test("should build complex query strings with wildcards", ({ expect }) => {
+    const query = buildQueryString({
+      and: [
+        { name: { startsWith: "John" } },
+        { email: { endsWith: "@example.com" } },
+        { bio: { contains: "developer" } },
+      ],
+    });
+    expect(query).toBe("name=John*&email=*@example.com&bio=*developer*");
+  });
+
+  test("should handle OR conditions with wildcards", ({ expect }) => {
+    const query = buildQueryString({
+      or: [
+        { name: { startsWith: "Admin" } },
+        { role: { contains: "manager" } },
+      ],
+    });
+    expect(query).toBe("(name=Admin*|role=*manager*)");
+  });
+
+  test("round-trip conversion should preserve wildcard semantics", ({
+    expect,
+  }) => {
+    const testCases = [
+      "name=John*",
+      "name=*Smith",
+      "name=*John*",
+      "email=admin*&role=*manager*",
+      "(name=*John*|name=*Jane*)&active=true",
+      "profile.city=*Paris*",
+    ];
+
+    for (const original of testCases) {
+      const parsed = parseQueryString(original);
+      const rebuilt = buildQueryString(parsed);
+      const reparsed = parseQueryString(rebuilt);
+      expect(reparsed).toEqual(parsed);
+    }
+  });
+});

package/src/orm/primitives/$repository.spec.ts

@@ -0,0 +1,137 @@
+import { Alepha, type Static } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { describe, expect, it } from "vitest";
+import { bigEntity } from "../__tests__/fixtures/bigEntitySchema.ts";
+import type { InsertUserEntity } from "../__tests__/fixtures/userEntitySchema.ts";
+import { userEntity } from "../__tests__/fixtures/userEntitySchema.ts";
+import { $repository } from "../index.ts";
+
+class App {
+  users = $repository(userEntity);
+  big = $repository(bigEntity);
+  create = (data: InsertUserEntity) => this.users.create(data);
+}
+
+const testPgAttr = async (alepha: Alepha) => {
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const entity = await app.users.create({
+    suspect: "hey",
+    name: "John",
+    profile: {
+      age: 30,
+    },
+  } as any);
+
+  expect((entity as any).suspect).toBeUndefined();
+  expect(entity.name).toEqual("John");
+  expect(entity.profile.age).toEqual(30);
+};
+
+describe("$repository - pg.attr", () => {
+  it("should filter out attributes not defined in schema", async () => {
+    await testPgAttr(Alepha.create());
+  });
+
+  it("should filter out attributes not defined in schema (sqlite)", async () => {
+    await testPgAttr(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+});
+
+const testAllTypes = async (alepha: Alepha) => {
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const data: Static<typeof bigEntity.insertSchema> = {
+    type: "big_entity",
+    a: "a",
+    b: 1.111,
+    date: "2024-01-01",
+    c: 2,
+    d: true,
+    e: {
+      a: "a",
+      b: 1,
+      c: 2,
+      d: true,
+      e: {
+        a: "a",
+        b: 1,
+        c: 2,
+        d: true,
+        j: [
+          {
+            a: "a",
+            b: 1,
+            c: 2,
+            d: true,
+            e: {
+              a: "a",
+              b: 1,
+              c: 2,
+              d: true,
+            },
+          },
+        ],
+      },
+    },
+    f: ["a", "b"],
+    g: [1.111],
+    h: [2, 1],
+    i: [true],
+    j: [
+      {
+        a: "a",
+        b: 1,
+        c: 2,
+        d: true,
+        e: {
+          a: "a",
+          b: 1,
+          c: 2,
+          d: true,
+        },
+      },
+    ],
+    k: alepha.inject(DateTimeProvider).nowISOString(),
+    l: "123e4567-e89b-12d3-a456-426614174000",
+    m: "a" as const,
+  };
+  const entity = await app.big.create(data);
+
+  expect(entity).toEqual({
+    id: entity.id,
+    ...data,
+  });
+
+  const it = await app.big.findMany({
+    where: {
+      type: "big_entity",
+    },
+  });
+
+  expect(it).toHaveLength(1);
+};
+
+describe("$repository - all types", () => {
+  it("should handle all supported data types", async () => {
+    await testAllTypes(Alepha.create());
+  });
+
+  it("should handle all supported data types (sqlite)", async () => {
+    await testAllTypes(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+});

package/src/orm/primitives/$sequence.spec.ts

@@ -0,0 +1,29 @@
+import { Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $sequence } from "../index.ts";
+
+describe("$sequence", () => {
+  class App {
+    seq = $sequence();
+    seq2 = $sequence({ startWith: 100, increment: 2 });
+  }
+
+  const alepha = Alepha.create();
+  const app = alepha.inject(App);
+
+  it("should generate sequential numbers", async () => {
+    expect(await app.seq.next()).toBe(1);
+    expect(await app.seq.next()).toBe(2);
+    expect(await app.seq.next()).toBe(3);
+    expect(await app.seq.current()).toBe(3);
+    expect(await app.seq.next()).toBe(4);
+  });
+
+  it("should support custom start and increment options", async () => {
+    expect(await app.seq2.next()).toBe(100);
+    expect(await app.seq2.next()).toBe(102);
+    expect(await app.seq2.next()).toBe(104);
+    expect(await app.seq2.current()).toBe(104);
+    expect(await app.seq2.next()).toBe(106);
+  });
+});

package/src/orm/primitives/$transaction.spec.ts

@@ -0,0 +1,82 @@
+import { $inject, Alepha, t } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { describe, expect, it } from "vitest";
+import { DbConflictError } from "../errors/DbConflictError.ts";
+import { $entity, $repository, $transaction, pg } from "../index.ts";
+
+const a = $entity({
+  name: "a",
+  schema: t.object({
+    id: pg.primaryKey(
+      t.integer(),
+      {},
+      {
+        mode: "byDefault",
+      },
+    ),
+    v: pg.version(),
+    counter: t.integer(),
+  }),
+});
+
+class App {
+  dt = $inject(DateTimeProvider);
+
+  repository = $repository(a);
+
+  runIncrementTest = $transaction({
+    handler: async (tx, id: number, val: number, waitMs = 0) => {
+      const e = await this.repository.findById(id, {
+        tx,
+      });
+      if (waitMs) {
+        await this.dt.wait(waitMs);
+      }
+      e.counter += val;
+      return await this.repository.save(e, { tx });
+    },
+  });
+
+  runCollisionTest = $transaction({
+    handler: async (tx) => {
+      await this.repository.deleteMany({}, { tx });
+      const { id } = await this.repository.create({ counter: 0 }, { tx });
+      await this.repository.create({ counter: 0 }, { tx });
+      await this.repository.create({ counter: 0, id: id }, { tx });
+    },
+  });
+}
+
+describe("$transaction", () => {
+  it(
+    "should handle version mismatch with retry",
+    { timeout: 10000 },
+    async () => {
+      const alepha = Alepha.create();
+      const app = alepha.inject(App);
+      await alepha.start();
+
+      const { id } = await app.repository.create({ counter: 0 });
+
+      const tx = app.runIncrementTest(id, 10, 200);
+      await app.runIncrementTest(id, 100);
+      await tx;
+
+      const r3 = await app.repository.findById(id);
+
+      expect(r3.counter).toBe(110);
+    },
+  );
+
+  it("should rollback on conflict error", { timeout: 10000 }, async () => {
+    const alepha = Alepha.create();
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    await app.repository.create({ counter: 0 });
+
+    await expect(() => app.runCollisionTest()).rejects.toThrow(DbConflictError);
+
+    expect(await app.repository.count()).toBe(1);
+  });
+});

package/src/orm/providers/drivers/BunPostgresProvider.ts

@@ -137,7 +137,7 @@ export class BunPostgresProvider extends DatabaseProvider {
       // never migrate in serverless mode (vercel, netlify, ...)
       if (!this.alepha.isServerless()) {
         try {
-          await this.migrate.run();
+          await this.migrateLock.run();
         } catch (error) {
           throw new DbMigrationError(error);
         }
@@ -217,9 +217,9 @@ export class BunPostgresProvider extends DatabaseProvider {
     }
   }
 
-  protected migrate = $lock({
+  protected migrateLock = $lock({
     handler: async () => {
-      await this.migrateDatabase();
+      await this.migrate();
     },
   });
 }

package/src/orm/providers/drivers/BunSqliteProvider.ts

@@ -154,7 +154,7 @@ export class BunSqliteProvider extends DatabaseProvider {
         },
       });
 
-      await this.migrateDatabase();
+      await this.migrate();
 
       this.log.info(`Using Bun SQLite database at ${filepath}`);
     },

package/src/orm/providers/drivers/CloudflareD1Provider.ts

@@ -125,7 +125,7 @@ export class CloudflareD1Provider extends DatabaseProvider {
 
       this.drizzleDb = drizzle(this.d1) as DrizzleD1Database;
 
-      await this.migrateDatabase();
+      await this.migrate();
 
       this.log.info("Using Cloudflare D1 database");
     },

package/src/orm/providers/drivers/DatabaseProvider.ts

@@ -95,7 +95,7 @@ export abstract class DatabaseProvider {
   /**
    * Base migration orchestration - handles environment logic
    */
-  protected async migrateDatabase(): Promise<void> {
+  public async migrate(): Promise<void> {
     const migrationsFolder = this.getMigrationsFolder();
 
     // Handle different environments

package/src/orm/providers/drivers/NodePostgresProvider.ts

@@ -127,7 +127,7 @@ export class NodePostgresProvider extends DatabaseProvider {
       // never migrate in serverless mode (vercel, netlify, ...)
       if (!this.alepha.isServerless()) {
         try {
-          await this.migrate.run();
+          await this.migrateLock.run();
         } catch (error) {
           throw new DbMigrationError(error);
         }
@@ -196,9 +196,9 @@ export class NodePostgresProvider extends DatabaseProvider {
     }
   }
 
-  protected migrate = $lock({
+  protected migrateLock = $lock({
     handler: async () => {
-      await this.migrateDatabase();
+      await this.migrate();
     },
   });
 

package/src/orm/providers/drivers/NodeSqliteProvider.ts

@@ -157,7 +157,7 @@ export class NodeSqliteProvider extends DatabaseProvider {
 
       this.sqlite = new DatabaseSync(filepath);
 
-      await this.migrateDatabase();
+      await this.migrate();
 
       this.log.info(`Using SQLite database at ${filepath}`);
     },

package/src/orm/providers/drivers/PglitePostgresProvider.ts

@@ -55,7 +55,7 @@ export class PglitePostgresProvider extends DatabaseProvider {
       if (this.alepha.isTest()) {
         path = ":memory:"; // use in-memory database for tests by default
       } else {
-        path = "node_modules/.db"; // default path for dev
+        path = "node_modules/.alepha/pglite"; // default path for dev
       }
     } else {
       if (path.includes(":memory:")) {
@@ -112,7 +112,7 @@ export class PglitePostgresProvider extends DatabaseProvider {
         client: this.client,
       });
 
-      await this.migrateDatabase();
+      await this.migrate();
 
       this.log.info(`Using PGlite database at ${path}`);
     },