@fougere/core 0.5.0-alpha.1 → 0.7.0-alpha.0

package/src/boot/apply.ts

@@ -1,5 +1,5 @@
 import type { FougereConfig } from '../config-loader.js';
-import { setLogLevel, logLevel, envLevel } from '../builtins/logger.js';
+import { setLogLevel, logLevel, envLevel } from '../builtin/logger.js';
 import { dequal } from 'dequal';
 
 export interface ConfigApplication {
@@ -9,25 +9,13 @@ export interface ConfigApplication {
   pending: string[];
 }
 
-/**
- * What a (re-)read config changes in a process that is already running.
- *
- * The rule it realizes, and the only one worth remembering: **a value that is
- * CONSULTED can change under a running app; a value that was CONSUMED to build
- * something cannot, without rebuilding what it built.** `logLevel` is consulted at
- * every emission, so it moves. `db` opened a connection, `ports:` registered a class,
- * the entities built façades — those are consumed, and this function reports them
- * rather than pretending.
- *
- * The list of consulted keys is not declared anywhere: a key is consulted when this
- * function does something with it, which is the only definition that cannot go stale.
- */
+/** What a (re-)read config changes in a process that is already running. */
 export function applyConfig(next: FougereConfig, inForce?: FougereConfig): ConfigApplication {
   const applied: string[] = [];
   const pending: string[] = [];
 
   // The CLI speaks through the environment, so it keeps winning over the file — read
-  // through `envLevel`, which is where the environment is already judged. Casting it
+  // through `envLevel`, which is where the environment is already validated. Casting it
   // here was a second reader that validated nothing: `FOUGERE_LOG_LEVEL=verbose` set
   // the threshold to `undefined` and every log passed.
   const wanted = envLevel() ?? next.logLevel ?? 'debug';

package/src/boot/auth.ts

@@ -3,15 +3,9 @@
  * the contract between core and an `@fougere/auth-*` package.
  */
 import type { SchemaView } from '@fougere/schema';
-import type { EntityOrm, OrmFactory } from '../orm.js';
+import type { Storage, StorageFactory } from '../storage.js';
 
-/**
- * Lazy auth declaration written in fougere.config.ts.
- *
- * Each @fougere/auth-* package exports a factory (e.g. `betterAuth(opts)`) that
- * returns this shape. The `create()` method is called once at boot with the
- * resolved db + ormFactory, so the provider can wire its engine through Fougere.
- */
+/** Lazy auth declaration written in fougere.config.ts. */
 export interface AuthConfig {
   /** Build the runtime — invoked by createApp at boot with the resolved storage handles. */
   create(ctx: AuthContext): AuthRuntime | Promise<AuthRuntime>;
@@ -29,8 +23,8 @@ export interface AuthConfig {
 export interface AuthContext {
   /** Storage handle (Kysely DB instance, Prisma client, etc.) — opaque to core. */
   db: unknown;
-  /** Per-entity ORM factory — auth provider uses this to back its adapter. */
-  ormFactory: OrmFactory;
+  /** Per-entity storage factory — auth provider uses this to back its adapter. */
+  storageFactory: StorageFactory;
 }
 
 /**
@@ -40,12 +34,8 @@ export interface AuthContext {
 export interface AuthRuntime {
   /** Entities used by the provider, including any defaults it filled in. */
   entities: Record<string, SchemaView>;
-  /**
-   * Per-entity ORMs the provider built for itself. Exposed so app code can
-   * query auth tables (e.g. list active sessions for a user) without rebuilding
-   * the same EntityOrm.
-   */
-  orms: Record<string, EntityOrm>;
+  /** Per-entity ORMs the provider built for itself. */
+  storages: Record<string, Storage>;
   /** Web Standard handler that processes /auth/* requests. */
   handler: (request: Request) => Promise<Response>;
   /** Programmatic API exposed by the provider (getSession, signOut, ...). */

package/src/boot/boot.ts

@@ -2,7 +2,7 @@ import { createApp } from './bootstrap.js';
 import { seeding } from './seed.js';
 import { scanProject } from '../scan/scanner.js';
 import { loadConfig, type FougereConfig } from '../config-loader.js';
-import { Logger } from '../builtins/logger.js';
+import { Logger } from '../builtin/logger.js';
 import { applyConfig } from './apply.js';
 import type { App, CreateAppOptions } from './types.js';
 import { migrating, type Extension } from './AppLifecycle.js';
@@ -25,24 +25,16 @@ interface BootOptions {
   remotes?: Record<string, string>;
   /** Builds the transport to reach `remotes`. Supplied by a layer-2 package. */
   remoteTransport?: (url: string) => Transport;
-  /**
-   * Carries an announced fact out of this process. Forwarded rather than dropped: a
-   * caller handing one in has no other way to reach the emitter, and this path silently
-   * kept it to itself.
-   */
+  /** Carries an announced fact out of this process. */
   onEmit?: CreateAppOptions['onEmit'];
   /**
-   * ORM setup — returns the storage handle (db), an ormFactory, and its two halves.
+   * storage setup — returns the storage handle (db), an storageFactory, and its two halves.
    * The `db` value is forwarded to the auth provider via AuthContext when `auth` is set.
    */
   db?: (config: FougereConfig) => {
     db?: unknown;
-    ormFactory: CreateAppOptions['ormFactory'];
-    /**
-     * Bring the schema up to date — an extension's `up`, because it runs after the
-     * container. It used to be called `afterBoot`, a word that also meant the host's
-     * post-boot and was read in four places under two senses.
-     */
+    storageFactory: CreateAppOptions['storageFactory'];
+    /** Bring the schema up to date — an extension's `up`, because it runs after the container. */
     migrate?: (app: App) => Promise<void> | void;
     /** Closes what the factory opened — `boot()` called it, so `boot()` releases it. */
     close?: () => Promise<void>;
@@ -54,12 +46,7 @@ interface BootOptions {
   extensions?: readonly (Extension | undefined)[];
 }
 
-/**
- * Boot a Fougere app from fougere.config.ts.
- *
- * Handles: config loading, container creation, DB setup, seeding.
- * Works for any surface (Nuxt, GraphQL standalone, CLI, tests).
- */
+/** Boot a Fougere app from fougere.config.ts. */
 export async function boot(options: BootOptions): Promise<App> {
   const bootStart = performance.now();
   const log = new Logger('boot');
@@ -88,7 +75,7 @@ export async function boot(options: BootOptions): Promise<App> {
     // handed the answer and reaches for nothing.
     scan: await scanProject(root, options.fronds, config.conventions),
     createContainer: options.createContainer,
-    ormFactory: dbSetup?.ormFactory,
+    storageFactory: dbSetup?.storageFactory,
     db: dbSetup?.db,
     auth: config.auth,
     remotes: options.remotes,
@@ -103,9 +90,7 @@ export async function boot(options: BootOptions): Promise<App> {
     // it was opened before the container existed, so it closes after the container goes.
     onDispose: dbSetup?.close,
     /**
-     * The whole ascent, in one ordered list — tables, then rows, then whatever the host
-     * takes on. It was four call sites under the name `afterBoot`, two of which meant
-     * different things and one of which was generated into a Nitro plugin.
+     * The whole ascent, in one ordered list — tables, then rows, then whatever the host takes on.
      */
     extensions: [
       migrating(dbSetup?.migrate),