alepha 0.20.2 → 0.20.4

package/src/orm/core/index.ts

@@ -4,7 +4,6 @@ import type { PgTransaction } from "drizzle-orm/pg-core";
 import { DbMigrationMode } from "./modes/DbMigrationMode.ts";
 import { $entity } from "./primitives/$entity.ts";
 import { $sequence } from "./primitives/$sequence.ts";
-import { $view } from "./primitives/$view.ts";
 import { DrizzleKitProvider } from "./providers/DrizzleKitProvider.ts";
 import { BunSqliteProvider } from "./providers/drivers/BunSqliteProvider.ts";
 import { CloudflareD1Provider } from "./providers/drivers/CloudflareD1Provider.ts";
@@ -102,7 +101,7 @@ export const SqliteProvider = NodeSqliteProvider;
 
 export const AlephaOrm = $module({
   name: "alepha.orm",
-  primitives: [$sequence, $entity, $view],
+  primitives: [$sequence, $entity],
   imports: [AlephaDateTime],
   services: [
     SqliteModelBuilder,

package/src/orm/core/primitives/$repository.ts

@@ -2,17 +2,14 @@ import { $context, $inject, type TObject } from "alepha";
 import { RepositoryProvider } from "../providers/RepositoryProvider.ts";
 import type { Repository } from "../services/Repository.ts";
 import type { EntityPrimitive } from "./$entity.ts";
-import type { ViewPrimitive } from "./$view.ts";
 
 /**
- * Get the repository for the given entity or view.
+ * Get the repository for the given entity.
  */
 export const $repository = <T extends TObject>(
-  entity: EntityPrimitive<T> | ViewPrimitive<T>,
+  entity: EntityPrimitive<T>,
 ): Repository<T> => {
   const { alepha } = $context();
   const repositoryProvider = alepha.inject(RepositoryProvider);
-  return $inject(
-    repositoryProvider.createClassRepository(entity as EntityPrimitive<T>),
-  );
+  return $inject(repositoryProvider.createClassRepository(entity));
 };

package/src/orm/core/primitives/$transactional.ts

@@ -31,6 +31,17 @@ export interface TransactionalOptions {
  * }
  * ```
  */
+// TODO: support savepoints for nested transactions.
+//   Today, a nested $transactional reuses the outer tx (correct for ACID), but
+//   there is no way to roll back ONLY the inner block while preserving the
+//   outer one. Drizzle exposes savepoints (`tx.transaction(...)` inside an
+//   existing tx maps to `SAVEPOINT` on Postgres). Plan:
+//     1. Detect "already inside a tx" in DatabaseProvider.transactional().
+//     2. When nested, open a savepoint instead of reusing the outer scope.
+//     3. On inner throw, ROLLBACK TO SAVEPOINT (don't bubble unless re-thrown).
+//     4. Add an option { savepoint?: boolean } on $transactional (default true
+//        when nested) so users can opt out for "inherit-and-bubble" semantics.
+//   Needs care around connection-bound state and Drizzle's tx proxy.
 export const $transactional = (options?: TransactionalOptions): Middleware => {
   return createMiddleware({
     name: "$transactional",

package/src/orm/core/providers/drivers/DatabaseProvider.ts

@@ -22,7 +22,6 @@ import type {
   SchemaToTableConfig,
 } from "../../primitives/$entity.ts";
 import type { SequencePrimitive } from "../../primitives/$sequence.ts";
-import type { ViewPrimitive } from "../../primitives/$view.ts";
 import { databaseEnvSchema } from "../../schemas/databaseEnvSchema.ts";
 import type { ModelBuilder } from "../../services/ModelBuilder.ts";
 import { DrizzleKitProvider } from "../DrizzleKitProvider.ts";
@@ -156,10 +155,6 @@ export abstract class DatabaseProvider {
     this.builder.buildTable(entity, this);
   }
 
-  public registerView(view: ViewPrimitive) {
-    this.builder.buildView(view, this);
-  }
-
   public registerSequence(sequence: SequencePrimitive) {
     this.sequencePrimitives.push(sequence);
     this.builder.buildSequence(sequence, this);

package/src/orm/core/providers/drivers/NodeSqliteProvider.ts

@@ -1,5 +1,4 @@
 import { mkdir } from "node:fs/promises";
-import { createRequire } from "node:module";
 import { dirname } from "node:path";
 import type { DatabaseSync } from "node:sqlite";
 import {
@@ -12,7 +11,11 @@ import {
   type Static,
   t,
 } from "alepha";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { BetterSQLiteSession } from "drizzle-orm/better-sqlite3/session";
 import type { PgDatabase } from "drizzle-orm/pg-core";
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core/db";
+import { SQLiteSyncDialect } from "drizzle-orm/sqlite-core/dialect";
 import { databaseEnvSchema } from "../../schemas/databaseEnvSchema.ts";
 import { SqliteModelBuilder } from "../../services/SqliteModelBuilder.ts";
 import { DatabaseProvider, type SQLLike } from "./DatabaseProvider.ts";
@@ -162,7 +165,7 @@ export class NodeSqliteProvider extends DatabaseProvider {
   protected readonly onStart = $hook({
     on: "start",
     handler: async () => {
-      const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+      const { DatabaseSync } = await import("node:sqlite");
 
       const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
 
@@ -323,13 +326,6 @@ export class NodeSqliteProvider extends DatabaseProvider {
   protected initDrizzle(): void {
     this.shimDatabaseSync();
 
-    const require = createRequire(import.meta.url);
-    const {
-      BetterSQLiteSession,
-    } = require("drizzle-orm/better-sqlite3/session");
-    const { SQLiteSyncDialect } = require("drizzle-orm/sqlite-core/dialect");
-    const { BaseSQLiteDatabase } = require("drizzle-orm/sqlite-core/db");
-
     const dialect = new SQLiteSyncDialect();
     const session = new BetterSQLiteSession(this.sqlite, dialect, undefined, {
       logger: {
@@ -339,14 +335,16 @@ export class NodeSqliteProvider extends DatabaseProvider {
       },
     });
 
-    this.drizzleDb = new BaseSQLiteDatabase("sync", dialect, session);
+    this.drizzleDb = new BaseSQLiteDatabase(
+      "sync",
+      dialect,
+      session,
+      undefined,
+    );
     this.log.debug("Using node:sqlite with sync driver");
   }
 
   protected async executeMigrations(migrationsFolder: string): Promise<void> {
-    const { migrate } = createRequire(import.meta.url)(
-      "drizzle-orm/better-sqlite3/migrator",
-    );
     migrate(this.drizzleDb, { migrationsFolder });
   }
 }

package/src/orm/core/schemas/updateSchema.ts

@@ -40,7 +40,7 @@ export const updateSchema = <T extends TObject>(
     }
 
     if (t.schema.isOptional(prop)) {
-      newProperties[key] = t.optional(t.union([prop, t.raw.Null()]));
+      newProperties[key] = t.optional(t.union([prop, t.null()]));
     } else {
       newProperties[key] = prop;
     }

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/PgRelationManager.ts

@@ -1,4 +1,4 @@
-import { type TObject, t, Value } from "alepha";
+import { $inject, SchemaValidator, type TObject, t } from "alepha";
 import { getTableName, type SQL, sql } from "drizzle-orm";
 import type { PgSelectBase, PgTableWithColumns } from "drizzle-orm/pg-core";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
@@ -8,6 +8,8 @@ import type { DatabaseProvider } from "../providers/drivers/DatabaseProvider.ts"
 import type { PgJoin } from "./QueryManager.ts";
 
 export class PgRelationManager {
+  protected readonly schemaValidator = $inject(SchemaValidator);
+
   /**
    * Recursively build joins for the query builder based on the relations map
    */
@@ -103,7 +105,7 @@ export class PgRelationManager {
     joins: PgJoin[],
     parentPath?: string,
   ): TObject {
-    const schema = Value.Clone(baseSchema) as TObject;
+    const schema = this.schemaValidator.clone(baseSchema) as TObject;
 
     // Group joins by parent
     const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);

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/core/__tests__/useQuery.browser.spec.tsx

@@ -0,0 +1,86 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { Alepha } from "alepha";
+import { AlephaDateTime } from "alepha/datetime";
+import { describe, test, vi } from "vitest";
+import { AlephaContext } from "../contexts/AlephaContext.ts";
+import { useQuery } from "../hooks/useQuery.ts";
+
+describe("useQuery", () => {
+  test("runs on mount and exposes data/loading/error/refetch", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create().with(AlephaDateTime);
+    await alepha.start();
+
+    const handler = vi.fn(async () => ({ users: ["a", "b"] }));
+
+    const wrapper = ({ children }: { children: React.ReactNode }) => (
+      <AlephaContext.Provider value={alepha}>{children}</AlephaContext.Provider>
+    );
+
+    const { result } = renderHook(() => useQuery({ handler }, []), { wrapper });
+
+    expect(result.current.data).toBe(undefined);
+    expect(typeof result.current.refetch).toBe("function");
+
+    await waitFor(() => {
+      expect(result.current.data).toEqual({ users: ["a", "b"] });
+    });
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(result.current.loading).toBe(false);
+    expect(result.current.error).toBe(undefined);
+
+    // refetch
+    handler.mockResolvedValueOnce({ users: ["c"] });
+    await act(async () => {
+      await result.current.refetch();
+    });
+
+    expect(result.current.data).toEqual({ users: ["c"] });
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+
+  test("does not run when enabled is false", async ({ expect }) => {
+    const alepha = Alepha.create().with(AlephaDateTime);
+    await alepha.start();
+
+    const handler = vi.fn(async () => "value");
+
+    const wrapper = ({ children }: { children: React.ReactNode }) => (
+      <AlephaContext.Provider value={alepha}>{children}</AlephaContext.Provider>
+    );
+
+    const { result } = renderHook(
+      () => useQuery({ handler, enabled: false }, []),
+      { wrapper },
+    );
+
+    // give it a tick to ensure no spontaneous run
+    await new Promise((r) => setTimeout(r, 20));
+    expect(handler).not.toHaveBeenCalled();
+    expect(result.current.data).toBe(undefined);
+  });
+
+  test("supports initialData", async ({ expect }) => {
+    const alepha = Alepha.create().with(AlephaDateTime);
+    await alepha.start();
+
+    const handler = vi.fn(async () => "fetched");
+
+    const wrapper = ({ children }: { children: React.ReactNode }) => (
+      <AlephaContext.Provider value={alepha}>{children}</AlephaContext.Provider>
+    );
+
+    const { result } = renderHook(
+      () => useQuery({ handler, initialData: "seed" }, []),
+      { wrapper },
+    );
+
+    expect(result.current.data).toBe("seed");
+
+    await waitFor(() => {
+      expect(result.current.data).toBe("fetched");
+    });
+  });
+});