alepha 0.14.2 → 0.14.3

package/src/cache/core/__tests__/shared.ts

@@ -0,0 +1,377 @@
+import { randomUUID } from "node:crypto";
+import { Alepha, type Env, type Service } from "alepha";
+import { $cache, CacheProvider, MemoryCacheProvider } from "alepha/cache";
+import { DateTimeProvider } from "alepha/datetime";
+import { expect } from "vitest";
+
+export class TestCache {
+  cursor_a = 0;
+  cursor_b = 0;
+
+  a = $cache({
+    key: (args) => args.name,
+    ttl: [5, "seconds"],
+    handler: async (user: { name: string }) => {
+      return `${user.name}:${this.cursor_a++}`;
+    },
+  });
+
+  b = $cache({
+    provider: "memory",
+    key: (args) => args.name,
+    ttl: 0,
+    handler: async (user: { name: string }) => {
+      return `${user.name}:${this.cursor_b++}`;
+    },
+  });
+}
+
+export const testCacheBasic = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+  const test = app.inject(TestCache);
+  const time = app.inject(DateTimeProvider);
+  await app.start();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+
+  if (!(app.inject(CacheProvider) instanceof MemoryCacheProvider)) {
+    return; // we can mock only MemoryCacheProvider
+  }
+
+  await time.travel([2, "seconds"]);
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+
+  await time.travel([4, "seconds"]);
+  expect(await test.a({ name: "A" })).toBe("A:2");
+  expect(await test.a({ name: "A" })).toBe("A:2");
+  expect(await test.a({ name: "B" })).toBe("B:3");
+};
+
+export const testCacheStop = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+  await app.start();
+  await app.stop();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:1");
+  expect(await test.a({ name: "A" })).toBe("A:2");
+};
+
+export const testCacheMissingProvider = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:1");
+};
+
+export const testCacheDisabled = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env: {
+      REDIS_CACHE_PREFIX: randomUUID(),
+      CACHE_ENABLED: false,
+      ...env,
+    },
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+  await app.start();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:1");
+  expect(await test.a({ name: "B" })).toBe("B:2");
+};
+
+export const testCacheInvalidateByKey = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+  await app.start();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+
+  await test.a.invalidate("A");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+  expect(await test.a({ name: "A" })).toBe("A:2");
+};
+
+export const testCacheInvalidateByArgs = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+  await app.start();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+
+  await test.a.invalidate(test.a.key({ name: "A" }));
+  expect(await test.a({ name: "B" })).toBe("B:1");
+  expect(await test.a({ name: "A" })).toBe("A:2");
+};
+
+export const testCacheInvalidateAll = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+  await app.start();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+
+  await test.a.invalidate();
+  expect(await test.a({ name: "A" })).toBe("A:1");
+};
+
+export const testCacheClear = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestCache);
+  await app.start();
+
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.b({ name: "A" })).toBe("A:0");
+  expect(await test.b({ name: "A" })).toBe("A:0");
+
+  await Promise.all(app.primitives($cache).map((cache) => cache.invalidate()));
+
+  expect(await test.a({ name: "A" })).toBe("A:1");
+  expect(await test.b({ name: "A" })).toBe("A:1");
+};
+
+export const testCacheReturnTypes = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  class Types {
+    json = $cache({
+      handler: () => ({ a: 1 }),
+    });
+    int = $cache({
+      handler: () => 1,
+    });
+    bool = $cache({
+      handler: () => true,
+    });
+    string = $cache({
+      handler: () => '{ "a": 1 }',
+    });
+  }
+
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(Types);
+
+  expect(await test.json()).toEqual({ a: 1 });
+  expect(await test.json()).toEqual({ a: 1 });
+  expect(await test.json()).toEqual({ a: 1 });
+  expect(await test.int()).toBe(1);
+  expect(await test.int()).toBe(1);
+  expect(await test.int()).toBe(1);
+  expect(await test.bool()).toBe(true);
+  expect(await test.bool()).toBe(true);
+  expect(await test.bool()).toBe(true);
+  expect(await test.string()).toBe('{ "a": 1 }');
+  expect(await test.string()).toBe('{ "a": 1 }');
+};
+
+export const testCacheKeys = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+) => {
+  const alepha = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+  class TestApp {
+    cache = $cache<string>();
+  }
+
+  const app = alepha.inject(TestApp);
+  const provider = alepha.inject(CacheProvider);
+  await alepha.start();
+
+  app.cache.set("test:A", "A");
+  app.cache.set("test:B", "B");
+  app.cache.set("hello", "C");
+  expect(await provider.keys("TestApp:cache").then((it) => it.length)).toEqual(
+    3,
+  );
+
+  await app.cache.invalidate("test:*");
+  expect(await provider.keys("TestApp:cache").then((it) => it.length)).toEqual(
+    1,
+  );
+};
+
+export const testSimpleKeyMappingHandler = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  class App {
+    i = 0;
+    run = $cache({
+      key: (name: string) => name,
+      ttl: [5, "seconds"],
+      handler: async (name: string) => {
+        this.i++;
+        return `${name}=${this.i}`;
+      },
+    });
+  }
+  const alepha = Alepha.create({
+    env,
+  })
+    .with({
+      provide: CacheProvider,
+      use: cacheProvider,
+    })
+    .with(App);
+
+  await alepha.start();
+  const app = alepha.inject(App);
+  expect(await app.run("A")).toBe("A=1");
+  expect(await app.run("A")).toBe("A=1");
+  expect(await app.run("A")).toBe("A=1");
+  expect(await app.run("A")).toBe("A=1");
+  expect(await app.run("B")).toBe("B=2");
+  expect(await app.run("B")).toBe("B=2");
+  expect(await app.run("B")).toBe("B=2");
+  expect(await app.run("C")).toBe("C=3");
+};
+
+export const testCacheProviderClear = async (
+  env: Env = {},
+  cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+  class TestClearCache {
+    cursor_a = 0;
+    cursor_b = 0;
+
+    a = $cache({
+      key: (args) => args.name,
+      ttl: [5, "seconds"],
+      handler: async (user: { name: string }) => {
+        return `${user.name}:${this.cursor_a++}`;
+      },
+    });
+
+    b = $cache({
+      key: (args) => args.name,
+      handler: async (user: { name: string }) => {
+        return `${user.name}:${this.cursor_b++}`;
+      },
+    });
+  }
+
+  const app = Alepha.create({
+    env,
+  }).with({
+    provide: CacheProvider,
+    use: cacheProvider,
+  });
+
+  const test = app.inject(TestClearCache);
+  const provider = app.inject(CacheProvider);
+  await app.start();
+
+  // Set some cache values
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.a({ name: "B" })).toBe("B:1");
+  expect(await test.b({ name: "C" })).toBe("C:0");
+  expect(await test.b({ name: "C" })).toBe("C:0");
+
+  // Verify cache is working
+  expect(await test.a({ name: "A" })).toBe("A:0");
+  expect(await test.b({ name: "C" })).toBe("C:0");
+
+  // Clear all cache
+  await provider.clear();
+
+  // Verify cache was cleared - new values should be generated
+  expect(await test.a({ name: "A" })).toBe("A:2");
+  expect(await test.a({ name: "B" })).toBe("B:3");
+  expect(await test.b({ name: "C" })).toBe("C:1");
+};

package/src/cache/core/primitives/$cache.spec.ts

@@ -0,0 +1,111 @@
+import { randomUUID } from "node:crypto";
+import { Alepha } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { describe, expect, it } from "vitest";
+import {
+  TestCache,
+  testCacheBasic,
+  testCacheClear,
+  testCacheDisabled,
+  testCacheInvalidateAll,
+  testCacheInvalidateByArgs,
+  testCacheInvalidateByKey,
+  testCacheKeys,
+  testCacheMissingProvider,
+  testCacheProviderClear,
+  testCacheReturnTypes,
+  testCacheStop,
+  testSimpleKeyMappingHandler,
+} from "../__tests__/shared.ts";
+import { $cache, MemoryCacheProvider } from "../index.ts";
+
+describe("$cache", () => {
+  it("should handle basic caching", async () => {
+    await testCacheBasic();
+  });
+
+  it("should handle stop lifecycle", async () => {
+    await testCacheStop();
+  });
+
+  it("should handle missing provider", async () => {
+    await testCacheMissingProvider();
+  });
+
+  it("should handle disabled cache", async () => {
+    await testCacheDisabled();
+  });
+
+  it("should invalidate by key", async () => {
+    await testCacheInvalidateByKey();
+  });
+
+  it("should invalidate by args", async () => {
+    await testCacheInvalidateByArgs();
+  });
+
+  it("should invalidate all entries", async () => {
+    await testCacheInvalidateAll();
+  });
+
+  it("should clear cache", async () => {
+    await testCacheClear();
+  });
+
+  it("should handle different return types", async () => {
+    await testCacheReturnTypes();
+  });
+
+  it("should generate cache keys correctly", async () => {
+    await testCacheKeys();
+  });
+
+  it("should handle infinite TTL", async () => {
+    const app = Alepha.create({ env: { REDIS_CACHE_PREFIX: randomUUID() } });
+    const test = app.inject(TestCache);
+    const time = app.inject(DateTimeProvider);
+    await app.start();
+
+    expect(await test.b({ name: "A" })).toBe("A:0");
+    expect(await test.b({ name: "A" })).toBe("A:0");
+    await time.travel([1, "day"]);
+    expect(await test.b({ name: "A" })).toBe("A:0");
+  });
+
+  it("should handle unique key without args", async () => {
+    let count = 0;
+    class A {
+      task = $cache({
+        handler: () => {
+          count++;
+          return "DONE";
+        },
+      });
+    }
+    const app = Alepha.create();
+    const test = app.inject(A);
+    await app.start();
+
+    expect(await test.task()).toBe("DONE");
+    expect(await test.task()).toBe("DONE");
+    expect(await test.task()).toBe("DONE");
+    expect(count).toBe(1);
+
+    await test.task.invalidate();
+    expect(await test.task()).toBe("DONE");
+    expect(await test.task()).toBe("DONE");
+    expect(count).toBe(2);
+
+    // [] means no args, it's JSON.stringify([])
+    const obj = await app.inject(MemoryCacheProvider).get("A:task", "[]");
+    expect(new TextDecoder().decode(obj?.slice(1))).toEqual("DONE");
+  });
+
+  it("should handle unique key with args", async () => {
+    await testSimpleKeyMappingHandler();
+  });
+
+  it("should clear provider cache", async () => {
+    await testCacheProviderClear();
+  });
+});

package/src/cache/redis/__tests__/cache-redis.spec.ts

@@ -0,0 +1,70 @@
+import { randomUUID } from "node:crypto";
+import { describe, it } from "vitest";
+import {
+  testCacheBasic,
+  testCacheClear,
+  testCacheDisabled,
+  testCacheInvalidateAll,
+  testCacheInvalidateByArgs,
+  testCacheInvalidateByKey,
+  testCacheKeys,
+  testCacheMissingProvider,
+  testCacheProviderClear,
+  testCacheReturnTypes,
+  testCacheStop,
+  testSimpleKeyMappingHandler,
+} from "../../core/__tests__/shared.ts";
+import { RedisCacheProvider } from "../index.ts";
+
+const provider = RedisCacheProvider;
+const env = () => ({ REDIS_CACHE_PREFIX: randomUUID() });
+
+describe("$cache - redis", () => {
+  it("should handle basic caching", async () => {
+    await testCacheBasic(env(), provider);
+  });
+
+  it("should handle stop lifecycle", async () => {
+    await testCacheStop(env(), provider);
+  });
+
+  it("should handle missing provider", async () => {
+    await testCacheMissingProvider(env(), provider);
+  });
+
+  it("should handle disabled cache", async () => {
+    await testCacheDisabled(env(), provider);
+  });
+
+  it("should invalidate by key", async () => {
+    await testCacheInvalidateByKey(env(), provider);
+  });
+
+  it("should invalidate by args", async () => {
+    await testCacheInvalidateByArgs(env(), provider);
+  });
+
+  it("should invalidate all entries", async () => {
+    await testCacheInvalidateAll(env(), provider);
+  });
+
+  it("should clear cache", async () => {
+    await testCacheClear(env(), provider);
+  });
+
+  it("should handle different return types", async () => {
+    await testCacheReturnTypes(env(), provider);
+  });
+
+  it("should generate cache keys correctly", async () => {
+    await testCacheKeys(env(), provider);
+  });
+
+  it("should handle unique key with args", async () => {
+    await testSimpleKeyMappingHandler();
+  });
+
+  it("should clear provider cache", async () => {
+    await testCacheProviderClear(env(), provider);
+  });
+});

package/src/cli/apps/AlephaCli.ts

@@ -1,13 +1,13 @@
-import { join } from "node:path";
 import { $hook, $inject, $module, Alepha } from "alepha";
 import { FileSystemProvider } from "alepha/file";
 import { BuildCommand } from "../commands/build.ts";
-import { ChangelogCommand, GitProvider } from "../commands/changelog.ts";
 import { CleanCommand } from "../commands/clean.ts";
 import { DbCommand } from "../commands/db.ts";
 import { DeployCommand } from "../commands/deploy.ts";
 import { DevCommand } from "../commands/dev.ts";
 import { FormatCommand } from "../commands/format.ts";
+import { GitProvider } from "../commands/gen/changelog.ts";
+import { GenCommand } from "../commands/gen.ts";
 import { InitCommand } from "../commands/init.ts";
 import { LintCommand } from "../commands/lint.ts";
 import { RootCommand } from "../commands/root.ts";
@@ -16,6 +16,25 @@ import { TestCommand } from "../commands/test.ts";
 import { TypecheckCommand } from "../commands/typecheck.ts";
 import { VerifyCommand } from "../commands/verify.ts";
 
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Register `tsx` when running in Node.js, ignore for Bun.
+ *
+ * It's required to have a full TypeScript support. (mostly .tsx files)
+ */
+
+if (typeof Bun === "undefined") {
+  const { register } = await import("tsx/esm/api");
+  register();
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Allow to extend Alepha CLI via `alepha.config.ts` file located in the project root.
+ */
+
 class AlephaCliExtension {
   protected readonly alepha = $inject(Alepha);
   protected readonly fs = $inject(FileSystemProvider);
@@ -24,7 +43,7 @@ class AlephaCliExtension {
     on: "configure",
     handler: async () => {
       const root = process.cwd();
-      const extensionPath = join(root, "alepha.config.ts");
+      const extensionPath = this.fs.join(root, "alepha.config.ts");
       const hasExtension = await this.fs.exists(extensionPath);
       if (!hasExtension) {
         return;
@@ -43,13 +62,14 @@ class AlephaCliExtension {
   });
 }
 
+// ---------------------------------------------------------------------------------------------------------------------
+
 export const AlephaCli = $module({
   name: "alepha.cli",
   services: [
     AlephaCliExtension,
     // Commands (one per file)
     BuildCommand,
-    ChangelogCommand,
     CleanCommand,
     DbCommand,
     DeployCommand,
@@ -62,6 +82,7 @@ export const AlephaCli = $module({
     TestCommand,
     TypecheckCommand,
     VerifyCommand,
+    GenCommand,
     // Support services
     GitProvider,
   ],

package/src/cli/commands/dev.ts

@@ -1,6 +1,6 @@
 import { access } from "node:fs/promises";
 import { join } from "node:path";
-import { $inject, t } from "alepha";
+import { $inject, Alepha, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { boot } from "alepha/vite";
@@ -9,6 +9,7 @@ import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 export class DevCommand {
   protected readonly log = $logger();
   protected readonly utils = $inject(AlephaCliUtils);
+  protected readonly alepha = $inject(Alepha);
 
   /**
    * Will run the project in watch mode.
@@ -36,16 +37,18 @@ export class DevCommand {
       const entry = await boot.getServerEntry(root, args);
       this.log.trace("Entry file found", { entry });
 
-      try {
-        await access(join(root, "index.html"));
-      } catch {
-        this.log.trace("No index.html found, running entry file with tsx");
-        let cmd = "tsx --watch";
+      const isFullstack = await this.isFullstackProject(root);
+
+      if (!isFullstack) {
+        const exe = this.alepha.isBun() ? "bun" : "tsx";
+        let cmd = `${exe} --watch`;
         if (await this.utils.exists(root, ".env")) {
           cmd += " --env-file=./.env";
         }
         cmd += ` ${entry}`;
-        await this.utils.exec(cmd);
+        await this.utils.exec(cmd, {
+          global: exe === "bun",
+        });
         return;
       }
 
@@ -54,4 +57,13 @@ export class DevCommand {
       await this.utils.exec("vite");
     },
   });
+
+  protected async isFullstackProject(root: string): Promise<boolean> {
+    try {
+      await access(join(root, "index.html"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
 }