@afora/core 0.0.5 → 0.0.7

package/dist/std/properties/password.d.ts

@@ -1,17 +1,36 @@
 import { Type } from "typebox";
+import { type IPropertyInput, PropertyInput } from "../../core/property/input.js";
 export declare const PASSWORD_MIN_LENGTH = 7;
 export declare const PASSWORD_MAX_LENGTH = 128;
 export declare const PASSWORD_SPECIAL_CHARACTERS = "!@#$%^&*()-_=+[]{}|\\;:'\",.<>/?`~";
 export declare function isPasswordHash(value: string): boolean;
 /** The rules a plain password breaks; empty when it is strong enough. */
 export declare function passwordIssues(value: string): string[];
-declare const Password_base: import("../../index.js").PropertyClass<Type.TString, string>;
+declare const PlainPassword_base: import("../../index.js").PropertyClass<Type.TString, string> & {
+    readonly type: {
+        readonly sensitive: true;
+    };
+};
+/**
+ * A password as a person types it, checked against the password rules
+ * (`passwordIssues`); sensitive. It is what an input takes for a `Password`,
+ * which stores the hash.
+ */
+export declare class PlainPassword extends PlainPassword_base {
+}
+declare const Password_base: import("../../index.js").PropertyClass<Type.TString, string> & {
+    readonly type: {
+        readonly sensitive: true;
+    };
+};
 /**
  * A password stored as an Argon2 hash. The constructor only accepts a hash,
  * e.g. one read from the database; `Password.hash` turns a plain password
- * into one.
+ * into one. Under `PropertyInput` it says so to what derives inputs: they
+ * take a `PlainPassword` and hash it.
  */
 export declare class Password extends Password_base {
+    static readonly [PropertyInput]: IPropertyInput<string>;
     /** Validates `plain` against the password rules and hashes it with the configured hasher (argon2id by default). */
     static hash(plain: string): Promise<Password>;
     /** Whether `input` is the password this hash was made from. */

package/dist/std/record-plugins.d.ts

@@ -6,7 +6,7 @@ declare const PublishableRecord_base: import("../index.js").RecordConstructor<im
         safeParse(value: unknown): import("../index.js").ParseResult<string | undefined>;
         readonly "~standard": import("../index.js").StandardSchemaV1.Props<string | undefined, string | undefined>;
     }>;
-}>, [], never, unknown>;
+}>, [], never, unknown, never, never>;
 /**
  * A `publishedAt` absent while the record is a draft; `publish(at?)` sets it
  * (to now by default), `unpublish()` clears it, `isPublished` tells.
@@ -30,7 +30,7 @@ declare const ArchivableRecord_base: import("../index.js").RecordConstructor<imp
         safeParse(value: unknown): import("../index.js").ParseResult<string | undefined>;
         readonly "~standard": import("../index.js").StandardSchemaV1.Props<string | undefined, string | undefined>;
     }>;
-}>, [], never, unknown>;
+}>, [], never, unknown, never, never>;
 /**
  * An `archivedAt` absent while the record is active; `archive(at?)` sets it,
  * `restore()` clears it, `isArchived` tells.
@@ -49,7 +49,7 @@ export declare class ArchivableRecord extends ArchivableRecord_base {
 export declare const Archivable: import("../index.js").IRecordPlugin<typeof ArchivableRecord, "archivable">;
 declare const TaggableRecord_base: import("../index.js").RecordConstructor<import("../core/property/types/property-options.interface.js").StoredFields<{
     tags: import("../index.js").IBlueprintList<import("../index.js").PropertyClass<import("typebox").TString, string>, true>;
-}>, [], never, unknown>;
+}>, [], never, unknown, never, never>;
 /**
  * `tags`, a list of strings, each once; `tag`, `untag` and `hasTag` change and read it.
  *
@@ -67,7 +67,7 @@ export declare class TaggableRecord extends TaggableRecord_base {
 export declare const Taggable: import("../index.js").IRecordPlugin<typeof TaggableRecord, "taggable">;
 declare const OwnableRecord_base: import("../index.js").RecordConstructor<import("../core/property/types/property-options.interface.js").StoredFields<{
     ownerId: import("../index.js").CallableProperty<typeof import("../index.js").Id>;
-}>, [], never, unknown>;
+}>, [], never, unknown, never, never>;
 /**
  * An `ownerId`, the id of who owns the record, with `isOwnedBy` and `transferTo`.
  *
@@ -84,7 +84,7 @@ export declare const Ownable: import("../index.js").IRecordPlugin<typeof Ownable
 declare const AuthenticatableRecord_base: import("../index.js").RecordConstructor<import("../core/property/types/property-options.interface.js").StoredFields<{
     email: import("../index.js").CallableProperty<import("../index.js").PropertyClass<import("typebox").TString, string>>;
     password: import("../index.js").CallableProperty<typeof Password>;
-}>, readonly ["password"], "email", unknown>;
+}>, readonly ["password"], "email", unknown, never, never>;
 /**
  * An `email`, unique, and a `password` hash, sensitive, changed by
  * `change.password` and checked by `verifyPassword`.

package/dist/std/use-cases/auth.d.ts

@@ -0,0 +1,5 @@
+import type { LoginMaker, RegisterMaker } from "./types.js";
+/** Stores an authenticatable entity, unless its email is taken. */
+export declare const register: import("../../index.js").IUseCasePlugin<"register", RegisterMaker>;
+/** Gives the authenticatable entity of an email, when the password matches. */
+export declare const login: import("../../index.js").IUseCasePlugin<"login", LoginMaker>;

package/dist/std/use-cases/crud.d.ts

@@ -0,0 +1,23 @@
+import type { UseCaseCompilation, UseCaseTargetInfo } from "../../core/use-case/types/plugin.interface.js";
+import type { AnyExceptionClass } from "../../core/use-case/use-case.js";
+import { type Options, type Step } from "./shared.js";
+import type { CreateMaker, DeleteMaker, GetMaker, ListMaker, RestoreMaker, UpdateMaker } from "./types.js";
+/**
+ * The declaration of `create` and of `register`, which adds `before` and
+ * its errors: an input of the keys of the entity, the entity built from it
+ * and stored.
+ */
+export declare function createCompilation(target: UseCaseTargetInfo, options: Options, verb: string, before?: readonly Step[], errors?: readonly AnyExceptionClass[]): UseCaseCompilation;
+/** Builds an entity from the input and stores it. */
+export declare const create: import("../../index.js").IUseCasePlugin<"create", CreateMaker>;
+/** Gives the entity of an id. */
+export declare const get: import("../../index.js").IUseCasePlugin<"get", GetMaker>;
+/** Gives a page of entities. */
+export declare const list: import("../../index.js").IUseCasePlugin<"list", ListMaker>;
+/** Changes the keys the input gives, of those the entity lets change. */
+export declare const update: import("../../index.js").IUseCasePlugin<"update", UpdateMaker>;
+/** Deletes the entity of an id, as the repository deletes: for good, or softly. */
+declare const remove: import("../../index.js").IUseCasePlugin<"delete", DeleteMaker>;
+export { remove as delete_ };
+/** Brings back a soft-deleted entity. */
+export declare const restore: import("../../index.js").IUseCasePlugin<"restore", RestoreMaker>;

package/dist/std/use-cases/index.d.ts

@@ -0,0 +1,11 @@
+import type { IUseCaseCatalog } from "../../core/use-case/types/plugin.interface.js";
+import type { StdUseCasePlugins } from "./types.js";
+/**
+ * The standard use cases, by name, for the `useCases` of `commandOf` to
+ * pick from, as `(ctx) => ({ create: ctx.create(Posts) })`: `create`, `get`,
+ * `list`, `update`, `delete` and `restore` for any entity; `publish`,
+ * `unpublish`, `archive`, `unarchive`, `tag` and `untag` for the entities
+ * with those record plugins; `register` and `login` for the
+ * authenticatable ones. `StdUseCases.context` is that `ctx`.
+ */
+export declare const StdUseCases: IUseCaseCatalog<StdUseCasePlugins>;

package/dist/std/use-cases/lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { ArchiveMaker, PublishMaker, TagMaker } from "./types.js";
+/** Publishes the entity of an id. */
+export declare const publish: import("../../index.js").IUseCasePlugin<"publish", PublishMaker>;
+/** Makes the entity of an id a draft again. */
+export declare const unpublish: import("../../index.js").IUseCasePlugin<"unpublish", PublishMaker>;
+/** Archives the entity of an id. */
+export declare const archive: import("../../index.js").IUseCasePlugin<"archive", ArchiveMaker>;
+/** Makes the archived entity of an id active again. */
+export declare const unarchive: import("../../index.js").IUseCasePlugin<"unarchive", ArchiveMaker>;
+/** Adds tags to the entity of an id. */
+export declare const tag: import("../../index.js").IUseCasePlugin<"tag", TagMaker>;
+/** Removes tags from the entity of an id. */
+export declare const untag: import("../../index.js").IUseCasePlugin<"untag", TagMaker>;

package/dist/std/use-cases/shared.d.ts

@@ -0,0 +1,60 @@
+import type { BlueprintField } from "../../core/blueprint/types/blueprint.interface.js";
+import type { UseCaseCompilation, UseCaseFieldPlan, UseCaseTargetInfo } from "../../core/use-case/types/plugin.interface.js";
+import type { AnyExceptionClass } from "../../core/use-case/use-case.js";
+/** A blueprint of the fields given, with no context of properties. */
+export declare const fields: import("../../index.js").BlueprintBuilder<readonly []>;
+export type Options = Readonly<Record<string, unknown>>;
+export type Step = Readonly<Record<string, unknown>>;
+export declare const capitalize: (key: string) => string;
+/** A value given in options as a step takes it: a string that starts with `$` is not a reference. */
+export declare function literal(value: unknown): unknown;
+/** The option `key`, checked to be one of the `allowed` options of the use case. */
+export declare function checkOptions(target: UseCaseTargetInfo, options: Options, allowed: readonly string[]): void;
+/** The name, description, tags and `deprecated` of the use case. */
+export declare function metaOf(target: UseCaseTargetInfo, options: Options, verb: string): Pick<UseCaseCompilation, "name" | "description" | "tags" | "deprecated">;
+/** The key of the response that holds the entity: the option `as`, `item` by default. */
+export declare function asOf(target: UseCaseTargetInfo, options: Options): string;
+/** The error of `kind` the options give, else `fallback`. */
+export declare function errorOf(target: UseCaseTargetInfo, options: Options, kind: "notFound" | "conflict" | "invalid" | "owner", fallback: AnyExceptionClass): AnyExceptionClass;
+/** The list of names an option gives, each a key of the entity. */
+export declare function keysOf(target: UseCaseTargetInfo, options: Options, option: string): readonly UseCaseFieldPlan[];
+/** The object an option gives, by key of the entity. */
+export declare function valuesOf(target: UseCaseTargetInfo, options: Options, option: string): Readonly<Record<string, unknown>>;
+/** Who owns the entity, as the option `owner` says. */
+export interface Owner {
+    readonly plan: UseCaseFieldPlan;
+    /** The key of the context that holds the id of the caller. */
+    readonly context: string;
+    /** The field of that context key: an id. */
+    readonly field: BlueprintField;
+    /** The reference to the id of the owner of the entity bound as `item`. */
+    readonly reference: string;
+}
+/**
+ * The option `owner: { key?, context }`: `key` (`ownerId` by default) holds
+ * the owner, an id or an entity, and `context` names the context key with
+ * the id of the caller.
+ */
+export declare function ownerOf(target: UseCaseTargetInfo, options: Options): Owner | undefined;
+/** The context blueprint an owner needs, if there is one. */
+export declare function contextOf(owner: Owner | undefined): Pick<UseCaseCompilation, "context">;
+/**
+ * The steps that load the entity of `$input.id` as `item`, throw `notFound`
+ * when there is none, and when it is not the caller's.
+ */
+export declare function loadSteps(owner: Owner | undefined, notFound: AnyExceptionClass): Step[];
+/** The id field of the entity of `target`. */
+export declare const idOf: (target: UseCaseTargetInfo) => BlueprintField;
+/** The classes of `errors`, each once. */
+export declare const distinct: (...errors: readonly AnyExceptionClass[]) => AnyExceptionClass[];
+/**
+ * A use case over one entity found by id: `{ id }` in, `{ [as]: entity }`
+ * out; loads it, checks the owner, runs `steps` (which leave the entity to
+ * give under `result`) and gives it.
+ */
+export declare function entityUseCase(target: UseCaseTargetInfo, options: Options, verb: string, allowed: readonly string[], steps: (context: {
+    readonly owner: Owner | undefined;
+}) => {
+    readonly steps: readonly Step[];
+    readonly result: string;
+}): UseCaseCompilation;

package/dist/std/use-cases/types.d.ts

@@ -0,0 +1,212 @@
+import type { AnyBlueprint, AnyBlueprintList, AnyRecordClass, BlueprintField, IBlueprint, IBlueprintCollection, IBlueprintList, OptionalBlueprint, OptionalBlueprintList, OptionalRecord } from "../../core/blueprint/types/blueprint.interface.js";
+import type { EntityIdentityKey } from "../../core/entity/types/entity.interface.js";
+import type { OptionalProperty } from "../../core/property/types/optional-property.type.js";
+import type { AnyPropertyConstructor } from "../../core/property/types/property-collection.type.js";
+import type { AnyRepository, AnyRepositoryEntity, EntityInstanceOf } from "../../core/repository/types/repository.interface.js";
+import type { IUseCasePlugin, UseCaseTarget } from "../../core/use-case/types/plugin.interface.js";
+import type { AnyExceptionClass, StepsUseCaseConstructor } from "../../core/use-case/use-case.js";
+import type { Integer, StringProperty } from "../properties/primitives.js";
+type EntityOf<Repository> = Repository extends {
+    readonly entity: infer Entity extends AnyRepositoryEntity;
+} ? Entity : never;
+type PropertiesOf<Entity> = Entity extends {
+    readonly blueprint: IBlueprint<infer Properties extends IBlueprintCollection>;
+} ? Properties : never;
+type Props<Repository> = PropertiesOf<EntityOf<Repository>>;
+type FieldAt<Properties, Key extends string> = Properties extends {
+    readonly [Name in Key]: infer Field extends BlueprintField;
+} ? Field : never;
+type IdField<Repository> = FieldAt<Props<Repository>, "id">;
+type KeyOf<Repository> = keyof Props<Repository> & string;
+/** Whether a field holds an entity, one that may be absent, or a list of them. */
+type HoldsEntity<Field> = Field extends AnyRepositoryEntity ? true : Field extends {
+    readonly record: AnyRepositoryEntity;
+} ? true : Field extends IBlueprintList<infer Item> ? Item extends AnyRepositoryEntity ? true : false : false;
+/** The field that accepts `undefined` too, as `optionalOf` gives it. */
+type Optional<Field> = Field extends AnyPropertyConstructor ? OptionalProperty<Field> : Field extends AnyBlueprintList ? OptionalBlueprintList<Field> : Field extends AnyBlueprint ? OptionalBlueprint<Field> : Field extends AnyRecordClass ? OptionalRecord<Field> : never;
+/** The errors a standard use case throws, in place of its defaults. */
+export interface StdUseCaseErrors {
+    /** For an entity that is not found, or is not the caller's. `UseCaseEntityNotFound` by default. */
+    readonly notFound?: AnyExceptionClass;
+    /** For an entity that already exists (`register`). `UseCaseEntityConflict` by default. */
+    readonly conflict?: AnyExceptionClass;
+    /** For credentials that do not match (`login`). `UseCaseInvalidCredentials` by default. */
+    readonly invalid?: AnyExceptionClass;
+    /** For a caller that is not found, when it owns what `create` makes. `notFound` by default. */
+    readonly owner?: AnyExceptionClass;
+}
+/** The options every standard use case takes. */
+export interface StdUseCaseOptions {
+    /** The `useCaseName`; the verb and the name of the entity by default, as `CreatePost`. */
+    readonly name?: string;
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly deprecated?: boolean;
+    readonly errors?: StdUseCaseErrors;
+}
+/** Who owns the entities: the caller, whose id the context gives. */
+export interface StdOwnerOption<Repository> {
+    /**
+     * `key` holds the owner, as an id or as an entity (`ownerId` by default,
+     * the key of the `ownable` plugin), and `context` names the context key
+     * with the id of the caller: `create` fills the key from it, a use case
+     * over one entity throws `notFound` for another owner's, and `list` gives
+     * only the caller's.
+     */
+    readonly owner?: {
+        readonly key?: KeyOf<Repository>;
+        readonly context: string;
+    };
+}
+/** The options of a standard use case that gives one entity. */
+export interface StdEntityOptions<Repository> extends StdUseCaseOptions, StdOwnerOption<Repository> {
+    /** The key of the response that holds the entity; `item` by default. */
+    readonly as?: string;
+}
+/** The options of `create` and `register`. */
+export interface StdCreateOptions<Repository> extends StdEntityOptions<Repository> {
+    /** Optional keys the input does not take. */
+    readonly omit?: readonly KeyOf<Repository>[];
+    /** Values the entity is built with, in place of taking them from the input. */
+    readonly values?: {
+        readonly [Key in KeyOf<Repository>]?: unknown;
+    };
+}
+/** The options of `publish`, `unpublish`, `archive` and `unarchive`. */
+export interface StdLifecycleOptions<Repository> extends StdEntityOptions<Repository> {
+    /** Change keys set before the entity is stored, e.g. `{ status: "published" }`. */
+    readonly set?: {
+        readonly [Key in KeyOf<Repository>]?: unknown;
+    };
+}
+/** The options of `list`. */
+export interface StdListOptions<Repository> extends StdUseCaseOptions, StdOwnerOption<Repository> {
+    /** The order of the page; newest first (`createdAt`, descending) by default. */
+    readonly orderBy?: readonly {
+        readonly key: KeyOf<Repository>;
+        readonly direction?: "asc" | "desc";
+    }[];
+}
+type None = Record<never, never>;
+type AsOf<Options> = Options extends {
+    readonly as: infer Key extends string;
+} ? Key : "item";
+type EntityResponse<Repository, Options> = {
+    readonly [Key in AsOf<Options>]: EntityOf<Repository>;
+};
+type OwnerContext<Repository, Options> = Options extends {
+    readonly owner: {
+        readonly context: infer Key extends string;
+    };
+} ? {
+    readonly [Name in Key]: IdField<Repository>;
+} : undefined;
+type OwnerKey<Options> = Options extends {
+    readonly owner: infer Owner;
+} ? Owner extends {
+    readonly key: infer Key;
+} ? Key : "ownerId" : never;
+type LeftOut<Options> = EntityIdentityKey | OwnerKey<Options> | (Options extends {
+    readonly omit: readonly (infer Key)[];
+} ? Key : never) | (Options extends {
+    readonly values: infer Values;
+} ? keyof Values : never);
+/** The input of `create`: the keys of the entity, an entity it holds by `<key>Id`. */
+type CreateInput<Repository, Options> = {
+    readonly [Key in KeyOf<Repository> as Key extends LeftOut<Options> ? never : Props<Repository>[Key] extends AnyRepositoryEntity ? `${Key}Id` : HoldsEntity<Props<Repository>[Key]> extends true ? never : Key]: Props<Repository>[Key] extends AnyRepositoryEntity ? FieldAt<PropertiesOf<Props<Repository>[Key]>, "id"> : Props<Repository>[Key];
+};
+type ChangeKey<Repository> = EntityInstanceOf<EntityOf<Repository>> extends {
+    readonly change: infer Changes;
+} ? keyof Changes & KeyOf<Repository> : never;
+/** The input of `update`: the id, and each change key, optional. */
+type UpdateInput<Repository> = {
+    readonly [Key in "id" | ChangeKey<Repository> as Key extends "id" ? Key : HoldsEntity<Props<Repository>[Key]> extends true ? never : Key]: Key extends "id" ? IdField<Repository> : Optional<Props<Repository>[Key]>;
+};
+type EntityUseCase<Repository extends AnyRepository, Options, Input extends IBlueprintCollection> = StepsUseCaseConstructor<Input, EntityResponse<Repository, Options>, {
+    readonly repository: Repository;
+}, OwnerContext<Repository, Options>>;
+type ById<Repository> = {
+    readonly id: IdField<Repository>;
+};
+/** `create`: for a repository with the `create` action. */
+export type CreateMaker = <Repository extends AnyRepository, const Options extends StdCreateOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "create">, options?: Options) => EntityUseCase<Repository, Options, CreateInput<Repository, Options>>;
+/** `get`: for a repository with `findById`. */
+export type GetMaker = <Repository extends AnyRepository, const Options extends StdEntityOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findById">, options?: Options) => EntityUseCase<Repository, Options, ById<Repository>>;
+/** `list`: for a repository with `findPage`. */
+export type ListMaker = <Repository extends AnyRepository, const Options extends StdListOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findPage">, options?: Options) => StepsUseCaseConstructor<{
+    readonly limit: OptionalProperty<typeof Integer>;
+    readonly offset: OptionalProperty<typeof Integer>;
+}, {
+    readonly items: IBlueprintList<EntityOf<Repository>>;
+    readonly total: typeof Integer;
+    readonly limit: typeof Integer;
+    readonly offset: typeof Integer;
+}, {
+    readonly repository: Repository;
+}, OwnerContext<Repository, Options>>;
+/** `update`: for a repository with `findById` and `update`. */
+export type UpdateMaker = <Repository extends AnyRepository, const Options extends StdEntityOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findById" | "update">, options?: Options) => EntityUseCase<Repository, Options, UpdateInput<Repository>>;
+/** `delete`: for a repository with `findById` and `delete`. */
+export type DeleteMaker = <Repository extends AnyRepository, const Options extends StdEntityOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findById" | "delete">, options?: Options) => EntityUseCase<Repository, Options, ById<Repository>>;
+/** `restore`: for a repository with soft deletion and the `restore` action. */
+export type RestoreMaker = <Repository extends AnyRepository, const Options extends StdUseCaseOptions & {
+    readonly as?: string;
+} = None>(repository: Repository & UseCaseTarget<Repository, "restore">, options?: Options) => StepsUseCaseConstructor<ById<Repository>, EntityResponse<Repository, Options>, {
+    readonly repository: Repository;
+}>;
+/** `publish` and `unpublish`: for a publishable entity. */
+export type PublishMaker = <Repository extends AnyRepository, const Options extends StdLifecycleOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findById" | "update", {
+    publish(at?: string): unknown;
+    unpublish(): unknown;
+}, "publishable">, options?: Options) => EntityUseCase<Repository, Options, ById<Repository>>;
+/** `archive` and `unarchive`: for an archivable entity. */
+export type ArchiveMaker = <Repository extends AnyRepository, const Options extends StdLifecycleOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findById" | "update", {
+    archive(at?: string): unknown;
+    readonly isArchived: boolean;
+}, "archivable">, options?: Options) => EntityUseCase<Repository, Options, ById<Repository>>;
+/** `tag` and `untag`: for a taggable entity. */
+export type TagMaker = <Repository extends AnyRepository, const Options extends StdEntityOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findById" | "update", {
+    tag(...tags: string[]): unknown;
+    untag(...tags: string[]): unknown;
+}, "taggable">, options?: Options) => EntityUseCase<Repository, Options, ById<Repository> & {
+    readonly tags: IBlueprintList<typeof StringProperty>;
+}>;
+type Authenticatable = {
+    verifyPassword(plain: string): Promise<boolean>;
+};
+/** `register`: for an authenticatable entity, with `findByEmail` and `create`. */
+export type RegisterMaker = <Repository extends AnyRepository, const Options extends StdCreateOptions<Repository> = None>(repository: Repository & UseCaseTarget<Repository, "findByEmail" | "create", Authenticatable, "authenticatable">, options?: Options) => EntityUseCase<Repository, Options, CreateInput<Repository, Options>>;
+/** `login`: for an authenticatable entity, with `findByEmail`. */
+export type LoginMaker = <Repository extends AnyRepository, const Options extends StdUseCaseOptions & {
+    readonly as?: string;
+} = None>(repository: Repository & UseCaseTarget<Repository, "findByEmail", Authenticatable, "authenticatable">, options?: Options) => StepsUseCaseConstructor<{
+    readonly email: FieldAt<Props<Repository>, "email">;
+    readonly password: typeof StringProperty;
+}, EntityResponse<Repository, Options>, {
+    readonly repository: Repository;
+}>;
+/**
+ * The standard use cases, by name: what the `useCases` of `commandOf` gets
+ * to pick from, each called with a repository and its options.
+ */
+export interface StdUseCaseContext {
+    readonly create: CreateMaker;
+    readonly get: GetMaker;
+    readonly list: ListMaker;
+    readonly update: UpdateMaker;
+    readonly delete: DeleteMaker;
+    readonly restore: RestoreMaker;
+    readonly publish: PublishMaker;
+    readonly unpublish: PublishMaker;
+    readonly archive: ArchiveMaker;
+    readonly unarchive: ArchiveMaker;
+    readonly tag: TagMaker;
+    readonly untag: TagMaker;
+    readonly register: RegisterMaker;
+    readonly login: LoginMaker;
+}
+/** The plugins of `StdUseCases`, by name. */
+export type StdUseCasePlugins = {
+    readonly [Name in keyof StdUseCaseContext]: IUseCasePlugin<Name, StdUseCaseContext[Name]>;
+};
+export {};

package/dist/testing/index.js

@@ -1,10 +1,10 @@
-import"../index-hn82hm31.js";
+import"../index-r78dsvtc.js";
 import {
   RepositoryUniqueViolation2,
   RepositoryEntityNotFound2,
   blueprintOf2,
   entityOf2
-} from "../index-8m80wjzf.js";
+} from "../index-q6hggpzw.js";
 
 // src/testing/provider-contract.ts
 function contextOf(name = "Accounts") {
@@ -129,6 +129,14 @@ function providerContract(runner, makeProvider, options = {}) {
         await provider.update(context, { ...data, name: "Other" });
         expect(await provider.findOne(context, { where: { id: data.id } })).toEqual({ ...data, name: "Other" });
       });
+      it("update clears a value that is left out", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ deletedAt: "2024-01-01T00:00:00.000Z" });
+        await seed(data);
+        const { deletedAt: _deletedAt, ...alive } = data;
+        await provider.update(context, alive);
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual(alive);
+      });
       it("soft-deleted rows keep occupying unique values", async () => {
         const { provider, context, seed } = await fixture();
         await seed(row({
@@ -371,6 +379,95 @@ function providerContract(runner, makeProvider, options = {}) {
         expect(stored).toEqual(data);
       });
     });
+    describe("keyset", () => {
+      const keyset = (name, body) => it(name, async () => {
+        const enabled = options.keyset ?? (await makeProvider()).capabilities?.keyset;
+        if (enabled === true)
+          await body();
+      });
+      const seeded = async () => {
+        const f = await fixture();
+        const [a, b, c, d, e, g] = [
+          row({ n: 1, group: 1, name: "Gil" }),
+          row({ group: 1, name: "Érico" }),
+          row({ n: 2, group: 2, name: "Ana" }),
+          row({ n: 2, group: 1, name: "ana" }),
+          row({ group: 2, name: "Bia" }),
+          row({ n: 3, group: 2, name: "Zoe" })
+        ];
+        await f.seed(a, b, c, d, e, g);
+        const find = (query) => f.provider.findMany(f.context, query).then(ids);
+        return { ...f, a, b, c, d, e, g, find };
+      };
+      const by = (key, direction = "asc") => [{ key, direction }, { key: "id" }];
+      keyset("gives the rows strictly after the position, ascending", async () => {
+        const { find, a, c, d, g } = await seeded();
+        const orderBy = by("n");
+        expect(await find({ orderBy, after: [1, a.id] })).toEqual([
+          c.id,
+          d.id,
+          g.id
+        ]);
+        expect(await find({ orderBy, after: [2, c.id] })).toEqual([
+          d.id,
+          g.id
+        ]);
+        expect(await find({ orderBy, after: [3, g.id] })).toEqual([]);
+      });
+      keyset("follows a descending order", async () => {
+        const { find, a, c, d, g } = await seeded();
+        const orderBy = by("n", "desc");
+        expect(await find({
+          orderBy,
+          after: [3, g.id],
+          where: { n: { in: [1, 2] } }
+        })).toEqual([c.id, d.id, a.id]);
+        expect(await find({
+          orderBy,
+          after: [2, d.id],
+          where: { n: { in: [1, 2] } }
+        })).toEqual([a.id]);
+      });
+      keyset("missing values are first ascending and last descending", async () => {
+        const { find, a, b, c, d, e, g } = await seeded();
+        expect(await find({ orderBy: by("n"), after: [undefined, b.id] })).toEqual([e.id, a.id, c.id, d.id, g.id]);
+        expect(await find({ orderBy: by("n"), after: [undefined, e.id] })).toEqual([a.id, c.id, d.id, g.id]);
+        expect(await find({ orderBy: by("n", "desc"), after: [1, a.id] })).toEqual([b.id, e.id]);
+        expect(await find({ orderBy: by("n", "desc"), after: [undefined, b.id] })).toEqual([e.id]);
+        expect(await find({ orderBy: by("n", "desc"), after: [undefined, e.id] })).toEqual([]);
+      });
+      keyset("compares strings by code point", async () => {
+        const { find, a, b, c, d, e, g } = await seeded();
+        expect(await find({ orderBy: by("name"), after: ["Bia", e.id] })).toEqual([a.id, g.id, d.id, b.id]);
+        expect(await find({ orderBy: by("name", "desc"), after: ["ana", d.id] })).toEqual([g.id, a.id, e.id, c.id]);
+      });
+      keyset("combines with where, withDeleted and limit; count ignores it", async () => {
+        const { provider, context, find, a, b, d } = await seeded();
+        const orderBy = [{ key: "id" }];
+        expect(await find({
+          orderBy,
+          after: [a.id],
+          where: { group: 1 },
+          limit: 1
+        })).toEqual([b.id]);
+        expect(await find({ orderBy, after: [b.id], where: { group: 1 } })).toEqual([d.id]);
+        await provider.update(context, {
+          ...d,
+          deletedAt: "2024-01-01T00:00:00.000Z"
+        });
+        expect(await find({ orderBy, after: [b.id], where: { group: 1 } })).toEqual([]);
+        expect(await find({
+          orderBy,
+          after: [b.id],
+          where: { group: 1 },
+          withDeleted: true
+        })).toEqual([d.id]);
+        expect(await provider.count(context, {
+          orderBy,
+          after: [b.id]
+        })).toBe(5);
+      });
+    });
     const withTransactions = async () => {
       const enabled = options.transactions ?? (await makeProvider()).capabilities?.transactions;
       return enabled === true;

package/dist/testing/provider-contract.d.ts

@@ -13,6 +13,11 @@ export interface ProviderContractOptions {
      * Run the transaction cases. Defaults to `provider.capabilities?.transactions`.
      */
     readonly transactions?: boolean;
+    /**
+     * Run the cases of `after`, which `findCursor` gives to `findMany`. Defaults
+     * to `provider.capabilities?.keyset`.
+     */
+    readonly keyset?: boolean;
 }
 /**
  * Registers the behavior every `IRepositoryProvider` v2 must have. Pass the

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@afora/core",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "Domain modeling on TypeBox: entities with invariants, repositories, use cases, sensitive data masking and layered exceptions, usable by any Standard Schema consumer.",
 	"keywords": [
 		"domain-driven-design",