@aventara/core 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/config/define-fields.d.ts

@@ -1,42 +0,0 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { AdapterFieldKey } from "../adapters/adapter-resource.js";
-import type { FrameworkResourceKey, FrameworkScalarFieldConfig, FrameworkScalarTypeRef } from "./framework-fields-config.js";
-/**
- * What a configuration may say about a field the adapter already discovered:
- * everything in {@link FrameworkScalarFieldConfig} except `type`.
- */
-export type KnownScalarFieldConfig<M extends AdapterModel = AdapterModel> = Omit<FrameworkScalarFieldConfig<M>, "type"> & {
-    readonly type?: never;
-};
-/**
- * A scalar field the configuration adds, which the adapter did not discover.
- * `type`, `nullable` and `list` are required; it takes no `json` shape.
- */
-export type AddedScalarFieldConfig<M extends AdapterModel = AdapterModel> = Omit<FrameworkScalarFieldConfig<M>, "type" | "nullable" | "list" | "json"> & {
-    readonly type: FrameworkScalarTypeRef<M>;
-    readonly nullable: boolean;
-    readonly list: boolean;
-    readonly json?: never;
-};
-/** The shape one authored field name admits, by what the adapter knows of it. */
-type ScalarFieldConfigFor<M extends AdapterModel, R extends FrameworkResourceKey<M>, F> = string extends AdapterFieldKey<M, R> ? FrameworkScalarFieldConfig<M> : F extends AdapterFieldKey<M, R> ? M["resources"][R]["fields"][F] extends {
-    readonly kind: "relation";
-} ? never : M["resources"][R]["fields"][F] extends {
-    readonly type: {
-        readonly scalar: "json";
-    };
-} ? KnownScalarFieldConfig<M> : Omit<KnownScalarFieldConfig<M>, "json"> & {
-    readonly json?: never;
-} : AddedScalarFieldConfig<M>;
-/** The shape an authored `fields` block is checked against, keyed on its own names. */
-export type FrameworkFieldsShape<M extends AdapterModel, Self> = {
-    readonly [R in keyof Self]: R extends FrameworkResourceKey<M> ? {
-        readonly [F in keyof Self[R]]: ScalarFieldConfigFor<M, R, F>;
-    } : never;
-};
-/**
- * Authors stage 1 of a configuration: the `fields` block, checked against
- * what the adapter discovered and returned unwidened.
- */
-export declare function defineFields<M extends AdapterModel, const Self extends FrameworkFieldsShape<M, Self>>(_model: M, fields: Self): Self;
-export {};

package/dist/config/define-fields.js

@@ -1,3 +0,0 @@
-export function defineFields(_model, fields) {
-    return fields;
-}

package/dist/config/framework-behaviors-config.d.ts

@@ -1,30 +0,0 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { ComputedReadBehavior, ComputeOnCreate, ComputeOnUpdate } from "../runtime/field-behavior.js";
-import type { AnyFrameworkConfig } from "./any-framework-config.js";
-import type { EffectiveFieldKey } from "./effective-fields.js";
-import type { FrameworkResourceKey } from "./framework-fields-config.js";
-/** A read behavior: a compute function, or one declaring the fields it reads. */
-export type FrameworkReadBehavior<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = ComputedReadBehavior<M, Cfg, R>;
-/**
- * A field's behaviors: a value computed on create, on update, or on read.
- * `false` turns off a behavior set at an outer layer.
- */
-export type FrameworkFieldBehaviorConfig<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = {
-    /** Computes the field's value when a row is created. */
-    readonly create?: false | ComputeOnCreate<M, Cfg, R>;
-    /** Computes the field's value when a row is updated. */
-    readonly update?: false | ComputeOnUpdate<M, Cfg, R>;
-    /** Computes the field's value when a row is read. */
-    readonly read?: false | FrameworkReadBehavior<M, Cfg, R>;
-};
-/** Behaviors for one Resource's fields. */
-export type FrameworkResourceBehaviorsConfig<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = {
-    /** Behaviors per field name. */
-    readonly fields: Readonly<Partial<{
-        [F in EffectiveFieldKey<M, Cfg, R>]: FrameworkFieldBehaviorConfig<M, Cfg, R>;
-    }>>;
-};
-/** Server-side behaviors, per Resource. */
-export type FrameworkBehaviorsConfig<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig> = Readonly<Partial<{
-    [R in FrameworkResourceKey<M>]: FrameworkResourceBehaviorsConfig<M, Cfg, R>;
-}>>;

package/dist/config/framework-fields-config.d.ts

@@ -1,42 +0,0 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { ScalarFieldCapabilities, ScalarFormat } from "../contracts/field.js";
-import type { JsonShape } from "../contracts/json-shape.js";
-import type { LifecycleTrait } from "../contracts/lifecycle-trait.js";
-/** The lifecycle traits a configuration may set on a field. */
-export type FrameworkFieldLifecycleTrait = Extract<LifecycleTrait, "VIRTUAL">;
-/** The names of the Resources in adapter model `M`. */
-export type FrameworkResourceKey<M extends AdapterModel> = Extract<keyof M["resources"], string>;
-/** A scalar type or an enum of adapter model `M`, by name. */
-export type FrameworkScalarTypeRef<M extends AdapterModel> = {
-    readonly scalar: Extract<keyof M["scalars"], string>;
-} | {
-    readonly enum: Extract<keyof M["enums"], string>;
-};
-/**
- * A scalar field's settings. For a discovered field, the discovered values are
- * the baseline; a field the adapter did not discover must state `type`,
- * `nullable` and `list`.
- */
-export type FrameworkScalarFieldConfig<M extends AdapterModel = AdapterModel> = {
-    /** The field's scalar or enum type. */
-    readonly type?: FrameworkScalarTypeRef<M>;
-    /** The scalar's format name, carried in the Contract. */
-    readonly format?: ScalarFormat;
-    /** Whether the field may be `null`. */
-    readonly nullable?: boolean;
-    /** Whether the field holds a list of values. */
-    readonly list?: boolean;
-    /** Persistence traits: `"VIRTUAL"` marks a field the store does not hold. */
-    readonly lifecycle?: readonly FrameworkFieldLifecycleTrait[];
-    /** The field's capabilities; see {@link ScalarFieldCapabilities}. */
-    readonly capabilities?: Partial<ScalarFieldCapabilities>;
-    /**
-     * A Json field's shape, built with `AvZ` from `@aventara/core/json`: writes
-     * to the field are checked against it, and its value is typed by it.
-     */
-    readonly json?: JsonShape;
-};
-/** Field settings for one Resource, by field name. */
-export type FrameworkResourceFieldsConfig<M extends AdapterModel = AdapterModel> = Readonly<Record<string, FrameworkScalarFieldConfig<M>>>;
-/** Fields to add or describe, per Resource. */
-export type FrameworkFieldsConfig<M extends AdapterModel = AdapterModel> = Readonly<Partial<Record<FrameworkResourceKey<M>, FrameworkResourceFieldsConfig<M>>>>;

package/dist/config/framework-restrictions-config.d.ts

@@ -1,142 +0,0 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { AdapterFieldKey } from "../adapters/adapter-resource.js";
-import type { PaginationCapability, ProjectionScope, RelationFilterCapability, RelationMutationDirective, RelationReducer, ScalarFilterOperator, ScalarMutationDirective, WriteScope } from "../contracts/capability.js";
-import type { AnyFrameworkConfig } from "./any-framework-config.js";
-import type { EffectiveFieldKey } from "./effective-fields.js";
-import type { FrameworkResourceKey } from "./framework-fields-config.js";
-/**
- * `true` keeps a capability, `false` removes it, and a list keeps only the
- * listed entries. Restrictions only narrow what the adapter offers.
- */
-export type FrameworkCapabilitySetRestriction<T extends string> = boolean | readonly T[];
-/**
- * A restriction on a relation's `select` or `include` capability: `true`,
- * `false`, or the projection positions to keep.
- */
-export type FrameworkProjectionScopeRestriction = boolean | readonly ProjectionScope[];
-/**
- * A restriction on a relation's `create` or `update` capability. A directive
- * list narrows the directives only; the object form can also narrow the write
- * positions (`scopes`).
- *
- * `directives: []` leaves the relation writable with no directive;
- * `scopes: []` or `false` makes it not writable.
- */
-export type FrameworkRelationMutationRestriction = boolean | readonly RelationMutationDirective[] | {
-    readonly directives?: readonly RelationMutationDirective[];
-    readonly scopes?: readonly WriteScope[];
-};
-/**
- * A restriction on a relation's `reducers` capability: `true`, `false`, a
- * reducer list, or an object narrowing reducers and projection positions.
- */
-export type FrameworkRelationReducerRestriction = boolean | readonly RelationReducer[] | {
-    readonly reducers?: readonly RelationReducer[];
-    readonly scopes?: readonly ProjectionScope[];
-};
-/** Restrictions on a scalar field's capabilities. */
-export type FrameworkScalarCapabilityRestrictions = {
-    /** Whether the field can be selected. */
-    readonly select?: boolean;
-    /** The filter operators to keep. */
-    readonly filter?: FrameworkCapabilitySetRestriction<ScalarFilterOperator>;
-    /** Whether results can be ordered by the field. */
-    readonly order?: boolean;
-    /** Whether ordering can place `null`s first or last. */
-    readonly orderNulls?: boolean;
-    /** The directives to keep when creating. */
-    readonly create?: FrameworkCapabilitySetRestriction<ScalarMutationDirective>;
-    /** The directives to keep when updating. */
-    readonly update?: FrameworkCapabilitySetRestriction<ScalarMutationDirective>;
-};
-/**
- * Restrictions on a relation field's capabilities. `select`, `include`,
- * `reducers`, `create` and `update` can also be narrowed by argument position.
- */
-export type FrameworkRelationCapabilityRestrictions = {
-    readonly select?: FrameworkProjectionScopeRestriction;
-    readonly include?: FrameworkProjectionScopeRestriction;
-    readonly filter?: FrameworkCapabilitySetRestriction<RelationFilterCapability>;
-    readonly order?: boolean;
-    readonly pagination?: FrameworkCapabilitySetRestriction<PaginationCapability>;
-    readonly reducers?: FrameworkRelationReducerRestriction;
-    readonly create?: FrameworkRelationMutationRestriction;
-    readonly update?: FrameworkRelationMutationRestriction;
-};
-/** Restrictions for one scalar field. */
-export type FrameworkScalarFieldRestrictions = {
-    /** `true` hides the field. */
-    readonly hidden?: boolean;
-    /** Capabilities to narrow. */
-    readonly capabilities?: FrameworkScalarCapabilityRestrictions;
-};
-/** Restrictions for one relation field. */
-export type FrameworkRelationFieldRestrictions = {
-    /** `true` hides the field. */
-    readonly hidden?: boolean;
-    /** Capabilities to narrow. */
-    readonly capabilities?: FrameworkRelationCapabilityRestrictions;
-};
-/** Restrictions for one field: scalar or relation. */
-export type FrameworkFieldRestrictions = FrameworkScalarFieldRestrictions | FrameworkRelationFieldRestrictions;
-/**
- * Standard operations to turn off, by family and variant: `false` removes
- * one the adapter offers.
- */
-export type FrameworkResourceOperationRestrictions = {
-    readonly find?: {
-        readonly first?: boolean;
-        readonly unique?: boolean;
-        readonly many?: boolean;
-        readonly count?: boolean;
-    };
-    readonly create?: {
-        readonly one?: boolean;
-        readonly many?: boolean;
-        readonly count?: boolean;
-    };
-    readonly update?: {
-        readonly first?: boolean;
-        readonly unique?: boolean;
-        readonly many?: boolean;
-        readonly count?: boolean;
-    };
-    readonly delete?: {
-        readonly first?: boolean;
-        readonly unique?: boolean;
-        readonly many?: boolean;
-        readonly count?: boolean;
-    };
-    readonly upsert?: {
-        readonly unique?: boolean;
-    };
-};
-/** The restriction shape an adapter-discovered field admits, by its kind. */
-type AdapterFieldRestrictionsFor<TField> = TField extends {
-    readonly kind: "scalar";
-} ? FrameworkScalarFieldRestrictions : TField extends {
-    readonly kind: "relation";
-} ? FrameworkRelationFieldRestrictions : FrameworkFieldRestrictions;
-/**
- * The restriction shape one effective field name admits. Three cases, in
- * order.
- */
-type FieldRestrictionsFor<M extends AdapterModel, R extends FrameworkResourceKey<M>, F extends string> = string extends F ? FrameworkFieldRestrictions : F extends AdapterFieldKey<M, R> ? AdapterFieldRestrictionsFor<M["resources"][R]["fields"][F]> : FrameworkScalarFieldRestrictions;
-/** Restrictions for one Resource's fields, by field name. */
-export type FrameworkResourceFieldRestrictions<M extends AdapterModel, Cfg, R extends FrameworkResourceKey<M>> = Readonly<Partial<{
-    [F in EffectiveFieldKey<M, Cfg, R>]: FieldRestrictionsFor<M, R, F>;
-}>>;
-/** Restrictions for one Resource. */
-export type FrameworkResourceRestrictions<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = {
-    /** `true` hides the whole Resource. */
-    readonly hidden?: boolean;
-    /** Restrictions per field. */
-    readonly fields?: FrameworkResourceFieldRestrictions<M, Cfg, R>;
-    /** Standard operations to turn off. */
-    readonly operations?: FrameworkResourceOperationRestrictions;
-};
-/** What to hide or narrow, per Resource. */
-export type FrameworkRestrictionsConfig<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig> = Readonly<Partial<{
-    [R in FrameworkResourceKey<M>]: FrameworkResourceRestrictions<M, Cfg, R>;
-}>>;
-export {};

package/dist/json/avz.d.ts

@@ -1,96 +0,0 @@
-import type { JsonSchemaPrimitive, JsonShape, JsonShapeValue } from "../contracts/json-shape.js";
-/** The forms a Json Shape takes. */
-export type AvZKind = "string" | "number" | "int" | "boolean" | "null" | "literal" | "enum" | "object" | "array" | "tuple" | "record" | "union" | "discriminatedUnion" | "optional" | "nullable";
-/**
- * A Json Shape built with {@link AvZ}: opaque, its `kind` the only member. Its
- * TypeScript type is `AvZ.infer<typeof shape>`.
- */
-export interface AvZShape<Value = unknown, Kind extends AvZKind = AvZKind> extends JsonShape<Value> {
-    readonly kind: Kind;
-}
-/** The fields of an object shape, by key. */
-export type AvZFields = {
-    readonly [key: string]: AvZShape;
-};
-declare const avzOptionalKey: unique symbol;
-/** Marks a shape whose object key may be left out. Type-level only. */
-interface AvZOptionalKey {
-    readonly [avzOptionalKey]: true;
-}
-type FieldKeysOptional<Fields extends AvZFields> = {
-    [Key in keyof Fields]: Fields[Key] extends AvZOptionalKey ? Key : never;
-}[keyof Fields];
-type Flatten<T> = {
-    [Key in keyof T]: T[Key];
-} & {};
-/** The value an object shape describes. */
-type AvZObjectValue<Fields extends AvZFields> = ObjectValueOf<Fields, FieldKeysOptional<Fields>>;
-type ObjectValueOf<Fields extends AvZFields, Optional extends keyof Fields> = Flatten<{
-    -readonly [Key in Exclude<keyof Fields, Optional>]: JsonShapeValue<Fields[Key]>;
-} & {
-    -readonly [Key in Optional]?: JsonShapeValue<Fields[Key]>;
-}>;
-/** An object shape: closed, so a key it does not declare is refused. */
-export interface AvZObject<Fields extends AvZFields = AvZFields> extends AvZShape<AvZObjectValue<Fields>, "object"> {
-    readonly fields: Fields;
-}
-/** A shape whose object key may be left out. */
-export interface AvZOptional<Inner extends AvZShape = AvZShape> extends AvZShape<JsonShapeValue<Inner> | undefined, "optional">, AvZOptionalKey {
-}
-/** A shape that also admits `null`. */
-export type AvZNullable<Inner extends AvZShape = AvZShape> = AvZShape<JsonShapeValue<Inner> | null, "nullable"> & (Inner extends AvZOptionalKey ? AvZOptionalKey : unknown);
-/** A value a literal shape may hold. */
-export type AvZLiteralValue = JsonSchemaPrimitive;
-/** What keys a record shape: any string, an enum's values or one literal. */
-type AvZRecordKey = AvZShape<string, "string"> | AvZShape<string, "enum"> | AvZShape<string, "literal">;
-/** An option of a discriminated union: an object whose discriminator is a literal or an enum. */
-type AvZDiscriminable<Discriminator extends string> = AvZObject<{
-    readonly [Key in Discriminator]: AvZShape<AvZLiteralValue, "literal"> | AvZShape<string, "enum">;
-} & AvZFields>;
-type TupleValue<Items extends readonly AvZShape[]> = {
-    -readonly [Index in keyof Items]: JsonShapeValue<Items[Index]>;
-};
-/**
- * Builds Json Shapes: the type of a Json field, declared in the configuration as
- * `fields: { Post: { meta: { json: AvZ.object({ … }) } } }`. Types only — no
- * rules, refinements, transforms or defaults. Objects are closed: a key the shape
- * does not declare is refused.
- */
-export declare class AvZ {
-    private constructor();
-    /** Any string. */
-    static readonly string: () => AvZShape<string, "string">;
-    /** Any finite number. */
-    static readonly number: () => AvZShape<number, "number">;
-    /** An integer (a safe one). */
-    static readonly int: () => AvZShape<number, "int">;
-    /** `true` or `false`. */
-    static readonly boolean: () => AvZShape<boolean, "boolean">;
-    /** `null`. */
-    static readonly null: () => AvZShape<null, "null">;
-    /** Exactly `value`: a string, a finite number, a boolean or `null`. */
-    static readonly literal: <const Value extends AvZLiteralValue>(value: Value) => AvZShape<Value, "literal">;
-    /** One of `values`. */
-    static readonly enum: <const Values extends readonly [string, ...string[]]>(values: Values) => AvZShape<Values[number], "enum">;
-    /** An object with exactly these keys; `AvZ.optional` marks one that may be left out. */
-    static readonly object: <const Fields extends AvZFields>(fields: Fields) => AvZObject<Fields>;
-    /** A list of `item`s. */
-    static readonly array: <Item extends AvZShape>(item: Item) => AvZShape<JsonShapeValue<Item>[], "array">;
-    /** A list of exactly these items, in order. */
-    static readonly tuple: <const Items extends readonly [AvZShape, ...AvZShape[]]>(items: Items) => AvZShape<TupleValue<Items>, "tuple">;
-    /** An object of `value`s, keyed by any string, an enum's values or a literal. */
-    static readonly record: <Key extends AvZRecordKey, Value extends AvZShape>(key: Key, value: Value) => AvZShape<Record<JsonShapeValue<Key>, JsonShapeValue<Value>>, "record">;
-    /** Any one of `options`. */
-    static readonly union: <const Options extends readonly [AvZShape, AvZShape, ...AvZShape[]]>(options: Options) => AvZShape<JsonShapeValue<Options[number]>, "union">;
-    /** One of `options`, told apart by the literal or enum at `discriminator`. */
-    static readonly discriminatedUnion: <Discriminator extends string, const Options extends readonly [AvZDiscriminable<Discriminator>, ...AvZDiscriminable<Discriminator>[]]>(discriminator: Discriminator, options: Options) => AvZShape<JsonShapeValue<Options[number]>, "discriminatedUnion">;
-    /** An object key that may be left out. */
-    static readonly optional: <Inner extends AvZShape>(inner: Inner) => AvZOptional<Inner>;
-    /** `inner`, or `null`. */
-    static readonly nullable: <Inner extends AvZShape>(inner: Inner) => AvZNullable<Inner>;
-}
-export declare namespace AvZ {
-    /** The TypeScript type a shape describes. */
-    type infer<Shape extends JsonShape> = JsonShapeValue<Shape>;
-}
-export {};

package/dist/runtime/field-behavior.d.ts

@@ -1,48 +0,0 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { AnyFrameworkConfig } from "../config/any-framework-config.js";
-import type { RequestOrigin } from "../config/config-layer.js";
-import type { EffectiveFieldKey } from "../config/effective-fields.js";
-import type { FrameworkResourceKey } from "../config/framework-fields-config.js";
-import type { PipelineContext } from "./pipeline.js";
-/**
- * What a write-stage compute callback is told about the field it is computing.
- */
-type ComputedWriteContext<M extends AdapterModel, Cfg, R extends FrameworkResourceKey<M>> = {
-    readonly origin: RequestOrigin;
-    readonly resource: R;
-    readonly field: EffectiveFieldKey<M, Cfg, R>;
-    readonly value: unknown;
-    readonly data: Readonly<Record<EffectiveFieldKey<M, Cfg, R>, unknown>>;
-    readonly operation: PipelineContext;
-};
-/**
- * Computes a field's value when a row is created. It receives the incoming
- * `data` and returns the value to store.
- */
-export type ComputeOnCreate<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = (context: ComputedWriteContext<M, Cfg, R>) => unknown | Promise<unknown>;
-/**
- * Computes a field's value when a row is updated. It receives the incoming
- * `data` and returns the value to store.
- */
-export type ComputeOnUpdate<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = (context: ComputedWriteContext<M, Cfg, R>) => unknown | Promise<unknown>;
-/**
- * Computes a field's value when a row is read. It receives the stored `record`
- * and returns the value to return.
- */
-export type ComputeOnRead<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = (context: {
-    readonly origin: RequestOrigin;
-    readonly resource: R;
-    readonly field: EffectiveFieldKey<M, Cfg, R>;
-    readonly value: unknown;
-    readonly record: Readonly<Record<EffectiveFieldKey<M, Cfg, R>, unknown>>;
-    readonly operation: PipelineContext;
-}) => unknown | Promise<unknown>;
-/**
- * A computed read: a compute function, or `{ compute, dependsOn }` naming the
- * fields it reads.
- */
-export type ComputedReadBehavior<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig, R extends FrameworkResourceKey<M> = FrameworkResourceKey<M>> = ComputeOnRead<M, Cfg, R> | {
-    readonly dependsOn?: readonly EffectiveFieldKey<M, Cfg, R>[];
-    readonly compute: ComputeOnRead<M, Cfg, R>;
-};
-export {};