alepha 0.20.2 → 0.20.3

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

@@ -2,7 +2,6 @@ import { AlephaError } from "alepha";
 import type { SQL } from "drizzle-orm";
 import type { EntityPrimitive } from "../primitives/$entity.ts";
 import type { SequencePrimitive } from "../primitives/$sequence.ts";
-import type { ViewPrimitive } from "../primitives/$view.ts";
 
 /**
  * Database-specific table configuration functions
@@ -43,17 +42,6 @@ export abstract class ModelBuilder {
     },
   ): void;
 
-  /**
-   * Build a view from a view primitive.
-   */
-  abstract buildView(
-    view: ViewPrimitive,
-    options: {
-      tables: Map<string, unknown>;
-      schema: string;
-    },
-  ): void;
-
   /**
    * Build a sequence from a sequence primitive.
    */
@@ -192,7 +180,7 @@ export abstract class ModelBuilder {
             // Resolve foreign column references
             const foreignColumns = fkDef.foreignColumns.map((colRef) => {
               const entityCol = colRef();
-              if (!entityCol || !entityCol.entity || !entityCol.name) {
+              if (!entityCol?.entity || !entityCol.name) {
                 throw new AlephaError(
                   `Invalid foreign column reference in ${entity.name}`,
                 );

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

@@ -114,11 +114,7 @@ export abstract class Repository<T extends TObject> {
   constructor(entity: EntityPrimitive<T>, provider = DatabaseProvider) {
     this.entity = entity;
     this.provider = this.alepha.inject(provider);
-    if ((entity as any).isView) {
-      this.provider.registerView(entity as any);
-    } else {
-      this.provider.registerEntity(entity as EntityPrimitive);
-    }
+    this.provider.registerEntity(entity as EntityPrimitive);
   }
 
   /**
@@ -150,13 +146,6 @@ export abstract class Repository<T extends TObject> {
     return this.entity.name;
   }
 
-  /**
-   * Whether this repository is backed by a view (read-only).
-   */
-  public get isReadOnly(): boolean {
-    return (this.entity as any).isView === true;
-  }
-
   /**
    * Getter for the database connection from the database provider.
    *
@@ -663,7 +652,6 @@ export abstract class Repository<T extends TObject> {
     data: Static<TObjectInsert<T>>,
     opts: StatementOptions = {},
   ): Promise<Static<T>> {
-    this.assertWritable();
     this.stampOrganization(data);
     await this.alepha.events.emit("repository:create:before", {
       tableName: this.tableName,
@@ -705,7 +693,6 @@ export abstract class Repository<T extends TObject> {
     values: Array<Static<TObjectInsert<T>>>,
     opts: StatementOptions & { batchSize?: number } = {},
   ): Promise<Static<T>[]> {
-    this.assertWritable();
     if (values.length === 0) {
       return [];
     }
@@ -784,7 +771,6 @@ export abstract class Repository<T extends TObject> {
       set?: WithSQL<Static<TObjectUpdate<T>>>;
     } = {},
   ): Promise<Static<T>> {
-    this.assertWritable();
     this.stampOrganization(data);
     await this.alepha.events.emit("repository:create:before", {
       tableName: this.tableName,
@@ -857,7 +843,6 @@ export abstract class Repository<T extends TObject> {
     data: WithSQL<Static<TObjectUpdate<T>>>,
     opts: StatementOptions = {},
   ): Promise<Static<T>> {
-    this.assertWritable();
     await this.alepha.events.emit("repository:update:before", {
       tableName: this.tableName,
       where,
@@ -938,7 +923,6 @@ export abstract class Repository<T extends TObject> {
     entity: Static<T>,
     opts: StatementOptions = {},
   ): Promise<void> {
-    this.assertWritable();
     const row = entity as any;
 
     const id = row[this.id.key];
@@ -1024,7 +1008,6 @@ export abstract class Repository<T extends TObject> {
     data: WithSQL<Static<TObjectUpdate<T>>>,
     opts: StatementOptions = {},
   ): Promise<Array<number | string>> {
-    this.assertWritable();
     await this.alepha.events.emit("repository:update:before", {
       tableName: this.tableName,
       where,
@@ -1076,7 +1059,6 @@ export abstract class Repository<T extends TObject> {
     where: PgQueryWhereOrSQL<T> = {},
     opts: StatementOptions = {},
   ): Promise<Array<number | string>> {
-    this.assertWritable();
     const deletedAt = this.deletedAt();
     if (deletedAt && !opts.force) {
       return await this.updateMany(
@@ -1639,29 +1621,6 @@ export abstract class Repository<T extends TObject> {
     return entity as Static<T>;
   }
 
-  /**
-   * Throw if this repository is read-only (backed by a view).
-   */
-  protected assertWritable(): void {
-    if (this.isReadOnly) {
-      throw new AlephaError(
-        `Cannot write to view '${this.tableName}'. Views are read-only.`,
-      );
-    }
-  }
-
-  /**
-   * Refresh a materialized view. PostgreSQL only.
-   */
-  public async refresh(): Promise<void> {
-    if (!(this.entity as any).materialized) {
-      throw new AlephaError(
-        `Cannot refresh '${this.tableName}'. Only materialized views support refresh.`,
-      );
-    }
-    await this.provider.execute(`REFRESH MATERIALIZED VIEW ${this.tableName}`);
-  }
-
   /**
    * Build a cache key from method name and query parameters.
    */

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

@@ -16,7 +16,6 @@ import {
   type SQLiteColumnBuilderBase,
   type SQLiteTableWithColumns,
   sqliteTable,
-  sqliteView,
   unique,
   uniqueIndex,
 } from "drizzle-orm/sqlite-core";
@@ -33,7 +32,6 @@ import {
 } from "../constants/PG_SYMBOLS.ts";
 import type { EntityPrimitive } from "../primitives/$entity.ts";
 import type { SequencePrimitive } from "../primitives/$sequence.ts";
-import type { ViewPrimitive } from "../primitives/$view.ts";
 import { ModelBuilder } from "./ModelBuilder.ts";
 
 export class SqliteModelBuilder extends ModelBuilder {
@@ -66,33 +64,6 @@ export class SqliteModelBuilder extends ModelBuilder {
     options.tables.set(tableName, table);
   }
 
-  public buildView(
-    view: ViewPrimitive,
-    options: {
-      tables: Map<string, unknown>;
-      schema: string;
-    },
-  ) {
-    const viewName = view.name;
-    if (options.tables.has(viewName)) {
-      return;
-    }
-
-    if (view.materialized) {
-      throw new AlephaError("SQLite does not support materialized views");
-    }
-
-    const columns = this.schemaToSqliteColumns(
-      viewName,
-      view.schema,
-      new Map(),
-      options.tables,
-    );
-
-    const drizzleView = sqliteView(viewName, columns).existing();
-    options.tables.set(viewName, drizzleView);
-  }
-
   public buildSequence(
     sequence: SequencePrimitive,
     options: {
@@ -193,10 +164,8 @@ export class SqliteModelBuilder extends ModelBuilder {
         col = col.notNull();
       }
 
-      return {
-        ...columns,
-        [key]: col,
-      };
+      (columns as Record<string, unknown>)[key] = col;
+      return columns;
     }, {}) as SchemaToSqliteBuilder<T>;
   };
 

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

@@ -16,7 +16,6 @@ import {
   type SequencePrimitive,
   schema,
   sql,
-  type ViewPrimitive,
 } from "alepha/orm";
 import type { BuildExtraConfigColumns } from "drizzle-orm";
 import * as pg from "drizzle-orm/pg-core";
@@ -29,11 +28,9 @@ import {
   type PgTableExtraConfigValue,
   type PgTableWithColumns,
   pgEnum,
-  pgMaterializedView,
   pgSchema,
   pgSequence,
   pgTable,
-  pgView,
   unique,
   uniqueIndex,
 } from "drizzle-orm/pg-core";
@@ -108,36 +105,6 @@ export class PostgresModelBuilder extends ModelBuilder {
     options.tables.set(tableName, table);
   }
 
-  public buildView(
-    view: ViewPrimitive,
-    options: {
-      tables: Map<string, unknown>;
-      schema: string;
-    },
-  ) {
-    const viewName = view.name;
-    if (options.tables.has(viewName)) {
-      return;
-    }
-
-    const columns = this.schemaToPgColumns(
-      viewName,
-      view.schema,
-      { enum: pgEnum, table: pgTable, sequence: pgSequence } as any,
-      new Map(),
-      options.tables,
-    );
-
-    let drizzleView: unknown;
-    if (view.materialized) {
-      drizzleView = pgMaterializedView(viewName, columns).existing();
-    } else {
-      drizzleView = pgView(viewName, columns).existing();
-    }
-
-    options.tables.set(viewName, drizzleView);
-  }
-
   public buildSequence(
     sequence: SequencePrimitive,
     options: {
@@ -244,10 +211,8 @@ export class PostgresModelBuilder extends ModelBuilder {
           col = col.notNull();
         }
 
-        return {
-          ...columns,
-          [key]: col,
-        };
+        (columns as Record<string, unknown>)[key] = col;
+        return columns;
       },
       {},
     ) as FromSchema<T>;
@@ -325,7 +290,14 @@ export class PostgresModelBuilder extends ModelBuilder {
       return pg.numeric(key);
     }
 
-    if (t.schema.isString(value)) {
+    const isTypeEnum = (value: any): value is { enum: any[] } =>
+      t.schema.isUnsafe(value) &&
+      "type" in value &&
+      value.type === "string" &&
+      "enum" in value &&
+      Array.isArray(value.enum);
+
+    if (t.schema.isString(value) && !isTypeEnum(value)) {
       return this.mapStringToColumn(key, value);
     }
 
@@ -341,13 +313,6 @@ export class PostgresModelBuilder extends ModelBuilder {
       return schema(key, value);
     }
 
-    const isTypeEnum = (value: any): value is { enum: any[] } =>
-      t.schema.isUnsafe(value) &&
-      "type" in value &&
-      value.type === "string" &&
-      "enum" in value &&
-      Array.isArray(value.enum);
-
     if (t.schema.isArray(value)) {
       if (t.schema.isObject(value.items)) {
         return schema(key, value);

package/src/react/intro/components/GettingStartedAuthSlide.tsx

@@ -8,7 +8,7 @@ import type { GettingStartedSlide } from "./GettingStarted.tsx";
  * Returns undefined if auth routes are not configured.
  */
 export const useAuthSlide = (): GettingStartedSlide | undefined => {
-  const { user } = useAuth();
+  const { user, logout } = useAuth();
   const router = useRouter();
 
   // Check if auth routes exist
@@ -19,8 +19,6 @@ export const useAuthSlide = (): GettingStartedSlide | undefined => {
 
   // User is logged in - show user info and logout option
   if (user) {
-    const logoutAnchorProps = router.anchor(router.path("logout"));
-
     return {
       text: "Welcome back!",
       sub: `You're signed in as ${user.email || user.username || "user"}.`,
@@ -33,7 +31,16 @@ export const useAuthSlide = (): GettingStartedSlide | undefined => {
           num: "→",
           text: (
             <>
-              <a {...logoutAnchorProps}>Sign out</a> to test the login flow
+              <a
+                href="#"
+                onClick={(e) => {
+                  e.preventDefault();
+                  logout();
+                }}
+              >
+                Sign out
+              </a>{" "}
+              to test the login flow
             </>
           ),
         },

package/src/react/router/__tests__/ReactBrowserProvider.browser.spec.ts

@@ -1,9 +1,22 @@
 import { Alepha } from "alepha";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ReactBrowserProvider } from "../providers/ReactBrowserProvider.ts";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  ReactBrowserProvider,
+  type RouterPushOptions,
+  reactBrowserOptions,
+} from "../providers/ReactBrowserProvider.ts";
 
 class TestReactBrowserProvider extends ReactBrowserProvider {
   public testGetHydrationState = this.getHydrationState.bind(this);
+  public testAttachAnchorInterceptor = this.attachAnchorInterceptor.bind(this);
+  public pushCalls: Array<{ url: string; options?: RouterPushOptions }> = [];
+
+  public override async push(
+    url: string,
+    options?: RouterPushOptions,
+  ): Promise<void> {
+    this.pushCalls.push({ url, options });
+  }
 }
 
 describe("ReactBrowserProvider", () => {
@@ -102,4 +115,202 @@ describe("ReactBrowserProvider", () => {
       expect(result?.["alepha.i18n.locale"]).toBe("en");
     });
   });
+
+  describe("attachAnchorInterceptor", () => {
+    let alepha: Alepha;
+    let provider: TestReactBrowserProvider;
+    let detach: () => void;
+    let container: HTMLDivElement;
+
+    const createAnchor = (
+      attrs: Record<string, string>,
+      inner?: HTMLElement,
+    ): HTMLAnchorElement => {
+      const a = document.createElement("a");
+      for (const [k, v] of Object.entries(attrs)) {
+        a.setAttribute(k, v);
+      }
+      if (inner) {
+        a.appendChild(inner);
+      } else {
+        a.textContent = "link";
+      }
+      container.appendChild(a);
+      return a;
+    };
+
+    const click = (
+      target: HTMLElement,
+      init: MouseEventInit = {},
+    ): MouseEvent => {
+      const ev = new MouseEvent("click", {
+        bubbles: true,
+        cancelable: true,
+        button: 0,
+        ...init,
+      });
+      target.dispatchEvent(ev);
+      return ev;
+    };
+
+    beforeEach(() => {
+      alepha = Alepha.create();
+      provider = alepha.inject(TestReactBrowserProvider);
+      container = document.createElement("div");
+      document.body.appendChild(container);
+      detach = provider.testAttachAnchorInterceptor();
+    });
+
+    afterEach(() => {
+      detach();
+      container.remove();
+    });
+
+    it("intercepts plain internal /foo anchor clicks", () => {
+      const a = createAnchor({ href: "/foo" });
+
+      const ev = click(a);
+
+      expect(provider.pushCalls).toHaveLength(1);
+      expect(provider.pushCalls[0].url).toBe("/foo");
+      expect(ev.defaultPrevented).toBe(true);
+    });
+
+    it("preserves query and hash when intercepting", () => {
+      const a = createAnchor({ href: "/foo?x=1#bar" });
+
+      click(a);
+
+      expect(provider.pushCalls[0].url).toBe("/foo?x=1#bar");
+    });
+
+    it("ignores cmd-click (metaKey)", () => {
+      const a = createAnchor({ href: "/foo" });
+
+      const ev = click(a, { metaKey: true });
+
+      expect(provider.pushCalls).toHaveLength(0);
+      expect(ev.defaultPrevented).toBe(false);
+    });
+
+    it("ignores ctrl-click", () => {
+      const a = createAnchor({ href: "/foo" });
+
+      click(a, { ctrlKey: true });
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores shift-click", () => {
+      const a = createAnchor({ href: "/foo" });
+
+      click(a, { shiftKey: true });
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores alt-click", () => {
+      const a = createAnchor({ href: "/foo" });
+
+      click(a, { altKey: true });
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores non-primary mouse buttons", () => {
+      const a = createAnchor({ href: "/foo" });
+
+      click(a, { button: 1 });
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores anchors with target='_blank'", () => {
+      const a = createAnchor({ href: "/foo", target: "_blank" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores anchors with download attribute", () => {
+      const a = createAnchor({ href: "/foo", download: "" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores anchors with data-no-router attribute", () => {
+      const a = createAnchor({ href: "/foo", "data-no-router": "" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores mailto: hrefs", () => {
+      const a = createAnchor({ href: "mailto:foo@bar.com" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores tel: hrefs", () => {
+      const a = createAnchor({ href: "tel:+15555555" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores hrefs to external origins", () => {
+      const a = createAnchor({ href: "https://example.com/foo" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("ignores hash-only #section hrefs", () => {
+      const a = createAnchor({ href: "#section" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("intercepts when click target is nested inside the anchor", () => {
+      const span = document.createElement("span");
+      span.textContent = "inner";
+      createAnchor({ href: "/foo" }, span);
+
+      click(span);
+
+      expect(provider.pushCalls).toHaveLength(1);
+      expect(provider.pushCalls[0].url).toBe("/foo");
+    });
+
+    it("skips when defaultPrevented is already true", () => {
+      const a = createAnchor({ href: "/foo" });
+      a.addEventListener("click", (ev) => ev.preventDefault());
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+
+    it("respects interceptAnchorClicks=false at runtime", () => {
+      alepha.store.set(reactBrowserOptions.key, {
+        ...alepha.store.get(reactBrowserOptions.key)!,
+        interceptAnchorClicks: false,
+      });
+      const a = createAnchor({ href: "/foo" });
+
+      click(a);
+
+      expect(provider.pushCalls).toHaveLength(0);
+    });
+  });
 });

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

@@ -28,9 +28,20 @@ export const reactBrowserOptions = $atom({
   name: "alepha.react.browser.options",
   schema: t.object({
     scrollRestoration: t.enum(["top", "manual"]), // TODO: must be per page?
+    /**
+     * Intercept clicks on plain `<a href="/...">` anchors and route them
+     * through the SPA router, so authors don't need `<Link>` everywhere
+     * (notably for SSR/Markdown HTML rendered as raw markup).
+     *
+     * Skips: modifier keys, non-primary mouse buttons, `target` other than
+     * `_self`, `download`, `data-no-router`, non-http(s) schemes, hash-only
+     * hrefs, external origins, and clicks already `defaultPrevented`.
+     */
+    interceptAnchorClicks: t.boolean({ default: true }),
   }),
   default: {
     scrollRestoration: "top" as const,
+    interceptAnchorClicks: true,
   },
 });
 
@@ -325,8 +336,70 @@ export class ReactBrowserProvider {
 
         this.render();
       });
+
+      this.attachAnchorInterceptor();
     },
   });
+
+  /**
+   * Attach a delegated click listener that routes plain `<a href="/...">`
+   * clicks through the SPA router. Returns a detach function (used in tests).
+   *
+   * Bails out on modifier keys, non-primary mouse buttons, `target`, `download`,
+   * `data-no-router`, hash-only/external/non-http hrefs, and already-prevented
+   * events. Honors the runtime `interceptAnchorClicks` flag.
+   */
+  protected attachAnchorInterceptor(): () => void {
+    const onClick = (ev: MouseEvent) => {
+      if (!this.options.interceptAnchorClicks) return;
+      if (ev.defaultPrevented) return;
+      if (ev.button !== 0) return;
+      if (ev.metaKey || ev.ctrlKey || ev.shiftKey || ev.altKey) return;
+
+      const node = ev.target as Element | null;
+      const a = node?.closest?.("a");
+      if (!a) return;
+
+      if (a.hasAttribute("download")) return;
+      if (a.hasAttribute("data-no-router")) return;
+
+      const target = a.getAttribute("target");
+      if (target && target !== "_self") return;
+
+      const href = a.getAttribute("href");
+      if (!href) return;
+      if (href.startsWith("#")) return;
+      if (/^[a-z][a-z0-9+.-]*:/i.test(href)) {
+        // absolute scheme: only intercept if it points at our own origin
+        let url: URL;
+        try {
+          url = new URL(href);
+        } catch {
+          return;
+        }
+        if (url.origin !== this.location.origin) return;
+        ev.preventDefault();
+        const path = url.pathname + url.search + url.hash;
+        this.push(this.stripBase(path)).catch((e) => this.log.error(e));
+        return;
+      }
+
+      ev.preventDefault();
+      const url = new URL(href, this.location.href);
+      const path = url.pathname + url.search + url.hash;
+      this.push(this.stripBase(path)).catch((e) => this.log.error(e));
+    };
+
+    this.document.addEventListener("click", onClick);
+    return () => this.document.removeEventListener("click", onClick);
+  }
+
+  protected stripBase(path: string): string {
+    if (this.base && path.startsWith(this.base)) {
+      return path.slice(this.base.length) || "/";
+    }
+    return path;
+  }
 }
 
 // ---------------------------------------------------------------------------------------------------------------------

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

@@ -52,7 +52,7 @@ export class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
     previous: PreviousLayerData[] = [],
     meta = {},
     isStale: () => boolean = () => false,
-  ): Promise<string | void> {
+  ): Promise<string | undefined> {
     const { pathname, search } = url;
 
     const entry: Partial<ReactRouterState> = {

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

@@ -65,7 +65,7 @@ export class ReactPreloadProvider {
     handler: ({ response }) => {
       // Only add to HTML responses (SSR pages)
       const contentType = response.headers["content-type"];
-      if (!contentType || !contentType.includes("text/html")) {
+      if (!contentType?.includes("text/html")) {
         return;
       }
 

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

@@ -306,6 +306,7 @@ export class ReactServerProvider {
       // Skip SSR for file-like URLs hitting the catch-all wildcard.
       // Bots and crawlers often probe paths like /hello.txt, /wp-login.php, etc.
       // Rendering a full React page for these is wasteful — return a plain 404 instead.
+      // biome-ignore lint/complexity/useOptionalChain: staticFilePattern is `false | RegExp`; optional chaining doesn't narrow `false`
       if (staticFilePattern && staticFilePattern.test(url.pathname)) {
         reply.status = 404;
         reply.headers["content-type"] = "text/plain";

package/src/scheduler/providers/CronProvider.ts

@@ -67,7 +67,7 @@ export class CronProvider {
         ? this.cronJobs.find((c) => c.name === name)
         : name;
 
-    if (!cron || !cron.running) {
+    if (!cron?.running) {
       return;
     }