@fougere/core 0.2.0-alpha.2 → 0.4.0-alpha.0

package/src/dispatch/RouteRegistry.ts

@@ -0,0 +1,73 @@
+import { RouteAddress } from '../contract/RouteAddress.js';
+import type { Route } from './Route.js';
+import type { RouteResolver } from './RouteResolver.js';
+
+/** Exact registry of every operation the application can dispatch. */
+export class RouteRegistry {
+  private readonly byAddress = new Map<string, Route>();
+  private readonly resolvers: RouteResolver[] = [];
+  private readonly pending = new Map<string, Promise<Route | undefined>>();
+
+  get size(): number {
+    return this.byAddress.size;
+  }
+
+  register(route: Route): void {
+    const key = route.address.key();
+    const existing = this.byAddress.get(key);
+    if (existing) {
+      throw new Error(
+        `Route collision at '${route.address}': ${existing.kind} and ${route.kind}`,
+      );
+    }
+    this.byAddress.set(key, route);
+  }
+
+  addResolver(resolver: RouteResolver): void {
+    this.resolvers.push(resolver);
+  }
+
+  find(address: RouteAddress): Route | undefined {
+    const exact = this.byAddress.get(address.key());
+    if (exact || address.surface === undefined) return exact;
+
+    const shared = this.byAddress.get(new RouteAddress({
+      entity: address.entity,
+      operation: address.operation,
+    }).key());
+    return shared?.kind === 'system' ? shared : undefined;
+  }
+
+  async resolve(address: RouteAddress): Promise<Route | undefined> {
+    const known = this.find(address);
+    if (known) return known;
+
+    const key = address.key();
+    const running = this.pending.get(key);
+    if (running) return running;
+
+    const resolution = this.resolveUnknown(address).finally(() => this.pending.delete(key));
+    this.pending.set(key, resolution);
+    return resolution;
+  }
+
+  private async resolveUnknown(address: RouteAddress): Promise<Route | undefined> {
+    for (const resolver of this.resolvers) {
+      const route = await resolver.resolve(address);
+      if (!route) continue;
+      this.register(route);
+      return route;
+    }
+    return undefined;
+  }
+
+  routes(): Route[] {
+    return [...this.byAddress.values()];
+  }
+
+  operationNames(entity: string, surface?: string): string[] {
+    return this.routes()
+      .filter((route) => route.address.entity === entity && route.address.surface === surface)
+      .map((route) => route.address.operation);
+  }
+}

package/src/dispatch/RouteResolver.ts

@@ -0,0 +1,7 @@
+import type { RouteAddress } from '../contract/RouteAddress.js';
+import type { Route } from './Route.js';
+
+/** Resolves routes that cannot be known when the registry is built. */
+export interface RouteResolver {
+  resolve(address: RouteAddress): Route | undefined | Promise<Route | undefined>;
+}

package/src/dispatch/StorageGuard.ts

@@ -0,0 +1,71 @@
+import { ValueJudge, type Fields } from '@fougere/schema';
+import { assertListOptions } from '../orm.js';
+import { ErrorCode, FougereError } from '../wire/errors.js';
+
+interface Writer {
+  create(...args: [Record<string, unknown>, ...unknown[]]): Promise<unknown>;
+  update(...args: [unknown, Record<string, unknown>, ...unknown[]]): Promise<unknown>;
+}
+
+/**
+ * Judges storage writes and list options without narrowing the ORM interface.
+ *
+ * Storage is a way out like the client surface, so what goes to it is judged too — the
+ * same rule `OutputProjector` applies on the other exit.
+ */
+export class StorageGuard {
+  constructor(
+    private readonly fields: Fields,
+    private readonly entity: string,
+  ) {}
+
+  guard<T extends object>(orm: T): T {
+    const writer = orm as unknown as Writer;
+    if (typeof writer.create !== 'function' || typeof writer.update !== 'function') return orm;
+
+    const validation = this;
+    const guarded = Object.create(orm) as T & Writer;
+
+    guarded.create = async function (...args) {
+      validation.judge(args[0], 'create');
+      return writer.create.apply(this, args);
+    };
+
+    guarded.update = async function (...args) {
+      validation.judge(args[1], 'update');
+      return writer.update.apply(this, args);
+    };
+
+    const reader = orm as unknown as { list?: (...args: unknown[]) => unknown };
+    if (typeof reader.list === 'function') {
+      (guarded as unknown as typeof reader).list = async function (...args: unknown[]) {
+        assertListOptions(args[0] as object | undefined, validation.entity);
+        return (reader.list as Function).apply(this, args);
+      };
+    }
+
+    return guarded;
+  }
+
+  private judge(value: unknown, operation: string): void {
+    if (typeof value !== 'object' || value === null) return;
+
+    const errors: string[] = [];
+    for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
+      const field = this.fields[key];
+      if (!field || item === undefined) continue;
+      const checked = ValueJudge.of(field).check(item);
+      if ('error' in checked) errors.push(`${key}: ${checked.error}`);
+    }
+
+    if (errors.length > 0) {
+      throw new FougereError({
+        code: ErrorCode.INTERNAL_ERROR,
+        message: `Refused on the way out — ${errors.join(', ')}`,
+        entity: this.entity,
+        operation,
+        details: errors,
+      });
+    }
+  }
+}