@afora/core 0.0.2 → 0.0.4

package/dist/core/output/types/output.interface.d.ts

@@ -0,0 +1,171 @@
+import type { AnyBlueprint } from "../../blueprint/types/blueprint.interface.js";
+import type { AnyCommand } from "../../command/types/command.interface.js";
+import type { JsonValue } from "../../json.js";
+import type { Kind } from "../../symbols/kind.js";
+import type { AnyExceptionClass } from "../../use-case/use-case.js";
+/** The options of a stage: a JSON object. */
+export type StageOptions = {
+    readonly [key: string]: JsonValue;
+};
+/** An HTTP-style status by exception name. */
+export type OutputStatuses = Readonly<Record<string, number>>;
+/** The call of an operation: `context` is what the command (or use case) declares. */
+export interface OperationCallOptions {
+    readonly context?: unknown;
+}
+/**
+ * One operation of a command, as an output sees it. Frozen; transforms change
+ * a copy with `operationOf`.
+ */
+export interface OperationDescriptor {
+    readonly kind: "operation";
+    readonly version: 1;
+    /** `"Users.register"`. */
+    readonly id: string;
+    /** The name of the command. */
+    readonly command: string;
+    /** The operation name inside the command. */
+    readonly name: string;
+    /** The `useCaseName`. */
+    readonly useCase: string;
+    /** The use case description, else the command one. */
+    readonly description?: string;
+    /** The command tags, then the use case ones, deduplicated. */
+    readonly tags: readonly string[];
+    readonly deprecated: boolean;
+    readonly input: AnyBlueprint;
+    readonly response: AnyBlueprint;
+    /** The command context, else the use case one. */
+    readonly context?: AnyBlueprint;
+    /** The `errors` of the use case. */
+    readonly errors: readonly AnyExceptionClass[];
+    /** Set by transforms; `{}` initially. */
+    readonly meta: Readonly<Record<string, unknown>>;
+    /** `command.run(name, input, options)`. */
+    invoke(input: unknown, options?: OperationCallOptions): Promise<unknown>;
+}
+/** What `operationOf` can change. */
+export interface OperationPatch {
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly tags?: readonly string[];
+    readonly description?: string | undefined;
+    readonly deprecated?: boolean;
+    readonly invoke?: OperationDescriptor["invoke"];
+}
+/** What a stage knows about the output running it. */
+export interface StageContext {
+    readonly output: {
+        readonly name: string;
+        readonly statuses: OutputStatuses;
+    };
+}
+/** A stage that changes (or removes, with `null`) each operation. */
+export interface TransformStage<Options extends object = StageOptions> {
+    readonly kind: "transform";
+    readonly name?: string;
+    readonly options?: Options;
+    apply(operation: OperationDescriptor, context: StageContext): OperationDescriptor | null;
+}
+/** The last stage: builds something concrete out of the operations. */
+export interface SinkStage<Result = unknown, Options extends object = StageOptions> {
+    readonly kind: "sink";
+    readonly name?: string;
+    readonly options?: Options;
+    build(operations: readonly OperationDescriptor[], context: StageContext): Result;
+}
+/** Any stage. */
+export type Stage = TransformStage<any> | SinkStage<any, any>;
+type AnyTransform = TransformStage<any>;
+type AnySink<Result> = SinkStage<Result, any>;
+/** What a stage is, out of band: a name and JSON options, or opaque. */
+export type StageDescription = {
+    readonly kind: "transform" | "sink";
+    readonly name: string;
+    readonly options: StageOptions;
+} | {
+    readonly kind: "opaque";
+};
+export interface TransformSettings<Options extends object> {
+    readonly name: string;
+    /** Returns the operation, a changed copy, or `null` to remove it. */
+    readonly apply: (operation: OperationDescriptor, options: Options, context: StageContext) => OperationDescriptor | null;
+    /** Why `options` cannot be used, or `undefined`. Checked when the stage is made. */
+    readonly validate?: (options: Options) => string | undefined;
+}
+export interface SinkSettings<Result, Options extends object> {
+    readonly name: string;
+    readonly build: (operations: readonly OperationDescriptor[], options: Options, context: StageContext) => Result;
+    /** Why `options` cannot be used, or `undefined`. Checked when the stage is made. */
+    readonly validate?: (options: Options) => string | undefined;
+}
+/** Makes a stage from JSON options. */
+export type TransformFactory<Options extends object = StageOptions> = (options?: Options) => TransformStage<Options>;
+export type SinkFactory<Result = unknown, Options extends object = StageOptions> = (options?: Options) => SinkStage<Result, Options>;
+/** Any stage factory. */
+export type StageFactory = TransformFactory<any> | SinkFactory<any, any>;
+/** Stage factories by name. */
+export interface IStageCatalog<Factories extends Readonly<Record<string, StageFactory>> = Readonly<Record<string, StageFactory>>> {
+    readonly [Kind]: "stage-catalog";
+    readonly stages: Factories;
+    readonly list: readonly StageFactory[];
+    /** Makes the stage `name` with `options`; throws `InvalidOutputStage` for an unknown name. */
+    resolve(name: string, options?: StageOptions): Stage;
+}
+/** The result of the sink at the end of a pipe, or `never` when there is none. */
+export type PipeResult<Pipe extends readonly Stage[]> = Pipe extends readonly [
+    ...Stage[],
+    SinkStage<infer Result, any>
+] ? Result : never;
+/** An application, as far as an output is concerned: it gives its commands. */
+export interface OutputApplication {
+    readonly [Kind]: "application";
+    readonly commands: Readonly<Record<string, AnyCommand>>;
+}
+/** What an output takes its commands from. */
+export type OutputSource = AnyCommand | OutputApplication;
+export interface OutputSettings<Pipe extends readonly Stage[]> {
+    readonly name: string;
+    /** The commands the output exposes: commands, applications (all their commands) or a mix. */
+    readonly commands: OutputApplication | readonly OutputSource[];
+    /** HTTP-style status by exception name. */
+    readonly statuses?: OutputStatuses;
+    readonly pipe?: Pipe;
+}
+/** An output made by `outputOf`. */
+export interface OutputOf<Result = never> {
+    readonly [Kind]: "output";
+    readonly outputName: string;
+    readonly commands: readonly AnyCommand[];
+    /** The operations after the transforms, in declaration order. */
+    readonly operations: readonly OperationDescriptor[];
+    readonly stages: readonly Stage[];
+    readonly statuses: OutputStatuses;
+    /** The result of the sink (memoized); throws when the pipe has no sink. */
+    build(): Result;
+    /** The result of the sink when the last stage is one, else a new, unnamed output. */
+    pipe<Built>(...stages: [...AnyTransform[], AnySink<Built>]): Built;
+    pipe(...stages: Stage[]): OutputOf<never>;
+}
+/** Any output. */
+export type AnyOutput = OutputOf<any>;
+/** An RFC 9457 problem. */
+export interface Problem {
+    readonly type: string;
+    readonly title: string;
+    readonly status: number;
+    readonly detail: string;
+    readonly layer?: string;
+    /** Only for a 400 with validation issues. */
+    readonly issues?: readonly {
+        readonly path: readonly (string | number)[];
+        readonly code: string;
+        readonly message: string;
+    }[];
+    /** Only with `debug`. */
+    readonly trace?: string;
+}
+export interface ProblemOptions {
+    readonly status: number;
+    readonly debug?: boolean;
+}
+export {};

package/dist/core/property/abstract-property.d.ts

@@ -1,4 +1,4 @@
-import type { TSchema } from "typebox";
+import type { Static, TSchema } from "typebox";
 import type { ParseResult } from "../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../standard/standard-schema.js";
 import { State } from "../symbols/state.js";
@@ -9,11 +9,12 @@ import type { AnyPropertyConstructor } from "./types/property-collection.type.js
 import type { PropertyValue } from "./types/property-constructor.type.js";
 import type { PropertyOptions } from "./types/property-options.interface.js";
 import type { IPropertyType } from "./types/property-type.interface.js";
-export declare abstract class AbstractProperty<SchemaType extends TSchema> implements IProperty<SchemaType> {
+/** A property instance; `Value` is the value of its schema, as in `ISchema`. */
+export declare abstract class AbstractProperty<SchemaType extends TSchema, Value = Static<SchemaType>> implements IProperty<SchemaType, Value> {
     get [State](): PropertyStates;
-    readonly definition: AbstractDefineProperty<SchemaType>;
-    readonly value: PropertyValue<SchemaType>;
-    constructor(value: PropertyValue<SchemaType>);
+    readonly definition: AbstractDefineProperty<SchemaType, Value>;
+    readonly value: PropertyValue<SchemaType, Value>;
+    constructor(value: PropertyValue<SchemaType, Value>);
     /**
      * Builds an instance from the property's `default` value. Throws if the
      * property is required and has no `default`.
@@ -32,11 +33,11 @@ export declare abstract class AbstractProperty<SchemaType extends TSchema> imple
      * `pattern`... are checked along with its own constraints, which they can
      * only narrow. Its demo value is `default`, or the first of `examples`.
      */
-    static with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<Self["type"] extends IPropertyType<infer SchemaType> ? SchemaType : never>): Self;
+    static with<Self extends AnyPropertyConstructor>(this: Self, options: Self["type"] extends IPropertyType<infer SchemaType, infer Value> ? PropertyOptions<SchemaType, Value> : never): Self;
     /**
      * The Standard Schema of the class it is read from, a subclass included:
      * `validate` gives the handled value, or the issues that reject it.
      */
     static get "~standard"(): StandardSchemaV1.Props<any, any>;
-    protected abstract createDefinition(): AbstractDefineProperty<SchemaType>;
+    protected abstract createDefinition(): AbstractDefineProperty<SchemaType, Value>;
 }

package/dist/core/property/define-property.d.ts

@@ -4,15 +4,16 @@ import { State } from "../symbols/state.js";
 import { PropertyStates } from "./enums/property-states.js";
 import type { IDefineProperty } from "./types/define-property.interface.js";
 import type { IPropertyType } from "./types/property-type.interface.js";
-export declare abstract class AbstractDefineProperty<SchemaType extends TSchema> implements IDefineProperty<SchemaType> {
+/** How a property handles its value; `Value` is the value of its schema, as in `ISchema`. */
+export declare abstract class AbstractDefineProperty<SchemaType extends TSchema, Value = Static<SchemaType>> implements IDefineProperty<SchemaType, Value> {
     [State]: PropertyStates;
-    abstract get type(): IPropertyType<SchemaType>;
+    abstract get type(): IPropertyType<SchemaType, Value>;
     /**
      * The value handled by the property; throws `PropertyRequired` for
      * `undefined` on a required property, and `InvalidPropertyValue` (or the
      * exception of a handler) for a value it rejects.
      */
-    make(value: Static<SchemaType>): Static<SchemaType>;
+    make(value: Value): Value;
     /**
      * Like `make`, but never throws: the handled value, or an issue for each
      * reason the value is rejected, whose `cause` is the exception `make` would
@@ -21,11 +22,11 @@ export declare abstract class AbstractDefineProperty<SchemaType extends TSchema>
      * `Exception`, from any step, rejects the value too, as the cause of an
      * `InvalidPropertyValue`.
      */
-    parse(value: unknown): ParseResult<Static<SchemaType>>;
-    protected preHandle(value: Static<SchemaType>): Static<SchemaType>;
-    protected afterHandle(value: Static<SchemaType>): Static<SchemaType>;
+    parse(value: unknown): ParseResult<Value>;
+    protected preHandle(value: Value): Value;
+    protected afterHandle(value: Value): Value;
     /** The value, or `MISMATCH` when the schema rejects it. */
-    protected handle(value: Static<SchemaType>): Static<SchemaType>;
+    protected handle(value: Value): Value;
     /** `attempt`, with the error of any step as a failure. */
     private attemptWithoutThrowing;
     /** Runs the pipeline, updating the state, and tells why it stopped if it did. */

package/dist/core/property/property.d.ts

@@ -8,10 +8,15 @@ import type { PropertyValue } from "./types/property-constructor.type.js";
 import type { PropertyOptions } from "./types/property-options.interface.js";
 import type { IPropertyType, UniqueMark } from "./types/property-type.interface.js";
 type SchemaValueType<SchemaType extends TSchema, Optional extends boolean = false> = Optional extends true ? TOptional<SchemaType> : SchemaType;
-type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false, Unique extends boolean = false> = {
+/**
+ * What `propertyOf` takes. `SchemaType` is inferred from `schema` alone: the
+ * value is `NoInfer`, since inferring through `Static` makes TypeScript
+ * measure `Static` itself, which costs about a second on every check.
+ */
+type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false, Unique extends boolean = false, Value = Static<SchemaType>> = {
     name: string;
     schema: SchemaType;
-    default?: Static<SchemaType>;
+    default?: NoInfer<Value>;
     optional?: Optional;
     /** A record masks its value in `toJSON`, at any depth, as `Password`. */
     sensitive?: boolean;
@@ -20,27 +25,33 @@ type PropertyOfArgs<SchemaType extends TSchema, Optional extends boolean = false
      * do not check it, repositories (or the database) enforce it.
      */
     unique?: Unique;
-    preHandle?: (value: Static<SchemaType>) => Static<SchemaType>;
-    afterHandle?: (value: Static<SchemaType>) => Static<SchemaType>;
+    preHandle?: (value: NoInfer<Value>) => NoInfer<Value>;
+    afterHandle?: (value: NoInfer<Value>) => NoInfer<Value>;
 };
-/** The instance type of a class declared with `propertyOf`. */
-export declare class DeclaredProperty<SchemaType extends TSchema> extends AbstractProperty<SchemaType> {
-    protected createDefinition(): AbstractDefineProperty<SchemaType>;
+/**
+ * The instance type of a class declared with `propertyOf`; `Value` is the
+ * value of its schema, as in `ISchema`.
+ */
+export declare class DeclaredProperty<SchemaType extends TSchema, Value = Static<SchemaType>> extends AbstractProperty<SchemaType, Value> {
+    protected createDefinition(): AbstractDefineProperty<SchemaType, Value>;
 }
-/** A class declared with `propertyOf`; extend it to add behavior, as `Id` does. */
-export interface PropertyClass<SchemaType extends TSchema> {
-    new (value: PropertyValue<SchemaType>): DeclaredProperty<SchemaType>;
-    readonly type: IPropertyType<SchemaType>;
+/**
+ * A class declared with `propertyOf`; extend it to add behavior, as `Id` does.
+ * `Value` is the value of its schema, as in `ISchema`.
+ */
+export interface PropertyClass<SchemaType extends TSchema, Value = Static<SchemaType>> {
+    new (value: PropertyValue<SchemaType, Value>): DeclaredProperty<SchemaType, Value>;
+    readonly type: IPropertyType<SchemaType, Value>;
     /** The value handled by the property, or every issue that rejects `value`; never throws. */
-    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType>>;
+    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType, Value>>;
     /** The Standard Schema of the class: `validate` gives the handled value. */
-    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType>, PropertyValue<SchemaType>>;
+    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType, Value>, PropertyValue<SchemaType, Value>>;
     /**
      * A subclass narrowed and documented by `options`, e.g.
      * `Integer.with({ min: 1, description: "Age in years" })`.
      */
-    with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<SchemaType>): Self;
+    with<Self extends AnyPropertyConstructor>(this: Self, options: PropertyOptions<SchemaType, Value>): Self;
     demo<Self extends AbstractProperty<any>>(this: new (value: never) => Self): Self;
 }
-export declare function propertyOf<SchemaType extends TSchema, Optional extends boolean = false, const Unique extends boolean = false>({ name, schema, optional, sensitive, unique, default: _default, preHandle: onPreHandle, afterHandle: onAfterHandle, }: PropertyOfArgs<SchemaType, Optional, Unique>): PropertyClass<SchemaValueType<SchemaType, Optional>> & UniqueMark<Unique>;
+export declare function propertyOf<SchemaType extends TSchema, Optional extends boolean = false, const Unique extends boolean = false>({ name, schema, optional, sensitive, unique, default: _default, preHandle: onPreHandle, afterHandle: onAfterHandle, }: PropertyOfArgs<SchemaType, Optional, Unique>): PropertyClass<SchemaValueType<SchemaType, Optional>, Static<SchemaType>> & UniqueMark<Unique>;
 export {};

package/dist/core/property/types/abstract-property-constructor.type.d.ts

@@ -1,13 +1,14 @@
-import type { TSchema } from "typebox";
+import type { Static, TSchema } from "typebox";
 import type { ParseResult } from "../../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../../standard/standard-schema.js";
 import type { AbstractProperty } from "../abstract-property.js";
 import type { PropertyValue } from "./property-constructor.type.js";
 import type { IPropertyType } from "./property-type.interface.js";
-export type AbstractPropertyConstructor<SchemaType extends TSchema> = {
-    new (value: PropertyValue<SchemaType>): AbstractProperty<SchemaType>;
-    readonly type: IPropertyType<SchemaType>;
-    demo(): AbstractProperty<SchemaType>;
-    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType>>;
-    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType>, PropertyValue<SchemaType>>;
+/** A property class; `Value` is the value of its schema, as in `ISchema`. */
+export type AbstractPropertyConstructor<SchemaType extends TSchema, Value = Static<SchemaType>> = {
+    new (value: PropertyValue<SchemaType, Value>): AbstractProperty<SchemaType, Value>;
+    readonly type: IPropertyType<SchemaType, Value>;
+    demo(): AbstractProperty<SchemaType, Value>;
+    safeParse(value: unknown): ParseResult<PropertyValue<SchemaType, Value>>;
+    readonly "~standard": StandardSchemaV1.Props<PropertyValue<SchemaType, Value>, PropertyValue<SchemaType, Value>>;
 };

package/dist/core/property/types/define-property.interface.d.ts

@@ -3,10 +3,11 @@ import type { ParseResult } from "../../parse/types/parse.interface.js";
 import { State } from "../../symbols/state.js";
 import type { PropertyStates } from "../enums/property-states.js";
 import type { IPropertyType } from "./property-type.interface.js";
-export interface IDefineProperty<SchemaType extends TSchema> {
+/** How a property handles its value; `Value` is the value of its schema, as in `ISchema`. */
+export interface IDefineProperty<SchemaType extends TSchema, Value = Static<SchemaType>> {
     [State]: PropertyStates;
-    get type(): IPropertyType<SchemaType>;
-    make(value: Static<SchemaType>): Static<SchemaType>;
+    get type(): IPropertyType<SchemaType, Value>;
+    make(value: Value): Value;
     /** Like `make`, but returns the issues of a rejected value instead of throwing. */
-    parse(value: unknown): ParseResult<Static<SchemaType>>;
+    parse(value: unknown): ParseResult<Value>;
 }

package/dist/core/property/types/optional-property.type.d.ts

@@ -11,10 +11,10 @@ import type { IPropertyType, UniqueTypeOf } from "./property-type.interface.js";
  * own methods and statics (e.g. `Password#verify`, `Id.generate`) are kept.
  */
 export type OptionalProperty<Property extends AnyPropertyConstructor> = Property extends {
-    readonly type: IPropertyType<infer SchemaType>;
+    readonly type: IPropertyType<infer SchemaType, infer Value>;
 } ? SchemaType extends TOptional<TSchema> ? StoredField<Property> : Omit<Property, "type" | "prototype" | "safeParse" | "~standard" | CallableKey> & {
-    new (value: PropertyValue<TOptional<SchemaType>>): AbstractProperty<TOptional<SchemaType>> & Omit<InstanceType<Property>, keyof AbstractProperty<TSchema>>;
-    readonly type: IPropertyType<TOptional<SchemaType>> & UniqueTypeOf<Property>;
-    safeParse(value: unknown): ParseResult<PropertyValue<TOptional<SchemaType>>>;
-    readonly "~standard": StandardSchemaV1.Props<PropertyValue<TOptional<SchemaType>>, PropertyValue<TOptional<SchemaType>>>;
+    new (value: PropertyValue<TOptional<SchemaType>, Value>): AbstractProperty<TOptional<SchemaType>, Value> & Omit<InstanceType<Property>, keyof AbstractProperty<TSchema>>;
+    readonly type: IPropertyType<TOptional<SchemaType>, Value> & UniqueTypeOf<Property>;
+    safeParse(value: unknown): ParseResult<PropertyValue<TOptional<SchemaType>, Value>>;
+    readonly "~standard": StandardSchemaV1.Props<PropertyValue<TOptional<SchemaType>, Value>, PropertyValue<TOptional<SchemaType>, Value>>;
 } : never;

package/dist/core/property/types/property-collection.type.d.ts

@@ -7,8 +7,8 @@ import type { IPropertyType } from "./property-type.interface.js";
  * to `unknown`, which a constructor taking a narrower value would reject.
  */
 export type AnyPropertyConstructor = {
-    new (value: any): AbstractProperty<any>;
-    readonly type: IPropertyType<any>;
+    new (value: any): AbstractProperty<any, any>;
+    readonly type: IPropertyType<any, any>;
     safeParse(value: unknown): ParseResult<any>;
     readonly "~standard": StandardSchemaV1.Props<any, any>;
 };

package/dist/core/property/types/property-constructor.type.d.ts

@@ -1,2 +1,6 @@
 import type { Static, TOptional, TSchema } from "typebox";
-export type PropertyValue<SchemaType extends TSchema> = SchemaType extends TOptional<TSchema> ? Static<SchemaType> | undefined : Static<SchemaType>;
+/**
+ * The value a property holds: the value of its schema, or `undefined` too
+ * when it is optional. `Value` is the value of the schema, as in `ISchema`.
+ */
+export type PropertyValue<SchemaType extends TSchema, Value = Static<SchemaType>> = SchemaType extends TOptional<TSchema> ? Value | undefined : Value;

package/dist/core/property/types/property-options.interface.d.ts

@@ -46,7 +46,7 @@ export interface StringConstraints {
  * What `Property.with` and `ctx.<property>(options)` take: the metadata of any
  * property, plus the constraints of its kind of schema, for strings and numbers.
  */
-export type PropertyOptions<SchemaType extends TSchema> = PropertyMetadata<NonNullable<Static<SchemaType>>> & (SchemaType extends TString ? StringConstraints : SchemaType extends TNumber | TInteger ? NumberConstraints : unknown);
+export type PropertyOptions<SchemaType extends TSchema, Value = Static<SchemaType>> = PropertyMetadata<NonNullable<Value>> & (SchemaType extends TString ? StringConstraints : SchemaType extends TNumber | TInteger ? NumberConstraints : unknown);
 /**
  * Brands a `CallableProperty` with the property it stands for.
  *
@@ -60,18 +60,27 @@ export declare const Callable: unique symbol;
 export type CallableProperty<Property extends {
     readonly type: IPropertyType<TSchema>;
 }> = Property & {
-    (options?: PropertyOptions<SchemaOfProperty<Property>>): Property;
+    (options?: OptionsOfProperty<Property>): Property;
     readonly [Callable]: Property;
 };
-/** The schema of a property class. */
-type SchemaOfProperty<Property> = Property extends {
-    readonly type: IPropertyType<infer SchemaType>;
-} ? SchemaType : TSchema;
-/** `Field`, or the property it stands for when it is a `CallableProperty`, as a blueprint stores it. */
+/**
+ * The `PropertyOptions` of a property class, from its schema and the value
+ * its type carries, so `Static` is not measured again.
+ */
+type OptionsOfProperty<Property> = Property extends {
+    readonly type: IPropertyType<infer SchemaType, infer Value>;
+} ? PropertyOptions<SchemaType, Value> : PropertyOptions<TSchema>;
+/**
+ * `Field`, or the property it stands for when it is a `CallableProperty`, as a blueprint stores it.
+ * @internal
+ */
 export type StoredField<Field> = Field extends {
     readonly [Callable]: infer Property;
 } ? Property : Field;
-/** `StoredField` of every field of a collection. */
+/**
+ * `StoredField` of every field of a collection.
+ * @internal
+ */
 export type StoredFields<Fields> = {
     [Key in keyof Fields]: StoredField<Fields[Key]>;
 };

package/dist/core/property/types/property-type.interface.d.ts

@@ -1,11 +1,15 @@
 import type { Static, TSchema } from "typebox";
 import type { ISchema } from "../../schema/types/schema.interface.js";
 import { Demo } from "../../symbols/demo.js";
-export interface IPropertyType<SchemaType extends TSchema> {
+/**
+ * What a property declares about itself. `Value` is the value of its schema,
+ * computed where `SchemaType` is known, as in `ISchema`.
+ */
+export interface IPropertyType<SchemaType extends TSchema, Value = Static<SchemaType>> {
     /** Value used by `demo()`; it is the property's `default`, when there is one. */
-    readonly [Demo]: Static<SchemaType> | undefined;
+    readonly [Demo]: Value | undefined;
     readonly name: string;
-    readonly schema: ISchema<SchemaType>;
+    readonly schema: ISchema<SchemaType, Value>;
     readonly optional?: boolean;
     /** Whether a record masks its value in `toJSON`, at any depth. */
     readonly sensitive?: boolean;

package/dist/core/property/types/property.interface.d.ts

@@ -1,7 +1,8 @@
-import type { TSchema } from "typebox";
+import type { Static, TSchema } from "typebox";
 import type { AbstractDefineProperty } from "../define-property.js";
 import type { PropertyValue } from "./property-constructor.type.js";
-export interface IProperty<SchemaType extends TSchema> {
-    readonly definition: AbstractDefineProperty<SchemaType>;
-    readonly value: PropertyValue<SchemaType>;
+/** A property instance; `Value` is the value of its schema, as in `ISchema`. */
+export interface IProperty<SchemaType extends TSchema, Value = Static<SchemaType>> {
+    readonly definition: AbstractDefineProperty<SchemaType, Value>;
+    readonly value: PropertyValue<SchemaType, Value>;
 }

package/dist/core/record/abstract-record.d.ts

@@ -1,7 +1,13 @@
 import type { BlueprintData, BlueprintField, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection } from "../blueprint/types/blueprint.interface.js";
 import type { ParseResult } from "../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../standard/standard-schema.js";
+import { Meta } from "../symbols/meta.js";
 import type { IRecord, RecordChange, RecordEffects, RecordSettings } from "./types/record.interface.js";
+/** The statics of a class made by `recordOf`, that its records read. */
+interface RecordDeclaration<Properties extends IBlueprintCollection> {
+    readonly blueprint: IBlueprint<Properties>;
+    readonly options: RecordSettings<Properties>;
+}
 /**
  * The names of the record's own members, and of those every object inherits
  * (`toString`, `valueOf`, `__proto__`...), which no key of a blueprint can take.
@@ -32,8 +38,10 @@ export declare function recordFieldDataOf(field: BlueprintField | undefined, val
  * and the one it replaced.
  */
 export declare function storeRecordValue(record: {
-    readonly blueprint: {
-        readonly properties: IBlueprintCollection;
+    readonly [Meta]: {
+        readonly blueprint: {
+            readonly properties: IBlueprintCollection;
+        };
     };
 }, key: string, value: unknown): {
     readonly next: unknown;
@@ -47,8 +55,7 @@ export declare const RecordPluginHooks: unique symbol;
  */
 export declare function runRecordEffects<Self extends object>(record: Self, key: PropertyKey, next: unknown, previous: unknown): Self;
 export declare abstract class AbstractRecord<Properties extends IBlueprintCollection> implements IRecord<Properties> {
-    readonly blueprint: IBlueprint<Properties>;
-    readonly options: RecordSettings<Properties>;
+    get [Meta](): RecordDeclaration<Properties>;
     constructor(value: BlueprintInput<Properties>);
     /**
      * An instance of the class for `value`, each key handled, or every issue
@@ -82,3 +89,4 @@ export declare abstract class AbstractRecord<Properties extends IBlueprintCollec
      */
     protected onSet(): RecordEffects<IRecord<Properties>>;
 }
+export {};

package/dist/core/record/types/plugin.interface.d.ts

@@ -90,13 +90,17 @@ export interface IRecordPluginCatalog<Plugins extends Readonly<globalThis.Record
     /** `resolve` for each of `references`, e.g. `JSON.parse(JSON.stringify(Post.plugins))`. */
     resolveAll(references: readonly RecordPluginReference[]): readonly AnyRecordPlugin[];
 }
-/** The plugins of a catalog made of `Plugins`, by name. */
+/**
+ * The plugins of a catalog made of `Plugins`, by name.
+ * @internal
+ */
 export type RecordPluginsByName<Plugins extends readonly AnyRecordPlugin[]> = {
     readonly [Plugin in Plugins[number] as Plugin["name"]]: Plugin;
 };
 /**
  * What `options.plugins` picks from: the plugins of every catalog, by name; a
  * later catalog replaces a plugin of an earlier one with the same name.
+ * @internal
  */
 export type RecordPluginContext<Catalogs extends readonly IRecordPluginCatalog[]> = Catalogs extends readonly [
     infer Head extends IRecordPluginCatalog,
@@ -111,7 +115,10 @@ type PluginProperties<Plugin> = Plugin extends {
         readonly blueprint: IBlueprint<infer Properties, boolean>;
     };
 } ? Properties : never;
-/** The fields of a record, and those of each of its plugins. */
+/**
+ * The fields of a record, and those of each of its plugins.
+ * @internal
+ */
 export type WithPluginProperties<Properties extends IBlueprintCollection, Plugins extends readonly AnyRecordPlugin[]> = [Plugins[number]] extends [never] ? Properties : Properties & UnionToIntersection<PluginProperties<Plugins[number]>> extends infer Merged ? {
     readonly [Key in keyof Merged]: Merged[Key];
 } : never;
@@ -119,7 +126,10 @@ export type WithPluginProperties<Properties extends IBlueprintCollection, Plugin
 type PluginInstance<Plugin> = Plugin extends {
     readonly record: abstract new (value: never) => infer Instance;
 } ? Instance : never;
-/** What the plugins add to the records they are applied to: their keys and methods. */
+/**
+ * What the plugins add to the records they are applied to: their keys and methods.
+ * @internal
+ */
 export type PluginMembers<Plugins extends readonly AnyRecordPlugin[]> = [
     Plugins[number]
 ] extends [never] ? unknown : UnionToIntersection<PluginInstance<Plugins[number]>>;

package/dist/core/record/types/record.interface.d.ts

@@ -1,14 +1,25 @@
-import type { BlueprintData, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection, RecordAccepts } from "../../blueprint/types/blueprint.interface.js";
+import type { AnyBlueprint, BlueprintData, BlueprintInput, BlueprintValue, IBlueprint, IBlueprintCollection, RecordAccepts } from "../../blueprint/types/blueprint.interface.js";
 import type { ParseResult } from "../../parse/types/parse.interface.js";
 import type { StandardSchemaV1 } from "../../standard/standard-schema.js";
 import type { Kind } from "../../symbols/kind.js";
+import type { Meta } from "../../symbols/meta.js";
 import type { AbstractRecord } from "../abstract-record.js";
 import type { AnyRecordPlugin, RecordPluginsOption, RecordUniqueKeys } from "./plugin.interface.js";
 /** The value of a record, read from its blueprint. */
-export type RecordValue<Record extends AnyRecordShape> = Record["blueprint"] extends IBlueprint<infer Properties> ? BlueprintValue<Properties> : never;
-/** Anything with a blueprint, as records are. */
+export type RecordValue<Record extends AnyRecordShape> = Record extends {
+    readonly [Meta]: {
+        readonly blueprint: IBlueprint<infer Properties>;
+    };
+} ? BlueprintValue<Properties> : Record extends {
+    readonly blueprint: IBlueprint<infer Properties>;
+} ? BlueprintValue<Properties> : never;
+/** A record instance's metadata, or a record class's statics. */
 type AnyRecordShape = {
-    readonly blueprint: IBlueprint<any>;
+    readonly blueprint: AnyBlueprint;
+} | {
+    readonly [Meta]: {
+        readonly blueprint: AnyBlueprint;
+    };
 };
 /** A side effect of a change to a key: its new value and the one it replaced. */
 export type RecordEffect<Value> = (value: Value, previous: Value) => void;
@@ -81,10 +92,11 @@ type RecordChangeMethods<Self, Properties extends IBlueprintCollection, Key exte
     readonly [K in Key]: (value: K extends keyof BlueprintValue<Properties> ? BlueprintValue<Properties>[K] : never) => Self;
 };
 export interface IRecord<Properties extends IBlueprintCollection> {
-    /** The blueprint whose shape the record implements. */
-    readonly blueprint: IBlueprint<Properties>;
-    /** Which keys are sensitive, unique or have a `change.<key>` method. */
-    readonly options: RecordSettings<Properties>;
+    /** Declaration metadata, separate from domain keys. */
+    readonly [Meta]: {
+        readonly blueprint: IBlueprint<Properties>;
+        readonly options: RecordSettings<Properties>;
+    };
     /** The value with the sensitive keys, and every `sensitive` property, masked. */
     toJSON(): Readonly<Partial<BlueprintData<Properties>>>;
 }

package/dist/core/repository/exceptions.d.ts

@@ -1,3 +1,7 @@
+/** A query contains unsupported keys, ordering or pagination. */
+export declare const InvalidRepositoryQuery: import("../../index.js").DeclaredExceptionClass<{
+    readonly reason: string;
+}>;
 /** `repositoryOf` got something other than an entity, actions and a provider. */
 export declare const InvalidRepositoryDeclaration: import("../../index.js").DeclaredExceptionClass<{
     readonly reason: string;

package/dist/core/repository/in-memory.d.ts

@@ -3,5 +3,8 @@ import type { IRepositoryProvider } from "./types/repository.interface.js";
  * A provider that keeps the values in memory, one table per entity class,
  * enforcing its unique keys. Each `repositoryOf` without a provider gets its
  * own; repositories given the same one share the tables of their entities.
+ * Its `transaction` works on isolated snapshots: commits on success, discards
+ * on rejection, runs one at a time and makes other operations wait; nested
+ * transactions are savepoints.
  */
 export declare function inMemoryProvider(): IRepositoryProvider;

package/dist/core/repository/provider.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderDescription, ProviderOptions, ProviderSettings } from "./types/query.interface.js";
+import type { IRepositoryProvider } from "./types/repository.interface.js";
+/** Creates a provider once and attaches an immutable, serializable declaration out of band. */
+export declare function providerOf<Options extends ProviderOptions = ProviderOptions, Provider extends IRepositoryProvider = IRepositoryProvider>(settings: ProviderSettings<Options, Provider>): Provider;
+/** Describes a named provider; an anonymous one needs an explicit import on extraction. */
+export declare function providerDescriptionOf(provider: IRepositoryProvider): ProviderDescription;