alepha 0.14.1 → 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,39 @@
-import { join } from "node:path";
 import { $hook, $inject, $module, Alepha } from "alepha";
 import { FileSystemProvider } from "alepha/file";
-import { BiomeCommands } from "../commands/BiomeCommands.ts";
-import { ChangelogCommands } from "../commands/ChangelogCommands.ts";
-import { CoreCommands } from "../commands/CoreCommands.ts";
-import { DeployCommands } from "../commands/DeployCommands.ts";
-import { DrizzleCommands } from "../commands/DrizzleCommands.ts";
-import { VerifyCommands } from "../commands/VerifyCommands.ts";
-import { ViteCommands } from "../commands/ViteCommands.ts";
+import { BuildCommand } from "../commands/build.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";
+import { RunCommand } from "../commands/run.ts";
+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);
@@ -17,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;
@@ -36,16 +62,28 @@ class AlephaCliExtension {
   });
 }
 
+// ---------------------------------------------------------------------------------------------------------------------
+
 export const AlephaCli = $module({
   name: "alepha.cli",
   services: [
     AlephaCliExtension,
-    BiomeCommands,
-    ChangelogCommands,
-    CoreCommands,
-    DeployCommands,
-    DrizzleCommands,
-    VerifyCommands,
-    ViteCommands,
+    // Commands (one per file)
+    BuildCommand,
+    CleanCommand,
+    DbCommand,
+    DeployCommand,
+    DevCommand,
+    FormatCommand,
+    InitCommand,
+    LintCommand,
+    RootCommand,
+    RunCommand,
+    TestCommand,
+    TypecheckCommand,
+    VerifyCommand,
+    GenCommand,
+    // Support services
+    GitProvider,
   ],
 });

package/src/cli/apps/AlephaPackageBuilderCli.ts

@@ -66,7 +66,8 @@ export class AlephaPackageBuilderCli {
       }
 
       if (packageName === "@alepha/ui") {
-        pkgData.exports["./styles"] = "./styles.css";
+        pkgData.exports["./styles"] = "./src/core/styles.css";
+        pkgData.exports["./json/styles"] = "./src/json/styles.css";
       }
 
       await this.fs.writeFile("package.json", JSON.stringify(pkgData, null, 2));

package/src/cli/assets/appRouterTs.ts

@@ -1,5 +1,5 @@
 export const appRouterTs = () => `
-import { $page } from "@alepha/react";
+import { $page } from "@alepha/react/router";
 
 export class AppRouter {
   home = $page({