alepha 0.19.4 → 0.19.5

package/src/cli/platform/services/PlatformOrchestrator.ts

@@ -1,4 +1,4 @@
-import { $inject, AlephaError } from "alepha";
+import { $inject, Alepha, AlephaError } from "alepha";
 import type { RunnerMethod } from "alepha/command";
 import { $logger, ConsoleColorProvider } from "alepha/logger";
 import { CloudflareAdapter } from "../adapters/CloudflareAdapter.ts";
@@ -9,6 +9,10 @@ import type {
   PlatformState,
 } from "../adapters/PlatformAdapter.ts";
 import { VercelAdapter } from "../adapters/VercelAdapter.ts";
+import {
+  PlatformHook,
+  type PlatformHookContext,
+} from "../hooks/PlatformHook.ts";
 import { type NamingContext, NamingService } from "./NamingService.ts";
 import {
   PlatformInspector,
@@ -28,6 +32,7 @@ export class PlatformOrchestrator {
   protected readonly naming = $inject(NamingService);
   protected readonly cloudflareAdapter = $inject(CloudflareAdapter);
   protected readonly vercelAdapter = $inject(VercelAdapter);
+  protected readonly alepha = $inject(Alepha);
 
   // -------------------------------------------------------------------------
   // Adapter resolution
@@ -104,7 +109,12 @@ export class PlatformOrchestrator {
       }
     }
 
-    // 7. Secrets (push .env.{env} secrets to deployed workers)
+    // 7. Platform hooks (register external resources: Stripe webhooks, etc.)
+    //    Run before secrets() so any secret a hook writes to .env.<env>
+    //    gets pushed to the deployed worker in the same up cycle.
+    await this.runHooks("register", ctx, urls, run);
+
+    // 8. Secrets (push .env.{env} secrets to deployed workers)
     await adapter.secrets(ctx, run);
 
     run.end();
@@ -166,6 +176,9 @@ export class PlatformOrchestrator {
     // Auth
     await adapter.authenticate(ctx, run);
 
+    // Platform hooks (tear down external resources first, while creds still valid)
+    await this.runHooks("unregister", ctx, [], run);
+
     // Teardown
     await adapter.teardown(ctx, run);
     run.end();
@@ -173,6 +186,58 @@ export class PlatformOrchestrator {
     return true;
   }
 
+  // -------------------------------------------------------------------------
+  // Platform hooks
+  // -------------------------------------------------------------------------
+
+  /**
+   * Run all registered PlatformHook instances.
+   *
+   * Discovered dynamically via `alepha.services(PlatformHook)`: any plugin
+   * that registers a PlatformHook subclass in its `$module.services`
+   * participates automatically, without the core knowing about it.
+   */
+  protected async runHooks(
+    phase: "register" | "unregister",
+    ctx: PlatformContext,
+    deployUrls: string[],
+    run: RunnerMethod,
+  ): Promise<void> {
+    const hooks = this.alepha.services(PlatformHook);
+    if (hooks.length === 0) return;
+
+    const baseUrl = ctx.envConfig.domain
+      ? `https://${ctx.envConfig.domain}`
+      : deployUrls[0];
+
+    if (!baseUrl) {
+      this.log.debug("Skipping platform hooks: no base URL available");
+      return;
+    }
+
+    const hookCtx: PlatformHookContext = { ...ctx, baseUrl, run };
+
+    for (const hook of hooks) {
+      this.log.info(`Platform hook: ${hook.name} (${phase})`);
+      try {
+        if (phase === "register") {
+          await hook.register(hookCtx);
+        } else {
+          await hook.unregister(hookCtx);
+        }
+      } catch (err) {
+        // unregister must never block teardown
+        if (phase === "unregister") {
+          this.log.warn(
+            `Platform hook ${hook.name} failed to unregister: ${(err as Error).message}`,
+          );
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+
   // -------------------------------------------------------------------------
   // plan
   // -------------------------------------------------------------------------

package/src/cli/vendor/__tests__/VendorService.spec.ts

@@ -443,7 +443,12 @@ describe("VendorService", () => {
         packages: ["pkg"],
       });
 
-      expect(result.packages[0].modified).toEqual(["file.ts"]);
+      expect(result.packages[0].modified).toHaveLength(1);
+      expect(result.packages[0].modified[0].file).toBe("file.ts");
+      expect(result.packages[0].modified[0].changes).toEqual([
+        { line: 1, type: "removed", text: "original" },
+        { line: 1, type: "added", text: "modified by user" },
+      ]);
       expect(result.totalChanges).toBe(1);
     });
 
@@ -493,6 +498,40 @@ describe("VendorService", () => {
       expect(result.totalChanges).toBe(0);
     });
 
+    it("should include line-level changes for multi-line modifications", async ({
+      expect,
+    }) => {
+      const { service, fs } = createDiffTestService();
+      await writeVendorLock(fs);
+
+      await fs.mkdir("/tmp/test-baseline/packages/pkg", { recursive: true });
+      await fs.writeFile(
+        "/tmp/test-baseline/packages/pkg/config.ts",
+        "const a = 1;\nconst b = 2;\nconst c = 3;",
+      );
+
+      await fs.mkdir("/project/packages/pkg", { recursive: true });
+      await fs.writeFile(
+        "/project/packages/pkg/config.ts",
+        "const a = 1;\nconst b = 99;\nconst c = 3;\nconst d = 4;",
+      );
+
+      const result = await service.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg"],
+      });
+
+      const fileDiff = result.packages[0].modified[0];
+      expect(fileDiff.file).toBe("config.ts");
+      expect(fileDiff.changes).toEqual([
+        { line: 2, type: "removed", text: "const b = 2;" },
+        { line: 2, type: "added", text: "const b = 99;" },
+        { line: 4, type: "added", text: "const d = 4;" },
+      ]);
+    });
+
     it("should clean up temp directory after diff", async ({ expect }) => {
       const { service, fs } = createDiffTestService();
       await writeVendorLock(fs);

package/src/cli/vendor/commands/VendorCommand.ts

@@ -5,6 +5,7 @@ import { $logger, ConsoleColorProvider } from "alepha/logger";
 import { vendorOptions } from "../atoms/vendorOptions.ts";
 import type {
   VendorDiffResult,
+  VendorPackageDiff,
   VendorSyncResult,
 } from "../services/VendorService.ts";
 import { VendorService } from "../services/VendorService.ts";
@@ -81,22 +82,7 @@ export class VendorCommand {
         );
 
         for (const pkg of result.aborted.packages) {
-          const count =
-            pkg.added.length + pkg.modified.length + pkg.removed.length;
-          if (count === 0) continue;
-
-          process.stdout.write(
-            `\n${c.set("CYAN", pkg.name)}: ${count} ${count === 1 ? "file differs" : "files differ"}\n`,
-          );
-          for (const file of pkg.added) {
-            process.stdout.write(`  ${c.set("GREEN", "A")} ${file}\n`);
-          }
-          for (const file of pkg.modified) {
-            process.stdout.write(`  ${c.set("ORANGE", "M")} ${file}\n`);
-          }
-          for (const file of pkg.removed) {
-            process.stdout.write(`  ${c.set("RED", "D")} ${file}\n`);
-          }
+          this.printPackageDiff(pkg);
         }
 
         process.stdout.write("\n");
@@ -160,35 +146,52 @@ export class VendorCommand {
         return;
       }
 
-      const c = this.color;
-
       for (const pkg of result.packages) {
-        const count =
-          pkg.added.length + pkg.modified.length + pkg.removed.length;
-        if (count === 0) {
-          process.stdout.write(`\n${c.set("CYAN", pkg.name)}: no changes\n`);
-          continue;
-        }
-
-        process.stdout.write(
-          `\n${c.set("CYAN", pkg.name)}: ${count} ${count === 1 ? "file differs" : "files differ"}\n`,
-        );
-
-        for (const file of pkg.added) {
-          process.stdout.write(`  ${c.set("GREEN", "A")} ${file}\n`);
-        }
-        for (const file of pkg.modified) {
-          process.stdout.write(`  ${c.set("ORANGE", "M")} ${file}\n`);
-        }
-        for (const file of pkg.removed) {
-          process.stdout.write(`  ${c.set("RED", "D")} ${file}\n`);
-        }
+        this.printPackageDiff(pkg);
       }
 
       process.stdout.write("\n");
     },
   });
 
+  // ─────────────────────────────────────────────────────────────────────────
+  // Helpers
+  // ─────────────────────────────────────────────────────────────────────────
+
+  protected printPackageDiff(pkg: VendorPackageDiff) {
+    const c = this.color;
+    const count = pkg.added.length + pkg.modified.length + pkg.removed.length;
+
+    if (count === 0) {
+      process.stdout.write(`\n${c.set("CYAN", pkg.name)}: no changes\n`);
+      return;
+    }
+
+    process.stdout.write(
+      `\n${c.set("CYAN", pkg.name)}: ${count} ${count === 1 ? "file differs" : "files differ"}\n`,
+    );
+
+    for (const file of pkg.added) {
+      process.stdout.write(`  ${c.set("GREEN", "A")} ${file}\n`);
+    }
+
+    for (const fileDiff of pkg.modified) {
+      process.stdout.write(`  ${c.set("ORANGE", "M")} ${fileDiff.file}\n`);
+      for (const change of fileDiff.changes) {
+        const prefix = change.type === "removed" ? "-" : "+";
+        const color = change.type === "removed" ? "RED" : "GREEN";
+        const lineNum = `L${change.line}`;
+        process.stdout.write(
+          `      ${c.set("DIM", lineNum.padEnd(5))} ${c.set(color, `${prefix} ${change.text}`)}\n`,
+        );
+      }
+    }
+
+    for (const file of pkg.removed) {
+      process.stdout.write(`  ${c.set("RED", "D")} ${file}\n`);
+    }
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // Parent command
   // ─────────────────────────────────────────────────────────────────────────

package/src/cli/vendor/services/VendorService.ts

@@ -32,13 +32,30 @@ export interface VendorDiffOptions {
   packages: string[];
 }
 
+/**
+ * A single line change within a modified file.
+ */
+export interface VendorLineDiff {
+  line: number;
+  type: "added" | "removed";
+  text: string;
+}
+
+/**
+ * A modified file with its line-level changes.
+ */
+export interface VendorFileDiff {
+  file: string;
+  changes: VendorLineDiff[];
+}
+
 /**
  * Diff result for a single vendored package.
  */
 export interface VendorPackageDiff {
   name: string;
   added: string[];
-  modified: string[];
+  modified: VendorFileDiff[];
   removed: string[];
 }
 
@@ -388,9 +405,13 @@ export class VendorService {
   protected async diffDirectories(
     localDir: string,
     remoteDir: string,
-  ): Promise<{ added: string[]; modified: string[]; removed: string[] }> {
+  ): Promise<{
+    added: string[];
+    modified: VendorFileDiff[];
+    removed: string[];
+  }> {
     const added: string[] = [];
-    const modified: string[] = [];
+    const modified: VendorFileDiff[] = [];
     const removed: string[] = [];
 
     const [localFiles, remoteFiles] = await Promise.all([
@@ -418,7 +439,11 @@ export class VendorService {
         ]);
 
         if (!localContent.equals(remoteContent)) {
-          modified.push(file);
+          const changes = this.computeLineDiff(
+            remoteContent.toString(),
+            localContent.toString(),
+          );
+          modified.push({ file, changes });
         }
       } catch {
         // Skip directories and unreadable entries
@@ -434,4 +459,83 @@ export class VendorService {
 
     return { added, modified, removed };
   }
+
+  /**
+   * Compute line-level differences between two file contents.
+   *
+   * Uses a longest-common-subsequence algorithm to produce minimal
+   * added/removed line changes with accurate line numbers.
+   */
+  protected computeLineDiff(baseline: string, local: string): VendorLineDiff[] {
+    const baseLines = baseline.split("\n");
+    const localLines = local.split("\n");
+    const lcs = this.longestCommonSubsequence(baseLines, localLines);
+    const changes: VendorLineDiff[] = [];
+
+    let bi = 0;
+    let li = 0;
+    let ci = 0;
+
+    while (bi < baseLines.length || li < localLines.length) {
+      if (ci < lcs.length && bi < baseLines.length && li < localLines.length) {
+        if (baseLines[bi] === lcs[ci] && localLines[li] === lcs[ci]) {
+          // Line is unchanged
+          bi++;
+          li++;
+          ci++;
+        } else if (baseLines[bi] !== lcs[ci]) {
+          changes.push({ line: bi + 1, type: "removed", text: baseLines[bi] });
+          bi++;
+        } else {
+          changes.push({ line: li + 1, type: "added", text: localLines[li] });
+          li++;
+        }
+      } else if (bi < baseLines.length) {
+        changes.push({ line: bi + 1, type: "removed", text: baseLines[bi] });
+        bi++;
+      } else {
+        changes.push({ line: li + 1, type: "added", text: localLines[li] });
+        li++;
+      }
+    }
+
+    return changes;
+  }
+
+  /**
+   * Compute the longest common subsequence of two string arrays.
+   */
+  protected longestCommonSubsequence(a: string[], b: string[]): string[] {
+    const m = a.length;
+    const n = b.length;
+    const dp: number[][] = Array.from({ length: m + 1 }, () =>
+      Array(n + 1).fill(0),
+    );
+
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        dp[i][j] =
+          a[i - 1] === b[j - 1]
+            ? dp[i - 1][j - 1] + 1
+            : Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+
+    const result: string[] = [];
+    let i = m;
+    let j = n;
+    while (i > 0 && j > 0) {
+      if (a[i - 1] === b[j - 1]) {
+        result.unshift(a[i - 1]);
+        i--;
+        j--;
+      } else if (dp[i - 1][j] > dp[i][j - 1]) {
+        i--;
+      } else {
+        j--;
+      }
+    }
+
+    return result;
+  }
 }

package/src/command/__tests__/CliProvider.spec.ts

@@ -26,6 +26,7 @@ class TestCliProvider extends CliProvider {
   public testFindPostHooks = this.findPostHooks.bind(this);
   public testGetEnumValues = this.getEnumValues.bind(this);
   public testFormatFlagDescription = this.formatFlagDescription.bind(this);
+  public testParseCommandEnv = this.parseCommandEnv.bind(this);
 
   /**
    * Extract flag definitions from a command's flags schema (for testing printHelp logic).
@@ -1291,6 +1292,50 @@ describe("CliProvider", () => {
     });
   });
 
+  // ─────────────────────────────────────────────────────────────────────────────
+  // parseCommandEnv
+  // ─────────────────────────────────────────────────────────────────────────────
+
+  describe("parseCommandEnv", () => {
+    it("should use default value for required field with default when env var is missing", () => {
+      const cli = createTestCli();
+      const schema = t.object({
+        MY_VAR: t.text({ default: "fallback" }),
+      });
+
+      delete process.env.MY_VAR;
+      const result = cli.testParseCommandEnv(schema, "test");
+      expect(result.MY_VAR).toBe("fallback");
+    });
+
+    it("should prefer env var over default when both exist", () => {
+      const cli = createTestCli();
+      const schema = t.object({
+        MY_VAR: t.text({ default: "fallback" }),
+      });
+
+      process.env.MY_VAR = "from-env";
+      try {
+        const result = cli.testParseCommandEnv(schema, "test");
+        expect(result.MY_VAR).toBe("from-env");
+      } finally {
+        delete process.env.MY_VAR;
+      }
+    });
+
+    it("should throw for required field without default when env var is missing", () => {
+      const cli = createTestCli();
+      const schema = t.object({
+        MY_VAR: t.text(),
+      });
+
+      delete process.env.MY_VAR;
+      expect(() => cli.testParseCommandEnv(schema, "test")).toThrow(
+        "Missing required environment variable",
+      );
+    });
+  });
+
   // ─────────────────────────────────────────────────────────────────────────────
   // run (test helper)
   // ─────────────────────────────────────────────────────────────────────────────

package/src/command/providers/CliProvider.ts

@@ -594,11 +594,10 @@ export class CliProvider {
 
       if (value !== undefined) {
         result[key] = value;
+      } else if ("default" in propSchema) {
+        result[key] = propSchema.default;
       } else if (t.schema.isOptional(propSchema)) {
-        // Check for default value
-        if ("default" in propSchema) {
-          result[key] = propSchema.default;
-        }
+        // Optional with no default — leave undefined
       } else {
         missing.push(key);
       }

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

@@ -533,6 +533,8 @@ export abstract class Repository<T extends TObject> {
     } = {},
     opts: StatementOptions & { count?: boolean } = {},
   ): Promise<Page<PgStatic<T, R>>> {
+    // Overflow-safe: pageQuerySchema constrains size to [1, 100] and page to >= 0.
+    // With max size=100, page would need to exceed 2^45 to overflow Number.MAX_SAFE_INTEGER.
     const limit = query.limit ?? pagination.size ?? 10;
     const page = pagination.page ?? 0;
     const offset = query.offset ?? page * limit;
@@ -674,7 +676,9 @@ export abstract class Repository<T extends TObject> {
         .returning(this.table)
         .then(([it]) => this.clean(it, this.entity.schema));
 
-      this.dbCache.invalidateTable(this.tableName).catch(() => {});
+      this.dbCache
+        .invalidateTable(this.tableName)
+        .catch((err) => this.log.warn("Cache invalidation failed", err));
 
       await this.alepha.events.emit("repository:create:after", {
         tableName: this.tableName,
@@ -728,7 +732,9 @@ export abstract class Repository<T extends TObject> {
         allEntities.push(...entities);
       }
 
-      this.dbCache.invalidateTable(this.tableName).catch(() => {});
+      this.dbCache
+        .invalidateTable(this.tableName)
+        .catch((err) => this.log.warn("Cache invalidation failed", err));
 
       await this.alepha.events.emit("repository:create:after", {
         tableName: this.tableName,
@@ -825,7 +831,9 @@ export abstract class Repository<T extends TObject> {
         .returning(this.table)
         .then(([it]) => this.clean(it, this.entity.schema));
 
-      this.dbCache.invalidateTable(this.tableName).catch(() => {});
+      this.dbCache
+        .invalidateTable(this.tableName)
+        .catch((err) => this.log.warn("Cache invalidation failed", err));
 
       await this.alepha.events.emit("repository:create:after", {
         tableName: this.tableName,
@@ -889,7 +897,9 @@ export abstract class Repository<T extends TObject> {
     try {
       const entity = this.clean(response[0], this.entity.schema);
 
-      this.dbCache.invalidateTable(this.tableName).catch(() => {});
+      this.dbCache
+        .invalidateTable(this.tableName)
+        .catch((err) => this.log.warn("Cache invalidation failed", err));
 
       await this.alepha.events.emit("repository:update:after", {
         tableName: this.tableName,
@@ -1041,7 +1051,9 @@ export abstract class Repository<T extends TObject> {
         .where(this.toSQL(where))
         .returning();
 
-      this.dbCache.invalidateTable(this.tableName).catch(() => {});
+      this.dbCache
+        .invalidateTable(this.tableName)
+        .catch((err) => this.log.warn("Cache invalidation failed", err));
 
       await this.alepha.events.emit("repository:update:after", {
         tableName: this.tableName,
@@ -1089,7 +1101,9 @@ export abstract class Repository<T extends TObject> {
         .returning({ id: (this.table as any)[this.id.key] });
       const ids = result.map((row) => row.id);
 
-      this.dbCache.invalidateTable(this.tableName).catch(() => {});
+      this.dbCache
+        .invalidateTable(this.tableName)
+        .catch((err) => this.log.warn("Cache invalidation failed", err));
 
       await this.alepha.events.emit("repository:delete:after", {
         tableName: this.tableName,

package/src/react/i18n/__tests__/I18nProvider.spec.ts

@@ -366,6 +366,89 @@ describe("I18nProvider", () => {
     );
   });
 
+  describe("when only non-English dictionaries are registered", () => {
+    test("should default to the first registered language", async ({
+      expect,
+    }) => {
+      class App {
+        fr = $dictionary({
+          lazy: async () => ({ default: { hello: "Bonjour" } }),
+        });
+      }
+
+      const alepha = Alepha.create().with(AlephaReactI18n);
+      const app = alepha.inject(App);
+      const i18n = alepha.inject(I18nProvider);
+
+      expect(i18n.lang).toBe("fr");
+    });
+
+    test("should translate using the first registered language", async ({
+      expect,
+    }) => {
+      class App {
+        fr = $dictionary({
+          lazy: async () => ({
+            default: { greeting: "Bonjour!", settings: "Paramètres" },
+          }),
+        });
+      }
+
+      const alepha = Alepha.create().with(AlephaReactI18n);
+      const app = alepha.inject(App);
+      const i18n = alepha.inject(I18nProvider);
+
+      await alepha.start();
+
+      expect(i18n.tr("greeting")).toBe("Bonjour!");
+      expect(i18n.tr("settings")).toBe("Paramètres");
+    });
+
+    test("should not include 'en' in languages list", async ({ expect }) => {
+      class App {
+        fr = $dictionary({
+          lazy: async () => ({ default: { hello: "Bonjour" } }),
+        });
+
+        de = $dictionary({
+          lazy: async () => ({ default: { hello: "Hallo" } }),
+        });
+      }
+
+      const alepha = Alepha.create().with(AlephaReactI18n);
+      const app = alepha.inject(App);
+      const i18n = alepha.inject(I18nProvider);
+
+      expect(i18n.languages).toEqual(["fr", "de"]);
+    });
+
+    test("should fallback to the first registered language for missing keys", async ({
+      expect,
+    }) => {
+      class App {
+        fr = $dictionary({
+          lazy: async () => ({
+            default: { hello: "Bonjour", world: "Monde" },
+          }),
+        });
+
+        de = $dictionary({
+          lazy: async () => ({ default: { hello: "Hallo" } }),
+        });
+      }
+
+      const alepha = Alepha.create().with(AlephaReactI18n);
+      const app = alepha.inject(App);
+      const i18n = alepha.inject(I18nProvider);
+
+      await alepha.start();
+      await i18n.setLang("de");
+
+      expect(i18n.tr("hello")).toBe("Hallo");
+      expect(i18n.tr("world")).toBe("Monde"); // Falls back to FR
+    });
+  });
+
   test("should handle partial interpolation args", async ({ expect }) => {
     class App {
       en = $dictionary({