@fougere/core 0.12.1-alpha.0 → 0.12.4-alpha.0

package/src/Source.ts

@@ -7,10 +7,10 @@ import type { SourceConfig } from './SourceConfig.js';
 /** Whether an entity asks for one, anywhere but on its key. */
 export function declares(schema: SchemaView, constraint: Constraint): boolean {
   const fields = Object.values(schema.getFields());
-  if (constraint === 'relation') return fields.some((field) => Role.of(field).isReference);
-  if ((schema.getUnique() ?? []).length > 0) return true;
+  if (constraint === 'relation') return fields.some((field) => Role.of(field).isReference());
+  if (schema.getUnique().length > 0) return true;
 
-  return fields.some((field) => Role.of(field).isUnique);
+  return fields.some((field) => Role.of(field).isUnique());
 }
 
 /**

package/src/SourceView.ts

@@ -1,7 +1,5 @@
 /** The app as ONE source sees it. */
 export interface SourceView {
   fronds: readonly { readonly name: string; readonly entities: readonly { readonly name: string }[] }[];
-  /** The auth provider's own entities, when they ride with this source. */
-  auth?: unknown;
   elsewhere: readonly string[];
 }

package/src/boot/App.ts

@@ -3,10 +3,10 @@ import type { Fronds } from '../descriptor/Fronds.js';
 import type { SchemaView } from '@fougere/schema';
 import type { AppMiddleware } from '../wire/AppMiddleware.js';
 import type { RpcAnswer } from '../wire/RpcAnswer.js';
-import type { AuthRuntime } from './AuthRuntime.js';
 import type { EffectiveOperationsMap } from '../EffectiveOperationsMap.js';
 import type { DispatchObserver } from '../dispatch/DispatchObserver.js';
 import type { DispatchPort } from '../dispatch/DispatchPort.js';
+import type { Storage } from '../storage/Storage.js';
 
 /** The App object returned by createApp(). */
 export interface App extends DispatchPort {
@@ -42,7 +42,7 @@ export interface App extends DispatchPort {
    * The storage an entity is backed by, resolved through its owning frond's scope — the dual of
    * {@link facadeFor}.
    */
-  storageFor(entity: string): unknown | undefined;
+  storageFor<T = Record<string, unknown>>(entity: string): Storage<T> | undefined;
   /** The presenter of an entity, resolved through its owning frond's scope. */
   presenterFor(entity: string): unknown | undefined;
   /** Dispose the root container. */
@@ -66,6 +66,4 @@ export interface App extends DispatchPort {
   use(middleware: AppMiddleware): void;
   /** Register an app middleware scoped to a specific entity. */
   use(entity: string, middleware: AppMiddleware): void;
-  /** Auth runtime, present when fougere.config.ts declares `auth`. */
-  auth?: AuthRuntime;
 }

package/src/boot/AppLifecycle.ts

@@ -12,6 +12,7 @@ export class AppLifecycle {
       if (at === -1) this.members.push(extension);
       else this.members[at] = extension;
     }
+
     return this;
   }
 
@@ -24,18 +25,29 @@ export class AppLifecycle {
   }
 
   async down(app: App): Promise<void> {
-    const refused: unknown[] = [];
-    for (const extension of [...this.members].reverse()) {
-      try {
-        await extension.down?.(app);
-      } catch (error) {
-        refused.push(error);
-      }
-    }
-    if (refused.length > 0) {
-      throw new AggregateError(refused, `${refused.length} extension(s) refused to release`);
+    await closeAll(
+      [...this.members].reverse().map((extension) => () => extension.down?.(app)),
+      'extension(s) refused to release',
+    );
+  }
+}
+
+/**
+ * Every level told to close even when one refuses, the refusals leaving together in one
+ * `AggregateError` — one already carried by a level is flattened into the list.
+ */
+export async function closeAll(levels: readonly (() => unknown)[], refusals: string): Promise<void> {
+  const refused: unknown[] = [];
+  for (const level of levels) {
+    try {
+      await level();
+    } catch (error) {
+      if (error instanceof AggregateError) refused.push(...error.errors);
+      else refused.push(error);
     }
   }
+
+  if (refused.length > 0) throw new AggregateError(refused, `${refused.length} ${refusals}`);
 }
 
 /** The replaceable migration slot of the application lifecycle. */

package/src/boot/AuthRuntime.ts

@@ -1,19 +1,12 @@
-import type { SchemaView } from '@fougere/schema';
-import type { Storage } from '../storage/Storage.js';
-
-/**
- * Runtime returned by an auth provider's create(config, ctx) function.
- * The core mounts this on the App and the HTTP layer (Nuxt module / router) uses it.
- */
+/** What an auth extension registers under {@link AUTH} once it has risen. */
 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. */
-  storages: Record<string, Storage>;
-  /** Web Standard handler that processes /auth/* requests. */
+  /** Web Standard handler that processes `/auth/*` requests. */
   handler: (request: Request) => Promise<Response>;
   /** Programmatic API exposed by the provider (getSession, signOut, ...). */
   api: Record<string, unknown>;
-  /** Effective mount path (echoes config.basePath or the provider's default). */
+  /** Effective mount path. */
   basePath: string;
 }
+
+/** The container key an auth provider registers its runtime under. */
+export const AUTH = 'AuthRuntime';

package/src/boot/CreateAppOptions.ts

@@ -6,8 +6,6 @@ import type { StorageFactory } from '../storage/StorageFactory.js';
 import type { Constraint } from '../Constraint.js';
 import type { Transport } from '../wire/Transport.js';
 import type { Extension } from './Extension.js';
-import type { AuthConfig } from './AuthConfig.js';
-import type { DispatchObserver } from '../dispatch/DispatchObserver.js';
 import type { App } from './App.js';
 
 /** Options for createApp(). */
@@ -86,13 +84,4 @@ export interface CreateAppOptions {
   adapters?: Record<string, boolean | undefined>;
   /** Carries an announced fact out of this process — a broker, a queue, a log. */
   onEmit?: (fact: string, payload: unknown) => void | Promise<void>;
-  /** Passive observers of every dispatch transition. */
-  dispatchObservers?: readonly DispatchObserver[];
-  /**
-   * Storage handle to expose to the auth provider via AuthContext.db.
-   * Required when `auth` is set.
-   */
-  db?: unknown;
-  /** Auth declaration to wire into the app at boot. */
-  auth?: AuthConfig;
 }

package/src/boot/Emissions.ts

@@ -1,4 +1,5 @@
 import { applyCreate, dotted, lowerFirst, type SchemaView } from '@fougere/schema';
+import { addressOf, facadeKeyOf } from '../wire/Facade.js';
 import type { Container } from '@fougere/container';
 import { validationErrorsOf } from '../wire/FougereError.js';
 import { awaitKeyOf, emitKeyOf, factsAnnouncedBy, factsAwaitedBy } from '../wire/Emit.js';
@@ -318,6 +319,7 @@ export class Emissions {
    */
   private stamped(fact: string, raw: unknown): unknown {
     const shape = this.shapes.get(fact);
+
     return shape && raw !== null && typeof raw === 'object' && !Array.isArray(raw)
       ? applyCreate(shape.getFields(), raw as Record<string, unknown>)
       : raw;
@@ -337,6 +339,7 @@ export class Emissions {
     const listeners = this.subscribers.get(fact) ?? [];
     if (listeners.length === 0) {
       this.log.debug(`${fact} — nobody listens in this process`);
+
       return [];
     }
 
@@ -350,6 +353,7 @@ export class Emissions {
         } catch (cause) {
           throw new Error(`${fact} → ${facade} could not be reached`, { cause });
         }
+
         return handler[op]({ ...Invocation.empty, input: payload });
       }),
     }));
@@ -359,17 +363,13 @@ export class Emissions {
   private describeRefusal(fact: string, cause: unknown): string | undefined {
     const refusals = validationErrorsOf(cause);
     if (!refusals?.length) return undefined;
+
     return `refused the shape — ${refusals.map((d) => `${dotted(d.path)}: ${d.message}`).join(', ')}.`
       + ` If '${fact}' gained a field, this copy is older than the sender's: re-run \`fougere sync\`.`;
   }
 }
 
-/**
- * The container key a declared CLASS NAME answers under — `RedactHandler` → `redactHandler`,
- * the same key `facadeKeyOf` builds from an address.
- */
+/** The container key a declared CLASS NAME answers under — `RedactHandler` → `redactHandler`. */
 function facadeOf(declared: string): string {
-  const key = lowerFirst(declared);
-
-  return key.endsWith('Handler') ? key : `${key}Handler`;
+  return facadeKeyOf(addressOf(declared));
 }

package/src/boot/Hosting.ts

@@ -2,6 +2,7 @@ import type { SchemaView } from '@fougere/schema';
 import type { Constraint } from '../Constraint.js';
 import type { Peer } from './Peer.js';
 import type { Journal } from '../dispatch/Journal.js';
+import type { Storage } from '../storage/Storage.js';
 
 /**
  * Where an entity's rows are hosted, and what the host keeps — what a `ref()` asks the boot.
@@ -17,7 +18,7 @@ export interface Hosting {
    * Resolved through the frond that owns it, never the asking frond's scope: a scope sees its
    * parent and not its siblings, so a target of another frond was answered by nothing.
    */
-  storageOf(entity: string): unknown | undefined;
+  storageOf(entity: string): Storage | undefined;
   /** Every entity of every frond — a row is named from wherever its namer was declared. */
   entities(): ReadonlyMap<string, SchemaView>;
   /**

package/src/boot/ambient.als.ts

@@ -17,12 +17,14 @@ export const ambient: Ambient = {
         + `are ONE frame — declare a single Together naming every member.`,
       ));
     }
+
     return frame.run(key, fn);
   },
 
   beforeAnnounce(fact: string): Promise<void> {
     const open = frame.getStore();
     if (open === undefined) return Promise.resolve();
+
     return Promise.reject(new Error(
       `${fact} cannot be announced inside Together<[…]> (${open}): announcing is dispatch, `
       + `so subscribers and the carrier would have it while these writes can still be taken `

package/src/boot/apply.ts

@@ -40,5 +40,6 @@ export function applyConfig(next: FougereConfig, inForce?: FougereConfig): Confi
       pending.push(key);
     }
   }
+
   return { applied, pending };
 }

package/src/boot/arity.ts

@@ -0,0 +1,42 @@
+import type { Diagnostic } from '../diagnostic.js';
+import type { FrondDescriptor } from '../descriptor/FrondDescriptor.js';
+
+interface Constructed {
+  ctor: { name: string; length: number };
+  deps: string[];
+  filePath: string;
+}
+
+/**
+ * What the container hands a constructor is `deps`, one argument per key and in order — so a
+ * constructor asking for more is handed `undefined`. The scan reads `deps` off the signature and
+ * cannot miss; a frond declared by hand can, and `Function.length` is the one thing a
+ * constructor says about itself once the types are gone.
+ *
+ * `length` is a floor and never a count: a class that writes no constructor inherits
+ * `(...args) => super(...args)`, which is 0, while the scan read its parent's dependencies.
+ */
+export function refuseArityDrift(frond: FrondDescriptor, refused: Diagnostic[]): void {
+  const constructed: Constructed[] = [
+    ...frond.handlers,
+    ...frond.presenters,
+    ...frond.collectors,
+    ...frond.providers,
+    ...frond.middlewares,
+  ];
+
+  for (const { ctor, deps, filePath } of constructed) {
+    if (ctor.length <= deps.length) continue;
+
+    refused.push({
+      severity: 'blocking',
+      code: 'constructor-arity',
+      filePath,
+      frond: frond.name,
+      subject: ctor.name,
+      message: `${ctor.name}'s constructor takes ${ctor.length} parameter(s) and ${deps.length} `
+        + `dependenc${deps.length === 1 ? 'y is' : 'ies are'} declared (${deps.join(', ') || 'none'}) — `
+        + 'the rest would be handed `undefined`.',
+    });
+  }
+}