alepha 0.20.1 → 0.20.3

package/src/orm/__tests__/$repository-tests.ts

@@ -1014,6 +1014,7 @@ export const testTransactionThrowsWhenUnsupported = async (alepha: Alepha) => {
         original,
       );
     } else {
+      // biome-ignore lint/performance/noDelete: setting to undefined fails because the prototype has a getter
       delete provider.supportsTransactions;
     }
   }

package/src/orm/__tests__/orm-next-tests.ts

@@ -1,8 +1,8 @@
-import { type Alepha, AlephaError, t } from "alepha";
+import { type Alepha, t } from "alepha";
 import { sql } from "drizzle-orm";
 import { expect } from "vitest";
 import { PG_GENERATED } from "../core/constants/PG_SYMBOLS.ts";
-import { $entity, $repository, $view, db, pgAttr } from "../core/index.ts";
+import { $entity, $repository, db, pgAttr } from "../core/index.ts";
 
 // ============================================================================
 // Shared entity definitions
@@ -425,68 +425,3 @@ export const testQueryCacheCustomKey = async (alepha: Alepha) => {
   );
   expect(cached).toHaveLength(1);
 };
-
-// ============================================================================
-// Feature 8: Database Views
-// ============================================================================
-
-export const testViewReadOnly = async (alepha: Alepha) => {
-  // Create the underlying table
-  const itemEntity = $entity({
-    name: "view_items",
-    schema: t.object({
-      id: db.primaryKey(),
-      name: t.text(),
-      price: t.number(),
-    }),
-  });
-
-  // Create a view
-  const itemView = $view({
-    name: "view_items_summary",
-    schema: t.object({
-      id: t.integer(),
-      name: t.text(),
-      price: t.number(),
-    }),
-    query: sql`SELECT id, name, price FROM view_items`,
-  });
-
-  class App {
-    items = $repository(itemEntity);
-    summary = $repository(itemView);
-  }
-
-  const app = alepha.inject(App);
-  await alepha.start();
-
-  // Verify the repository detects it's a view
-  expect(app.summary.isReadOnly).toBe(true);
-  expect(app.items.isReadOnly).toBe(false);
-
-  // Write operations should throw on views
-  await expect(
-    app.summary.create({ id: 1, name: "test", price: 10 } as any),
-  ).rejects.toThrow(AlephaError);
-};
-
-export const testViewRefreshThrowsForNonMaterialized = async (
-  alepha: Alepha,
-) => {
-  const view = $view({
-    name: "non_mat_view",
-    schema: t.object({
-      id: t.integer(),
-    }),
-    query: sql`SELECT 1 as id`,
-  });
-
-  class App {
-    repo = $repository(view);
-  }
-
-  const app = alepha.inject(App);
-  await alepha.start();
-
-  await expect(app.repo.refresh()).rejects.toThrow(AlephaError);
-};

package/src/orm/__tests__/orm-next.spec.ts

@@ -14,8 +14,6 @@ import {
   testPartialIndex,
   testQueryCache,
   testQueryCacheCustomKey,
-  testViewReadOnly,
-  testViewRefreshThrowsForNonMaterialized,
 } from "./orm-next-tests.ts";
 
 const sqlite = () =>
@@ -119,22 +117,3 @@ describe("query caching", () => {
     await testQueryCacheCustomKey(postgres());
   });
 });
-
-// =============================================================================
-// Feature 8: Database Views
-// =============================================================================
-
-describe("database views", () => {
-  it("should block writes on view repositories (sqlite)", async () => {
-    await testViewReadOnly(sqlite());
-  });
-  it("should block writes on view repositories (postgres)", async () => {
-    await testViewReadOnly(postgres());
-  });
-  it("should throw on refresh for non-materialized view (sqlite)", async () => {
-    await testViewRefreshThrowsForNonMaterialized(sqlite());
-  });
-  it("should throw on refresh for non-materialized view (postgres)", async () => {
-    await testViewRefreshThrowsForNonMaterialized(postgres());
-  });
-});

package/src/orm/core/index.shared.ts

@@ -12,13 +12,11 @@ export * from "./errors/DbEntityNotFoundError.ts";
 export * from "./errors/DbForeignKeyError.ts";
 export * from "./errors/DbNotNullError.ts";
 export * from "./errors/DbTableNotFoundError.ts";
-export * from "./helpers/parseQueryString.ts";
 export * from "./helpers/pgAttr.ts";
 export * from "./interfaces/AggregateQuery.ts";
 export * from "./interfaces/FilterOperators.ts";
 export * from "./interfaces/PgQuery.ts";
 export * from "./interfaces/PgQueryWhere.ts";
 export * from "./primitives/$entity.ts";
-export * from "./primitives/$view.ts";
 export * from "./providers/DatabaseTypeProvider.ts";
 export * from "./schemas/legacyIdSchema.ts";

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/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/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/form/index.ts

@@ -9,6 +9,8 @@ export * from "./hooks/useForm.ts";
 export * from "./hooks/useFormState.ts";
 export * from "./hooks/useFormValues.ts";
 export * from "./services/FormModel.ts";
+export * from "./services/parseField.ts";
+export * from "./services/prettyName.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------