alepha 0.19.2 → 0.19.4

package/src/orm/core/providers/DrizzleKitProvider.ts

@@ -29,10 +29,13 @@ export class DrizzleKitProvider {
     }
 
     if (this.alepha.isTest()) {
-      // In test mode, we want to generate migrations from scratch (no snapshots)
-      // to ensure the generated SQL is correct and can be applied cleanly.
       const { statements } = await this.generateMigration(provider);
-      await this.executeFallbackStatements(statements, provider);
+      await this.executeStatements(
+        statements.map((s) =>
+          s.replace(/^CREATE SCHEMA /i, "CREATE SCHEMA IF NOT EXISTS "),
+        ),
+        provider,
+      );
       return;
     }
 
@@ -52,14 +55,18 @@ export class DrizzleKitProvider {
         await this.pushPostgres(kit, models, provider);
       }
     } catch (error) {
-      // Fallback: generate migrations from scratch (no snapshots)
-      // Covers drivers that don't support introspection (e.g. PgLite, sqlite-proxy)
+      // Fallback: generate migrations from scratch (no snapshots).
+      // Covers drivers that don't support introspection (e.g. PgLite, sqlite-proxy).
+      //
+      // If push partially executed (e.g. interactive rename applied then errored),
+      // the fallback would re-create tables that already exist. Guard against this
+      // by attempting the statements individually and ignoring "already exists" errors.
       this.log.debug(
         "Push sync not available, falling back to migration generation",
         { error },
       );
       const { statements } = await this.generateMigration(provider);
-      await this.executeFallbackStatements(statements, provider);
+      await this.executeStatementsLenient(statements, provider);
     }
 
     this.log.info(
@@ -127,7 +134,6 @@ export class DrizzleKitProvider {
   public getModels(provider: DatabaseProvider): Record<string, unknown> {
     const models: Record<string, unknown> = {};
 
-    // Required for pushSchema with Postgres and POSTGRES_SCHEMA
     for (const [key, value] of provider.schemas.entries()) {
       models[`__schema_${key}`] = value;
     }
@@ -232,14 +238,10 @@ export class DrizzleKitProvider {
     };
 
     if (provider.dialect === "sqlite") {
-      result = await this.muteSpinner(() =>
-        kit.pushSQLiteSchema(models, provider.db as any),
-      );
+      result = await kit.pushSQLiteSchema(models, provider.db as any);
     } else {
       const wrappedDb = this.wrapDbForDrizzleKit(provider.db);
-      result = await this.muteSpinner(() =>
-        kit.pushSchema(models, wrappedDb, [provider.schema]),
-      );
+      result = await kit.pushSchema(models, wrappedDb, [provider.schema]);
     }
 
     return {
@@ -256,11 +258,11 @@ export class DrizzleKitProvider {
     models: Record<string, unknown>,
     provider: DatabaseProvider,
   ): Promise<void> {
-    const result = await this.muteSpinner(() =>
-      kit.pushSQLiteSchema(models, provider.db as any),
+    const { statementsToExecute } = await kit.pushSQLiteSchema(
+      models,
+      provider.db as any,
     );
-
-    await this.runPushResult(result, provider);
+    await this.executeStatements(statementsToExecute, provider);
   }
 
   /**
@@ -275,78 +277,61 @@ export class DrizzleKitProvider {
       await this.createSchemaIfNotExists(provider, provider.schema);
     }
 
-    // Drizzle Kit's pushSchema internally does:
-    //   const res = await drizzleInstance.execute(sql.raw(query));
-    //   return res.rows;
-    //
-    // This assumes node-postgres (pg) format where execute() returns { rows: [...] }.
-    // But postgres.js (used by Alepha) returns a Result that extends Array — no .rows property.
-    // We wrap the db instance so execute() returns { rows: [...] } as expected.
+    // Drizzle Kit's pushSchema expects execute() to return { rows: T[] }
+    // (node-postgres/pg format), but postgres.js returns a Result that
+    // extends Array directly — no .rows property.
     const wrappedDb = this.wrapDbForDrizzleKit(provider.db);
 
-    const result = await this.muteSpinner(() =>
-      kit.pushSchema(models, wrappedDb, [provider.schema]),
-    );
-
-    await this.runPushResult(result, provider);
+    const { statementsToExecute } = await kit.pushSchema(models, wrappedDb, [
+      provider.schema,
+    ]);
+    await this.executeStatements(statementsToExecute, provider);
   }
 
   /**
-   * Run the statements returned by Drizzle Kit's pushSchema, with safety filters and logging.
+   * Execute a list of SQL statements against the provider.
    */
-  protected async runPushResult(
-    result: {
-      statementsToExecute: string[];
-      warnings: string[];
-      hasDataLoss: boolean;
-    },
+  protected async executeStatements(
+    statements: string[],
     provider: DatabaseProvider,
-  ) {
-    // Filter out destructive schema/table drops — never auto-apply those in dev.
-    const safe = (result.statementsToExecute as string[]).filter((s) => {
-      const upper = s.trimStart().toUpperCase();
-      if (upper.startsWith("DROP SCHEMA") || upper.startsWith("DROP TABLE")) {
-        this.log.warn("Skipping destructive statement", { statement: s });
-        return false;
-      }
-      return true;
-    });
-
-    if (result.hasDataLoss) {
-      this.log.warn("Push would cause data loss", {
-        warnings: result.warnings,
-        statements: result.statementsToExecute,
+  ): Promise<void> {
+    if (statements.length > 0) {
+      this.log.debug(`Executing ${statements.length} statements ...`, {
+        statements,
       });
     }
-
-    if (safe.length > 0) {
-      this.log.debug(`Pushing ${safe.length} statements ...`, {
-        statements: safe,
-      });
-      for (const statement of safe) {
-        await provider.execute(sql.raw(statement));
-      }
+    for (const statement of statements) {
+      await provider.execute(sql.raw(statement));
     }
   }
 
   /**
-   * Execute migration statements as a fallback when push sync is not available.
-   * Used for drivers that don't support Drizzle Kit introspection (e.g. PgLite).
+   * Execute SQL statements, ignoring "already exists" errors.
+   *
+   * Used by the fallback migration path where push may have partially
+   * applied changes before erroring, leaving some objects already created.
    */
-  protected async executeFallbackStatements(
+  protected async executeStatementsLenient(
     statements: string[],
     provider: DatabaseProvider,
   ): Promise<void> {
+    if (statements.length > 0) {
+      this.log.debug(
+        `Executing ${statements.length} statements (lenient) ...`,
+        { statements },
+      );
+    }
     for (const statement of statements) {
-      const upper = statement.trimStart().toUpperCase();
-      // Schema lifecycle is managed by createSchemaIfNotExists / generateTestSchema.
-      if (
-        upper.startsWith("DROP SCHEMA") ||
-        upper.startsWith("CREATE SCHEMA")
-      ) {
-        continue;
+      try {
+        await provider.execute(sql.raw(statement));
+      } catch (error: any) {
+        const message = error?.message ?? "";
+        if (message.includes("already exists")) {
+          this.log.debug(`Skipped (already exists): ${statement.slice(0, 80)}`);
+          continue;
+        }
+        throw error;
       }
-      await provider.execute(sql.raw(statement));
     }
   }
 
@@ -375,7 +360,7 @@ export class DrizzleKitProvider {
 
   // -------------------------------------------------------------------------------------------------------------------
 
-  // TODO: remove both hacks when Drizzle Kit is updated !
+  // TODO: remove when Drizzle Kit fixes postgres.js compatibility
 
   /**
    * Wrap a Drizzle PgDatabase instance for compatibility with Drizzle Kit.
@@ -401,40 +386,6 @@ export class DrizzleKitProvider {
     });
   }
 
-  /**
-   * Suppress Drizzle Kit's spinner output during a callback.
-   *
-   * Drizzle Kit uses hanji's renderWithTask with a setInterval-based spinner.
-   * If the wrapped task throws, the interval is never cleared and leaks
-   * spinner frames to stdout. We keep the filter active until the next
-   * tick after the promise settles to catch any straggling writes.
-   */
-  protected async muteSpinner<T>(fn: () => Promise<T>): Promise<T> {
-    const originalWrite = process.stdout.write;
-    const filter = (chunk: any, ...args: any[]) => {
-      const str =
-        typeof chunk === "string" ? chunk : (chunk?.toString?.() ?? "");
-      if (str.includes("Pulling schema from database")) {
-        return true;
-      }
-      if (str.includes("\x1B[1A")) {
-        return true;
-      }
-      return (originalWrite as any).call(process.stdout, chunk, ...args);
-    };
-    process.stdout.write = filter as any;
-    try {
-      return await fn();
-    } finally {
-      // Delay restore to catch orphaned setInterval spinner writes
-      // that fire after the promise rejects but before cleanup.
-      await new Promise((r) => setTimeout(r, 200));
-      process.stdout.write = originalWrite;
-    }
-  }
-
-  // -------------------------------------------------------------------------------------------------------------------
-
   /**
    * Try to load the official Drizzle Kit API.
    */

package/src/orm/postgres/services/PostgresModelBuilder.ts

@@ -4,14 +4,12 @@ import {
   type FromSchema,
   ModelBuilder,
   PG_CREATED_AT,
-  PG_ENUM,
   PG_GENERATED,
   PG_IDENTITY,
   PG_PRIMARY_KEY,
   PG_REF,
   PG_SERIAL,
   PG_UPDATED_AT,
-  type PgEnumOptions,
   type PgGeneratedOptions,
   type PgIdentityOptions,
   type PgRefOptions,
@@ -384,10 +382,9 @@ export class PostgresModelBuilder extends ModelBuilder {
         );
       }
 
-      // SQL Enum
-      if (PG_ENUM in value && value[PG_ENUM]) {
-        const options = value[PG_ENUM] as PgEnumOptions;
-        const enumName = options.name ?? `${tableName}_${key}_enum`;
+      // SQL Enum (default for t.enum unless mode: "text")
+      if ((value as any).mode !== "text") {
+        const enumName = (value as any).enumName ?? `${tableName}_${key}_enum`;
 
         if (enums.has(enumName)) {
           const values = (

package/src/react/router/__tests__/$page.browser.spec.tsx

@@ -882,4 +882,161 @@ describe("$page browser tests", () => {
       });
     });
   });
+
+  describe("transition supersession", () => {
+    it("should not commit a stale slow transition when a newer navigation already won", async () => {
+      let resolvePageA: ((value: { data: string }) => void) | undefined;
+      const pageARendered = vi.fn();
+      const pageBRendered = vi.fn();
+
+      class App {
+        pageA = $page({
+          path: "/page-a",
+          loader: () =>
+            new Promise<{ data: string }>((resolve) => {
+              resolvePageA = resolve;
+            }),
+          component: ({ data }: { data: string }) => {
+            pageARendered();
+            return <div data-testid="page-a">A: {data}</div>;
+          },
+        });
+
+        pageB = $page({
+          path: "/page-b",
+          component: () => {
+            pageBRendered();
+            return <div data-testid="page-b">B</div>;
+          },
+        });
+      }
+
+      alepha = Alepha.create().with(AlephaReact).with(App);
+      await alepha.start();
+
+      const router = alepha.inject(ReactRouter);
+
+      // Start navigating to /page-a — its loader hangs, push() will not
+      // resolve until we manually resolve the loader below.
+      const pushAPromise = router.push("/page-a");
+
+      // Yield so the in-flight transition for /page-a actually starts and
+      // reaches the awaited loader before pushB enters the race.
+      await new Promise((r) => setTimeout(r, 0));
+
+      // Navigate to /page-b before /page-a finishes loading. This should
+      // supersede the in-flight /page-a transition.
+      await act(async () => {
+        await router.push("/page-b");
+      });
+
+      // /page-b should now be the committed router state.
+      expect(router.state.name).toBe("pageB");
+      expect(router.state.url.pathname).toBe("/page-b");
+
+      // Now resolve /page-a's loader: this is the race window where the
+      // stale /page-a transition could overwrite /page-b.
+      resolvePageA?.({ data: "loaded" });
+      await act(async () => {
+        await pushAPromise;
+      });
+
+      // Stale /page-a must NOT have committed.
+      expect(router.state.name).toBe("pageB");
+      expect(router.state.url.pathname).toBe("/page-b");
+      // /page-a's component must never have been instantiated.
+      expect(pageARendered).not.toHaveBeenCalled();
+    });
+
+    it("should not fire onEnter for a stale superseded page", async () => {
+      let resolvePageA: (() => void) | undefined;
+      const pageAOnEnter = vi.fn();
+      const pageBOnEnter = vi.fn();
+
+      class App {
+        pageA = $page({
+          path: "/page-a",
+          loader: () =>
+            new Promise<void>((resolve) => {
+              resolvePageA = resolve;
+            }),
+          onEnter: pageAOnEnter,
+          component: () => <div data-testid="page-a">A</div>,
+        });
+
+        pageB = $page({
+          path: "/page-b",
+          onEnter: pageBOnEnter,
+          component: () => <div data-testid="page-b">B</div>,
+        });
+      }
+
+      alepha = Alepha.create().with(AlephaReact).with(App);
+      await alepha.start();
+
+      const router = alepha.inject(ReactRouter);
+
+      const pushAPromise = router.push("/page-a");
+      await new Promise((r) => setTimeout(r, 0));
+
+      await act(async () => {
+        await router.push("/page-b");
+      });
+
+      expect(router.state.name).toBe("pageB");
+      expect(pageBOnEnter).toHaveBeenCalledTimes(1);
+      expect(pageAOnEnter).not.toHaveBeenCalled();
+
+      // Resolve the stale loader: it must remain a no-op.
+      resolvePageA?.();
+      await act(async () => {
+        await pushAPromise;
+      });
+
+      expect(router.state.name).toBe("pageB");
+      expect(pageAOnEnter).not.toHaveBeenCalled();
+      expect(pageBOnEnter).toHaveBeenCalledTimes(1);
+    });
+
+    it("should not call pushState for a stale superseded transition", async () => {
+      let resolvePageA: (() => void) | undefined;
+
+      class App {
+        pageA = $page({
+          path: "/page-a",
+          loader: () =>
+            new Promise<void>((resolve) => {
+              resolvePageA = resolve;
+            }),
+          component: () => <div data-testid="page-a">A</div>,
+        });
+
+        pageB = $page({
+          path: "/page-b",
+          component: () => <div data-testid="page-b">B</div>,
+        });
+      }
+
+      alepha = Alepha.create().with(AlephaReact).with(App);
+      await alepha.start();
+
+      const router = alepha.inject(ReactRouter);
+
+      const pushAPromise = router.push("/page-a");
+      await new Promise((r) => setTimeout(r, 0));
+
+      await act(async () => {
+        await router.push("/page-b");
+      });
+      expect(window.location.pathname).toBe("/page-b");
+
+      resolvePageA?.();
+      await act(async () => {
+        await pushAPromise;
+      });
+
+      // The stale /page-a transition must not have rewritten the URL bar.
+      expect(window.location.pathname).toBe("/page-b");
+    });
+  });
 });

package/src/react/router/providers/ReactBrowserProvider.ts

@@ -79,6 +79,17 @@ export class ReactBrowserProvider {
     from?: string;
   };
 
+  /**
+   * Monotonic counter used to detect stale (superseded) transitions.
+   *
+   * Each call to `render()` captures `++this.transitionId` and any
+   * subsequent `render()` invalidates older in-flight transitions.
+   * This prevents a slow page from racing past a newer navigation
+   * (e.g. user clicks /pageA which has a 2s loader, then clicks /pageB
+   * — pageB must remain the committed page).
+   */
+  protected transitionId = 0;
+
   public get state(): ReactRouterState {
     return this.alepha.store.get("alepha.react.router.state")!;
   }
@@ -167,12 +178,21 @@ export class ReactBrowserProvider {
       options,
     });
 
+    const myTransitionId = ++this.transitionId;
+
     await this.render({
       url,
       previous: options.force ? [] : this.state.layers,
       meta: options.meta,
+      transitionId: myTransitionId,
     });
 
+    // A newer navigation has superseded us — bail out without touching
+    // history, otherwise we'd push a duplicate/stale entry.
+    if (myTransitionId !== this.transitionId) {
+      return;
+    }
+
     // when redirecting in browser
     if (this.state.url.pathname + this.state.url.search !== url) {
       this.pushState(this.state.url.pathname + this.state.url.search);
@@ -183,6 +203,7 @@ export class ReactBrowserProvider {
   }
 
   protected async render(options: RouterRenderOptions = {}): Promise<void> {
+    const myTransitionId = options.transitionId ?? ++this.transitionId;
     const previous = options.previous ?? this.state.layers;
     const url = options.url ?? this.url;
     const start = this.dateTimeProvider.now();
@@ -196,12 +217,25 @@ export class ReactBrowserProvider {
       to: url,
     });
 
+    const isStale = () => this.transitionId !== myTransitionId;
+
     const redirect = await this.router.transition(
       new URL(`http://localhost${url}`),
       previous,
       options.meta,
+      isStale,
     );
 
+    // A newer navigation has superseded us between the time we awaited
+    // transition() and now. Drop everything: don't follow redirects, don't
+    // log success, don't clear `transitioning` (the newer render owns it).
+    if (isStale()) {
+      this.log.debug("Transition superseded — discarding stale result", {
+        to: url,
+      });
+      return;
+    }
+
     if (redirect) {
       this.log.info("Redirecting to", {
         redirect,
@@ -307,4 +341,9 @@ export interface RouterRenderOptions {
   url?: string;
   previous?: PreviousLayerData[];
   meta?: Record<string, any>;
+  /**
+   * Transition id used to detect supersession by a newer navigation.
+   * When omitted, render() allocates a fresh id internally.
+   */
+  transitionId?: number;
 }

package/src/react/router/providers/ReactBrowserRouterProvider.ts

@@ -51,6 +51,7 @@ export class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
     url: URL,
     previous: PreviousLayerData[] = [],
     meta = {},
+    isStale: () => boolean = () => false,
   ): Promise<string | void> {
     const { pathname, search } = url;
 
@@ -101,6 +102,13 @@ export class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
           state,
           previous,
         );
+        // A newer navigation already won — bail before committing or
+        // emitting any further events. The caller (ReactBrowserProvider)
+        // also re-checks staleness, but stopping here avoids running
+        // success hooks for a transition the user no longer wants.
+        if (isStale()) {
+          return;
+        }
         if (redirect) {
           return redirect;
         }
@@ -120,6 +128,13 @@ export class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
       });
       await this.alepha.events.emit("react:transition:success", { state });
     } catch (e) {
+      // If we were superseded mid-flight, swallow the error: the user has
+      // already moved on, and an error UI for an abandoned page would
+      // overwrite the newer page they actually want.
+      if (isStale()) {
+        return;
+      }
+
       this.log.error("Transition has failed", e);
 
       let element: ReactNode | undefined;
@@ -151,6 +166,13 @@ export class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
       });
     }
 
+    // Final supersession check before any side effects (onLeave/onEnter,
+    // store mutation, head rewrite). Stale transitions must be a complete
+    // no-op from this point on.
+    if (isStale()) {
+      return;
+    }
+
     // [feature]: local hook for leaving a page
     if (previous) {
       for (let i = 0; i < previous.length; i++) {