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

package/src/dispatch/LocalRoutePolicy.ts

@@ -22,6 +22,7 @@ export class LocalRoutePolicy implements RoutePolicy {
     const hosted = this.hostedNames(call.address.surface);
     const entity = call.address.entity;
     const surface = call.address.surface;
+
     return new FougereError({
       code: ErrorCode.NOT_FOUND,
       message: (surface

package/src/dispatch/RouteRegistry.ts

@@ -35,6 +35,7 @@ export class RouteRegistry {
       entity: address.entity,
       operation: address.operation,
     }).key());
+
     return shared?.kind === 'system' ? shared : undefined;
   }
 
@@ -48,6 +49,7 @@ export class RouteRegistry {
 
     const resolution = this.resolveUnknown(address).finally(() => this.pending.delete(key));
     this.pending.set(key, resolution);
+
     return resolution;
   }
 
@@ -56,8 +58,10 @@ export class RouteRegistry {
       const route = await resolver(address);
       if (!route) continue;
       this.register(route);
+
       return route;
     }
+
     return undefined;
   }
 

package/src/dispatch/StorageGuard.ts

@@ -1,4 +1,4 @@
-import { FieldSet, FieldValueValidator, InputRefusal, type Fields, type Verdict } from '@fougere/schema';
+import { FieldSet, FieldValueValidator, InputRefusal, Role, type Fields, type Verdict } from '@fougere/schema';
 import { COMPARISONS, comparisonOf, unknownIn } from '../storage/Comparison.js';
 import { assertListOptions } from '../storage/Storage.js';
 import { ErrorCode } from '../wire/ErrorCode.js';
@@ -69,12 +69,14 @@ export class StorageGuard {
     guarded.create = async function (...args) {
       args[0] = validation.validated(args[0], 'create');
       await validation.targetsOf([args[0]], 'create');
+
       return writer.create.apply(this, args);
     };
 
     guarded.update = async function (...args) {
       args[1] = validation.validated(args[1], 'update');
       await validation.targetsOf([args[1]], 'update');
+
       return writer.update.apply(this, args);
     };
 
@@ -83,6 +85,7 @@ export class StorageGuard {
       guarded.upsert = async function (...args) {
         args[0] = validation.validated(args[0], 'upsert');
         await validation.targetsOf([args[0]], 'upsert');
+
         return upsert.apply(this, args);
       };
     }
@@ -94,6 +97,7 @@ export class StorageGuard {
       guarded.upsertAll = async function (...args) {
         args[0] = args[0].map((row, index) => validation.validated(row, 'upsertAll', index));
         await validation.targetsOf(args[0], 'upsertAll');
+
         return upsertAll.apply(this, args);
       };
     }
@@ -122,6 +126,7 @@ export class StorageGuard {
   private rowAt(row: unknown, index: number): string {
     const primary = FieldSet.of(this.fields).primary;
     const key = primary === undefined ? undefined : (row as Record<string, unknown>)[primary];
+
     return key === undefined ? `row ${index} of this page` : `row ${primary} ${JSON.stringify(key)}`;
   }
 
@@ -213,6 +218,8 @@ export class StorageGuard {
   private written(key: string, item: unknown): Verdict {
     const field = this.fields[key];
     if (!field) return { message: InputRefusal.unknownField };
+    // Declared, and still nothing to write: the other side of the relation carries the key.
+    if (Role.of(field).isCollection()) return { message: InputRefusal.readOnly };
     if (item === undefined) return { value: item };
 
     return FieldValueValidator.of(field).parse(item);
@@ -220,6 +227,7 @@ export class StorageGuard {
 
   private value(field: Fields[string], asked: unknown): Verdict {
     if (asked === null || asked === undefined) return { value: asked };
+
     return FieldValueValidator.of(field).parse(asked);
   }
 

package/src/identity-keys.ts

@@ -5,6 +5,7 @@ import { b64url } from './crypto/encoding.js';
 /** A fresh Ed25519 pair, PEM both ways. The root's and a frond's are the same kind. */
 export function generateKeyPair(): { privateKey: string; publicKey: string } {
   const { privateKey, publicKey } = generateKeyPairSync('ed25519');
+
   return {
     privateKey: privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(),
     publicKey: publicKey.export({ type: 'spki', format: 'pem' }).toString(),
@@ -26,5 +27,6 @@ export function issueGrant(
   const header = b64url(JSON.stringify({ alg: 'EdDSA', typ: 'fougere-grant' }));
   const payload = b64url(JSON.stringify({ sub: name, jwk, iat: now, exp: now + ttlDays * 86_400_000 }));
   const signingInput = `${header}.${payload}`;
+
   return `${signingInput}.${b64url(new Uint8Array(sign(null, Buffer.from(signingInput), createPrivateKey(rootPrivateKey))))}`;
 }

package/src/loader.ts

@@ -11,6 +11,7 @@ const defaultLoader: ModuleLoader = async (filePath, options) => {
   // On the URL, never on the path: `pathToFileURL` percent-encodes a `?` into the
   // filename, and the import then looks for a file whose name ends in `%3Fv=…`.
   const url = pathToFileURL(filePath).href;
+
   return await import(options?.fresh ? `${url}?v=${Date.now()}` : url);
 };
 

package/src/prefab/CrudConstructor.ts

@@ -52,6 +52,7 @@ const returns = (raw: string, name: string, extra?: { array?: boolean; nullable?
 function crudOps(entity: SchemaView & { partial?: () => SchemaView }): Record<string, OperationContract> {
   const name = (entity as { name?: string }).name ?? 'Entity';
   const input = inputParam(name);
+
   return {
     list: {
       output: entity, cardinality: 'page',

package/src/prefab/collector.ts

@@ -10,6 +10,7 @@ export function Collector<T extends abstract new (...args: any[]) => any>(target
   class CollectorBase {
     static readonly __entity = target;
   }
+
   return CollectorBase;
 }
 

package/src/prefab/presenter.ts

@@ -18,6 +18,7 @@ export function Presenter<E extends EntityConstructor>(entity: E, views?: Presen
     static readonly __entity = entity;
     static readonly __views = views;
   }
+
   return PresenterBase;
 }
 

package/src/storage/Storage.ts

@@ -159,6 +159,7 @@ const HELD = 'Storage';
  */
 export function togetherKeyOf(entities: readonly string[], providers: readonly string[] = []): string {
   const named = entities.map(upperFirst).join(SEPARATOR);
+
   return `${named}${providers.length ? KINDS + providers.map(upperFirst).join(SEPARATOR) : ''}${FRAME}`;
 }
 
@@ -174,5 +175,6 @@ export function membersOfTogetherKey(key: string): { entities: string[]; provide
   if (key.length <= FRAME.length || !key.endsWith(FRAME)) return undefined;
   const [entities = '', providers = ''] = key.slice(0, -FRAME.length).split(KINDS);
   const split = (list: string) => list.split(SEPARATOR).filter(Boolean);
+
   return { entities: split(entities), providers: split(providers) };
 }

package/src/storage/Store.ts

@@ -21,7 +21,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
   return (entity: SchemaView, name: string): Storage => {
     const fields = entity.getFields();
     const store = open(entity, name);
-    const pk = Object.entries(fields).find(([, field]) => Role.of(field).isPrimary)?.[0] ?? 'id';
+    const pk = Object.entries(fields).find(([, field]) => Role.of(field).isPrimary())?.[0] ?? 'id';
     // `Storage.findById(id: string)` — but a key can hold a number, and a Map keyed on
     // `1` does not answer `'1'`. SQL never had the question; here the divergence was
     // silent and only on this storage.
@@ -57,6 +57,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
         const previous = await store.get(keyOf(id));
         const values = previous ? { ...previous, ...applyUpdate(fields, input) } : created;
         await store.set(keyOf(id), values);
+
         return pick(values);
       };
 
@@ -71,10 +72,12 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
         },
         async findById(id: string) {
           const values = await store.get(keyOf(id));
+
           return values && pick(values);
         },
         async findBy(criteria: Record<string, unknown>) {
           const values = (await store.all()).find((held) => matches(held, criteria));
+
           return values && pick(values);
         },
         async findAllBy(criteria: Record<string, unknown>) {
@@ -87,6 +90,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
             const values = await store.get(keyOf(id));
             if (values) found.set(String(id), pick(values));
           }
+
           return found;
         },
         // The dual, same contract as SQL: grouped by the value read off the instance.
@@ -100,11 +104,13 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
             const bucket = grouped.get(key);
             if (bucket) bucket.push(pick(values)); else grouped.set(key, [pick(values)]);
           }
+
           return grouped;
         },
         upsert,
         async upsertAll(inputs: readonly Partial<Record<string, unknown>>[]) {
           for (const input of inputs) await upsert(input);
+
           return inputs.length;
         },
         async create(input: Partial<Record<string, unknown>>) {
@@ -125,6 +131,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
             throw new Error(`${name}.create: '${pk}' ${JSON.stringify(id)} already exists.`);
           }
           await store.set(keyOf(id), values);
+
           return pick(values);
         },
         async update(id: string, input: Partial<Record<string, unknown>>) {
@@ -132,6 +139,7 @@ export function storageOver(open: (entity: SchemaView, name: string) => Store):
           if (!existing) throw new Error(`Not found: ${id}`);
           const updated = { ...existing, ...applyUpdate(fields, input), [pk]: existing[pk] };
           await store.set(keyOf(id), updated);
+
           return pick(updated);
         },
         async delete(id: string) { return await store.delete(keyOf(id)); },

package/src/verify.ts

@@ -42,6 +42,7 @@ function registrationsOf(frond: FrondDescriptor): Map<string, Registration> {
     put(storageKeyOf(e.name), 'storage');
     put(repositoryKeyOf(e.name), 'repository');
   }
+
   return out;
 }
 
@@ -143,6 +144,7 @@ export function verify(app: { fronds: readonly FrondDescriptor[] }): Misplaced[]
       }
     }
   }
+
   return violations;
 }
 

package/src/wire/AppMiddleware.ts

@@ -27,7 +27,9 @@ export function runMiddlewares(
     if (index < middlewares.length) {
       return middlewares[index++](ctx, next);
     }
+
     return handler();
   };
+
   return next();
 }

package/src/wire/FougereError.ts

@@ -41,6 +41,7 @@ export class FougereError<Code extends ErrorCode = ErrorCode> extends Error {
   static fromJSON(json: unknown): FougereError {
     const raw = (typeof json === 'object' && json !== null ? json : {}) as Record<string, unknown>;
     const known = Object.values(ErrorCode).includes(raw.code as ErrorCode);
+
     return new FougereError({
       code: known ? (raw.code as ErrorCode) : ErrorCode.INTERNAL_ERROR,
       message: typeof raw.message === 'string' ? raw.message : 'Unknown error',
@@ -65,5 +66,6 @@ export function validationErrorsOf(error: unknown): ValidationError[] | undefine
       && Array.isArray((entry as ValidationError).path)
       && typeof (entry as ValidationError).message === 'string',
   );
+
   return refusals.length === details.length ? refusals : undefined;
 }

package/src/wire/Invocation.ts

@@ -8,6 +8,7 @@ function canonicalValue(value: unknown): unknown {
 
   const prototype = Object.getPrototypeOf(value);
   if (prototype !== Object.prototype && prototype !== null) return value;
+
   return canonicalRecord(value);
 }
 
@@ -19,6 +20,7 @@ function canonicalRecord(value: unknown): Record<string, unknown> {
   for (const [key, member] of Object.entries(value)) {
     if (member !== undefined) result[key] = canonicalValue(member);
   }
+
   return Object.freeze(result);
 }
 

package/src/wire/OperationContract.ts

@@ -39,6 +39,7 @@ export function cardinalityOf(type: TypeRef | undefined): OperationContract['car
   if (inner.name === 'Page' || inner.name === 'ListResult') return 'page';
   if (inner.array) return 'many';
   if (PRIMITIVE_RETURNS.has(inner.name)) return 'none';
+
   return inner.nullable || inner.undefined ? 'maybe' : 'one';
 }
 

package/src/wire/RouteAddress.ts

@@ -3,6 +3,7 @@ import type { RouteAddressInput } from './RouteAddressInput.js';
 /** Refuses an empty segment, so no address can be built that nothing can serve. */
 function required(value: string, name: string): string {
   if (value.trim().length === 0) throw new TypeError(`Route ${name} cannot be empty`);
+
   return value;
 }
 
@@ -38,6 +39,7 @@ export class RouteAddress {
   /** Writes the address the way a log and an error message name it. */
   toString(): string {
     const audience = this.surface ? `${this.surface}/` : '';
+
     return `${audience}${this.entity}.${this.operation}`;
   }
 

package/src/wire/binding.ts

@@ -38,6 +38,7 @@ const PRIMITIVES = new Set(['string', 'number', 'boolean']);
 function coercionFor(typeName: string): 'number' | 'boolean' | undefined {
   if (typeName === 'number') return 'number';
   if (typeName === 'boolean') return 'boolean';
+
   return undefined;
 }
 

package/src/wire/card/IdentityCard.ts

@@ -27,6 +27,7 @@ export function assertIdentityCard(value: unknown, source: string): IdentityCard
     if (!frond || typeof frond.name !== 'string') throw cardRefusal(source, 'a frond with no name');
     if (!Array.isArray(frond.facades)) throw cardRefusal(source, `frond '${frond.name}' has no valid facades array`);
   }
+
   return card as IdentityCard;
 }
 

package/src/wire/drift.ts

@@ -29,6 +29,7 @@ function facadesOf(card: IdentityCard, frond: string): Map<string, Answering> {
       found.set(facade.name, { ops: new Set(facade.ops.map((op) => op.name)), schema: facade.schema });
     }
   }
+
   return found;
 }
 
@@ -38,6 +39,7 @@ function factsOf(card: IdentityCard, frond: string): Map<string, SchemaDescripto
     if (one.name !== frond) continue;
     for (const fact of one.facts ?? []) found.set(fact.name, fact.schema as SchemaDescriptor | undefined);
   }
+
   return found;
 }
 
@@ -117,6 +119,7 @@ export function explain(drift: CardDrift): string[] {
     if (changes === 'gone') { lines.push(`${fact} — you subscribe to it, it is no longer announced`); continue; }
     for (const change of changes) lines.push(`${fact} — ${describe(change)} → re-sync and deploy the readers, THEN the sender`);
   }
+
   return lines;
 }
 

package/src/wire/http-error.ts

@@ -40,6 +40,7 @@ export function toPublicError(err: FougereError): ReturnType<FougereError['toJSO
   if (err.code !== ErrorCode.INTERNAL_ERROR) return err.toJSON();
   const where = [err.entity, err.operation].filter(Boolean).join('.');
   log.error(`${where || 'internal'}: ${err.message}`, err.cause ?? err);
+
   return {
     code: ErrorCode.INTERNAL_ERROR,
     message: 'Internal error',
@@ -60,5 +61,6 @@ export function toHttpError(err: unknown): { status: number; body: ReturnType<Fo
     message: (err as { message?: string })?.message ?? 'Internal error',
     cause: err,
   });
+
   return { status: 500, body: toPublicError(framed) };
 }

package/src/wire/loggerMiddleware.ts

@@ -19,6 +19,7 @@ export function loggerMiddleware(logger: Logger): AppMiddleware {
       const result = await next();
       const ms = (performance.now() - start).toFixed(1);
       logger.info(`${ctx.entity}.${ctx.operation} (${ms}ms)`);
+
       return result;
     } catch (err) {
       const ms = (performance.now() - start).toFixed(1);