alepha 0.18.2 → 0.18.3

package/src/orm/postgres/index.ts

@@ -1,5 +1,5 @@
-import { $module, type Alepha, t } from "alepha";
-import { AlephaOrm, DatabaseProvider } from "alepha/orm";
+import { $module, type Alepha } from "alepha";
+import { AlephaOrm, DatabaseProvider, databaseEnvSchema } from "alepha/orm";
 import { BunPostgresProvider } from "./providers/BunPostgresProvider.ts";
 import { CloudflareHyperdriveProvider } from "./providers/CloudflareHyperdriveProvider.ts";
 import { NodePostgresProvider } from "./providers/NodePostgresProvider.ts";
@@ -14,6 +14,7 @@ export * from "./providers/CloudflareHyperdriveProvider.ts";
 export * from "./providers/NodePostgresProvider.ts";
 export * from "./providers/PglitePostgresProvider.ts";
 export * from "./providers/PostgresProvider.ts";
+export * from "./schemas/postgresEnvSchema.ts";
 export * from "./services/PostgresModelBuilder.ts";
 export * from "./types/byte.ts";
 
@@ -31,11 +32,7 @@ export const AlephaOrmPostgres = $module({
     PostgresModelBuilder,
   ],
   register: (alepha: Alepha) => {
-    const env = alepha.parseEnv(
-      t.object({
-        DATABASE_URL: t.optional(t.text()),
-      }),
-    );
+    const env = alepha.parseEnv(databaseEnvSchema);
 
     const url = env.DATABASE_URL;
     const isBun = alepha.isBun();

package/src/orm/postgres/providers/BunPostgresProvider.ts

@@ -66,8 +66,18 @@ export class BunPostgresProvider extends PostgresProvider {
 
     const { drizzle } = await import("drizzle-orm/bun-sql");
 
-    // Create Bun SQL client
-    this.client = new Bun.SQL(this.url);
+    // Create Bun SQL client with pool options
+    const bunOptions: Record<string, any> = { url: this.url };
+    if (this.pgEnv.POOL_MAX != null) {
+      bunOptions.max = this.pgEnv.POOL_MAX;
+    }
+    if (this.pgEnv.POOL_IDLE_TIMEOUT != null) {
+      bunOptions.idleTimeout = this.pgEnv.POOL_IDLE_TIMEOUT;
+    }
+    if (this.pgEnv.POOL_CONNECT_TIMEOUT != null) {
+      bunOptions.connectionTimeout = this.pgEnv.POOL_CONNECT_TIMEOUT;
+    }
+    this.client = new Bun.SQL(bunOptions);
 
     // Test connection
     await this.client.unsafe("SELECT 1");

package/src/orm/postgres/providers/NodePostgresProvider.ts

@@ -104,6 +104,13 @@ export class NodePostgresProvider extends PostgresProvider {
       },
     };
 
+    // Pool options — only set when explicitly configured via env vars
+    if (this.pgEnv.POOL_MAX != null) options.max = this.pgEnv.POOL_MAX;
+    if (this.pgEnv.POOL_IDLE_TIMEOUT != null)
+      options.idle_timeout = this.pgEnv.POOL_IDLE_TIMEOUT;
+    if (this.pgEnv.POOL_CONNECT_TIMEOUT != null)
+      options.connect_timeout = this.pgEnv.POOL_CONNECT_TIMEOUT;
+
     // Set search_path at connection level so schema-free migration SQL
     // resolves to the correct PostgreSQL schema across all pool connections.
     if (this.schema !== "public") {

package/src/orm/postgres/providers/PglitePostgresProvider.ts

@@ -1,26 +1,14 @@
 import { mkdir } from "node:fs/promises";
 import { createRequire } from "node:module";
 import type { PGlite } from "@electric-sql/pglite";
-import { $env, $hook, $inject, AlephaError, t } from "alepha";
-import { DatabaseProvider, type SQLLike } from "alepha/orm";
+import { $env, $hook, $inject, AlephaError } from "alepha";
+import { DatabaseProvider, databaseEnvSchema, type SQLLike } from "alepha/orm";
 import { sql } from "drizzle-orm";
 import type { PgliteDatabase } from "drizzle-orm/pglite";
 import { migrate } from "drizzle-orm/pglite/migrator";
+import { postgresEnvSchema } from "../schemas/postgresEnvSchema.ts";
 import { PostgresModelBuilder } from "../services/PostgresModelBuilder.ts";
 
-const envSchema = t.object({
-  /**
-   * Same as NodePostgresProvider connection string.
-   * But, will accept only `file:` protocol for the database path.
-   *
-   * DATABASE_URL=memory://
-   * DATABASE_URL=./db
-   * DATABASE_URL=file://absolute/path/to/db
-   */
-  DATABASE_URL: t.optional(t.text()),
-  POSTGRES_SCHEMA: t.optional(t.text()),
-});
-
 export interface PgLiteModule {
   PGlite: typeof PGlite;
 }
@@ -35,10 +23,11 @@ export class PglitePostgresProvider extends DatabaseProvider {
   }
 
   public override get schema(): string {
-    return this.env.POSTGRES_SCHEMA ?? "public";
+    return this.pgEnv.POSTGRES_SCHEMA ?? "public";
   }
 
-  protected readonly env = $env(envSchema);
+  protected readonly env = $env(databaseEnvSchema);
+  protected readonly pgEnv = $env(postgresEnvSchema);
   protected readonly builder = $inject(PostgresModelBuilder);
 
   protected client?: PGlite;
@@ -54,6 +43,10 @@ export class PglitePostgresProvider extends DatabaseProvider {
 
   public override readonly dialect = "postgresql";
 
+  public override get supportsTransactions(): boolean {
+    return false;
+  }
+
   public override get url(): string {
     let path = this.env.DATABASE_URL;
 

package/src/orm/postgres/providers/PostgresProvider.ts

@@ -1,49 +1,19 @@
-import {
-  $env,
-  $hook,
-  $inject,
-  $pipeline,
-  AlephaError,
-  type Static,
-  t,
-} from "alepha";
+import { $env, $hook, $inject, $pipeline, AlephaError } from "alepha";
 import { $lock } from "alepha/lock";
 import {
   DatabaseProvider,
   DbError,
   DbMigrationError,
+  databaseEnvSchema,
   type SQLLike,
 } from "alepha/orm";
 import { sql } from "drizzle-orm";
 import type { PgDatabase } from "drizzle-orm/pg-core";
+import { postgresEnvSchema } from "../schemas/postgresEnvSchema.ts";
 import { PostgresModelBuilder } from "../services/PostgresModelBuilder.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-const envSchema = t.object({
-  /**
-   * Main configuration for database connection.
-   * Accept a string in the format of a Postgres connection URL.
-   * Example: postgres://user:password@localhost:5432/database
-   * or
-   * Example: postgres://user:password@localhost:5432/database?sslmode=require
-   */
-  DATABASE_URL: t.optional(t.text()),
-
-  /**
-   * In addition to the DATABASE_URL, you can specify the postgres schema name.
-   *
-   * It will monkey patch drizzle tables.
-   */
-  POSTGRES_SCHEMA: t.optional(t.text()),
-});
-
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-
-// ---------------------------------------------------------------------------------------------------------------------
-
 /**
  * Abstract base class for PostgreSQL database providers.
  *
@@ -56,7 +26,8 @@ declare module "alepha" {
  * Subclasses must implement `connect()`, `close()`, and `executeMigrations()`.
  */
 export abstract class PostgresProvider extends DatabaseProvider {
-  protected readonly env = $env(envSchema);
+  protected readonly env = $env(databaseEnvSchema);
+  protected readonly pgEnv = $env(postgresEnvSchema);
   protected readonly builder = $inject(PostgresModelBuilder);
 
   public override readonly dialect = "postgresql";
@@ -101,8 +72,8 @@ export abstract class PostgresProvider extends DatabaseProvider {
       return this.schemaForTesting;
     }
 
-    if (this.env.POSTGRES_SCHEMA) {
-      return this.env.POSTGRES_SCHEMA;
+    if (this.pgEnv.POSTGRES_SCHEMA) {
+      return this.pgEnv.POSTGRES_SCHEMA;
     }
 
     return "public";

package/src/orm/postgres/schemas/postgresEnvSchema.ts

@@ -0,0 +1,32 @@
+import { type Static, t } from "alepha";
+
+/**
+ * PostgreSQL-specific environment schema.
+ *
+ * Additional env vars for PostgreSQL providers on top of `databaseEnvSchema`.
+ */
+export const postgresEnvSchema = t.object({
+  /**
+   * PostgreSQL schema name (defaults to `"public"` when unset).
+   */
+  POSTGRES_SCHEMA: t.optional(t.text()),
+
+  /**
+   * Maximum number of connections in the pool.
+   */
+  POOL_MAX: t.optional(t.integer()),
+
+  /**
+   * Seconds a connection can be idle before being closed.
+   */
+  POOL_IDLE_TIMEOUT: t.optional(t.integer()),
+
+  /**
+   * Seconds to wait when establishing a new connection.
+   */
+  POOL_CONNECT_TIMEOUT: t.optional(t.integer()),
+});
+
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof postgresEnvSchema>> {}
+}

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

@@ -5,16 +5,19 @@ import {
   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,
   type SequencePrimitive,
   schema,
+  type ViewPrimitive,
 } from "alepha/orm";
 import type { BuildExtraConfigColumns } from "drizzle-orm";
 import * as pg from "drizzle-orm/pg-core";
@@ -27,9 +30,11 @@ import {
   type PgTableExtraConfigValue,
   type PgTableWithColumns,
   pgEnum,
+  pgMaterializedView,
   pgSchema,
   pgSequence,
   pgTable,
+  pgView,
   unique,
   uniqueIndex,
 } from "drizzle-orm/pg-core";
@@ -97,6 +102,36 @@ 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: {
@@ -194,6 +229,11 @@ export class PostgresModelBuilder extends ModelBuilder {
           }, config.actions);
         }
 
+        if (PG_GENERATED in value) {
+          const gen = value[PG_GENERATED] as PgGeneratedOptions;
+          col = col.generatedAlwaysAs(gen.expression);
+        }
+
         if (schema.required?.includes(key)) {
           col = col.notNull();
         }

package/src/react/core/components/ErrorBoundary.tsx

@@ -12,7 +12,7 @@ export interface ErrorBoundaryProps {
    * Fallback React node to render when an error is caught.
    * If not provided, a default error message will be shown.
    */
-  fallback: (error: Error) => ReactNode;
+  fallback: (error: Error, reset: () => void) => ReactNode;
 
   /**
    * Optional callback that receives the error and error info.
@@ -63,7 +63,10 @@ export class ErrorBoundary extends React.Component<
 
   render(): ReactNode {
     if (this.state.error) {
-      return this.props.fallback(this.state.error);
+      const reset = () => {
+        this.setState({ error: undefined });
+      };
+      return this.props.fallback(this.state.error, reset);
     }
 
     return this.props.children;

package/src/react/form/hooks/useFieldValue.ts

@@ -0,0 +1,34 @@
+import { useAlepha } from "alepha/react";
+import { useEffect, useState } from "react";
+import type { BaseInputField } from "../services/FormModel.ts";
+
+/**
+ * Hook to subscribe to a single form field's value.
+ * Only re-renders when this specific field changes.
+ *
+ * @returns A tuple of [value, setValue] similar to useState.
+ */
+export const useFieldValue = (
+  input: BaseInputField,
+): [any, (value: any) => void] => {
+  const alepha = useAlepha();
+  const [value, setValue] = useState(input?.initialValue);
+
+  useEffect(() => {
+    if (!input?.form || !alepha.isBrowser()) {
+      return;
+    }
+
+    return alepha.events.on("form:change", (ev) => {
+      if (ev.id === input.form.id && ev.path === input.path) {
+        setValue(ev.value);
+      }
+    });
+  }, []);
+
+  const setFieldValue = (newValue: any) => {
+    input.set(newValue);
+  };
+
+  return [value, setFieldValue];
+};

package/src/react/form/hooks/useForm.browser.spec.tsx

@@ -3,8 +3,20 @@ import { Alepha, t } from "alepha";
 import { AlephaLogger } from "alepha/logger";
 import { AlephaContext } from "alepha/react";
 import type { ReactNode } from "react";
+import { useState } from "react";
 import { describe, it } from "vitest";
-import { useForm } from "../index.ts";
+import { useFieldValue, useForm } from "../index.ts";
+
+const TestInput = ({ input, testId }: { input: any; testId: string }) => {
+  const [value, setValue] = useFieldValue(input);
+  return (
+    <input
+      data-testid={testId}
+      value={value ?? ""}
+      onChange={(ev) => setValue(ev.target.value)}
+    />
+  );
+};
 
 describe("useForm", () => {
   const renderWithAlepha = (alepha: Alepha, element: ReactNode) => {
@@ -29,17 +41,23 @@ describe("useForm", () => {
             }),
           }),
         }),
-        handler: (values, args) => {
+        handler: (values) => {
           calls.push(values);
         },
       });
 
       return (
         <form {...form.props} data-testid="test-form">
-          <input {...form.input.str.props} />
-          <input {...form.input.int.props} />
-          <input {...form.input.nested.items.str.props} />
-          <input {...form.input.nested.items.another.items.level.props} />
+          <TestInput input={form.input.str} testId="test-str" />
+          <TestInput input={form.input.int} testId="test-int" />
+          <TestInput
+            input={form.input.nested.items.str}
+            testId="test-nested.str"
+          />
+          <TestInput
+            input={form.input.nested.items.another.items.level}
+            testId="test-nested.another.level"
+          />
           <button type="submit">Submit</button>
         </form>
       );
@@ -312,9 +330,18 @@ describe("useForm", () => {
 
       return (
         <form {...form.props} data-testid="complex-form">
-          <input {...form.input.company.items.name.props} />
-          <input {...form.input.company.items.address.items.street.props} />
-          <input {...form.input.company.items.address.items.city.props} />
+          <TestInput
+            input={form.input.company.items.name}
+            testId="complex-test-company.name"
+          />
+          <TestInput
+            input={form.input.company.items.address.items.street}
+            testId="complex-test-company.address.street"
+          />
+          <TestInput
+            input={form.input.company.items.address.items.city}
+            testId="complex-test-company.address.city"
+          />
           <button
             type="button"
             data-testid="set-employees"
@@ -363,4 +390,62 @@ describe("useForm", () => {
       ],
     });
   });
+
+  it("should update initialValues after save so reset uses new values", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create().with(AlephaLogger);
+
+    const Form = () => {
+      const [saved, setSaved] = useState({ name: "original" });
+
+      const form = useForm({
+        id: "reset-test",
+        schema: t.object({
+          name: t.text(),
+        }),
+        initialValues: saved,
+        handler: async (values) => {
+          setSaved({ ...values });
+        },
+      });
+
+      return (
+        <form {...form.props} data-testid="reset-form">
+          <TestInput input={form.input.name} testId="reset-name" />
+          <button type="submit">Save</button>
+          <button type="reset">Reset</button>
+        </form>
+      );
+    };
+
+    await alepha.start();
+    const ui = renderWithAlepha(alepha, <Form />);
+
+    const input = () =>
+      (ui.getByTestId("reset-name") as HTMLInputElement).value;
+
+    // Initial value
+    expect(input()).toBe("original");
+
+    // Edit and save
+    fireEvent.change(ui.getByTestId("reset-name"), {
+      target: { value: "updated" },
+    });
+    fireEvent.submit(ui.getByText("Save"));
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // After save, initialValues should be updated
+    // Edit again
+    fireEvent.change(ui.getByTestId("reset-name"), {
+      target: { value: "temporary" },
+    });
+    expect(input()).toBe("temporary");
+
+    // Reset should go back to saved value, not original
+    fireEvent.click(ui.getByText("Reset"));
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(input()).toBe("updated");
+  });
 });

package/src/react/form/hooks/useForm.ts

@@ -1,6 +1,6 @@
 import type { TObject } from "alepha";
 import { useAlepha } from "alepha/react";
-import { useId, useMemo } from "react";
+import { useEffect, useId, useMemo, useRef } from "react";
 import { type FormCtrlOptions, FormModel } from "../services/FormModel.ts";
 
 /**
@@ -37,11 +37,23 @@ export const useForm = <T extends TObject>(
 ): FormModel<T> => {
   const alepha = useAlepha();
   const formId = useId();
+  const initialValuesRef = useRef(options.initialValues);
 
-  return useMemo(() => {
+  const form = useMemo(() => {
     return alepha.inject(FormModel<T>, {
       lifetime: "transient",
       args: [options.id || formId, options],
     });
   }, deps);
+
+  useEffect(() => {
+    if (initialValuesRef.current !== options.initialValues) {
+      initialValuesRef.current = options.initialValues;
+      if (options.initialValues) {
+        form.setInitialValues(options.initialValues as Record<string, any>);
+      }
+    }
+  }, [options.initialValues]);
+
+  return form;
 };

package/src/react/form/hooks/useFormState.ts

@@ -58,16 +58,6 @@ export const useFormState = <
       );
     }
 
-    if (hasValues) {
-      listeners.push(
-        alepha.events.on("form:reset", (event) => {
-          if (event.id === form.id) {
-            setValues(event.values);
-          }
-        }),
-      );
-    }
-
     if (hasLoading) {
       listeners.push(
         alepha.events.on("form:submit:begin", (event) => {
@@ -98,6 +88,16 @@ export const useFormState = <
       );
     }
 
+    if (hasDirty) {
+      listeners.push(
+        alepha.events.on("form:reset", (event) => {
+          if (event.id === form.id) {
+            setDirty(false);
+          }
+        }),
+      );
+    }
+
     if (hasErrors) {
       listeners.push(
         alepha.events.on("form:submit:error", (event) => {

package/src/react/form/hooks/useFormValues.ts

@@ -0,0 +1,29 @@
+import type { TObject } from "alepha";
+import { useAlepha } from "alepha/react";
+import { useEffect, useState } from "react";
+import type { FormModel } from "../services/FormModel.ts";
+
+/**
+ * Hook to subscribe to all form values.
+ * Re-renders on every field change — use only when needed (debug panels, live previews).
+ */
+export const useFormValues = <T extends TObject>(
+  form: FormModel<T>,
+): Record<string, any> => {
+  const alepha = useAlepha();
+  const [values, setValues] = useState<Record<string, any>>(form.currentValues);
+
+  useEffect(() => {
+    if (!alepha.isBrowser()) {
+      return;
+    }
+
+    return alepha.events.on("form:change", (ev) => {
+      if (ev.id === form.id) {
+        setValues(form.currentValues);
+      }
+    });
+  }, []);
+
+  return values;
+};

package/src/react/form/index.ts

@@ -4,8 +4,10 @@ import { $module } from "alepha";
 
 export { default as FormState } from "./components/FormState.tsx";
 export * from "./errors/FormValidationError.ts";
+export * from "./hooks/useFieldValue.ts";
 export * from "./hooks/useForm.ts";
 export * from "./hooks/useFormState.ts";
+export * from "./hooks/useFormValues.ts";
 export * from "./services/FormModel.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -13,11 +15,11 @@ export * from "./services/FormModel.ts";
 declare module "alepha" {
   interface Hooks {
     "form:change": { id: string; path: string; value: any };
-    "form:reset": { id: string; values: Record<string, any> };
     "form:submit:begin": { id: string };
     "form:submit:success": { id: string; values: Record<string, any> };
     "form:submit:error": { id: string; error: Error };
     "form:submit:end": { id: string };
+    "form:reset": { id: string };
   }
 }