@fougere/core 0.17.4-alpha.0 → 0.19.0-alpha.0

package/src/wire/Placement.ts

@@ -0,0 +1,4 @@
+/** Where something answers — in this process, or a process away. */
+export const PLACEMENTS = ['local', 'remote'] as const;
+
+export type Placement = (typeof PLACEMENTS)[number];

package/src/wire/RouteKind.ts

@@ -1,2 +1,4 @@
+import type { Placement } from './Placement.js';
+
 /** Which kind of destination served a call — it travels in a `CallRecord`. */
-export type RouteKind = 'local' | 'remote' | 'system';
+export type RouteKind = Placement | 'system';

package/src/wire/SignedCall.ts

@@ -5,6 +5,8 @@ export interface SignedCall {
   params?: Record<string, unknown>;
   query?: Record<string, unknown>;
   input?: unknown;
+  /** What code wrote for the handler — pinned like the input, or a signed call replays with others. */
+  args?: readonly unknown[];
   state?: Record<string, unknown>;
   /** The hour, pinned like the input: moving it is moving the call. */
   runAt?: number;

package/src/wire/StateShape.ts

@@ -1,4 +1,4 @@
-import { InputValidator, dotted, optional, type Field, type Fields } from '@fougere/schema';
+import { Schema, dotted, optional, type Field, type Fields, type SchemaConstructor, type SchemaView } from '@fougere/schema';
 import { ErrorCode } from './ErrorCode.js';
 import { FougereError } from './FougereError.js';
 
@@ -16,19 +16,16 @@ export interface StateDeclaration {
  * Documented: [collectors](https://fougere.dev/docs/business/collectors).
  */
 export class StateShape {
-  static readonly empty = new StateShape({});
+  static readonly empty = new StateShape(Schema.of({ fields: {} }));
 
-  private readonly validator: InputValidator;
-
-  private constructor(private readonly fields: Fields) {
-    this.validator = InputValidator.of(fields);
-  }
+  private constructor(private readonly schema: SchemaView) {}
 
   /** Two extensions declaring one member refuse: the field that judges it would depend on wiring order. */
   static of(declarations: readonly StateDeclaration[]): StateShape {
-    const fields: Fields = {};
     const owners = new Map<string, string>();
+    let schema: SchemaConstructor<Fields> = Schema.of({ fields: {} as Fields });
     for (const { name, state } of declarations) {
+      const fields: Fields = {};
       for (const [member, field] of Object.entries(state ?? {})) {
         const owner = owners.get(member);
         if (owner) {
@@ -40,9 +37,10 @@ export class StateShape {
         owners.set(member, name);
         fields[member] = optional(field);
       }
+      schema = schema.extend(fields);
     }
 
-    return new StateShape(fields);
+    return new StateShape(schema);
   }
 
   /**
@@ -58,10 +56,10 @@ export class StateShape {
     const written = Object.fromEntries(Object.entries(state).filter(([member, value]) => entered[member] !== value));
     if (Object.keys(written).length === 0) return state;
 
-    const result = this.validator.validate(written);
+    const result = this.schema.validate(written);
     if (result.success) return { ...state, ...result.data };
 
-    const declared = Object.keys(this.fields);
+    const declared = Object.keys(this.schema.getFields());
     const errors = result.errors.map((error) => ({ ...error, path: ['state', ...error.path] }));
 
     throw new FougereError({

package/src/wire/TypeRef.ts

@@ -16,4 +16,8 @@ export interface TypeRef {
   undefined?: boolean;
   /** Whether this is a Promise wrapper (unwrapped in output). */
   promise?: boolean;
+  /** `Post['title']` — the field this type is read from, whose rules the value obeys. */
+  field?: { entity: string; name: string };
+  /** The entity whose row this value designates — set by the scan when `field` is its primary. */
+  identifies?: string;
 }

package/src/wire/binding.ts

@@ -17,7 +17,11 @@ type ParamSource =
    * (`Emissions.stamped`, which realizes `created()`); this is the declared form of it.
    */
   | { kind: 'pipe'; factName: string }
-  | { kind: 'param'; name: string; coerce?: 'number' | 'boolean' }
+  /**
+   * `field` is where the value's rules are declared — `title: Post['title']`. `identifies` names
+   * the entity whose row the value designates, when that field is its primary.
+   */
+  | { kind: 'param'; name: string; coerce?: 'number' | 'boolean'; field?: { entity: string; name: string }; identifies?: string }
   | { kind: 'input' }
   | { kind: 'context' }
   /** The whole query bag, for an op whose argument IS the options (list). */
@@ -76,7 +80,11 @@ function sourceOf(param: Param, collectorTypeNames: Set<string>): ParamSource {
 
   if (collectorTypeNames.has(typeKey)) return { kind: 'collector', typeName: typeKey };
   if (typeName === 'InvocationContext') return { kind: 'context' };
-  if (PRIMITIVES.has(typeName)) return { kind: 'param', name: param.name, coerce: coercionFor(typeName) };
+  if (PRIMITIVES.has(typeName)) {
+    const { field, identifies } = param.type;
+
+    return { kind: 'param', name: param.name, coerce: coercionFor(typeName), ...(field && { field }), ...(identifies && { identifies }) };
+  }
 
   return { kind: 'input' };
 }

package/src/wire/card/CardOp.ts

@@ -1,24 +1,18 @@
 import type { SchemaDescriptor } from '@fougere/schema';
-import type { ErrorCode } from '../ErrorCode.js';
+import type { OperationContract } from '../OperationContract.js';
+import type { OperationKind } from '../OperationKind.js';
 
 /**
  * One operation, as a stranger meets it — its name, what it is for, what it takes and whether it
  * reads or writes.
  */
-export interface CardOp {
+export interface CardOp extends Pick<OperationContract, 'description' | 'cardinality' | 'errors'> {
   name: string;
-  /** The author's own doc sentence, when the method carries one. */
-  description?: string;
   /** JSON Schema of what it accepts, when the contract names a view. */
   input?: SchemaDescriptor;
   /** JSON Schema of what it emits, when the contract names one. */
   output?: SchemaDescriptor;
-  /** `query` reads, `command` writes — the same call REST turns into GET vs POST. */
-  kind: 'query' | 'command';
-  /** How much `output` describes. */
-  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
-  /** What this op can REFUSE, beyond what `kind` and `input` already imply. */
-  errors?: ErrorCode[];
+  kind: OperationKind;
   /** The fact this op is handed when it is announced — its `Fact<T>`, which IS the subscription. */
   listens?: string;
 }

package/src/wire/refusals.ts

@@ -14,10 +14,11 @@
  * Documented: [observability](https://fougere.dev/docs/infra/observability).
  */
 import { ErrorCode } from './ErrorCode.js';
+import type { OperationKind } from './OperationKind.js';
 
 /** The little of an operation this reads — so a card op and an effective one both fit. */
 export interface Refusable {
-  kind?: 'query' | 'command';
+  kind?: OperationKind;
   input?: unknown;
   errors?: readonly string[];
   /** Absent on a card op read from a frond that answers in this process. */

package/src/wire/topology/DeclaredFrond.ts

@@ -1,7 +1,9 @@
+import type { Placement } from '../Placement.js';
+
 /** A frond the config knows of, and where it says to reach it. */
 export interface DeclaredFrond {
   frond: string;
-  placement: 'local' | 'remote';
+  placement: Placement;
   /**
    * Host and port of the address `remotes:` names, absent when the frond runs here. Never the
    * whole address: a declared one may carry credentials, and this answer leaves the process.

package/src/wire/topology/FrondPlacement.ts

@@ -1,7 +1,9 @@
+import type { Placement } from '../Placement.js';
+
 /** A frond this process knows about, and whether it runs here. */
 export interface FrondPlacement {
   frond: string;
-  placement: 'local' | 'remote';
+  placement: Placement;
   entities: number;
   facades: number;
 }